匿名函数，内置函数，闭包

1. 内容
   1. 匿名函数：一句话函数，比较简单的函数。 函数名 = lambda 参数 : 返回值

   

   1. 此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func。 func() 函数执行
   2. lambda 是定义匿名函数的关键字，相当于函数的def.
   3. lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。 #所有类型的形参都可以加，但是一般使用匿名函数只是加位置参数，其他的用不到 func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs print(func(3, 4,c=666,name='alex')) # {'name': 'alex'}
   4. 返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。
   5. 匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据.

   练习： def func(a,b): return a + b print(func(4,5)) # 构建匿名函数 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])) #(22,44) print(func2('asdfg')) #('a', 'd')
   • 写匿名函数：接收两个int参数，将较大的数据返回。
   • func = lambda a,b: a if a > b else b print(func(5,7)) # 7

   1. 内置函数 # # python 提供了68个内置函数。 reversed() 内建函数将返回一个反序访问的迭代器。 enumerate() 内建函数同样也返回迭代器。 和range类似，map 、zip以及filter内置函数在Python 3.0 中也转变成迭代器以节约内存空间。 #print() ''' 源码分析 def print(self, *args, sep=' ', end='\n', file=None): # known special case of print """ print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件 sep: 打印多个值之间的分隔符，默认为空格 end: 每一次打印的结尾，默认为换行符 flush: 立即把内容输出到流文件，不作缓存 """ ''' print(1,2,3,4)#1 2 3 4 print(1,2,3,4,sep='&')#1&2&3&4 print(1,2,3,sep='*')#1*2*3 print(111,end='') print(222)#两行的结果：111222 f = open('log','w',encoding='utf-8') print('写入文件',file=f,flush=True) #int() #str() #bytes() 把字符串转换成bytes类型 # 将字符串转换成字节 s = '你好' bs = bytes(s,encoding='utf-8') print(bs) #b'\xe4\xbd\xa0\xe5\xa5\xbd' # 将字节转换成字符串 bs = b'\xe4\xbd\xa0\xe5\xa5\xbd' s1 = str(bs,encoding='utf-8') print(s1) #你好 #bool() #set() # list() 将一个可迭代对象转换成列表 l1 = list() #空列表 l2 = list('abcd') print(l2)#['a', 'b', 'c', 'd'] #tuple() 将一个可迭代对象转换成元组 tu1 = tuple('abcd') print(tu1)#('a', 'b', 'c', 'd') # dict 创建字典的几种方式 # 直接创建 dic = {'name': '太白', 'age': 18} # 元组的解构 dic = dict([(1,'one'),(2,'two'),(3,'three')] # dic = dict(one=1,two=2,three=3) print(dic)#{'one': 1, 'two': 2, 'three': 3} # fromkeys dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]} print(dic)#{'one': 1, 'two': 2, 'three': 3} # update dic = {} dic.update([(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]) print(dic)#{1: 'a', 2: 'b', 3: 'c', 4: 'd'} # 字典的推导式 dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]} print(dic)#{'one': 1, 'two': 2, 'three': 3} lst1 = ['jay', 'jj', 'meet'] lst2 = ['周杰伦','林俊杰','元宝'] dic = { lst2[i]: lst1[i] for i in range(len(lst1))} print(dic)#{'周杰伦': 'jay', '林俊杰': 'jj', '元宝': 'meet'} # dic = dict(zip(['one', 'two', 'three'],[1, 2, 3])) print(dic)#{'one': 1, 'two': 2, 'three': 3} # abs() 返回绝对值*** i = -5 print(abs(i))#5 print(abs(-6)) # sum（）求和【针对数字】，可以设置初始 *** print(sum([1.1,2.4,3.88]))#7.38 print(sum([1,2,3]))#6 print(sum((1,2,3),100))#106 可以设置初始值，让初始值为100 l1 = [i for i in range(10)] print(sum(l1))#45 print(sum(l1,100))#145 s1 = '12345' #字符串 print(sum(s1)) # 错误 # reversed 返回的是一个翻转的迭代器(将一个序列翻转, 返回翻转序列的迭代器) *** l1 = [i for i in range(10)] l1.reverse() # 列表的方法 print(l1)#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]#对原列表操作 ret = reversed([1, 4, 3, 7, 9]) print(list(ret)) # [9, 7, 3, 4, 1] l1 = [i for i in range(10)] obj = reversed(l1) #将可迭代对象转化为迭代器 返回的是迭代器 print(obj)#<list_reverseiterator object at 0x000002092EC877F0> print(l1)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #原列表不变 print(list(obj))#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]转化为列表进行取值 # zip 拉链方法 ***面试题会考 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回。 l1 = [1, 2, 3, 4, 5] tu1 = ('太白', 'b哥', '德刚') s1 = 'abcd' obj = zip(l1,tu1,s1) print(obj)#<zip object at 0x00000284D0211088> python内部提供的迭代器 for i in obj: print(i) #结果： (1, '太白', 'a') (2, 'b哥', 'b') (3, '德刚', 'c') 或： print(list(obj))#[(1, '太白', 'a'), (2, 'b哥', 'b'), (3, '德刚', 'c')] # ************* 以下方法最最最重要 # min()求最小值 和 max()求最大值 # 返回此序列最小值 l1 = [33, 2, 3, 54, 7, -1, -9] print(min(l1))#-9 print(min([1,2,-5]))#-5 # 以绝对值的方式获取最小值 #1：求最小的绝对值 l1 = [33, 2, 3, 54, 7, -1, -9] l2 = [] func = lambda a: abs(a) for i in l1: l2.append(func(i)) print（l2）#[33, 2, 3, 54, 7, 1, 9] print(min(l2)) #1 #2：找出绝对值最小的元素 #自己写函数 l1 = [33, 2, 3, 54, 7, -1, -9] def abss(a): return abs(a) print(min(l1,key=abss)) #-1 #直接用内置函数abs() l1 = [33, 2, 3, 54, 7, -1, -9] print(min(l1,key=abs))#-1 print(min([1,2,-5,],key=abs)) #1 ## key=函数名，按照绝对值的大小，返回此序列最小值 print(min(-5,6,-3,key=lambda x:abs(x)))# -3 可以设置很多参数比较大小 【凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中，以返回值比较大小。】 【 min函数循环的是什么，返回的就是什么。正常情况下：列表：返回列表中的元素。字典：返回字典的键。】 【 加key,是可以加'函数名'，min自动会获取传入min函数中的参数的每个元素，然后通过函数的返回值比较大小((key=函数名，看该函数返回的是什么。按照什么比较大小，就将什么设置为返回值)，返回最小的返回值对应的那个传入参数的元素。】 dic = {'a': 3, 'b': 2, 'c': 1} # 求出值最小的键 print(min(dic)) #a min默认会按照字典的键去比较大小。 #按照字典的值比较大小 #1： dic = {'a':3,'b':2,'c':1} def func(a): return dic[a] #key对应的函数的返回值是什么，就按什么比较大小 print(min(dic,key=func))#c #2：min函数按照什么循环，lambda函数的参数位置就写什么。后面的返回值是根据它转化的。 dic = {'a':3,'b':2,'c':1} func = lambda a :dic[a] print(min(dic,key=func))#c #简化： # a为dic的key，按lambda的返回值（即dic的值dic[a]）进行比较，返回最小的值对应的键。 dic = {'a':3,'b':2,'c':1} print(min(dic,key=lambda a:dic[a])) # c 字典中最小值对应的键。min函数循环的是什么，返回的就是什么。按键循环 print(dic[min(dic,key=lambda a:dic[a])]) #1 字典中最小的值 l2 = [('太白', 18), ('alex', 73), ('wusir', 35), ('口天吴', 41)] print(min(l2)) #('alex', 73) #min函数返回元组，它循环的是什么，返回的就是什么。默认按照列表中每个元组中第一个元素的首字母的Unicode比较 #自定制，+key print(min(l2,key=lambda x:x[1]))#('太白', 18) print(min(l2,key=lambda x:x[1])[0])#太白 print(min(l2,key=lambda x:x[1])[1])#18 # max最大值 与最小值用法相同 # sorted 排序函数（可加key自定制） 语法:sorted(iterable,key=None,reverse=False) iterable : 可迭代对象 key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序 reverse :是否是倒叙,True 倒叙 False 正序 l1 = [22, 33, 1, 2, 8, 7, 6, 5] l2 = sorted(l1) print(l1)#[22, 33, 1, 2, 8, 7, 6, 5]原列表不会改变 print(l2)#[1, 2, 5, 6, 7, 8, 22, 33] #倒序： lst = [1,3,2,5,4] lst3 = sorted(lst,reverse=True) print(lst3) #[5, 4, 3, 2, 1] #字典使用sorted排序 dic = {1:'a',3:'c',2:'b'} print(sorted(dic)) # 字典排序返回的就是排序后的key [1, 2, 3] l2 = [('大壮', 76), ('雪飞', 70), ('纳钦', 94), ('张珵', 98), ('b哥',96)] print(sorted(l2))#[('b哥', 96), ('大壮', 76), ('张珵', 98), ('纳钦', 94), ('雪飞', 70)] print(sorted(l2,key= lambda x:x[1])) # [('雪飞', 70), ('大壮', 76), ('纳钦', 94), ('b哥', 96), ('张珵', 98)]返回的是一个列表，默认从低到高 print(sorted(l2,key= lambda x:x[1],reverse=True)) #[('张珵', 98), ('b哥', 96), ('纳钦', 94), ('大壮', 76), ('雪飞', 70)] #和函数组合使用 #定义一个列表,然后根据元素的长度排序 lst = ['天龙八部', '西游记', '红楼梦', '三国演义'] #计算字符串的长度 def func(s): return len(s) print(sorted(lst, key=func))#['西游记', '红楼梦', '天龙八部', '三国演义'] #和lambda组合使用 lst = ['天龙八部', '西游记', '红楼梦', '三国演义'] print(sorted(lst, key=lambda s: len(s)))#['西游记', '红楼梦', '天龙八部', '三国演义'] #按照年龄对学生信息进行排序 lst = [{'id': 1, 'name': 'alex', 'age': 18}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 3, 'name': 'taibai', 'age': 16}, ] print(sorted(lst, key=lambda e: e['age']))#[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}] # filter()筛选过滤 类似于列表推导式的筛选模式 返回的是迭代器 语法: filter(function, iterable) function: 用来筛选的函数, 在filter中会自动的把iterable中的元素传递给function, 然后根据function返回的True或者False来判断是否保留此项数据 iterable: 可迭代对象 lst = [{'id': 1, 'name': 'alex', 'age': 18}, {'id': 1, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'taibai', 'age': 16}, ] ls = filter(lambda e: e['age'] > 16, lst) #返回的是迭代器 print(list(ls))#转化成列表 [{'id': 1, 'name': 'alex', 'age': 18}, {'id': 1, 'name': 'wusir', 'age': 17}] #列表推导式的筛选模式 l1 = [2, 3, 4, 1, 6, 7, 8] print([i for i in l1 if i > 3]) # 返回的是列表 l1 = [2, 3, 4, 1, 6, 7, 8] ret = filter(lambda x: x > 3,l1) # 返回的是迭代器 print(ret)#<filter object at 0x00000165B06D7F28> print(list(ret))#[4, 6, 7, 8] # map() 映射函数 类似于列表推导式的循环模式 返回的是迭代器 语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取出来执行function #列表推导式的循环模式 print([i**2 for i in range(1,6)]) # 返回的是列表 #[1, 4, 9, 16, 25] #计算每个元素的平方,返回新列表 ret = map(lambda x: x**2,range(1,6)) # 返回的是迭代器 print(ret)#<map object at 0x00000191237C7EB8> print(list(ret))#[1, 4, 9, 16, 25] # 计算两个列表中相同位置的数据的和 lst1 = [1, 2, 3, 4, 5] lst2 = [2, 4, 6, 8, 10] print(list(map(lambda x, y: x+y, lst1, lst2)))#[3, 6, 9, 12, 15] # reduce # 在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入 # reduce 的使用方式:reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行 from functools import reduce def func(x,y): return x + y ret = reduce(func,[3,4,5,6,7]) print(ret) # 结果 25 #普通函数版 from functools import reduce def func(x,y): return x * 10 + y l = reduce(func,[1,2,3,4]) print(l)#1234 第一次的时候 x是1, y是2 x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了 #匿名函数版 from functools import reduce l = reduce(lambda x,y:x*10+y,[1,2,3,4]) print(l)#1234 from functools import reduce def func(x,y): return x + y l = reduce(func,[11,2,3,4]) #第一次的时候取2个数据，之后都取1个。 print(l) ''' 第一次：x y : 11 2 x + y = 记录： 13 第二次：x = 13 y = 3 x + y = 记录： 16 第三次 x = 16 y = 4 ....... '''
   2. 闭包： 整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。 比如大众推出了一款新车：小白轿车。 第一天价格为：100000元，平均收盘价：100000元 第二天价格为：110000元，平均收盘价：（100000 + 110000）/2 元 第三天价格为：120000元，平均收盘价：（100000 + 110000 + 120000）/3 元

   

