# Python推导式使用详情

## 推导式

### 什么是推导式

val for val in Iterable

• 列表推导试：[val for val in Iterable]
• 集合推导式：{val for val in Iterable}
• 字典推导式：{x,y for x,y in Iterable}

### 基本语法

```# 常规写法
lst = []
for i in range(1, 11):
lst.append(i)
print(lst)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 推导式写法
lst = [i for i in range(1, 11)]
print(lst)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

### 其它使用方法

```# 处理容器中的数据：[1, 2, 3, 4, 5] -> [3, 6, 9, 12, 15]
lst = [1, 2, 3, 4, 5]
# 普通写法
new_lst = []
for i in lst:
res = i * 3
new_lst.append(res)
print(new_lst)  # [3, 6, 9, 12, 15]

# 推导式写法
new_lst = [i * 3 for i in lst]
print(new_lst)  # [3, 6, 9, 12, 15]```

```# 过滤出奇数
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 普通写法
new_lst = []
for i in lst:
if i % 2 == 1:
new_lst.append(i)
print(new_lst)  # [1, 3, 5, 7, 9]

# 推导式写法
# 推导式使用单项分支只能是在for语句结束之后使用
new_lst = [i for i in lst if i % 2 == 1]
print(new_lst)  # [1, 3, 5, 7, 9]```

```# 两个列表中的数据相加求和
lst = [1, 2, 3]
lst1 = [11, 22, 33]
# 普通方法
new_lst = []
for i in lst:
for j in lst1:
res = i + j
new_lst.append(res)
print(new_lst)  # [12, 23, 34, 13, 24, 35, 14, 25, 36]

# 推导式写法
new_lst = [i + j for i in lst for j in lst1]
print(new_lst)  # [12, 23, 34, 13, 24, 35, 14, 25, 36]```

## 列表推导式练习题

• 1、将字典中的数据变成['x=A', 'y=B', 'z=c']的样式

{'x': 'A', 'y': 'B', 'z': 'C' }

• 2、将所用元素变成纯小写

• 3、x是0-5之间的偶数,y是0-5之间的奇数 把x,y组成一起变成元组,放到列表当中
• 4、使用列表推导式 制作所有99乘法表中的运算
• 5、求M,N中矩阵和元素的乘积

M = [[1,2,3], [4,5,6], [7,8,9]]
N = [[2,2,2], [3,3,3], [4,4,4]]

```# 第五题解法之一

# =>实现效果1   [2, 4, 6, 12, 15, 18, 28, 32, 36]
# =>实现效果2   [[2, 4, 6], [12, 15, 18], [28, 32, 36]]
# 实现效果 1
lst_new = []
for i in range(len(M)) :
for j in range(len(N)) :
res = M[i][j] * N[i][j]
lst_new.append(res)
print(lst_new)
# 推导式写法
res = [M[i][j]*N[i][j] for i in range(len(M)) for j in range(len(N))]
print(res)
# 实现效果 2
lst_new = []
for i in range(len(M)) :
lst_new2 = []
for j in range(len(N)) :
res = M[i][j] * N[i][j]
lst_new2.append(res)
lst_new.append(lst_new2)
print(lst_new)
# 推导式写法
res = [[M[i][j]*N[i][j] for j in range(len(M))] for i in range(len(N))]
print(res)
```

## 集合推导式

```'''

满足年龄在18到21，存款大于等于5000，小于等于5500的人
开卡格式为：尊贵VIP卡老X（姓氏），否则开卡格式为：抠脚大汉老X（姓氏）
把开卡的种类统计出来
'''
lst = [
{"name": "刘鑫炜", "age": 18, "money": 10000},
{"name": "刘聪", "age": 19, "money": 5100},
{"name": "刘子豪", "age": 20, "money": 4800},
{"name": "孔祥群", "age": 21, "money": 2000},
{"name": "宋云杰", "age": 18, "money": 20}
]

# 常规写法
setvar = set()

for i in lst:
if (18 <= i['age'] <= 21) and (5000 <= i['money'] <= 5500):
res = '尊贵VIP老' + i['name'][0]
else:
res = '抠脚老汉' + i['name'][0]
print(setvar)   # {'尊贵VIP老刘', '抠脚老汉刘', '抠脚老汉孔', '抠脚老汉宋'}
# 打印显示只有4个元素，是因为集合的自动去重

# 使用集合推导式
# 推导式只能使用单项分支，但是可以在返回值使用三元运算符
setvar = {
"尊贵VIP卡老" + i["name"][0] if 18 <= i["age"] <= 21 and 5000 <= i["money"] <= 5500 else "抠脚大汉卡老" + i["name"][0] for i in lst}
print(setvar)   # {'抠脚大汉卡老孔', '抠脚大汉卡老刘', '尊贵VIP卡老刘', '抠脚大汉卡老宋'}```

