回顾
1.匿名函数
lambda 参数列表：返回值
2.函数作为变量
声明函数就是声明类型是function的变量，函数名是变量名。
函数作为参数、函数作为返回值
sort\max\min
3.作用域
全局变量、局部变量、global/nonlocal
global 变量名
变量名 = 值
迭代器(iter)
函数调用过程：
函数调用过程又叫压栈的过程：每次调用函数，系统都会在内存的栈区间自动开辟一个临时的内存空间，用来保存在函数中声名的局部变量（其中形参也是保存在这个区域中），当函数调用结束，这内存区域会自动销毁（这个内存中存储的数据也会销毁）
2.迭代器（iter）
- 什么是迭代器？
迭代器是python提供的容器型数据类型，可变，有序的
迭代器和之前的列表、字典、集合、元祖等容器不一样，她只能查看元素，而且看一个，里面的元素就会少一个
迭代器的值：a.只能将其他的序列转换成迭代器 b.生成器
迭代器的元素：可以是任何类型的数据，可以重复
iter1 = iter('abc')
print(iter1)
fn = lambda x:x
iter2 = iter([12, 34, 'abc', [1, 2],fn])
print(iter2)
2）查 - 获取元素的值
注意：不管以任何形式获取了迭代器中某个元素的值，这个元素都会从迭代器中消失
a.获取单个元素
next(迭代器)/迭代器.next() - 返回容器中最上面的元素
next(iter1)
#iter1.__next__()
print(next(iter1))
b.遍历取出迭代器中的每个元素
print('============================================')
iter3 = 'abcdefg'
for item in iter3:
print(item)
3)什么时候用迭代器：容器中的数据使用过后不需要保存了，这种数据就用迭代器来保存。
生成器（generator）
1.什么是生成器
生成器就是迭代器，但是迭代器不一定是生成器
1)怎么创建生成器
如果函数中有yield关键字，那么这个函数就不再是一个普通的函数；调用函数不再是执行函数体，获取返回值，而是创建这个函数对应的生成器对象
def nums():
for x in range(10):
print(x)
yield # --> ！
return 100
gen1 = nums() # 函数调用表达式nums()才是生成器
2）生成器怎么产生数据
一个生成器能够产生多少个数据，就看执行完生成器对应的函数体会遇到第几次yield关键字生成器是在获取数据的时候才会产生数据，执行生成器对应的函数的函数体，直到遇到yield为止，将yield后面的数据作为生成器的元素返回，并且会记录这次产生数据函数体结束的位置，下次在产生数据的时候，会接着上次结束的位置接着往后执行...如果从执行开始到函数结束，没有遇到yield，那么就不会产生数据。
def nums():
print('+++++++++++++')
yield 100
print('-------------')
yield 'abc'
print('*************')
for x in range(4):
yield x
创建一个生成器gen2
gen2 = nums()
print('取第一个值')
print(next(gen2))
print('取第二个值')
print(next(gen2))
print('取第三个值')
print(next(gen2))
print('取第四个值')
print(next(gen2))
print('取第五个值')
print(next(gen2))
print('取第六个值')
print(next(gen2))
#print('取第七个值')
#print(next(gen2)) # StopIteration
print('=====================================')
def nums2():
index = 0
while 1:
yield index
index += 1
gen3 = nums2()
for _ in range(10):
print(next(gen3))
print(next(gen3))
print(next(gen3))
练习：写一个生成器，能够产生'stuxxxx'的学号，stu0000 - stu9999
def stu_num():
index = 0
while 1:
n = 'stu' + str(index).rjust(4, '0')
yield n
index += 1
gen4 = stu_num()
for _ in range(100):
print(next(gen4))
生成器
1.生成式
生成式是生成器的另外一种写法（简写）
'''
a.语法
生成器变量 = 表达式 for 变量 in 序列
b.说明：表达式 ——可以是值、变量、运算表达式、函数调用表达式等，不能是赋值语句
c.展开
def 函数名（）：
for 变量 in 序列：
yield 表达式
'''
gen1 = (5 for x in range(5))
for _ in range(5):
print(next(gen1))
'''
a.语法2
生成器变量 = （表达式 for 变量 in 序列 if 条件语句） ——结果是生成器
列表变量 = [表达式 for 变量 in 序列] ——结果是列表
b.展开
def 函数名（）：
for 变量 in 序列：
if 条件语句：
yield 表达式
'''
gen2 = (x for x in range(10) if x % 2)
# 5个 1，3，5，7，9
for num in gen2:
print(num)
gen2 = ((x,x*2) for x in range(10) if x % 2)
for num in gen2:
print(num)
gen2 = ((x,x*2) for x in range(10) if x % 2)
list2 = list(gen2)
print(list2)
gen2 = ('num%d' % x for x in range(10) if x % 2)
print(next(gen2))
模块
python中一个py文件就是一个模块
'''
从封装的角度看：
函数是对功能的封装
模块可以通过多个函数对不同的功能进行封装，还可以通过全局变量队数据进行封装
'''
0.模块的分类：系统模块（内置模块）、第三方库、自定义模块
1.模块的导入
test
test1_a = 100
b = 'hello'
def test1_func1():
print('这是test1中的函数func1')
test2
def c_sum(n1,n2):
return n1+n2
if __name__ == '__main__':
for i in range(100):
print(i)
a. import 模块名 -- 可以通过'模块名.'的方式去使用这个模块中的所有全局变量
'''
import keyword
import random
import math
import test
print(test.test1_a)
test.test1_a = 200
print(test.test1_a)
test.test1_func1()
'''
b. from 模块名 import 全局变量1，全局变量2，...... -- 导入指定模块中指定的全局变量，导入后直接使用全局变量
'''
from random import randint
print(randint(10, 30))
from test import test1_func1,test1_a
test1_func1()
print(test1_a)
'''
c.import 模块名 as 新的模块名 -- 重命名
注意：模块重命名后，原名不能使用
'''
import test as TS
print(TS.test1_a)
TS.test1_func1()
'''
================导入模块并重命名================
'''
b = 'python'
from test import b as T_b
print(b,T_b)
'''
3.导入模块的原理：当代码执行到import或者from - import的时候，会自动将对应的模块中的代码全部执行一遍,同一个模块导入多次不会执行多次
4.阻止导入：将需要阻止被别的模块导入的代码放到以下的if语句中
'''
if name == 'main':
需要阻止导入的代码段
原理：每个模块都有一个属于自己的name属性，用来保存当前模块的模块名。默认情况下name
的值就模块对应的py文件的文件名。当我们直接运行某个模块的时候，对应的模块的name
会自动变成'main',其他模块是默认值。
'''
import PIL
import requests
import pygame
异常捕获
1.异常：程序错误、程序崩溃。程序中某句代码出现异常那么从这条语句开始后面的代码都不会执行，程序直接结束
2.异常捕获：让程序出现异常的时候程序不崩溃
1）方式一：捕获所有异常
'''
a.语法
try:
代码段1
except：
代码段2
其他语句
b.说明：先执行代码段1，如果代码段1不出现异常，直接执行后面的其他语句，如果出现异常就直接执行
代码段2，然后执行其他语句
'''
try:
print(int('12a'))
print('!!!!!!!!')
except:
print('出现异常')
2）方式二：捕获指定的一个或者多个异常，做相同的处理
'''
try:
代码段1
except 异常类型/(异常类型1,异常类型2)：
代码段2
其他语句
说明：先执行代码段1，如果代码段1不出现异常，直接执行后面的其他语句；如果出现异常，判断这个
异常类型和需要捕获的异常类型一致，程序不崩溃，直接执行代码段2，然后在执行其他语句；
如果异常类型和需要捕获的异常类型不一致，程序直接崩溃
注意：异常类型要求必须是直接或者间接继承Exception类的子类
'''
3）方式三：捕获不同类型的异常，并且可以对不同的异常做不同的处理
'''
try:
代码段1
except 异常类型1：
代码段2
except 异常类型2：
代码段3
.
.
.
finally:
print('写遗书！')
'''
3.finally后面的代码段，不管try中的代码发生了什么，都会执行
作业：输入年龄并且将年龄值转换为整数，如果输入错误程序不崩溃，让其重新输入，直到输入无误为止
print('====================作业==================')
age = 0
while 1:
try:
age = int(input('输入年龄：'))
except:
print('出现异常！请重新输入')
if age:
print('输入成功！')
break
