三元表达式，各种生成式，匿名函数相关知识点

知识点1：三元表达式

1.1 三元表达式的结构

值1 if 条件 else 值2
执行的流程 ：条件成立则使用：值1，条件不成立则使用：值2

1.2 三元表达式的实践

# 练习1 得到两个值中最大值的函数
def get_max(a, b):
    if a > b:
        return a
    return b


# 加入三元表达式
def get_max(a, b):
    return a if a > b else b


print(get_max(1, 100))  # 100


# 练习2
res = 100 if 10 < 20 else (200 if 1 else (300 if 'z' < 'a' else 400))
print(res)  # 100

1.3 结论

python中不是说代码越简洁越好，在精简的过程中还要具备代码的可读性。

知识点2 各种生成式

2.1 列表生成式

2.1.1 列表生成式的推导过程

# 目标：给下面列表中的每一个数据值后面加上 'AAA'

# 方法1 for循环的方法
list1 = ['a', 'b', 'c', 'd', 'e', 'f']
new_list = []
for i in list1:
    if i != 'a':
        i = i + 'AAA'
        new_list.append(i)

print(new_list)  # ['bAAA', 'cAAA', 'dAAA', 'eAAA', 'fAAA']

# 方法2 列表生成式
new_list = [i + 'AAA' for i in list1 if i != 'a']
print(new_list)  # ['bAAA', 'cAAA', 'dAAA', 'eAAA', 'fAAA']

2.1.2 列表生成式执行流程

先执行for循环，然后将一个个数据值交给for循环前面进行处理，如果for循环后面还有if判断，把判断条件符合的，交给for循环前面进行处理

2.2 字典生成式

2.2.1 字典生成式

new_dict = {i: 'jason' for i in range(6) if i != 6}
print(new_dict)  # {0: 'jason', 1: 'jason', 2: 'jason', 3: 'jason', 4: 'jason', 5: 'jason'}

2.2.2 字典生成式的执行流程

先执行for循环， 然后将一个个符合if条件的数据值给到for循环前面依次作为字典的键，加上默认的值生成一个字典

2.3 集合生成式

2.3.1 集合生成式

# 集合生成式
new_set = {i for i in range(10) if i > 5}
print(new_set)  # {8, 9, 6, 7}

2.3.2 集合生成式的执行流程

先执行for循环， 然后将一个个符合if条件的数据值给到for循环前面作为集合的数据值，最后生成一个集合

知识点3 匿名函数

3.1 语法结构

lambda 形参: 返回值

3.2使用场景

通常是搭配其他函数使用，用于减少代码量

3.3 实践

# 自定义函数
def add(a):
    return a + 1


print(add(1))

# 匿名函数
print((lambda a: a + 1)(1))

知识点4 匿名集合内置函数

4.1 max() 最大值

l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(max(l1))  # 10

# 特例:字典使用max()，参与执行的是键，并非值
dic1 = {
    'wang': 10000,
    'zhang': 10,
    'li': 2000,
    'ming': 30000
}

print(max(dic1))  # zhang
# a-z 97-122
# A-Z 65-90

dic1 = {
    'wang': 10000,
    'zhang': 10,
    'li': 2000,
    'ming': 30000
}


def get_value(k):
    return dic1.get(k)


res = max(dic1, key=lambda k: get_value(k))
print(dic1.get(res))  # 30000

4.2 min() 最小值

l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(min(l1))  # 1

知识点5 重要内置函数

5.1 map() 映射

5.1.1 使用场景（当要对一个集体中的每个元素值进行相同的操作时，可以使用map）

# 需求：把下面列表中的每一个数据值加10
def add(a):
    return a + 10


res = map(add, l1)
print(list(res))  # [11, 12, 13, 14, 15, 16]


l1 = [1, 2, 3, 4, 5, 6]
res = map(lambda x: x + 10, l1)
print(list(res))  # [11, 12, 13, 14, 15, 16]

5.2 fileter() 过滤

5.2.1 使用场景（当一个集体中需要剔除某个元素时使用）

l1 = ['wang', 'zhang', 'li', 'zhao']


def filter_one(x):
    return x != 'wang'


res = filter(filter_one, l1)
print(list(res))  # ['zhang', 'li', 'zhao']

res = filter(lambda a: a != 'wang', l1)
print(list(res))  # ['zhang', 'li', 'zhao']

5.3 reduce()

5.3.1 使用场景（将很多单体 变成一个整体）

# 需求：求列表中所有数据的和  求列表中所有数据再加上列表之外一个数字的和
l1 = [1, 2, 3, 4, 5, 6]

from functools import reduce

res = reduce(lambda x, y: x + y, l1)
res1 = reduce(lambda x, y: x + y, l1, 100)

print(res)  # 21
print(res1)  # 121

5.4 zip() 拉链

5.4.1 使用场景（把多个不同集体中的数据值单独拿出来，按照相同的顺序组合成多个元组，多个元组再组成一个列表）

l1 = [1, 2, 3, 4, 5, 6]
l2 = ['a', 'b', 'c', 'd', 'e']
s1 = 'jason'
res = zip(l1, l2, s1)
print(list(res))  # [(1, 'a', 'j'), (2, 'b', 'a'), (3, 'c', 's'), (4, 'd', 'o'), (5, 'e', 'n')]

作业：

1：用自己的语言描述多层装饰器：

总结:定义阶段：从里层向外层执行，调用阶段：从外层向里层执行，最后执行真正被装饰的函数。

下面以两层装饰器为例：
1.1定义阶段：
先执行被装饰函数上面的第一个装饰器，原本正常情况下是：正真被装饰函数名=里层装饰器名(真正被装饰函数名)，但是由于里层装饰器外面又套了一层装饰器，所以里层装饰器返回的函数名将代替真正被装饰的函数名，被外层装饰器装饰，以参数的形式传给外层装饰器，这时外层装饰器返回的函数名将接收这一结果，但是由于外层再无装饰器，所以真正的被装饰函数将代替外层装饰器返回的函数名接收这一结果，即：真正被装饰函数名=外层装饰器名(里层返回的函数名)

1.2调用阶段：
首先是真正的函数名()调用,由于定义阶段最后:真正被装饰的函数名=外层装饰器的里层函数名，所以就相当于是在调用外层装饰器的里层函数，所以外层装饰器最先执行，由于定义阶段外层装饰器传入的参数是里层装饰器的内层函数名，给它加括号就是在调用它，所以直接跳转到里层装饰器执行，而定义阶段里层装饰器传入的参数是真正的被装饰函数，所以最后调用真正的被装饰函数，真正被装饰的函数被执行，最后装饰器由内向外依次返回。

2：用自己的语言描述有参装饰器:

首先有参装饰器把参数传给装饰器内部函数，返回一个函数名，@+这个函数名就是一个装饰器，接着真正的被装饰函数名被传给装饰器执行，最后返回执行的结果。