三元表达式，生成式，内置函数，常见内置函数

7.7日每日精品总结

今日内容概要

1.三元表达式（主要是应对于二选一的情况下减少代码的行数）

2.各种生成式

3.匿名函数（没有名字的函数）

4.匿名函数内置函数使用

5.重要内置函数

6.常见内置函数

 

1.三元表达式

1.1何为三元表达式？？？？

三元表达式是python为我们提供的一种简化代码（多行变一行）的解决方案

eg：

编写一个函数 比较两个数的大小 返回较大的那个

def my_max(a, b):
    if a > b:
        return a
    else:
        return b
res = my_max(1, 10)
print(res)
    #一般来讲，写出这段代码需要五六行，显得非常的多，下面展示三元表达式的写法
def my_max(a, b):
    return a if a > b else b（三元表达式写法）
res = my_max(1, 10)
print(res)

#显然，三元表达式的写法就非常的简便，那么三元表达式的语法结构又是怎样的呢？
1.2三元表达式的语法结构

'''
主体：
    值1  if  条件  else  值二
流程：
    先看条件，如果if条件如果if后面的条件成立 则使用if前面的值
    如果if后面的条件不成立 则使用else后面的值
'''
#下面再看个案例：
username = input('username>>>:').strip()
                # .strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
    #普通代码
if username == 'jason':print('欢迎')
else:print('滚蛋')
     #三元表达式代码
print('欢迎') if username == 'jason' else print('滚蛋')
        #可见三元表达式将原本两行代码转为一行代码，这段代码先进行判断输入的内容是否等于'jason'，是则执行print('欢迎')，不是则执行print('滚蛋')

注意：但是在python中代码不是精简的越少越好 在精简的过程中还要保证代码的可读性↓
    

res = 123 if 10 > 5 else (222 if 0 else (666 if 1 == 2 else 666))

这段代码虽然很精简，但是他却妨碍了我们的阅读，所以最好是在两个值之间的时候运用三元表达式
2.各种生成式
2.1.列表生成式

name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
    # 给上述列表中所有的数据值加上_NB的后缀
    # 1.定义一个新的列表
    # new_list = []
    # 2.循环原列表中所有的数据值
    # for name in name_list:
    # 3.拼接_NB后缀
    # new_name = name + '_NB'
    # 4.追加到新列表中
    # new_list.append(new_name)
    # print(new_list)

显然用老办法确实过于复杂，下面是列表生成器用一行代码就可以实现

"""一行代码解决:  列表生成式"""
    # new_list = [name + '_NB' for name in name_list]  先执行for循环 然后将一个个的数据值交给for循环前面处理
    # print(new_list)
    # 还支持if判断   先执行for循环 然后将一个个的数据值交给if判断 结果为True则最后交给for循环前面处理
    # new_list = [name + '_NB' for name in name_list if name != 'jason']
    # print(new_list)
    # 列表生成式中只能出现for和if

列表生成式不但支持for循环，还支持if判断，执行if判断的时候，先执行for循环，然后将一个个的数据值交给if判断，最后的结果返回for循环前面处理，列表生成式中只能出现for和if

2.2.字典生成式

new_dict = {i: 'jason' for i in range(10) if i == 6}
print(new_dict)  # {6: 'jason'}

字典生成器同样先执行for后面的语句，然后交给if进行判断，成立则执行for前面的内容，不成立则执行下一步，直到for循环结束，最后得出的结果是一个字典

2.3.集合生成式

new_set = {i for i in range(10) if i == 6}
print(new_set)

与字典生成器一样，不过最后得出的结果只是一个集合

2.4.针对元组

"""
new_tuple = (i for i in range(10))
print(new_tuple)  <generator object <genexpr> at 0x000001E62B8ED740>
​
针对元组没有所谓的生成式一说 它是后面重点讲解的迭代器知识(生成器)
"""

 

 

3.匿名函数

在Python中，有时候我们需要一个简单的函数去返回一些结果，但是我们又不想通过 def 专门去定义函数再引用，这种情况下有没有好的办法来完成呢？

答案是使用匿名函数，而Python中的匿名函数通过 lambda 表达式来完成。

​

#当我们使用匿名函数时， lambda 只是一个表达式，它并不是一个代码块
语法结构
    lambda 形参: 返回值
具体案例
    (lambda x: x + 1)(123)  直接调用
    res = lambda x: x + 1  命名调用
         #lambda x是匿名函数的声明部分，而 x + 1则是匿名函数的实现部分
     print(res(123))
    命名调用流程：先执行res(123)这个函数，再执行lambda x: x + 1，再将所得到的值传给res，最后打印出结果
应用场景
    匿名函数通常都需要配合其他函数一起使用 用于减少代码

 

​

4.匿名集合内置函数使用

#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)
dic = {                 #字典
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}
​
def index(k):           #定义了一个index函数 同时传了k作为参数
    return dic.get(k)           #返回取到的v的值
# res = max(dic, key=lambda k: dic.get(k))
res = max(dic, key=index)   #先执行等号右边的函数在将最后执行完毕的最大的v所对应的key赋值给res
print(res)  # Bason
​
​
​
# print('A' > 'a')
"""
A-Z   65-90  #ASCII码值
a-z   97-122
"""

 

5重要内置函数

min()  最小值
map()  映射
​
# 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))
# 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)
# 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()
# l2 = [1, 2, 3]
# 需求:求列表中所有数据值的和
# 方式1:for循环
# 方式2:sum()
# res = sum(l2)
# print(res)
# 方式3:reduce()   将很多单体 变成一个整体
# from functools import reduce
#
# res = reduce(lambda x, y: x + y, l2, 100)
# res = reduce(lambda x, y: x + y, l2, 100)
# print(res)
​
​
# 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))

多层装饰器的执行流程

多层装饰器就是多个装饰器叠加使用

1．要执行的是语法糖，当然，多层装饰器自然有多个语法糖，看语法糖的顺序要从下往上看，直到遇到最后一个语法糖的时候才会使用形同的变量名传给装饰器函数使用。

现在定义仅有三个语法糖：

2.那么先执行语法糖三，将index作为参数传给outer3>outer3(index)

3.执行outer3(index)这个函数

4.打印 ‘加载了outer3‘

5.返回wrapper3  返回的wrapper3 = outer3(index)

6.随后执行@outer2这个语法糖步骤和语法糖三一样

7. 执行outer2(wrapper3)这个函数

8（打印‘加载了outer2‘）.

9返回wrapper2  返回的wrapper2 = outer2(wrapper3)

10.随后执行@outer1这个语法糖步骤和语法糖三二一样但是由于这是最后一个语法糖，所以这个时候就会使用相同的变量名给装饰器函数使用（index = outer1（wapper2））

11. 执行outer1(wrapper2)这个函数

12（打印‘加载了outer1‘）

13返回wrapper1  返回的wrapper1 = index = outer1(wrapper2)

14.执行wrapper1()

15打印‘执行了wrapper1‘

16，执行等号右边的代码，再用res1接收

17.18．19．20.21.流程同wrapper1（）

22.此时fun3是index，所以要执行index（）

23执行index函数内部代码