python 列表推导式、元组推导式 字典推导式 、三元运算符

一、基本语法结构

列表推导式的基本语法结构为：

[ expression for item in iterable if condition ]

其中，expression表示参与列表生成的表达式，可包含变量、函数调用等操作；item表示生成列表中的元素；iterable表示可迭代的对象，例如列表、元组、集合等；if condition表示对条件的筛选，可以省略。

expression表示要对每个item进行操作的表达式，item是可迭代对象中的每个元素，if condition是可选的筛选条件。在执行完毕后，将得到一个新的列表new_list。

"""
生成1-9的整数列表
"""
myList =  [x for x in range(1,10)]
#  [1,2,3,4,5,6,7,8,9]
print(myList)



"""
生成1~9之间的整数的平方列表
"""
square_list = [i**2 for i in range(1,11)]
# [1, 4, 9, 16, 25, 36, 49, 64, 81]
print(square_list)


"""
从一个字符串列表中筛选出长度超过3的字符串
"""

str_list = ['hello', 'world', 'python', 'list', 'comprehension', 'study']

new_list = [s for s in str_list if len(s) > 3]
# 
print(new_list)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
'
运行
运行

多重循环

my_list = [n*m for n in range(1,3) for m in range(1,3) ]
# 此处通过两层循环实现了乘法操作，即n和m分别取1、2时，它们的乘积构成了列表中的元素
# [1,2,2,4]
print(my_list)

1
2
3
4
5
6
'
运行
运行

嵌套列表推导式

有时候需要在生成一个列表时，对其中的元素进行更加复杂的操作，此时就可以使用嵌套列表推导式。嵌套列表推导式即在列表推导式的基础上再次嵌套列表推导式，其语法结构为：

[ expression for item in iterable if condition for sub_item in sub_iterable if sub_condition ]

其中，expression、item、iterable和condition的含义与上述基本语法结构中一致；sub_item表示在item遍历的基础上再次遍历的元素；sub_iterable表示sub_item的迭代对象；sub_condition表示对sub_item的筛选条件。

matrix = [[i*j for j in range(1,4)] for i in range(1,4)]
for row in matrix:
    print(row)

"""
[1, 2, 3]

[2, 4, 6]

[3, 6, 9]
"""


my_list = [
    [[1, 2, 3], [4, 5, 6]]
]
flat = [x for sub1 in my_list for sub2 in sub1 for x in sub2]
print(flat)
# [1, 2, 3, 4, 5, 6]
 
flat2 = [((x for x in sub2) for sub2 in sub1) for sub1 in my_list]
print(list(flat))
# [1, 2, 3, 4, 5, 6]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'
运行
运行

元组推导式

元组推导式类似于列表推导式，只是将中括号换为了小括号。
元组推导式和列表推导式不一样，其生成的是一个对象， 一个生成器对象，并不直接是一个元组；如果想要得到一个元组或列表的话，那么就需要通过tuple()或list()来进行转化。

import random
randomnumber = (random.randint(10, 100) for i in range(10))
print(randomnumber)
>>>
<generator object <genexpr> at 0x00000165F97CE5C8>
我们发现并没有生成元组，而只是得到了一个生成器，我们还需要转换一下：

import random
randomnumber = (random.randint(10, 100) for i in range(10))
print(tuple(randomnumber))
>>>
(68, 39, 49, 22, 34, 39, 12, 53, 19, 29)
综上，我们使用元组推导式时，得到的并不是一个元组，而是一个生成器，如果我们希望输出元组，我们还需要使用tuple() 函数转换一下。

另外，我们还可以直接遍历生成器：

import random
randomnumber = (random.randint(10, 100) for i in range(10))
##print(tuple(randomnumber))
for i in randomnumber:print(i, end = " ")
>>>
75 88 76 77 65 13 82 31 71 35 


import random
print(tuple(random.randint(10,1000) for i in range(10)))
print(list(random.randint(10,1000) for i in range(10)))
 
输出为：
(930, 139, 668, 598, 493, 936, 742, 763, 339, 205)
[437, 689, 372, 171, 876, 451, 336, 903, 513, 727]　　
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

元组推导式得到的结果是一个生成器对象，并不是一个元组。

如果我们不想转换成元组或列表，但还想输出生成器中的内容，那就要使用for循环来遍历它了。

import random
yz=(random.randint(10,1000) for i in range(10))
for i in yz:
	# 输出的是单个数，并不是元组；如果用默认的换行的话，输出的数更是每个一行(所以输出没有外面的括号)；
    print(i,end=' ') #不换行，用空格分割
 
输出为：
 
725 10 513 74 42 683 143 997 315 795 
1
2
3
4
5
6
7
8
9

魔法方法

对于生成器对象除了可以使用for循环来遍历它，还可以使用__next__来遍历它

import random #导入随机数模块
yz=(random.randint(10,1000) for i in range(10))
print(yz.__next__())#输出生成器中的第一个元素
print(yz.__next__())#输出生成器中的第二个元素
print(yz.__next__())#输出生成器中的第三个元素
 
420
709
760
1
2
3
4
5
6
7
8
9
'
运行
运行

