匿名函数-内置函数2-闭包

一、匿名函数

此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如

lambda是定义匿名函数的关键字，相当于函数的def

lambda后面直接加形参，形参加多少都可以，只要用逗号隔开就行。

返回值在冒号之后设置，返回值和正常的函数一样，可以说任意数据类型。

一句话函数，比较简单的函数。不管多复杂，只能写一行，且逻辑结束后直接返回函数

构建匿名函数

def func(a, b):
    return a + b
​
​
func1 = lambda a, b: a + b  # lambda相当于def定义函数，：之前的是形参，之后的是返回值
print(func1(1, 2))

接受两个int参数，将较大的数据返回。

f = lambda a, b: a if a > b else b

二、内置函数（2）重点

print（）：——屏幕输出。

int（）：——整数型

str（）：——字符型

list（）：——列表

tuple（）：——元组

abs（）：——返回绝对值

sum（）：——求和（可迭代对象，可设置初始值）

reversed（）：——将一个原列表翻转，返回的是一个翻转的迭代器。

bytes（）：——把字符串转成bytes

zip（）：——拉链方法

l1 = [1,2,3,4,5]
tul = ('小杨','小哥','刚刚')
s1 = 'abcd'
obj = zip(l1,tul,s1)
for i in obj:
    print(i)
​
(1, '小杨', 'a')
(2, '小哥', 'b')
(3, '刚刚', 'c')

********以下方法最重要。

凡是可以加key的：他会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中。

min（）：——求最小值 max（）：求最大值

以绝对值去取最大或最小

以返回值比大小

ll = [1, 22, 4, 5, 1, -5, 66, 65, 95, 12, 45, 1, -15, 48, 7]
print(max(ll, key=abs))
print(min(ll, key=abs))
# 输出
95
1

如果比较的是字典：默认会按照字典的键去比较大小。

会把 dic 的键取出来给 key 对应的函数，返回键所对应的值给min（）做比较，默认返回键

 # 求出值最小的键
 dic = {'a': 3, 'b': 2, 'c': 1}
 m = min(dic, key=lambda a: dic[a])  
 print(m)
 # 输出
 c 

sorted：——排序函数，排序成为一个新列表。

按照数字进行降序排序

ll = [('tai', 18), ('lsk', 73), ('asd', 50)]
s = sorted(ll, key=lambda x: x[1], reverse=True)
print(s)
# 输出
[('lsk', 73), ('asd', 50), ('tai', 18)]

filter：——列表推导式的筛选模式。列表推导式返回的是列表。filter返回的是迭代器

循环遍历ll的元素，把 ll 每个元素传到函数中的x，以返回值是真的留下来

ll = [2, 3, 4, 1, 5, 6, 7, 8]
f = filter(lambda x: x > 3, ll)
print(f)          # 返回的是一个迭代器
print(list(f))
# 输出
<filter object at 0x018E38E0>
[4, 5, 6, 7, 8]

map：——列表推导式的循环模式

f = map(lambda x: x ** 2, range(1, 6))
print(f)
print(list(f))
# 输出
<map object at 0x0223B6D0>
[1, 4, 9, 16, 25]

reduce：——在 from functools import reduce

from functools import reduce

def func(x,y):
    '''
    第一次： x = 11  y = 2   x + y =    记录：13
    第二次： x = 13  y = 3   x + y =    记录：16
    第二次： x = 16  y = 4   x + y =    记录：20
    '''
    return x + y

ll = reduce(func,[11,2,3,4,])
print(ll)
# 输出
20

三、闭包：封闭的东西，保证数据的安全。

举例

整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。

比如大众推出了一款新车：玩具车。

第一天价格为：100元，平均收盘价：100元

第二天价格为：110元，平均收盘价：（100 + 110）/2 元

第三天价格为：150元，平均收盘价：（100+ 110+ 150）/3 元

方案一：ll 会被误更导致数据出错

ll = []
def _average(count):
    ll.append(count)        # 每次新增给全局变量ll
    av = sum(ll) / len(ll)
    return av


print(_average(100))
print(_average(110))
'''
N多代码....
不小心给ll被更改
ll.append(10)
就会造成后面的数据出错
'''
print(_average(150))
print(_average(200))
# 输出：
100.0
105.0
120.0
140.0

方案二：闭包

def _average():
    ll = []                 # ll 为自由变量，和内层函数age做了绑定，在全局也找不到
    def age(count):
        ll.append(count)
        av = sum(ll) / len(ll)
        return av
    return age
​
ave = _average()
print(ave(100))
print(ave(110))
print(ave(150))
print(ave(200))
# 输出
100.0
105.0
120.0
140.0

闭包只能存在嵌套的函数中

闭包定义：内层函数对外层函数非全局变量的引用（使用），就会形成闭包。

被引用的非全局变量也称作为自由变量，这个自由变量会与内层函数产生一个绑定关系。

自由变量不会在内存中消失。

闭包的作用：保障数据安全。

如何用代码判断闭包：

# 是否是闭包？
def wrapper(a,b):
    '''
    相当于此处添加了两个变量
    a = 2
    b = 3
    '''
    def inner():
        print(a)
        print(b)
    return inner
​
a = 2
b = 3
ret = wrapper(a,b)
print(ret.__code__.co_freevars)
# 输出
('a', 'b')     # 这就是ret绑定的自由变量