一、推导式

概念

推导式（又称解析器），是 Python 独有的一种特性。使用推导式可以快速生成列表、元组、字典以及集合类型的数据，因此推导式又可细分为列表推导式、元组推导式、字典推导式以及集合推导式。

Python 列表推导式

列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。
列表推导式的语法格式如下：

[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

此格式中，[if 条件表达式] 不是必须的，可以使用，也可以省略。

等价于：

for 迭代变量 in 可迭代对象
 表达式

示例：

#实现要求计算0~9每个元素得的平方值，然后放到列表里面

#方法一
a1 = [x**2 for x in range(10)] 
print("a1:",a1)

#等价于  
#方法二
a2 = []
for x in range(10):
    a2.append(x**2)
print("a2:",a2)



#可以在列表推导式中添加 if 条件语句
#方法一
a3 = [x**2 for x in range(10) if x%2==0] 
print("a3:",a3)

#等价于  
#方法二
a4 = []
for x in range(10):
    if(x%2==0):
        a4.append(x**2)
print("a4:",a4)

运行结果是一致的。

同时推导式也支持多个循环（循环嵌套）

#实现嵌套循环
b1 = [(x,y) for x in range(2) for y in range(3)]
print("b1:",b1)

b2 = []
for x in range(2):
    for y in range(3):
        b2.append((x,y))
print("b2:",b2)

Python 元组推导式

元组推导式的语法格式如下：

(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )

其中，用 [] 括起来的部分，可以使用，也可以省略。

a = (x for x in range(1,10))
print(a)

从上面的执行结果可以看出，使用元组推导式生成的结果并不是一个元组，而是一个生成器对象

生成器：
生成器本质上也是迭代器，以 list 容器为例，在使用该容器迭代一组数据时，必须事先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素。（也就是说，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。）

如果我们想要使用元组推导式获得新元组或新元组中的元素，有以下三种方式：

①使用 tuple() 函数，可以直接将生成器对象转换成元组，例如：

a = (x for x in range(1,10))
print(tuple(a))

② 直接使用 for 循环遍历生成器对象，可以获得各个元素，例如：

a = (x for x in range(1,10))
for i in a:
    print(i,end=" ")

③使用 next() 方法遍历生成器对象，也可以获得各个元素，例如：

a = (x for x in range(3))
print(a.__next__())
print(a.__next__())
print(a.__next__())
print("转换后的元组",tuple(a))

注意，无论是使用 for 循环遍历生成器对象，还是使用 next() 方法遍历生成器对象，遍历后原生成器对象将不复存在，这就是遍历后转换原生成器对象却得到空元组的原因。

Python 字典推导式

Python 中，使用字典推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的字典。

字典推导式的语法格式如下：

{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

其中，用 [] 括起来的部分，可以使用，也可以省略。
可以看到，和其它推导式的语法格式相比，唯一不同在于，字典推导式用的是大括号{}。

#交换现有字典中各键值对的键和值。
old_dict = {"Tom":24,"Amy":16}

new_dict = {v:k for k,v in old_dict.items()}
print(new_dict)

Python 集合推导式

Python 中，使用集合推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的集合。
集合推导式的语法格式和字典推导式完全相同，如下所示：

{ 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }

其中，用 [] 括起来的部分，可以使用，也可以省略。

集合推导式和字典推导式的格式完全相同，那么给定一个类似的推导式，如何判断是哪种推导式呢？最简单直接的方式，就是根据表达式进行判断，如果表达式以键值对（key：value）的形式，则证明此推导式是字典推导式；反之，则是集合推导式。

既然生成的是集合，那么其保存的元素必须是唯一的。

tupledemo = (1,1,2,3,4,5,6,6)
new = {x**2 for x in tupledemo if x%2==0}
print(new)

二、zip 函数及用法

1.概念

zip() 函数是 Python 内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。
所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。

zip() 函数的语法格式为：

zip(iterable, …)
其中 iterable,… 表示多个列表、元组、字典、集合、字符串，甚至还可以为 range() 区间。

2.用法

my_list = [1,2,3]
my_tuple = (4,5,6)
print([x for x in zip(my_list,my_tuple)])

my_dict = {"Name":"Tom",\
            "Sex":"boy",\
            "Age":24}
print({x for x in zip(my_dict)})

my_str1 = "Hello"
my_str2 = "Hi"
print([x for x in zip(my_str1,my_str2)])

在使用 zip() 函数“压缩”多个序列时，它会分别取各序
列中第 1 个元素、第 2 个元素、… 第 n 个元素，各自组成新的元组。需要注意的是，当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。

另外，对于 zip() 函数返回的 zip 对象，既可以像上面程序那样，通过遍历提取其存储的元组，也可以向下面程序这样，通过调用 list() 函数将 zip() 对象强制转换成列表：

my_list = [1,2,3]
my_tuple = (4,5,6)
print(list(x for x in zip(my_list,my_tuple)))

1、Pythonic - 很Python

写一段代码生成1到100之间的数字的平方的列表，答案是：

1，4，9，16...

如果你这样写，你就不Pythonic了：

nums = []
for i in range(1, 101):
    nums.append(i * i)
print(nums)

正确的写法是使用Python的推导式：

nums = [i * i for i in range(1, 101)]

2、带条件的推导式

生成一个列表，包含1到100之间是3的倍数的数字的方法：

9, 36, 81...

代码：

nums = [i * i for i in range(1, 101) if i % 3 == 0]

3、带条件的表达式

生成一个列表，如果是3的倍数就用平方，否则就用是数字本身：

1, 2, 9, 4, 5, 36...

代码：

nums = [i * i if i % 3 == 0 else i for i in range(1, 101)]

结合上面的3个例子，来看一下推导式总结：

• 推导式从一个可枚举数据（列表，元组，集合，字典等）推导出一个列表。也可以推导出生成器，集合或字典。
• 推导式可以加推导条件，只对符合条件的元素推导
• 要推导出的元素使用表达式生成，可以用if else生成不同元素

[表达式 if 表达式条件 else 分支 for i in 序列 if 推导条件]

4、使用函数

如果推导条件或者表达式特别复杂怎么办？可以使用函数。
推导所有1-100之间的所有质数：2，3，5，7…

def is_prime(num):
    if num == 1:
        return False  
    for i in range(2, num):
       if (num % i) == 0:
           return False
    else:
       return True

p_nums = [i for i in range(1, 100) if is_prime(i)]
print(p_nums)

把推导的条件放在函数中，既可以应对复杂的条件，又可以利用推导式的简洁写法。
同理，如果生成推导结果的过程很复杂，也可以把逻辑放到函数中。
推导1900到2021年之间所有的年份，标记出闰年，生成结果：

1900, 1901, 1902, 1903, '闰1904'

代码：

def is_run(year):
    if (year % 4) == 0:
       if (year % 100) == 0:
           if (year % 400) == 0:
               return True   # 整百年能被400整除的是闰年
           else:
               return False
       else:
           return True       # 非整百年能被4整除的为闰年
    else:
       return False 


ryears = [f'闰{y}' if is_run(y) else y for y in range(1900, 2021)]    
print(ryears)

5、嵌套表达式 - 不推荐使用

从2000年到2021年，生成每个月份：‘2000年:1月’, ‘2000年:2月’, ‘2020年:3月’, …, ‘2021年:12月’

monthes = [f'{y}年:{m}月' for y in range(2000, 2022) for m in range(1,13) ]

这里有两个for循环，类似于：

monthes = []
for y in range(2000, 2022):
    for m in range(1,13):
        monthes.append(f'{y}年:{m}月')

是不是下面的特别容易懂？所以两层的循环不推荐使用推导式，哈哈。
那我为什么还要讲？你会碰到有人这么写，知道它的存在还是有点必要的。

6、推导巨大的列表 - 不要这么干！

推导出1到100亿之间的数字的平方，代码如下：

nums = [i * i for i in range(1, 10000000000)]

但是这段代码很可能会卡死你的电脑，除非你的电脑是超级计算机。因为它要在内存中做100亿次计算，然后保存这100亿个数字。

7、使用生成器

这种情况下，我们应该使用推导生成器，用法很简单：

• 把方括号改成圆括号就可以了

nums = (i * i for i in range(1, 10000000000))
print(nums)
print(next(nums))
print(next(nums))
print(next(nums))

打印出来是一个生成器：

<generator object <genexpr> at 0x7fa0b422feb0>
1
4
9

这是一个生成器，它不会一次性生成100亿个数字，只有调用next()的时候，它才会生成一个新的，返回给你。也就是说，同一个时间，只保存一个数字。

8、推导字典

推导字典的方式和推导列表很相似，只不过：

• 使用大括号
• 使用键值对

推导一个包含数字和数字平方组成的字典，结果是这样的：

{1: 1, 2: 4, 3: 9, ..., 100: 10000}

代码：

nums_dict = {n:n*n for n in range(1,101)}
print(nums_dict)

反过来，平方在前面，数字在后面：

nums_dict = {n*n:n for n in range(1,101)}
print(nums_dict)

给下面的字典按照分数排序：

{‘张三’:59, ‘李四’:87, ‘王五’:78, ‘赵六’:100, ‘刘七’:90}

排序结果：

{‘赵六’: 100, ‘刘七’: 90, ‘李四’: 87, ‘王五’: 78, ‘张三’: 59}

代码：

scores =  {'张三':59, '李四':87, '王五':78, '赵六':100, '刘七':90}
sored_scores = {item[0]:item[1] for item in sorted(scores.items(), key=lambda item:item[1], reverse=True)}
print(sored_scores)

• 先把字典scores变成一个元组列表：scores.items()
• 用sorted函数给元组列表排序：sorted(scores.items(), key=lambda item:item[1],
  reverse=True)
• 排序过程用lambda指定使用元组的第二列排序：key=lambda item:item[1]。默认是是第一列。
• 指定倒着排序，也就是分数高的在前面：reverse=True
• 使用推导式，把排好序的元组列表，生成一个新的排好序的字典：{item[0]:item[1] for item in … }

9、推导集合Set

推导集合的方式和列表是一样的，区别在于：

• 使用大括号，类似于推导字典，但它是单个元素，而不是键值对。
• 集合会自动过滤掉重复的元素。

下面的名字列表，去掉前后空格后去掉重复的名字：

[ ‘麦叔’, ‘张三’, ’ 麦叔 ', 'NBA ‘, ‘张小三’, ‘NBA’, ‘石石’, ’ 莫名’, ‘莫名’ ]

推导结果：

{‘石石’, ‘NAB’, ‘张小三’, ‘莫名’, ‘张三’, ‘麦叔’}

代码：

names = [ '麦叔', '张三', ' 麦叔 ', 'NBA ', '张小三', 'NBA', '石石', ' 莫名', '莫名' ]
new_names = {n.strip() for n in names}
print(new_names)