Python课堂笔记-第十四讲（模块、迭代器、生成器）

一、模块

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。

在Python中，一个.py文件就称之为一个模块（Module）。

1.1 使用模块有什么好处？

最大的好处是大大提高了代码的可维护性。
其次，编写代码不必从零开始，当一个模块编写完毕，就可以被其他地方引用。
我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。

1.2 模块的创建

在一个模块中引入外部模块
语法 ** import 模块名(模块名就是py文件)**
可以引入同一个模块多次，但是模块的实例只会创建一次。

# import 模块名
import test_m

# import 模块名 as 模块别名
import test_m as abc
print(abc)

在一个模块内部都有一个__name__，通过它可以获取模块的名字。
如果py文件直接运行时，那么__name__默认等于字符串’main’；
__name__属性值为__main__的模块是主模块，一个程序中只有一个主模块。

# 通过__name__可以获取模块的名字
print(__name__)

1.3 模块的使用

访问模块中的变量：语法 模块名.变量名
访问模块中的函数：语法 模块名.函数名
访问模块中的对象：语法 模块名.对象名

# 使用测试模块中的变量
# 语法: 模块名.变量名
print(test_m.a,test_m.b)
username = test_m.username
password = test_m.password

# 语法: 模块名.函数名
test_m.test2()

# 语法: 模块名.对象名
p = test_m.Person()
print(p.name)

我们也可以引入模块中部分内容，语法 from 模块名 import 变量，变量…

# from 模块名 import 变量,变量,变量......

from test_m import Person,test1,test2

p1 = Person()
print(p1.name)

test1()

还有一种引入方式，语法 from 模块名 import 变量 as 别名

# from 模块名 import 变量 as 别名

def test1():
    print('主模块中的test1..')

from test_m import test1 as new_test1

test1()
new_test1()

总结

模块是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。

1 import xxx
2 import xxx as yyy
3 from xxx import yyy,zzz,bbb
4 from xxx import *
5 from xxx import yyy as zzz

二、包

为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。

每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。
init.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块。

类似的，可以有多级目录，组成多级层次的包结构：
mycompany
├─ web
│ ├─ init.py
│ ├─ utils.py
│ └─ www.py
├─ init.py
├─ abc.py
└─ utils.py

文件www.py的模块名就是mycompany.web.www，两个文件utils.py的模块名分别是mycompany.utils和mycompany.web.utils。

三、推导式

推导式comprehensions（又称解析式），可以从一个数据序列构建另一个新的数据序列的结构体。

3种推导式：列表推导式、字典推导式、集合推导式

语法 [变量 for 变量 in 旧列表]
或者 [变量 for 变量 in 旧列表 if 条件判断]

# 将1 - 100之间能被3整除的，组成一个新的列表
new_lst = [i for i in range(1,101) if i % 3 == 0 and i % 6 == 0]
print(new_lst)

# 需求过滤掉长度小于等于3的人名，首字母大写
r = [n.capitalize() for n in names if len(n) > 3]
print(r)

四、迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象；迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束；迭代器只能往前不会后退。

4.1 迭代器有两个基本的方法：iter() 和 next()

__iter__() 方法返回一个特殊的迭代器对象
__next__() 方法会返回下一个迭代器对象

4.2 字符串、列表或元组对象都可用于创建迭代器

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
print (next(it)) # 输出迭代器的下一个元素
print (next(it))

# 输出
1
2

4.3 迭代器对象可以使用常规for语句进行遍历

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")

# 输出
1 2 3 4

4.4 也可以使用 next() 函数

import sys # 引入 sys 模块

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象

while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

4.5 如何判断一个对象是否是可迭代的?

from collections import Iterable
g = (x*3 for x in range(10))
lst = [1,2,3]
r = isinstance(g,Iterable)
print(r)

#True

4.6 可迭代对象包含哪些?

• 列表、集合、字典、字符串、元祖
• 生成器
  
  

4.7 创建一个迭代器

打印随机数，当遇到8就停止。

# 传入两个参数：第一个普通函数或可调用对象，用于不断调用产生值，
# 第二个是一个“停止符”，当前面的函数或对象产生这个值，就停止。
# iter()返回一个迭代器。

from random import randint
def random_int():
return randint(1,10)

test = iter(random_int,8)
for num in test:
print(num)

创建一个返回数字的迭代器，初始值为 1，逐步递增 1，在 20 次迭代后停止执行。

# StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，
# 在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

def __next__(self):
    if self.a <= 20:
        x = self.a
        self.a += 1
        return x
    else:
        raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
    print(x)

五、生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

什么情况下需要使用 yield？

一个函数 f，f 返回一个 list，这个 list 是动态计算出来的，并且这个 list 会很大，这个时候，我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个 list 元素，而不是直接得到一个完整的 list 来节省内存，这个时候 yield 就很有用。

5.1 生成器的实现

1、通过列表推导式来得到生成器

# 得到0 - 10之内分别和3相乘的列表 [0 3 6 9 12 15...] 
# range(5) 等价于 range(0,5) 等于 [1,2,3,4] * 3
new_lst = [x*3 for x in range(20)]

# 列表推导式的语法格式 
g = (x*3 for x in range(10))
print(type(g)) # generator
print(g.__next__())
print(g.__next__())

2、通过函数来得到生成器

'''
1. 定义一个函数，函数中要使用yield关键字
2. 调用函数，接收调用的结果，结果就是一个生成器
3. 借助next() __next__ 获取元素
'''

def fn():
    num = 0
    while True:
        num += 1
        yield num

g = fn()
print(g.__next__())
print(next(g))

5.2 可迭代、迭代器、生成器三个概念的联系和区别

可迭代
概念范围最大，生成器和迭代器肯定都可迭代，但可迭代不一定都是迭代器和生成器，比如上面说到的内置集合类数据类型。可以认为，在 Python 中，只要有集合特性的，都可迭代。

迭代器
迭代器特点是，均可以使用 for in 和 next 逐一遍历。

生成器
生成器一定是迭代器，也一定可迭代。

至于 Python 中为何要引入迭代器和生成器，除了节省内存空间外，也可以显著提升代码运行速度。

---

总结

点击访问源图