函数-5
函数-5
目录
-
三元表达式
-
各种生成式
-
匿名函数
-
重要的内置函数
-
常见内置函数
三元表达式
-
三元表达式的使用
仅限于二选一的情况，并不建议嵌套使用
-
三元表达式的语法结构
值1 if 条件 else 值2
如果If 后面的条件成立 ， 则执行 if 前面的值
如果 if 后面的条件不成立， 则使用else后面的值
-
使用三元表达式的事例
s1 = '嘿嘿' if 0 else '哈哈'
s2 = '吼吼' if 1 else '嘻嘻'
print(s1) # 哈哈
print(s2) # 吼吼
# username = input('username>>>:').strip()
# if username == 'jason':print('欢迎')
# else:print('滚蛋')
# print('欢迎') if username == 'jason' else print('滚蛋')
三元表达式就是在判断两者的时候，条件成立执行前者，反之执行后者。
各种生成式
- 列表生成式
name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
new_list = [name + '_NB' for name in name_list]
"""先执行for循环，然后再将一个个的数据值交给for循环前面进行处理"""
推导过程：
1.先定义一个新的列表
2.循环原来的列表中的数据值
3.对数据值经行修改
4.追加到新列表中
new_list = []
for name in name_list:
new_name = name + '_NB'
new_list.append(nwe_name)
print(new_list)
列表生成式不但支持for循环，还支持if判断
执行if判断的时候，先执行for循环，然后将一个个的数据值交给if判断，最后的结果返回for循环前面处理
列表生成式中只能出现for和if
- 字典生成式
new_dict = {i: 'jason' for i in range(10) if i == 6}
print(new_dict) # {6: 'jason'}
先执行for循环，然后将一个个数据交给if 条件进行判断，最后的结果返回给for的前面进行处理
- 集合生成式
new_set = {i for i in range(10) if i == 6}
print(new_set)
先执行for循环，然后将一个个数据交给if 条件进行判断，最后的结果返回给for的前面进行处理
- 注意
元组没有所谓的生成式，元组的话所用的为迭代器
匿名函数
-
什么是匿名函数
匿名函数就是没有函数名
-
匿名函数的语法结构
lambda 形参 ： 返回值
-
匿名函数的应用场景
(lambda x: x + 1)(123) 直接调用
res = lambda x: x + 1 命名调用
print(res(123))
匿名函数通常都需要配合其他函数一起使用 用于减少代码
- 匿名函数结合内置函数
求最大值：max()
1.如果有多个数据在列表中， 需要求出其中的最大值，用max()直接可求出
l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = max(l1)
print(res) # 2123432
max()自动获取列表中的最大值
- 当用max()获取字典中V值最大值，需要匿名函数来参与调用完成
dic = {
'jason': 100,
'aj': 123,
'Bason': 9999999,
'zero': 888
}
def index(k):
return dic.get(k)
# res = max(dic, key=lambda k: dic.get(k))
"""
相当于利用for循环将字典中的K键 传给 lambda 后面的形参K
dic.get(k)为函数的返回值
利用其函数的返回值来进行大小的比较
"""
res = max(dic, key=index)
print(res) # Bason
当用max()直接获取最大值时，由于其底层相当于for循环。在字典参与for循环时，只有K键才参与，其比较的只是K键进行比对，若想用V值比较时，需用函数或匿名函数来进行调用。
3. 最小值 ：min()
和max()一致
重要的内置函数
- map( ) 映射
映射：把一个数据通过处理变成另外一个数据，并且数据之间一一对应。
l1 = [11, 22, 33, 44, 55, 66]
需求:将列表中所有的数据值自增20
方式1:for循环
方式2:列表生成式
方式3:map函数
res = map(lambda x: x + 20, l1)
print(res) # <map object at 0x000001954B581100>
print(list(res))
"""将l1的数据交给匿名函数X，得到返回值X+20.通过映射返回给res """
def index(a):
return a + 20
res = map(index, l1)
print(list(res))
- filter( )
通常用于过滤的功能，需要加入过滤的条件，过滤的对象是所包含的元素之一。
l1 = ['jason', 'kevin', 'oscar', 'tony']
需求:移除数据值里面的jason
方式1:for循环
方式2:列表生成式
方式3:filter()
res = filter(lambda a: a != 'jason', l1)
"""将l1的数据交给匿名函数a，若a不等于'jason'那么通过filter函数，过滤jason """
print(res) # <filter object at 0x00000195F21E6C70>
print(list(res)) # ['kevin', 'oscar', 'tony']
def index(a):
return a != 'jason'
res = filter(index, l1)
print(list(res))
- reduce( )
reduce 函数可将多个元素变成一个整体
l2 = [1, 2, 3]
需求:求列表中所有数据值的和
方式1:for循环
方式2:sum()
res = sum(l2) # 直接求和
print(res)
方式3:reduce() 将很多单体 变成一个整体
# 不能直接用，导不出reduce，在 from functools import reduce 中
res = reduce(lambda x, y: x + y, l2)
print(res)
reduce 原理：
当用reduce传值的时候，内部有一个机制，第一次取值的时候分别取两个数值，分别给X,Y
接下来就只传一个值。在最后还可以加一个值
- zip( )
zip()
n1 = [1, 2, 3]
n2 = ['jason', 'kevin', 'oscar']
res = zip(n1, n2)
print(res) # <zip object at 0x000002A9E38C7F40>
print(list(res))
n1 = [1, 2, 3, 4]
n2 = [5, 6, 7, 8]
n3 = 'jack'
res = zip(n1, n2, n3)
print(list(res))
n1 = [1, 2, 3, 4, 5, 6, 7]
n2 = [5, 6, 7, 8]
n3 = 'jason'
res = zip(n1, n2, n3)
print(list(res))
zip函数可以拼接多个数据值
相当于基于for循环 ，依此去取每一个里面的数据值，然后zip函数自动做拼接操作。若元素不一致，按最少元素的个数来拼接。
多层装饰器的执行流程
def outter1(func1):
print('加载了outter1')
def wrapper1(*args, **kwargs):
print('执行了wrapper1')
res1 = func1(*args, **kwargs)
return res1
return wrapper1
def outter2(func2):
print('加载了outter2')
def wrapper2(*args, **kwargs):
print('执行了wrapper2')
res2 = func2(*args, **kwargs)
return res2
return wrapper2
def outter3(func3):
print('加载了outter3')
def wrapper3(*args, **kwargs):
print('执行了wrapper3')
res3 = func3(*args, **kwargs)
return res3
return wrapper3
@outter1 # index = outter1(wrapper2)
@outter2 # wrapper2 = outter2(wrapper3)
@outter3 # wrapper3 = outter3(index函数名)
def index():
print('from index')
1.先执行outter3()函数，然后打印''加载了outter3"
2.在内部进行了wrapper3，直接返回wrapper3
3.由于语法糖上还有语法糖，故接着执行outter2(wrapper3)
4.打印”加载了outter2“,
5.在内部进行了wrapper2
6.返回wrapper2
7.执行outter 1(wrapper2)
8.打印”加载了outter1“
9.在内部进行了wrapper1
10.返回wrapper1.
11.由于上面没有语法糖，故而将同函数名相同的变量名接收wrapper1，
12.开始执行操作，先执行wrapper1
13.打印”执行了wrapper1
14.“然后执行func1(*args, **kwargs)
15.此时func1 为wrapper2 ，故而执行wrapper2（）
16.打印"执行了wrapper2"，
17.随后执行func2，
18.此时func2 为wrapper3 ，故而执行wrapper3（），
19.打印”执行了wrapper3“
20.返回值res。返回给index。
21.打印‘from index’
** 有参装饰器的执行流程**
def outer(condition):
def login_auth(func_name): # 这里不能再填写其他形参
def inner(*args, **kwargs): # 这里不能再填写非被装饰对象所需的参数
username = input('username>>>:').strip()
password = input('password>>>:').strip()
# 应该根据用户的需求执行不同的代码
if condition == '列表':
print('使用列表作为数据来源 比对用户数据')
elif condition == '字典':
print('使用字典作为数据来源 比对用户数据')
elif condition == '文件':
print('使用文件作为数据来源 比对用户数据')
else:
print('去你妹的 我目前只有上面几种方式')
return inner
return login_auth
@outer('文件','jason')
def index():
print('from index')
index()
1.先看语法糖，执行outer函数
2.紧接着执行login_auth()函数，
3.返回值 login_auth
4.@outer('文件','jason')就相当于@login_auth ,
5.就是正常的装饰器了。把index传给login_auth
6.执行inner
7.需要经行判断的时候加参数到外层语法糖，
8.返回值inner
9.将返回值赋值给与index函数同名的变量。
10.打印出结果
浙公网安备 33010602011771号