首页 > 其他分享> > Day 13 匿名函数 :内置函数: 闭包

Day 13 匿名函数 :内置函数: 闭包

2020-07-25 06:31:13 作者：互联网

01 今日大纲内容

如何学习:
- 一定要把预习加上!
- 分配比例:
  - 文字总结格式(1/3),晚上20点-21点之前完成总结以及代码练习
  - 20点-21点之后写作业

02 昨日内容回顾作业讲解

生成器:生成器就是迭代器,生成器是自己用python代表构建的
- 1. 生成器函数
  2. 生成器表达式
  3. python内部提供的
- 如何判断函数与生成器函数
  - yield
  - yield (一个yield对一个next,返回值,不终止)与 return(终止函数,返回值)的区别
- 吃包子
- yield from 讲一个可迭代对象,变成一个生成器
- 列表推导式,生成器表达式
  - 循环模式[变量(加工后的变量 for 变量 in iterable)]
  - 筛选模式[变量(加工后的变量 for 变量 in iterable if 条件)]
- 内置函数(避免重复造轮子,提升开发效率,68个)

03 今日内容

匿名函数:一句话函数,比较简单的函数
1. 此函数不是没有名字,他是有名字的,他的名字就是你给其设置的变量,比如func
2. lambda 是定义匿名函数的关键字,相当于函数的def
3. lambda 后面直接加形参,形参加多少都可以,只要用逗号隔开就行
4. 返回值在冒号之后设置,返回值和正常函数一样,可以使任意数据类型
5. 匿名函数不管多复杂,只能写一行,且逻辑结束后直接返回数据
  课上练习:
  
  匿名函数 :一句话函数,比较简单的函数
  
  def func(a,b):
  return a + b
  
  构建匿名函数
  
  func1 = lambda a,b:a+b
  print(func1(1,2))
- 接收一个可切片的数据,返回索引为0与2的对应元素(元组形式)
  func2 = lambda a:(a[0],a[2])
  print(func2([22,33,44,55,66]))
- 写匿名函数,接收两个int参数,将较大的数据返回
  func3 = lambda a,b: a if a > b else b
  print(func3(1,200))

内置函数
# python提供了68个内置函数
# 今天讲的这部分大部分了解即可
# eval 剥去字符串的运算外衣,运行里面的代码,有返回值**
s1 = '1 + 3'
print(s1)
print(eval(s1))
s = "{'name':'alex'}"
print(s,type(s))
# print(dict(s)) ##错误
print(eval(s),type(eval(s)))
# 网络传输的str input 输入的时候,sql注入等等,绝对不能够使用eval,携带病毒的字符串,eval后直接运行病毒

# exec 与 eval 几乎是一样,代码流
msg = '''
for i in range(10):
    print(i)
'''
print(msg)
exec(msg)


# hash 哈希值
print(hash('ahsfgajhhalga'))

# help 帮助
s1 = 'laksldka'
print(help(str))
print(help(str.upper))
s1 = 'dasd'
s1.upper()    #对变量本身不更改
print(s1)

# # callable 判断一个对象是否可以被调用!!!
s1 = 'aksdajklf'
# s1()   # TypeError: 'str' object is not callable
def fun():
    pass
fun()   #可执行
print(callable(fun))
print(callable(s1))


# int # 整形
print(int(4.6))

# float # 浮点型
print(type(3.6))

# complex 复数
print(complex(1,2)) #(1+2j)

# bin:将十进制转换成2进制
print(bin(100))    # 0b1100100

# oct:将十进制转化成八进制字符串并返回
print(oct(10))     #0o12

# hex:将十进制转化成十六进制字符串并返回
print(hex(160))    #0xa0
print(hex(16))    #0x10
print(hex(13))    #0xd

# divmod ！！取商取余
print(divmod(10,3)) #(3, 1) 商3余1

# round:保留浮点数的小数位数!!
print(round(3.14156,2))

# pow:求x**y次幂 (三个参数时,对x**y的结果对z取余)
print(pow(2,3))     #2的三次方,8
print(pow(2,3,3))   #8除以3 余2

# bytes 编码
s1 = '太白'
b = s1.encode('utf-8')
print(b)
b = bytes(s1,encoding='utf-8')
print(b)

