Python 的列表解析式，集合解析式，字典解析式

这三种都是 python 里面的语法糖。

语法糖，Syntactic Sugar，就是为了写程序时候少出错，发明的一些简便的方法，但不影响这个语法的功能。

（我第一反应是 HP 里面的 chocolate frog，哈哈哈)

1. 列表解析式 list comprehension

通常我们定义有内容 list 时，想对内容进行一些计算再放进去，除了使用 for 循环迭代出列表内的元素，进行计算再放进去，还可以在列表内直接写解析式计算。

1.1 普通版：[expression for i in iterable]

比如，要求 1-10 的每个数字的算术平方根组成的集合。

用 for 循环的话：

lst = []

for i in range(1, 11):

    i = i ** 0.5 #不用pow()是因为这样计算比较快

    lst.append(i)

这样看起来就比较繁琐。

用列表解析式的话，就相当于把上面的内容都浓缩起来：

lst = [ i**0.5 for i in range(1,11) ]

这样看起来就很清爽，前面是要对 i 做的处理，后面是 i 从哪里迭代，这些都用中括号 [ ] 括起来，是生成一个列表。

1.2 进阶版 [expression for i in iterable if… for j in iterable if… …]

前面还是表达式，但是后面写的是双循环，还有判断条件，就是符合条件的再进前面的表达式。

比如，我想要 5 以内的单数，和 5 以内双数组成的所有二元组，然后把这些元组放在一个列表里。

用 for 循环的话：

lst = []

for i in range(1,6):

if i % 2 == 0:

    continue

for j in range(1,6):

    if j % 2 == 0:

        lst.append((i,j))

lst

[(1, 2), (1, 4), (3, 2), (3, 4), (5, 2), (5, 4)]

巨繁琐，但是如果用列表解析式的话：

[(i,j) for i in range(1,6) if i % 2 for j in range(1,6) if not j % 2]

[(1, 2), (1, 4), (3, 2), (3, 4), (5, 2), (5, 4)]

#减量不减价，你值得拥有。

但是要注意，列表解析式里不能有 elif 等比较复杂的语法结构，如果实在不行，还是用 for 循环吧。

而且一定要注意效率，怎么用 if 来筛选数据。比如:

[(i,j) for i in range(1,6) if i % 2 for j in range(1,6) if not j % 2]

[(i,j) for i in range(1,6) for j in range(1,6) if i % 2 if not j % 2]

[(i,j) for i in range(1,6) for j in range(1,6) if i % 2 == 0 and j % 2 != 0]

#前者的效率要略高，因为前者在第一个循环时就做了判断，不符合的话，就不用迭代第二个循环。

#第二个和第三个是一个类型，两个if就是嵌套解构

#而且一定要注意逻辑，看自己想要的到底是什么

还有列表解析式前面的 expression 得是有输出的，这个输出的结果才能放进列表里。

[print(i) for i in range(3)]

0

1

2

[None, None, None]

#i倒是会出现，但这是print的功能，print没有返回值，所以列表里面全都是None。

2. 集合解析式

普通版：{expression for i in iterable}

进阶版 {expression for i in iterable if… for j in iterable if… …}

用法和列表解析式是一样的，就是把中括号 [] 换成大括号 {}

需要注意得是，集合解析式，最终生成的也是集合，集合里面的元素必须是 hashable。所以这样是不行的：

{ [i] for i in range(5) }

#这样生成的元素都是list，不可hash，会报错

集合解析式也能自动去重（不能就怪了）：

{i for i in [1,1,1,1,1,1]}

{1}

3. 字典解析式

用法还是和前两者一样，区别就是：用 { } 包起来，而且前面的 expression 得是 key:value 的形式。

{i:[j] for i in range(3) for j in 'abc'}

{0: ['c'], 1: ['c'], 2: ['c']}

#注意key是去重的，所以第一个循环的元素带入第二个循环时，会与第二个循环的最后一个元素组成key:value

#key必须可hash，但是value不需要hashable，所以value可以用可变的数据结构