Python推导式

推导式是 for 循环的简化使用方法,使用推导式,将一个可迭代对象中的数据遍历到某一个容器当中。简单的来说就是用一行for循环语句,遍历一个可迭代对象中的所有数据,然后将遍历出来的数据进行处理放入对应的容器中的一个过程和方式。

而推导出类似函数的是三元运算符,这是一种使用条件判断语句的简化方法。

[En]

And deriving a similar function is the ternary operator, which is a simplified method for the use of conditional judgment statements.

val for val in Iterable

就是 存入容器中的数据 + for循环语句

演绎形式有三种表达方式,它们被包装在相应的符号中。

[En]

There are three ways to express the deductive form, which are wrapped in the corresponding symbols.

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

列表被推送到公式,遍历的数据最终将成为列表数据。

[En]

The list is pushed to the formula, and the traversed data will eventually become a list data.

列表中存入10条数据。

常规写法
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]

带判断条件的单圈导数

[En]

Single cycle derivation with judgment condition

过滤出奇数
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]

多循环推导式

两个列表中数据的总和<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>The sum of the data in the two lists</font>*</details>
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、将所用元素变成纯小写
["ADDD","dddDD","DDaa","sss"]

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)

集合派生和列表派生的用法基本相同,但包含了大括号,并且结果数据是一个集合。

[En]

The use of set derivation and list derivation is basically the same, but the outer braces are included, and the resulting data is a collection.

'''
案例:
    满足年龄在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

字典推导也是如此,但字典数据以键-值对的形式存在,因此返回的数据或返回的数据被更改为2以对应于键值。

[En]

The same is true for dictionary deduction, but the dictionary data exists in the form of key-value pairs, so the returned data, or the returned data, is changed to two to correspond to the key value.

将列表中的键值对更改为字典

[En]

Change the key-value pair in the list into a dictionary

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 将多个可迭代对象中的值一一对应组成元组,返回迭代器。

枚举,根据索引号码 和 Iterable 中的值,一个一个拿出来配对组成元组,放入迭代器中,然后返回迭代器。

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, '北')]

"""
您可以看到元列表中的数据和对应的索引号与元组一一对应<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>You can see that the data in the meta-list and the corresponding index number correspond to tuples one by one</font>*</details>
"""

上面的举例当中,如果使用字典推导式和enumerate函数配合,就可以用一句话达成组成一个字典的目的。

from collections import Iterator
lst = ['东', '南', '西', '北']

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

将多个Iterable中的值,一个一个拿出来配对组成元组放入迭代器中,如果某个元素多出,没有匹配项就会被舍弃。

zip(iterable, iterable1, ……)

参数是一个接一个的可迭代对象。

[En]

Parameters are iterable objects one by one.

迭代器

在下面的示例中,三个列表中的元素被形成一一对应的元组,但最小的列表中只有三个元素,因此只能一对一地形成三对元组,多余的元素被丢弃。

[En]

In the following example, the elements in the three lists are formed into tuples with one-to-one correspondence, but there are only three elements in the smallest list, so only three pairs of tuples can be formed one-to-one, and the extra elements are discarded.

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')]

推导式我们到此学习完了,但是我们就发现,推导式就是在容器中使用一个for循环而已,为什么没有元组推导式?

请见生成器

这里大家注意,如果条件允许的话,那么我们一定是要优先使用推导式而不是for循环加append的方式,原因很简单,因为底层逻辑的不同,使推导式的执行速度相比for循环加append更快。

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

经过测试我们可以看到,推导式的速度大约是for循环的2倍多,是什么导致的?还记得我们之前使用过的 dis模块吗?

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)
6 LOAD_GLOBAL 0 (range)
8 LOAD_CONST 1 (10)
10 CALL_FUNCTION 1
12 GET_ITER
>> 14 FOR_ITER 14 (to 30)
16 STORE_FAST 1 (i)

6 18 LOAD_FAST 0 (lst)
20 LOAD_ATTR 1 (append)
22 LOAD_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

Original: https://www.cnblogs.com/msr20666/p/16252242.html
Author: 小小垂髫
Title: Python推导式

原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/499612/

转载文章受原作者版权保护。转载请注明原作者出处!

(0)

大家都在看

亲爱的 Coder【最近整理,可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球