# ord:输入字符找到该字符的编码位置
# ascii Unicode
print(ord('a'))
print(ord('中')) #20013

# chr:输入位置,找出对应的字符
print(chr(98)) # b
print(chr(20014))   #Unicode

# repr:返回一个对象的string形式(原形毕露)!!!
s1 = '存龙'
print(s1)
print(repr(s1))
msg = f'我叫{s1}'
print(msg)
print(repr(msg))


# all 可迭代对象中,全都是True 才是True
l1 = [1, 2, '太白3', True, [1,2,3], '']
print(all(l1))  #False

# any :可迭代对象中,有一个是True 就是True
l1 = [1, 2, '太白3', True, [1,2,3], '']
print(any(l1))

# print函数
# print(self, *args, sep=' ', end='\n', file=None)
print(1,2,3,4)
print(1,2,3,4,sep='^')

print(1,end=' ')
print(2)

# list函数
l1 = [1,2,3,4]
l2 = list() #[]
l2 = list('asdhjashf')
print(l2)   #['a', 's', 'd', 'h', 'j', 'a', 's', 'h', 'f']

dict 字典创建的几种方式
这季节创建
# 元组的解构
dic = dict([(1,'one'),(2,'two'),(3,'three')])   #列表中放元组
print(dic)
dic = dict(one=1,two = 2)    #dict中放参数
print(dic)
# fromkeys
# 字典推导式


# abs()   #绝对值!!!
print(abs(-6))

# sum()   #求和!!!
l1 = [i for i in range(10)]
s1 = '123456'
print(sum(l1))  #45
print(sum(l1,100))  #145
# print(sum(s1)) #错误 TypeError: unsupported operand type(s) for +: 'int' and 'str'

# reversed 翻转 返回的是一个翻转的迭代器!!!
l1 = [i for i in range(10)]
l1.reverse()    #列表的方法,改变了原列表
print(l1)#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
l1 = [i for i in range(10)]
obj = reversed(l1)  #不对原列表进行操作
print(l1)   #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(l1)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# zip 拉链方法
l1 = [1,2,3,4,5,6]
tu1 = ('太白','b哥','的干煤化工')
s1 = 'sadjakjda'obj = zip(l1,tu1,s1)
print(list(obj))

# 以下方法最最最重要!!!!!!!!!!!
# min max
l1 = [33,2,3,54,7,-1,-9]
print(min(l1))
# 以绝对值的方法去最小值
l2 = []
func = lambda a:abs(a)
for i in l1:
    l2.append(func(i))
print(min(l2))

def abss(a):
    '''
    第一次:a = 33 以绝对值 取最小值 33
    第二次:a = 2  以绝对值 取最小值 2
    第三次:a = 3  以绝对值 取最小值 2
    ........
    第六次:a = -1 以绝对值 取最小值 1
    '''
    return abs(a)
print(min(l1,key = abss)) #abss不加(),使用变量名
# 凡是可以加key的:他会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中,
# 以返回值比较大小
dic = {'a':3,'b':2,'c':1}
求出最小的键
print(min(dic)) #min会按照字典的键去比较大小
def func(*args):
'''
    第一次:
    args:'a'  返回值:dic['a']  记录:3
    第二次:
    args:'b'  返回值:dic['b']  记录:2
    第三次:
    args :'c' 返回值:dic['c']  记录:1
'''
    return dic[args]
print(min(dic,key=lambda a:dic[a]))
func = lambda a:dic[a]
print(min(dic,key=func))
l2 = [('太白',18), ('alex', 73), ('wusir', 35), ('口天吴', 41)]
print(min(l2))
print(min(l2,key=lambda a:l2[1]))
# max pass

# sorted 加key
l1 = [22, 33, 1, 2, 8, 7,6,5]
l2 = sorted(l1)
print(l1)
print(l2)
l2 = [('大壮', 76), ('雪飞', 70), ('纳钦', 94), ('张珵', 98), ('b哥',96)]
print(sorted(l2))
print(sorted(l2,key=lambda a:a[1])) #返回的是一个列表，默认从低到高
print(sorted(l2,key=lambda a:a[1],reverse=True)) #返回的是一个列表，默认从低到高