# 封闭的东西： 保证数据的安全。 # 方案一： 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(110000)) .....(多行代码) l1.append(666) print(make_averager(120000)) print(make_averager(90000)) # 方案二： 数据安全，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(110000)) .....（多行代码） print(make_averager(120000)) print(make_averager(90000)) # 方案三： 闭包 #在函数中嵌套了一个函数。avg 这个变量接收的实际是averager函数名，也就是其对应的内存地址，我执行了三次avg 也就是执行了三次averager这个函数。 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给avg avg得到了内层函数的内存地址，所以外层函数执行完后，只要有内层函数的内存地址，下面的print语句依然可以执行内层函数 print(avg(100000)) print(avg(110000)) print(avg(120000)) print(avg(190000)) ## 函数名.__code__.co_freevars 查看函数的自由变量 print(avg.__code__.co_freevars)#('l1',) # 函数名.__code__.co_varnames 查看函数的局部变量 print(avg.__code__.co_varnames)#('new_value', 'total') #获取具体的自由变量对象，也就是cell对象。 print(avg.__closure__)#(<cell at 0x0000029744E374C8: list object at 0x0000029744ECE948>,) #cell_contents 自由变量具体的值 print(avg.__closure__[0].cell_contents)#[] def func(): return 666 print(func)#<function func at 0x00000219A46C9AE8> 函数名指向函数的内存地址 print(globals())#不包含 'ret': 666 ret = func() print(globals())#包含 'ret': 666 闭包： 多用于面试题： 什么是闭包？ 闭包有什么作用。 闭包的定义： 1，闭包只能存在嵌套函数中。闭包是嵌套在函数中的函数 2，闭包必须是内层函数对外层函数非全局变量的引用（使用），就会形成闭包。【使用：可改变 引用：直接使用，如print()】 自由变量：被引用的非全局变量也称作自由变量，这个自由变量会与内层函数产生一个绑定关系，自由变量不会在内存中消失，而且全局还引用不到。 闭包的作用：保证数据的安全。保存局部信息不被销毁，保证数据的安全性。 闭包的应用：可以保存一些非全局变量但是不易被销毁、改变的数据。装饰器 # 如何判断一个嵌套函数是不是闭包 1，闭包只能存在嵌套函数中。 2，内层函数对外层函数非全局变量的引用（使用），就会形成闭包。 # 例1：是闭包 def wrapper(): a = 1 #a是自由变量 def inner(): print(a) return inner ret = wrapper() # 例2：也是闭包！【讲】 def wrapper(a,b): #传参相当于a=2,b=3,相当于在函数内重新定义变量，所以a,b都是外层函数的非全局变量，即a,b都是自由变量 def inner(): print(a) print(b) return inner a = 2 b = 3 ret = wrapper(a,b) print(ret.__code__.co_freevars) # ('a', 'b') #用几个就有几个自由变量 print(ret.__closure__)#(<cell at 0x000001F3155274C8: int object at 0x00000000513A6C30>, <cell at 0x000001F3155274F8: int object at 0x00000000513A6C50>) print(ret.__closure__[0].cell_contents)# 2 print(ret.__closure__[1].cell_contents)# 3 #例3： def wrapper(): count = 1 # 不可变数据类型 def inner(): nonlocal count #count是自由变量 count += 1 print(count) # 1 inner() print(count) # 2 return inner ret = wrapper() print(ret.__code__.co_freevars)#('count',) # 如何代码判断闭包？ def make_averager(): l1 = [] #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)

1. 总结
   • 匿名函数。
   • 内置函数。*** 一定要记住，敲3遍以上。 ** 尽量记住，2遍。
   • 闭包：多用于面试题： 什么是闭包？ 闭包有什么作用。