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可以用可变的数据结构