可看到，当for循环输出生成器对象中的10个元素；再次转换成元组输出，但此时生成器的内容为空了，
因为：当我们对生成器对象当中的内容进行访问后，这个生成器对象已经不存在了，
所以再对它进行转换后，它就是一个空的元组了；

如果希望再使用这个生成器对象，则必须重新生成。

import random #导入随机数模块
yz=(random.randint(10,1000) for i in range(10))
for i in yz:
    print(i,end=' ')
print(tuple(yz))
 
输出为：
935 51 628 73 392 442 145 694 369 173 ()
1
2
3
4
5
6
7
8

字典推导式

语法1

new_dictionary = {key_exp:value_exp for key, value in dict.items() if condition}
字典推导式说明：
key：dict.items()字典中的key
value：dict.items()字典中的value
dict.items()：序列
condition：if条件表达式   :  可以用key，也可以用value   
key_exp：在for循环中，如果if条件表达式condition成立(即条件表达式成立)，返回对应的**key,value当作key_exp,value_exp**处理 
value_exp：在for循环中，如果if条件表达式condition成立(即条件表达式成立)，返回对应的**key,value当作key_exp,value_exp**处理
这样就返回一个新的字典。
1
2
3
4
5
6
7
8
9

    dictionary_1 = {'a': '1234', 'B': 'FFFF', 'c': ' 23432', 'D': '124fgr', 'e': 'eeeee', 'F': 'QQQQQ'}

    # 案例一：获取字典中key值是小写字母的键值对
    new_dict_1 = {key: value for key, value in dictionary_1.items() if key.islower()}
    new_dict_2 = {g: h for g, h in dictionary_1.items() if g.islower()}
    # g, h只是一个变量，使用任意字母都行，但是一定要前后保持一致。
    print(new_dict_1)
    print(new_dict_2)

	
	# 案例二：将字典中的所有key设置为小写
	#  字典推导式 key：可以是变量，也可以是表达式，函数等
	new_dict_3 = {key.lower(): value for key, value in dictionary_1.items()}
	# 将字典中的所有key设置为小写,value值设置为大写
	new_dict_4 = {key.lower(): value.upper() for key, value in dictionary_1.items()}
	print(new_dict_3)
	print(new_dict_4)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

三元表达式又称三元运算符，是软件编程中的一个固定格式，语法是“条件表达式?表达式1:表达式2”。常用于根据条件为变量赋值。
Python中也有三元表达式，不过Python的三元运算符和C语言以及Java等语言有所区别，语法格式为：
表达式1 if 条件表达式 else 表达式2
当表达式返回True时，返回结果表达式1，否则返回结果表达式2

语法2
{key_exp:value_exp1 if condition else value_exp2 for key, value in dict.items()}
字典推导式说明：
key：dict.items()字典中的key
value：dict.items()字典中的value
dict.items()：序列
condition：if条件表达式的判断内容
value_exp1：在for循环中，如果条件表达式condition成立(即条件表达式成立)，返回对应的key,value并作key_exp,value_exp1处理
value_exp2：在for循环中，如果条件表达式condition不成立(即条件表达式不成立)，返回对应的key,value并作key_exp,value_exp2处理

# 在爬虫中，我们需要获取cookies并以字典的形式传参，如果cookies是字符串则需要转换为字典，经典代码案例如下：
# 原来的cookies很长，这里截取一部分做演示：
cookies = "anonymid=jy0ui55o-u6f6zd; depovince=GW; _r01_=1; JSESSIONID=abcMktGLRGjLtdhBk7OVw; ick_login=a9b557b8-8138-4e9d-8601-de7b2a633f80"
# 字典推导式，将长的字符串转化为字典。
new_dict_1 = {cookie.split("=")[0]: cookie.split("=")[1] for cookie in cookies.split(";")} 
print(new_dict_1)
"""
代码分析：
在字符串cookies中’=’前面是key，’=’后面是value，每一个’;’构成一个键值对；多个键值对构成一个字典；
1.根据’;’将字符串拆分为列表；
2.根据第一步获取的列表，遍历时将每一个字符串根据’=’再次拆分；
3.根据第二步拆分的结果，列表第一个元素作为key,列表第二个元素作为value；
"""
new_dict_2 = {key: value for t in cookies.split(";") for key, value in (t.split("="),)}
# 先将字符串通过';'分解成短的带有等号的字符串，然后将这个短的字符串转化为元组，最后再通过'='分解成俩个值分别赋给key、value。
print(new_dict_2)
"""
# 下面是分解的演示：
for t in cookies.split(';'):
    print(type(t))
    print((t.split('='),))
    print(type((t.split('='),)))
print(cookies.split(';'))
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

三元表达式又称三元运算符，是软件编程中的一个固定格式，语法是“条件表达式?表达式1:表达式2”。常用于根据条件为变量赋值。
Python中也有三元表达式，不过Python的三元运算符和C语言以及Java等语言有所区别，语法格式为：

表达式1 if 条件表达式 else 表达式2
当表达式返回True时，返回结果表达式1，否则返回结果表达式2

断言

assert expression [, arguments]

result = assert a, b 效果 类似 C# ??