列表推导式

列表推导式格式为：

list1 = [表达式 for 变量 in 列表]
list2 = [表达式 for 变量 in 列表 if 条件]

例如：

old_list:list[int] = [1,2,3,4,5,6,7,8,9,10]  
new_list = [i for i in old_list if i % 2 == 0]

通过列表表达式来创建一个新列表，内部放入 old_list 列表中为偶数的值

list1 = [[1,2,3],[4,5,6],[7,8,9]]  
list2 = [num for row in list1 for num in row]  

通过列表表达式来拆解嵌套列表

list1 = ['红','蓝','橙','绿','黄']  
list2 = [1,2,3,4,5]  
list3 = [(a,b) for a in list1 for b in list2]

通过列表表达式可以构成笛卡尔积

字典推导式

字典推导式格式为：

dict1 = {键表达式: 值表达式 for 变量 in 列表}
dict2 = {键表达式: 值表达式 for 变量 in 列表 if 条件}

例如：

numbers = [1,2,3,4,5]
dict1 = {x: x**2 for x in numbers}

生成数字及其平方的字典

numbers = [1,2,3,4,5]
dict2 = {x: x**2 for x in numbers if x % 2 == 0}

加个判断就可以只找偶数的平方字典

names = ['A', 'B', 'C']
scores = [85, 92, 78]
dict1 = {name:score for name,score in zip(name,score)}

可以用两个列表创建一个字典，这里的 zip() 是为了同时迭代两个列表

dict1 = {'a':1,'b':2,'c':3,'d':4}  
dict2 = {v:k for k,v in dict1.items()}

可以通过字典表达式交换键值

集合推导式

集合推导式格式为：

set1 = {表达式 for 变量 in 列表}
set2 = {表达式 for 变量 in 列表 if 条件}

例如：

numbers = [1, 2, 3, 4, 5, 1, 2, 3]
set1 = {x**2 for x in numbers}

由于集合的性质，推导的值会自动去重

numbers = [1, 2, 3, 4, 5, 1, 2, 3]
set2 = {x**2 for x in numbers if x % 2 == 0}

同理，添加判断后只会有偶数值

list1 = [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
set1 = {num for row in list1 for num in row}

通过集合推导式，可以进行嵌套拆解后进行自动去重

生成器表达式

创建生成器表达式：

gen = (x**2 for x in range(5))
print(gen)  # <generator object <genexpr> at 0x...>

# 首次迭代
for value in gen:
    print(value)  # 0, 1, 4, 9, 16

# 再次迭代
for value in gen:
    print(value)  # 什么都不会输出

生成器表达式返回值是 generator ，并且是惰性执行，相比其他推导式的特点是节省内存，并且生成的值可以通过迭代器迭代一次

gen = (x**2 for x in range(5))

# 这些操作会耗尽生成器
list(gen)      # 转为列表
tuple(gen)     # 转为元组
set(gen)       # 转为集合
sum(gen)       # 求和
max(gen)       # 找最大值
min(gen)       # 找最小值
any(gen)       # 检查是否有True
all(gen)       # 检查是否全部True
for _ in gen:  # 循环遍历
    pass

# 这些不会耗尽，但只能看不能消耗
repr(gen)      # 只是字符串表示
str(gen)       # 只是字符串表示

最大的特点就是只能使用一次，并且几乎不占有内存，如果想要多次使用就推荐使用列表推导式，但是占用大量内存