Python Day12 迭代器和生成器【零基础】

Day12 迭代器和生成器

1. 迭代器

1.1 什么是迭代器（iter)

迭代器是容器型数据类型；

特点：打印一个迭代器的时候无法查看迭代器中所有的元素，迭代器无法通过len获取元素个数。

如果想要使用迭代器中的元素，必须将元素从迭代器中取出，而且在取得时候只能从上往下按顺序取，取一个少一个，取出来的数据无法放回迭代器。

1.2 创建迭代器

1）用iter将其他序列转换成迭代器
2）创建生成器

i1 = iter('abc')
print(i1)

i2 = iter([10, 20, 30, 40])
print(i2)

1.3 迭代器的查操作

如何获取迭代器里面的元素，不管用什么样的方法获取到元素，该元素一定会从迭代器中消失
1）获取单个元素:next(迭代器) - 获取最上面的一个元素

i1 = iter('abc')
print(next(i1))
print(next(i1))
print(next(i1))
# print(next(i1))   已经没有元素了，再取就会报错！

a
b
c

i2 = iter([10, 20, 30, 40])
print(next(i2))

10

2）遍历

i1 = iter('abc')

for i in i1:
    print(f'i: {i}')

i: a
i: b
i: c

i2 = iter([10, 20, 30, 40])

for i in i2:
    print(f'i: {i}')

i: 10
i: 20
i: 30
i: 40

3）迭代器可以转换为列表

i3 = iter('hello')
result = list(i3)
print(result)

[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]

2. 生成器

2.1 什么是生成器

生成器是容器型数据类型（具备创建多个数据的能力，而不是保存多个数据的能力）

特点：

• 内存的消耗减少，不会浪费
• 打印生成器无法查看所有的元素，生成器也不支持len操作。
• 获取元素的时候取一个少一个，也不可以放回去。
• 如果需要使用生成器中的数据，必须将数据创建出来，而且取一个少一个。
• 生成器获取数据的方式和迭代器一样。

2.2 创建生成器

生成器保存的并不是数据本身，而是产生数据的算法，算法就是产生数据的函数（函数才具备保存代码的能力）

怎么产生生成器：调用带有yield关键字的函数，就可以得到一个生成器。

def func1():
    yield  # yield的位置可以在return前面的任何地方
    print('+++++++')
    print('-------')
    print('=======')
    return 100

如果被调用的函数，函数体中有yield，调用该函数不会执行函数体，也不会获取函数返回值，得到的而是一个对应的生成器

2.3 创建生成器对应的函数

生成器创建数据的个数和数据的值，由在执行生成器对应的函数的时候，会遇到几次yield，每次遇到yield的时候对应的数据来决定，

执行函数体会遇到几次yield对应的生成器就可以创建多少个数据；

每次遇到yield，yield后面的值是什么，对应的元素就是什么。

def func2():
    yield 100
    yield 200
    yield 300


gen2 = func2()
print(next(gen2))
print(next(gen2))
print(next(gen2))

100
200
300

def func3(subject):
    for i in range(1, 10):
        yield f'{subject}{i:0>3}'


gen3 = func3('python')
print(next(gen3))
print('-----------------------------------华丽的分割线-----------------------------------')
for i in gen3:
    print(f'i:{i}')

python001
-----------------------------------华丽的分割线-----------------------------------
i:python002
i:python003
i:python004
i:python005
i:python006
i:python007
i:python008
i:python009

2.4 生成器产生数据的原理

调用函数创建生成器的时候不会执行函数体，获取生成器中的元素的时候才会执行函数体。

每次在执行函数体的时候从开始位置开始，执行到yield就停下来，并且将yield后面的数据作为获取到的元素。

def func4():
    print('-------1-------')
    yield 10
    print('-------2-------')
    yield 20
    print('-------3-------')
    yield 30


gen4 = func4()
print(next(gen4))
# print('----')
print(next(gen4))
# print('----')
print(next(gen4))

-------1-------
10
-------2-------
20
-------3-------
30

3. 模块

3.1 什么是模块

Python中一个py文件就是一个模块

3.2 怎么在一个模块中使用另外一个模块的内容

前提：被使用的模块名（py文件的文件名）必须符合变量名的要求

