Python 推导式、迭代器、生成器、模块和包

一、推导式

（一）.列表推导式（集合推导式也同理于此）

利用列表推导式，取出1-20内所有偶数

li = [i for i in range(1, 21) if i % 2 == 0] # 如果只有一个条件，要把if语句写在最后面

第一个i是放入列表的值，后面都是推导的公式

print(li)

第一个 i 相当于下面等价方案中的 append(i)。把 i 换成 "a" ，输出的列表中全是 "a"

等价于

for i in range(1,21):
if i%2==0:
li.append(li)
print(li)

利用列表推导式，取出1-20内所有数。其中奇数用字符"a"代替，偶数则正常输出

li = [i if i % 2 == 0 else "a" for i in range(1, 21)] # 添加多个条件的时候，要写在前面
print(li)

列表推导式练习：将列表 li=['a','b','c','d','e'] 倒序

print([li.pop() for i in range(len(li))])

pop()函数，remove and return the last element

（二）.字典推导式

例1：
a = {str(i): i for i in range(5)}
print(a) # {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4}

例2：
a = {"i": i for i in range(5)}
print(a) # {'i': 4}

因为字典的键是唯一的，“例2”中的这个推导式，把键的名字给写死了，每一次推导其实都是在修改原先的值。

例3：
print({i: 'a' for i in range(5)})

{0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a'}

“例3”是把值给写死了。相当于dict.fromkeys([0,1,2,3,4],"a")

（三）.元祖的话，是返回一个生成器对象：
print((i for i in range(5)))

<generator object at 0x01760960>

需要用tuple()来查看：
print(tuple(i for i in range(5)))

(0, 1, 2, 3, 4)

二、迭代器

查看一个对象是否可迭代，使用dir(li)方法，结果中出现了 "iter" 就是可迭代。

使用dir(li)查看，要有 "iter" 和 "next" 才算是一个迭代器。

枚举就是个迭代器

g = enumerate([1, 2, 3])
print(dir(g))

dir(g) 后，可以看到有 "iter" 和 "next"

（一）.__iter__() 和 next()：

(1).__iter__()把一个可迭代的对象变成迭代器。
li = [1, 2, 3]
g = li.__iter__() # 用这个方法变成迭代器
print(g.__next__()) # 实现迭代器（通俗理解：取值）

要赋值给一个变量。不然__next__()每次都是取第一个值

下面这样写，取的永远都是迭代器中的第一个值

print(li.__iter__().__next__())
print(li.__iter__().__next__())
print(li.__iter__().__next__())

这里就理解：！迭代器对象，必须赋值给一个变量接受！

(2).__next__()，实现迭代器，本质就是取出迭代器的下一个元素。注意：元素取完了，如果再 next() 就会报 StopIteration 异常！
li = [1, 2, 3]
g = iter(li)
print(next(g)) # 这里已经把第一个元素取出了
print("---")
for i in g: # 所以这里只会取出后面的2个值
print(i)

三、生成器 generator

在python中，使用了关键字yield的函数被成为生成器。本质上是迭代器，关键字：yield

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作。

在调用生成器运行的过程中，每次遇到yield时，函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行next()方法时，从当前位置继续运行。:

如下演示一个简单的生成器：
def fun():
i = 1
while i < 5:
print(i)
# yield # 实现生成器的功能。1、暂停，2、返回值。
yield "stop" # 可以这样写，返回一个信息
i += 1
print("**", i)
print(fun()) # 这里返回了一个内存地址
f = fun()
print(next(f))

使用yield演示斐波那契：
def fab(max_num):
n, a, b = 0, 0, 1
while n < max_num:
yield "暂停 打印b：", b
a, b = b, a + b
n += 1
for x in fab(20):
print(x)

四、模块和包

（一）.模块：本质上就是py文件。分为：内置模块，第三方模块。

(1).内置模块的使用：

导入所有内容：import modulename；很直观，但很占内存。

指定导入：from modulename import funcationname；明确知道自己要用什么方法。

(2).自定义模块的使用：

与当前py文件是同级路径：直接导入。

不同路径导入的参考：
import sys # 别忘了先导入这个
sys.path # 路径先调出来。返回一个列表，是python的安装目录
sys.path.append(r"") # 小括号内可添加自己py文件的绝对路径，记得取消转义

再 import modulename 就可以了

(3).得在自己写的py文件的最后一行加入：
if name == 'main':
functionname1()
functionname2()

有这段代码。测试是本身就有，还是导入进来的。

一定要对这个py文件本身执行，运行了，才会有结果。

（二）.包：很多py文件放在一个文件夹中。

（三）.if name == 'main':

就是个if判断，'main'就是个字符串，判断是导入的还是直接执行的。

当import一个py模块（文件）的时候，会把那个py模块（文件）执行一遍。

例1：

我有一个"test1.py"的模块（文件），如下代码：
import test2

print(name) # main
print(test2.__name__) # test2

"""
运行结果：

fengzi111
main
test2
"""

有另一个"test2.py"的文件，如下代码：
print("fengzi111")

if name == 'main':
print("fengzi222")

"test1.py"中，import了"test2"，那么"test2.py"就被执行了一遍。所以在"test1.py"的运行结果中，会出现fengzi111，因为 import test2 的时候，"test2.py"被执行了一遍。

为什么打印不出fengzi222？

"test2.py"是被引入进"test1.py"中的。"test2.py"中就有了if判断，判断的结果：它们两个不是同一个name。

看"test1.py"文件中的这条代码 print(test2.__name__)，这条代码特意显示了一下"test2.py"是什么名字。返回的结果是 test2，但现在执行的是"test1.py"这个文件呀！"test1"=="test2"吗？显然是False，那就不会有fengzi222了。