# filter  列表推导式的筛选模式
l1 = [2, 3, 4, 1, 6, 7, 8]
print([i for i in l1 if i > 3]) #返回的是列表
ret = filter(lambda a:a>3,l1)   #返回的是迭代器
print(ret)
print(list(ret))

# map  列表推导式的循环模式
l1 = [2, 3, 4, 1, 6, 7, 8]
print([i**2 for i in l1])   #返回的是列表
ret = map(lambda a:a**2,l1) #返回的是迭代器
print(list(ret))


# reduce    #累加 第一次取2个值,后续一次取1个值,根据函数来计算
from functools import reduce
def func(x,y):
    '''
    第一次:x,y:11,2   x+y
    '''
    return x+y
l = reduce(func,[11,2,3,4,5])
print(l)

闭包:整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。
比如大众推出了一款新车：小白轿车。
第一天价格为：100000元，平均收盘价：100000元
第二天价格为：110000元，平均收盘价：（100000 + 110000）/2 元
第三天价格为：120000元，平均收盘价：（100000 + 110000 + 120000）/3 元
1.闭包只存在于嵌套函数中
2.内层函数对外层函数非全局变量(自由变量)的引用或使用，就会形成闭包
3.被引用的非全局变量也称作自由变量,这个自由变量会与内层函数产生一个绑定关系
4.自由变量不会再内存中消失
5.闭包的作用,保证数据的安全.函数外访问不到l1
# 闭包
# 封闭的东西：保证数据安全

# 不断输入参数,求平均值 方案一:
l1 = [] # l1为全局变量,数据不安全
li = []
def make_averager(new_value):
    l1.append(new_value)
    total = sum(l1)
    averager = total/len(l1)
    return averager
print(make_averager(100000))
print(make_averager(180000))
print(make_averager(140000))
print(make_averager(103000))
print(make_averager(93000))


# 方案二:数据安全,l1不能是全局变量
# 每次执行的时候,l1列表都会重新赋值成[]
li = []
def make_averager(new_value):
    l1 = []
    l1.append(new_value)
    total = sum(l1)
    averager = total/len(l1)
    return averager
print(make_averager(100000))
print(make_averager(200000))


# 方案三:闭包
def make_averager():
    l1 = []
    def averager(new_value):
        l1.append(new_value)
        print(l1)
        total = sum(l1)
        return total/len(l1)
    return averager

avg = make_averager()   #averager
print(avg.__code__.co_freevars)
print(avg(100000))
print(avg(140000))
print(avg(167000))
print(avg(190000))
print(avg(173000))

def func():
    return 666
ret = func()    #函数消失了,但是返回值给了ret
print(globals())

闭包:多用于面试题:什么是闭包?闭包有什么用?
1.闭包只存在于嵌套函数中
2.内层函数对外层函数非全局变量的引用或使用，就会形成闭包 (自由变量)
被引用的费全局变量也称作自由变量,这个自由变量会与内层函数产生一个绑定关系
自由变量不会再内存中消失
闭包的作用,保证数据的安全.函数外访问不到l1

# 如何判断一个嵌套函数是不是闭包?
# 例一：是闭包
def wrapper():
    a = 1
    def inner():
        print(a)
    return inner
ret = wrapper()
# 例二：不是闭包
a = 2
def wrapper():
    def inner():
        print(a)
    return inner
ret = wrapper()


# 例三：
#   也是闭包！
def wrapper(a,b):
    def inner():
        print(a)
        print(b)
    return inner
# 传值相当于:
a = 2
b = 3
ret = wrapper(a,b)  #ret得到inner
# 如何利用代码判断闭包,对内层函数进行判断
print(ret.__code__.co_freevars)

def make_averager():
    l1 = []
    def averager(new_value):
        l1.append(new_value)
        print(l1)
        total = sum(l1)
        return total/len(l1)
    return averager

avg = make_averager()  # averager

04 今日总结

匿名函数
内置函数(三颗星一定记住,两颗星尽量记住)
闭包

05 预习内容

装饰器

标签：闭包,13,函数,s1,l1,print,averager,def
来源： https://www.cnblogs.com/Redbean1231/p/13375399.html

Day 13 匿名函数 :内置函数: 闭包

匿名函数 :一句话函数,比较简单的函数

构建匿名函数