各种生成式
# 1.列表生成式
name_list = ['jason','kevin','oscar','jerry','tony']
# 给上述列表中所有的数据值加上_NB的后缀(for循环)
# new_list = []
# for name in name_list:
# new_name = f'{name}_NB'
# new_list.append(new_name)
# print(new_list) # ['jason_NB', 'kevin_NB', 'oscar_NB', 'jerry_NB', 'tony_NB']
# 用列表生成式实现
# new_list = [f'{name}_NB' for name in name_list]
# print(new_list) # ['jason_NB', 'kevin_NB', 'oscar_NB', 'jerry_NB', 'tony_NB']
# 此外，列表生成式还支持if判断，先执行for循环，然后将一个个元素交给if判断，结果为True则最后交给for循环处理
# new_list = [f'{name}_NB' for name in name_list if name =='jason']
# print(new_list) # ['jason_NB']
'''列表生成式中只能出现for和if'''
# 字典生成式
# new_dict = {i:k for i in range(1,5) for k in range(10,15) if i ==1}
# print(new_dict) # {1: 14}
# 集合生成式(和列表生成式差不多)
# new_set = {i for i in range(0,5)}
# print(new_set) # {0, 1, 2, 3, 4}
# 元组生成器(迭代器)
new_tuple = (i for i in range(0,5))
print(new_tuple) # <generator object <genexpr> at 0x10f1be580>
'''针对元组没有生成器，它是一种迭代器'''
匿名函数
匿名函数就是没有函数名的函数
语法结构
lambda [行参]：[返回值]
具体案例：
# 匿名函数其实就是没有函数名的函数
# res = (lambda x:x+2) 命名调用
# print(res(123)) # 125
print((lambda x: x + 2)(100)) # 102 直接调用
应用场景
匿名函数通常都需要配合其他函数一起使用，用于减少代码
匿名集合内置函数使用
# max() # 求最大值
"""
max([字典]，key=[函数名]):max第一个参数为所要传入的字典，第二个参数为返回字典值的函数名
"""
l1 = [111,22,44,88,234,23,45,88,92,3333,55,123,45,76,99,1234]
res =max(l1)
print(res) # 3333
dic = {
'jason':100,
'aj':123,
'tom':2345,
'lili':100000
}
# res1= max(dic,key=lambda k:dic.get(k))
# print(res1) # lili
def index(k):
return dic.get(k)
res1 =max(dic,key=index)
print(res1) # lili
重要内置函数
# map()
# l1 = [11,22,33,44,55,66]
# 需求：将列表中所有的数据值自增20
# 方式1：for循环
# l2 = []
# for i in l1:
# j = i+20
# l2.append(j)
# print(l2) # [31, 42, 53, 64, 75, 86]
# 方式2：列表生成式
# l2 =[i+20 for i in l1]
# print(l2) # [31, 42, 53, 64, 75, 86]
# 方式3：map函数
# res = map(lambda x:x+20,l1) # (func, *iterables) 第一个参数为函数名或者匿名函数，第二个为可变长可迭代的容器
# print(res) # <map object at 0x100ed2250> 返回一个迭代器
# print(list(res)) # [31, 42, 53, 64, 75, 86]
# filter() 筛选 (function_or_None, iterable) 第一个为函数名或者匿名函数，第二个为可迭代的容器
# l1 = ['jason','kevin','tony','jack']
# 需求：移除列表中的'jason'
# res = filter(lambda x: x !='jason',l1)
# print(l1) # ['jason', 'kevin', 'tony', 'jack']
# reduce() 将容器内元素通过两个不断相加，然后求出总和
# l2 = [22,33,44]
from functools import reduce
# res = reduce(lambda x,y:x+y,l2)
# print(res) # 99
# res = reduce(lambda x,y:x+y,l2,1000)
# print(res) # 1099
# zip() # 将容器内的元素按位置一一对应，然后返回一个新的迭代器对象，一一对应的值组织成元组的形式存储在此容易
# 注意：因为集合是无序的，所以当zip方法内有集合元素时，不是按照{}内位置取元素
l1 = [1,2,3,4,5]
dict1= {'name':'jason','age':18,'gender':'man','hobby':'read'}
set1 ={11,22,33,44,55}
res= zip(l1,dict1,set1)
print(res) # <zip object at 0x10adf5100>
print(list(res)) # [(1, 'name', 33), (2, 'age', 11), (3, 'gender', 44), (4, 'hobby', 22)]
将有参装饰器用文字具体描述出来
def outter1(func1): # func1 = wrapper2
print('加载了outter1')
def wrapper1(*args, **kwargs):
print('执行了wrapper1')
res1 = func1(*args, **kwargs)
return res1
return wrapper1
def outter2(func2): # func2 = wrapper3
print('加载了outter2')
def wrapper2(*args, **kwargs):
print('执行了wrapper2')
res2 = func2(*args, **kwargs)
return res2
return wrapper2
def outter3(func3): # func3=index
print('加载了outter3')
def wrapper3(*args, **kwargs):
print('执行了wrapper3')
res3 = func3(*args, **kwargs)
return res3
return wrapper3
@outter1 # wrapper1=outter1(wrapper2)
@outter2 # wrapper2=outter2(wrapper3)
@outter3 # wrapper3=outter3(index)
def index():
print('from index')
index()
"""
1.当函数体含有多层语法糖装饰器时，语法糖会从下往上顺序执行
2.先加载了outter3函数，此函数内传了'真正的index函数名'，返回了wrapper3函数名--> wrapper3=outter3(index)
3.语法糖往上执行，加载到了outter2函数，此函数内传了刚刚返回的wrapper3函数名，返回的是wrapper2 -->wrapper2=outter2(wrapper3)
4.当检测到上面还有语法糖，就会继续向上加载ouuter1函数，此函数内传了刚刚返回的wrapper2，返回的是wrapper1 ，但再向上无语法糖，所以
第三层语法糖-->index =outter1(wrapper2),然后加载内部函数wrapper1
5.然后加载了wrapper1函数，当走到res1 = func1(*args, **kwargs)时因fun1此时传入的是wrapper2，所以加载wrapper2函数
6.当又走到res2 = func2(*args, **kwargs)时，传入的是wrapper3，又去加载wrapper3函数
7.因wrapper3的参数为真正的index函数名，所以最后加载index函数体代码
8.最后按顺序返回返回值res3,res2,res1
输出结果为：
加载了outter3
加载了outter2
加载了outter1
执行了wrapper1
执行了wrapper2
执行了wrapper3
"""
