Day 13 内置函数二，闭包

print(abs(-0.5))--绝对值
lst = [1,2,-3,-5,6]
print([abs(i) for i in lst])

enumerate('可迭代对对象','序号的起始值') 默认起始值为0
lst = [1,2,-3,-5,6]
print([i for i in enumerate(lst)])

max('123456') #求最大值
print(max('123456'))
min('123456') #求最小值
print(min('123456'))
sum([1,2,3,4,5])#求和
print(sum([1,2,3,4,5],100))

print(sep='',end='')
print(1,2,3,sep='*')
print(1,end='\t')
print(3,end=' ')
print(2)

print(12345,file=open('al.txt','w',encoding='utf-8'))

print(list('alex'))#['a', 'l', 'e', 'x']

print(dict(key=1,a='alex'))
print(dict([i for i in enumerate(range(20),3)]))
print(dict(((1,2),(2,3),(3,4))))

zip()#拉链--按照数量最小的合并
lst1 = [1,2,3,4,5]
lst2 = ['a','b','c','d','e','f']
lst3 = ['alex','wusir','bao','yuan']
print(list(zip(lst1,lst2)))#面试题
print(list(zip(lst1,lst2,lst3)))#面试题
print(dict(zip(lst1,lst2))) # 面试题

dir(list)#查询当前函数的所有方法

def func(a,b):
return a+b
print(func(1,2))

匿名函数:重要
f = lambda x,y:x+y
print(f(1,2))

def func():
return 1
print(func())
print((lambda x:x)(2)) # 同一行定义 同一行调用

lambda 关键字--定义函数--一行函数**********
x,y 形参
:x+y 返回值--只能返回一个数据类型

print(f.name) 匿名函数的名字 lambda

print((lambda x:[i for i in x])([1,2,3,4,5])) #同一行定义 同一行调用

lst = [lambda i:i*i for a in range(10)]
print(lst9)

lst = []
for a in range(10):
def func(i):
return i*i
lst.append(func)
print(lst2)

lst = [lambda :i*i for i in range(10)]
print(lst2)

for i in range(10):
pass
print(i)

lst = []
for i in range(10):
def func():
return i*i
lst.append(func)
print(lst2)

lst = list((lambda i:i*i for i in range(5)))
print(lst2)

lst = [x for x in (lambda :i**i for i in range(5))]
print(lst2)

lst1 = []
def func():
for i in range(5):
def foo():
return i**i
yield foo

for x in func():
lst1.append(x)
print(lst12)

一行函数
形参可以不写，实参一定要写
print(lambda 😃
print(lambda :x)

format()重要

print(format(13,">20")) # 右对齐
print(format(13,"<20")) # 左对齐
print(format(13,"^20")) # 居中
print(format(13,'b'))
print(format(12,'08b')) 2进制
print(format(12,'08d')) 10进制
print(format(12,'08o')) 8进制
print(format(12,'08x')) 16进制

filter()#过滤 重要
lst = [1,2,3,4,5,6,7]
def func(s):
return s > 3
print(list(filter(func,lst)))#func就是自己定义的一个过滤条件，lst要迭代对象

lst = [1,2,3,4,5,6,7]
print(list(filter(lambda x:x % 2 == 1,lst)))

map(#对象映射)重要
print(list(map(lambda x:x+1,[1,2,3,4,6,8])))
对可迭代对象中每个元素进行加工

reversed()#反转重要

lst = [1,2,3,4,5]
lst.reverse()
print(lst)

lst1 = list(reversed(lst))
print(lst)
print(lst1)

print(list(reversed('alex')))
lst = [1,2,3,4]
lst1 = list(reversed(lst))
print(lst)
print(lst1)

lst = [1,23,34,4,5,213,123,41,12,32,1]
print(sorted(lst)) # 升序
print(lst)

lst = [1,23,34,4,5,213,123,41,12,32,1]
print(sorted(lst,reverse=True)) # 降序

sorted()#排序重要
print(sorted([1,23,445,32,34,4,3,21]))

dic = {'key':1,'key1':2,'key2':3}
print(sorted(dic,key =lambda x:dic[x],reverse=True)) #制定排序规则

print(max([1,2,34,-33,4],key=abs))

from functools import reduce
reduce()累计算重要
print(reduce(lambda x,y:x-y,[1,2,3,4,5]))

闭包
def func():
a = 1
def f1():
def foo():
print(a)
return foo
return f1
ret = func()
a = ret()
a()

avg_lst = []
def func(pirce):
avg_lst.append(pirce)
avg = sum(avg_lst) / len(avg_lst)
return avg
print(func(150000))
print(func(160000))
print(func(170000))
print(func(150000))
avg_lst.append(18888888)

def func(pirce):
avg_lst = []
avg_lst.append(pirce)
avg = sum(avg_lst) / len(avg_lst)
return avg
print(func(150000))
print(func(160000))
print(func(170000))
print(func(150000))

def func():
avg_lst = [] # 自由变量
def foo(pirce):
avg_lst.append(pirce)
avg = sum(avg_lst) / len(avg_lst)
return avg
return foo
ret = func()()

print(ret(150000))
print(ret(160000))
print(ret(170000))
print(ret(150000))
print(ret(180000))
print(ret.closure)
(<cell at 0x0000018E93148588: list object at 0x0000018E931D9B08>,)

1.在嵌套函数内，使用非全局变量就是闭包(使用上一层变量，且不是本层变量)
闭包的作用：保证数据的安全（干净度）
print(ret.closure)#判断是否是闭包
print(ret.code.co_freevars)#获取自由变量
print(ret.code.co_varname)#获取局部变量
2.装饰器的本质
装饰器的本质就是闭包

总结
1.内置函数二
1.1匿名函数 lambda
lambda 形参:返回值--lambda x:x
形参可以不写，实参必须写，返回值只能是一个数据类型
匿名函数的名字叫lambda
1.2 abs() 绝对值
1.3 filter('函数名'，'可迭代对象')自己写函数的时候，可以制定过滤条件
1.4 map('函数名'，'可迭代对象') 写函数的时候，可以制定对元素的操作
1.4 zip('可迭代对象'，'可迭代对象') 返回的是[(1,2),(2,3),(3,4)]
1.4 sorted('可迭代对象'，key = '函数名',reverse = True) 指定函数的规则(默认是升序，写了reverse就是降序)
1.4 reversed('可迭代对象') #对可迭代对现象进行翻转，不可改变源数据
1.4 max('可迭代对象'，key = abs) #指定查找最大值的规则
1.4 min('可迭代对象'，key = abs) #指定查找最小值的规则
1.4 sum(list,tuple,set) #指定查找最小值的规则
1.4 reduce('函数','可迭代对象') #函数指定类计算的方式
1.4 format('函数','可迭代对象') #08b-2,08d-10,08o-8,08x-16

2.闭包
在嵌套函数内，不使用全局变量就是闭包.
闭包干啥:保证数据安全性，装饰器使用