## 字典推导式

```lst = [{'A': 'a'}, {'B': 'b'}]

dct = {k:v for i in lst for k,v in i.items()}

print(dct)  # {'A': 'a', 'B': 'b'}
```

### 字典推导式常用以配合的函数

enumerate 枚举，根据索引号码将可迭代对象中的值一一配对成元组，返回迭代器。
zip 将多个可迭代对象中的值一一对应组成元组，返回迭代器。

## enumerate

enumerate(iterable, [start = 0])

iterable：可迭代数据
start：可以选择开始的索引号（默认从0开始索引）

```from collections import Iterator
lst = ['东', '南', '西', '北']
# 基本使用
it = enumerate(lst)  # 实现功能返回迭代器
print(isinstance(it, Iterator))	 # True
# 强转成列表
new_lst = list(it)
print(new_lst)  # [(0, '东'), (1, '南'), (2, '西'), (3, '北')]
"""

"""```

```from collections import Iterator
lst = ['东', '南', '西', '北']
# enumerate 配合使用字典推导式 变成字典
dct = {k: v for k, v in enumerate(lst)}
print(dct)  # {0: '东', 1: '南', 2: '西', 3: '北'}```

## zip

zip(iterable, iterable1, ……)

```lst1 = [1, 2, 3, 4, 5]
lst2 = ['a', 'b', 'c', 'd']
lst3 = ['A', 'B', 'C']
it = zip(lst1, lst2, lst3)
lst = list(it)
print(lst)  # [(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C')]
```

## 优先使用推导式

```import time
# 列表循环插入数据
start_time = time.perf_counter()
lst = []
for i in range(15000000):
lst.append(i)
end_time = time.perf_counter()
print(end_time - start_time)  # 1.7453036000000002

""" 推导式比循环速度更快 """
start_time = time.perf_counter()
new_lst1 = [i for i in range(15000000)]
end_time = time.perf_counter()
print(end_time - start_time)  # 0.7337192000000001```

```import dis
def loop():
lst = []
for i in range(10):
lst.append(i)
return lst
def der():
lst = [i for i in range(10)]
return lst
dis.dis(loop)
print('-' * 100)
dis.dis(der)```

4           0 BUILD_LIST               0
2 STORE_FAST               0 (lst)
5           4 SETUP_LOOP              26 (to 32)
10 CALL_FUNCTION            1
12 GET_ITER
>>   14 FOR_ITER                14 (to 30)
16 STORE_FAST               1 (i)
24 CALL_FUNCTION            1
26 POP_TOP
28 JUMP_ABSOLUTE           14
>>   30 POP_BLOCK
7     >>   32 LOAD_FAST                0 (lst)
34 RETURN_VALUE
-----------------------------------------------------------------------------
11           0 LOAD_CONST               1 (` at 0x000002C71AD950C0, file "tset.py", line 11>)              2 LOAD_CONST               2 ('der..')              4 MAKE_FUNCTION            0              6 LOAD_GLOBAL              0 (range)              8 LOAD_CONST               3 (10)             10 CALL_FUNCTION            1             12 GET_ITER             14 CALL_FUNCTION            1             16 STORE_FAST               0 (lst) 12          18 LOAD_FAST                0 (lst)             20 RETURN_VALUE`

``` ```
``` 从上述结果中我们就是可以看出，在这种情况下，for循环因为开始定义列表、循环中的append方法的是使用，比推导式要多出几个环节，因此速度相比之下变得很慢，这就是原因。 再次我们也再说一句，之后碰到关于速度和底层之类的疑惑的时候，就可以简单的使用timeit和dis去验证和简答的理解。 到此这篇关于Python推导式使用详情的文章就介绍到这了,更多相关Python推导式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ ```
``` ```
``` ```
``` ```
``` ```
``` ```
``` ```
``` ```
``` 你可能感兴趣的 二分查找排序算法 周凡杨 java二分查找排序算法折半 java中的BigDecimal bijian1013 javaBigDecimal Shell echo命令详解 daizj echoshell Oracle DBA 简单操作 周凡杨 oracle dba sql 画图重绘 朱辉辉33 游戏 线程之初体验 西蜀石兰 线程 linux集群互相免登陆配置 林鹤霄 linux mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql 按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他 首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉 版权所有 IT知识库 CopyRight © 2000-2050 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号 ```