迭代器，生成器，模块，包，异常捕获

什么是迭代器？：

迭代器是容器型数据类型，打印一个迭代器无法查看这个迭代器中所有元素，迭代器无法通过len获取元素个数，如果想要使用迭代器中的元素，必须将元素从迭代器中取出来，而且取出的时候只能从上往下一个一个取，取出来的元素无法在放回迭代器。（迭代器也是全局变量）

创建迭代器：

方法1.用iter将其他序列转换成迭代器

#方法2.创建生成器
i1= iter('abc')
print(i1)
i2 = iter([1,2,3,4])
print(i2)
# print(len(i2)) 会报错

迭代器的查操作：

注意：不管以什么样的方式获取到的元素，被获取的元素一定会从迭代器中取出

获取单个元素：next(迭代器)

i2 = iter([1,2,3])
print(next(i2))
print(next(i2))
print(next(i2))
# print(next(i2))#当迭代器元素被取完时，再取元素会报错

遍历

i2 = iter([1,2,3])
for x in i2:
    print(f'x:{x}')

迭代器转换成序列

i2 = iter([1,2,3])
i3 = list(i2)#迭代器转换也算取出元素
print(i3)#[1, 2, 3]

什么是生成器

生成器是容器型数据类型（具有多个数据创建的能力，不是保存多个数据的能力）打印生成器无法查看所有元素，生成器也不支持len操作。如果需要使用生成器中的数据，必须将数据取出来，而且取一个少一个

生成器获取数据的方法和迭代器一样

生成器：生成器保存的并不是数据，而是产生数据的算法

创建生成器：调用带有yield关键字的函数，就可以得到一个生成器

def func1():
    yield
    print('你好吖!')
    return '你好吗？'
result = func1()
print(f'result:{result}')

如果被调用的函数里有yield关键字，调用函数的时候不会执行函数体，也不会获取返回值而是得到一个生成器对象（函数调用表达式的值就是生成器）

定义生成器对应的函数：

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

def func2():
    yield '你好吖'
    yield  100
    yield 200
gen2 = func2()
print(next(gen2))
print(next(gen2))
print(next(gen2))

def fun3 (subject):
    for x in range(1,100):
        yield f'{subject}{x:0>3}'
gen3 = fun3('python')
print(next(gen3))
for x in gen3:
    print(f'x:{x}')

生成器产生数据的原理：

调用函数创建生成器的时候不会执行函数体，获取生成器中的元素的时候才会执行函数体，每次在执行函数体的时候从开始位置开始，执行到yield就停下来，并将yield后面的数据作为获取到的元素

def func4():
    print('a')
    yield 1
    print('b')
    yield 2
    print('c')
    yield 3
gen4 = func4()
print(next(gen4))

模块

什么是模块：python中模块就是py文件

怎么在一个模块中使用另外一个模块：

前提：被使用模块的模块名（py文件名）必须符合变量名的要求
使用原则：先导入才能使用（能用的内容只能是全局变量）
怎么导入模块：方法一 impor 模块名(直接导入指定模块，导入可以 通过’模块名.xxx’的方式使用这个模块里的全部全局变量)

import main
print(main.a)
print(main.c)
print(main.func1())

方法二：form 模块名 import 变量1，变量2，…（导入指定模块中的指定变量

导入后可以直接使用指定的变量

from main import a,c,func1
print(a)
print(c)

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

from main import *
print(a)
print(c)

方法四： import 模块名 as 更新模块名（导入模块的时候对模块重命名，通过’新模块名.xxx’方式来使用全局变量）

from 模块名 impor 变量1 as 重命名变量1，变量2 as 新变量2（对导入的变量重命名）

import main as ma
print(ma.a)
print(ma.c)
print(ma.func1())

from 模块名 impor 变量1 as 重命名变量1，变量2 as 新变量2（对导入的变量重命名）

from main import a as ase,c as cs,func1 as func2,b as bs
print(ase)
print(cs)
print(func2())
print(bs)

导入模块的原理：

不管以什么方式导入了模块或者内容，系统都会在导入模块时进入对应的模块，将模块中的代码都执行一遍
原理存在的问题：可能再导入模块的时候执行一些完全没必要的代码
导入模块的时候悬着执行代码：再被导入的模块中添加指定的if语句（if name == ‘main’ :）

什么时包：

就是包涵__init__.py文件的文件夹
包就是用来管理py文件,对py文件的特定的方式分类

怎么使用包中的内容:

方法一

import 包名 (必须是包,文件夹无意义),导入后,可以通过’包名.xxx’的方式来使用,只能执行__in__py文件的内容3

import nihao
nihao.cai()

方法二: import 包名.模块名 (导入指定包中的指定模块,文件夹也可用)

import nihao.gong
print(nihao.gong)

方法三:from 包名 import 模块名1,模块名2,…(直接导入包中的模块，然后重命名)

from nihao import gong as neng
print(neng)

方法四:from 包名.模块名 import(直接导入包中指定多个模块)

from nihao.gong import cai,ni
print(cai)

异常捕获

异常就是错误(影响:会导致程序中断,提前结束)
异常捕获的作用:让程序出现异常的时候不崩溃,还可以往后执行
应用场景:导致异常的原是使用者操作不当出现的,又希望出现异常后还可以继续执行才使用异常捕获
注意：不要滥用异常捕获

结构:

'''
结构1:捕获所有错误异常
tey:
    需要捕获异常的代码
except:
    代码段2(捕获到异常需要执行的代码段)
过程:先执行代码段1,出现异常直接马上执行代码段2,如果没有异常,就不执行代码段2
结构二:捕获指定异常
tey:
    需要捕获异常的代码
except 异常类型:IndentationError
    代码段2(捕获到异常需要执行的代码段)
结构三:同时捕获多种异常
tey:
    需要捕获异常的代码
except(异常类型1,异常类型2,异常类型3....):
    代码段2(捕获到异常需要执行的代码段)
结构四:同时捕获多种异常,并根据异常类型进行不同的处理
tey:
    需要捕获异常的代码
except 异常类型1:
    代码段11(捕获到异常需要执行的代码段)
except 异常类型2:
    代码段22(捕获到异常需要执行的代码段)
'''

 try:
     print('123'[0])
     print('233'[6])
     print('666')
 except:
     print('捕获异常')
 print('程序结束')
 try:
     age = int(input('请输入年龄:'))
     if age < 18:
         print('未成年')
     else:
         print('成年')
 except:
     print('输入的不是年龄')