使用原则：先导入才能使用（能被别的模块使用的内容只能是全局变量）

3.3 如何导入模块

注：同级创建了个py文件test1.py

方法1：import 模块名 - 导入指定模块，导入后可以通过’模块名.xxx’的方式使用这个模块中所有的全局变量

# 导入方式1
import test1
print(test1.a)

100

方法2：from 模块名 import 变量1, 变量2, … - 导入指定模块中的指定变量，导入后可以直接使用所有指定的变量

# 导入方式2
from test1 import a, func1

print(a)
print(func1('123'))

100
6

方法3：from 模块名 import * - 导入指定模块中所有的变量，导入后可以直接使用所有的变量

# 导入方式3
from test1 import *

方法4：import 模块名 as 新模块名 - 导入模块的时候对模块进行重命名，使用的时候就用新模块名通过’新模块名.xxx’的方式使用模块中的全局变量

# 导入方式4
import test1 as t1

方法5：from 模块名 import 变量1 as 新变量1, 变量2 as 新变量2, … - 对导入的变量重命名

from test1 import func1 as f1
print(f1('912'))

12

3.4 导入模块的原理

不管以什么样的方式，导入了模块或者模块中的内容。系统都会在导入模块的时候进入到对应的模块，将模块中代码全部执行一遍。

当我们只需要模块中的某些功能的时候，如何选择性的导入：
在被导入的模块中添加被指定的if语句（if name == ‘main’)，将不需要被别的模块执行的代码放入到这个if语句中

if __name__ == '__main__':
    # 这个if语句中的代码不会被别的模块执行
    pass

4. 包

4.1 什么是包

包就是包含__init__.py文件的文件夹

包就是用来管理py文件的，对py文件按照特定方式进行分类

4.2 如何使用包中模块的内容

创建一个包

1）import 包名 - 导入指定的包（必须是包，文件夹无意义），导入后可以通过’包名.xxx’的方式使用__int__.py文件中所有内容

# 导入方式1：
import timeManage

2）import 包名.模块名 - 导入指定包中的指定模块（文件夹也可以用）

# 导入方式2：
import  timeManage.__bao__

3）from 包名 import 模块名1, 模块名2, 模块名3, …

# 导入方式3：
from timeManage import __bao__, __init__
print(timeManage)

4）from 包名.模块名 import 变量1, 变量2, …

# 导入方式4：
from timeManage.__init__ import a, b
print(timeManage)

5.异常捕获

5.1 什么是异常捕获

异常就是错误！

执行程序的过程中，如果出现异常，会中断程序的执行

exit() # 当程序遇到exit(),程序正常结束

print('++++++++')
print('========')
exit()
print('--------')

5.2 异常捕获

注意：不要滥用异常捕获
让程序出现异常的时候，不崩溃，还可以接着往后执行
运用场景：出现的异常并不是程序本身的问题，而是在程序执行过程中，外部给予的异常；
比如登录页面，用户没有按指定要求输入；
但是程序员又希望程序能继续执行，就需要异常捕获

结构1   -  捕获所有异常
try:
    代码段1（需要捕获异常的代码段）
except:
    代码段2（捕获到异常需要执行的代码段）

执行过程：先执行代码段1，如果出现异常直接马上执行代码段2；如果没有出现异常，就不执行代码段2


结构2  -   捕获指定异常
try:
    代码段1（需要捕获异常的代码段）
except 异常类型:
    代码段2（捕获到异常需要执行的代码段）
    
    
结构3  - 同时捕获多种异常
try:
    代码段1（需要捕获异常的代码段）
except (异常类型1, 异常类型2,...):
    代码段2（捕获到异常需要执行的代码段）
    
    
结构4 - 同时捕获多种异常
try:
    代码段1（需要捕获异常的代码段）
except 异常类型1:
    代码段11
except 异常类型2:
    代码段22

执行过程：先执行代码段1，如果出现异常，直接马上执行代码段2；如果没有出现异常，就不执行代码段2

try:
    age = int(input('请输入年龄：'))
    if age >= 18:
        print('成年')
    else:
        print('未成年')
except:
    print('输入有误！')

请输入年龄：abc
输入有误！

try:
    print('abc'[4])
except:
    print('捕获异常')

捕获异常