Day13_模块和异常

一、生成器

1.1 什么是生成器

1）容器（是一种可以创建多个数据的容器），生成器中保存的是创建数据的方法，而不是数据本身。
2）特点：
a.打印生成器无法查看元素；
b.不能通过len统计元素的个数;
c.如果需要生成器中的数据，必须将数据取出，而且取一个就少一个

3)生成器获取元素的方法和迭代器获取元素的方式一模一样

2.2 怎么创建生成器

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

def func1():
    print('hello')
    yield
    return 100


result = func1()
print(f'result:{result}')

2.3 怎么控制生成器中元素的个数和元素的值

执行常见生成器的函数的函数体的时候，会遇到几次yield，对应的生成器就可以创建几个数据，每次遇到yield，yield后面的值就是能创建出来的数据。

def func2():
    print('+++++')
    yield 100
    print('------')
    yield 200
    print('=======')
    yield 300


gen2 = func2()
print(gen2)
print('next:', next(gen2))
print('next:', next(gen2))
print('next:', next(gen2))
# print('next:', next(gen2))        # 报错！

print(list(gen2))       # []

def func3(n):
    yield 100
    if n % 2 == 0:
        yield 200
    yield 300


gen3 = func3(3)
print(gen3)
print(list(gen3))       # [100, 300]
# print(next(gen3))     # 报错！


num = 1000

二、模块

2.1 什么是模块

python一个py文件就是一个模块。

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

1)前提：如果想要在一个模块中使用另外一个模块中的内容，被使用的模块的模块名必须符合变量名的要求

'''
2)导入模块
a. import 模块名       -   导入指定模块，导入后可以通过'模块名.xxx'的方式使用这个模块中所有的内容
b. from 模块名 import 内容1, 内容2, ...    -       导入指定模块，导入后可以直接使用指定内容
c. from 模块名 import *        -   导入指定模块，导入后可以直接使用模块中所有内容
d. import 模块名 as 新模块名       -     导入指定模块后对应模块进行重命名： '新模块名.xxx'
e. from 模块名 import 内容1 as 新内容1      -   对导入的内容重命名
'''

# --------------- a.导入方式1 ----------------
# import test
#
# print(test.a)
# print(test.name)
# test.f_test1()

# --------------- b.导入方式2 ----------------
# from test import a, f_test1
#
# print(a)
# f_test1()
# # print(name)       # 报错！

# --------------- c.导入方式3 ----------------
# from test import *
#
# print(a)
# print(name)
# f_test1()


# --------------- d.导入方式4 ----------------
# import test as t1
#
# test = 1000
#
# print(t1.a)
# print(t1.name)
# t1.f_test1()
#
# print(test)


# --------------- e.导入方式5 ----------------
# from test import name as t_name, a
#
# name = '小花'
#
# print(name)
# print(t_name)
# print(a)

三、包

3.1 什么是包

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

3.2 怎么使用包或者文件夹中的模块中的内容

"""
1）import 包名     -   (只适用于包)导入指定的包，导入后可以通过'包名.xxx'去使用包中__init__.py文件中的所有的内容
2）from 包名 import 模块名1, 模块名2,....    -    导入指定包中指定的模块，导入后可以通过'模块名.xxx'使用指定模块中的内容
3）from 包名 import 内容1, 内容2,...     (只适用于包)导入指定包中__init__.py文件中的指定内容  
4）import 包名.模块名
5）from 包名.模块名 import 内容1, 内容2,...
"""

# -------------------导入方式1-----------------
# import files2
#
# files2.f_test2()
# print(files2.pi)

# -------------------导入方式2-----------------
# from files2 import test2, test4, pi, f_test2
#
# print(test2.msg)
# print(test4.abc)
# print(pi)
# f_test2()
#
# from files import test1
# print(test1.money)

# from files2.abc import test3
# print(test3.demo)

# -------------------导入方式3-----------------
# import files2.test2
# print(files2.test2.msg)

# import files2.test2 as t2
# print(t2.msg)

# import files2.abc.test3 as t3
# print(t3.demo)

# -------------------导入方式4-----------------
# from files2.test2 import msg
# print(msg)

# from files2.abc.test3 import demo
# print(demo)

3.3 导入原理

导入模块的时候系统会进入到指定模块，将模块中的代码全部执行一遍

四、异常

4.1 异常 - 程序中错误

程序出现异常(报错)会直接让程序结束运行（在哪个位置出现的异常，程序就会在哪个地方结束）

print('++++++++')
print('abc'[4])
print('--------')
print('========')

4.2 异常捕获 - 让程序在出现异常的时候程序不结束，还可以接着往后执行

"""
1)语法结构1  - 捕获所有异常
try:
    代码段1(需要捕获异常的代码)
except:
    代码段2(出现异常后会执行的代码)
finally:
    代码段3(最后无论如何都会执行的代码)

执行过程：先执行代码段1，执行代码段1的时候如果没有出现异常，就不执行代码段2；如果出现异常，程序不报错并且马上执行代码段2

2）语法结构2（推荐使用！）  -  捕获指定类型的异常
try:
    代码段1(需要捕获异常的代码)
except 异常类型:
    代码段2(出现异常后会执行的代码)
finally:
    代码段3(最后无论如何都会执行的代码)
    
    
3）语法结构3 - 同时捕获多种
try:
    代码段1(需要捕获异常的代码)
except (异常类型1, 异常类型2, ...):
    代码段2(出现异常后会执行的代码)
finally:
    代码段3
    
4）语法结构4 - 同时捕获多种
try:
    代码段1
except 异常类型1:
    代码段11
except (异常类型2, 异常类型22, ...):
    代码段22
except 异常类型3:
    代码段33
...
finally:
    代码段3


"""

try:
    age = int(input('请输入年龄:'))
    print(age)
except:
    print('年龄输入有误！')


try:
    print('abc'[4])
except KeyError:
    print('出错！')
finally:
    print('遗书')