1. 迭代器

1.1 函数调用过程:

函数调用过程又叫压栈的过程：每次调用函数，系统都会在内存的栈区间自动开辟一个临时的内存空间， 用来保存在函数中声明的局部变量(其中形参是也保存在这个区域中的)，当函数调用结束，这个内存区域会自动销毁(这个内存中存储的数据也会销毁)

1.2 迭代器(iter)

1.2.1 什么是迭代器

• 迭代器是python提供的容器型数据类型。 （可变，有序的）-- 不关注
• 迭代器和之前的列表、字典、集合、元祖等容器不一样，它只能查看元素，而且看一个对于迭代器来说，里面的元素就会少一个
• 迭代器的值：a.将其他的数据转换成迭代器 b.生成器
• 迭代器的元素: 任何类型的数据都可以，可以重复

iter1 = iter('abc')
print(iter1)

iter2 = iter([12, 34, 'abc', [1, 2], {'a': 10}, (1, 2), {1, 3}, lambda x: x])
print(iter2)

1.2.2 查 - 获取元素的值

注意: 不管以任何形式获取了迭代器中某个元素的值，这个元素都会从迭代器中消失

• 获取单个元素
  next(迭代器)/ 迭代器.next() - 返回容器中最上面的元素

print(next(iter1))
print(next(iter1))
print(next(iter1))
# print(next(iter1))     #  StopIteration

• 遍历取出迭代器中的每个元素

print('=============')
iter3 = iter('abcdef')
next(iter3)
next(iter3)
for item in iter3:
    print(item)

print('=============')
# print(next(iter3))   # StopIteration

1.2.3 什么时候使用迭代器

多个数据中，某个或者某些数据使用过了就不需要再保存了，这种数据就可以使用迭代器来保存。

2. 生成器

2.1 什么是生成器

生成器就是迭代器， 但是迭代器不一定是生成器

2.2 怎么创建生成器

如果函数中有yield关键字，那么这个函数就不再是一个普通的函数。
调用函数不再是执行函数体，获取返回值。而是创建这个函数对应的生成器对象

def nums():
    print('============')
    print(100)
    if False:
        yield
    return 100


gen1 = nums()      # 函数调用表达式nums()才是生成器

2.3 生成器怎么产生数据

一个生成器能够产生多少个数据，就看执行完生成器对应的函数体会遇到几次yield关键字；
生成器是在获取数据的时候才会产生数据，执行生成器对应的函数的函数体，直到遇到yield为止，将yield后面的数据作为生成器的元素返回，并且会记录这次产生数据函数体结束的位置，下次再产生数据的时候，会接着上次结束的位置接着往后执行...如果从执行开始到函数结束，没有遇到yield，那么就不会产生数据。

def nums():
    print('++++++')
    yield 'abc'
    print('-------')
    yield 100
    print('********')
    for x in range(5):
        yield x


# 创建一个生成器gen2
gen2 = nums()
print('取第一个值')
print(next(gen2))
print('取第二个值')
print(next(gen2))
print('取第三个值')
print(next(gen2))

def nums2():
    index = 0
    while True:
        yield index
        index += 2


gen3 = nums2()
for _ in range(10):
    print(next(gen3))


print(next(gen3))
print(next(gen3))

2.4 练习: 写一个生产器，能够产生'stuXXXX'的学号， stu0000 ~ stu9999

def stu_num_creater(count, width=0):
    for num in range(count):
        if width == 0:
            width = len(str(count))
        num_str = 'stu' + str(num).zfill(width)
        yield num_str


creater = stu_num_creater(100, 4)
print(next(creater))
for num in creater:
    print(num)

3. 生成式

生产式是生成器的另外一种写法（简写）

3.1 语法1：

• 生成器变量 = (表达式 for 变量 in 序列) -- 结果是生成器
  列表变量 = [表达式 for 变量 in 序列] -- 结果是列表

• 说明: 表达式 - 可以是值、变量、运算表达式、函数调用表达式等，只要不是赋值语句都可以

• 展开
  def 函数名():
  for 变量 in 序列:
  yield 表达式

gen1 = (x*2 for x in range(5))
print(gen1)
for num in gen1:
    print(num)

3.2 语法2：

生成器变量 = (表达式 for 变量 in 序列 if 条件语句)

• 展开
  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)

# next(gen2)


gen2 = ['num%d' % x for x in range(10) if x % 2]
print(gen2)

4. 模块

python中一个py文件就是一个模块
从封装的角度看：
函数是对功能的封装
模块可以通过多个函数对不同的功能进行封装，还可以通过全局变量对数据进行封装

4.1 模块的分类: 系

统模块(内置模块)、第三方库(别人写的)、自定义模块

4.2 模块的导入

• import 模块名 / import 模块名 as 新的模块名 --- 可以通过'模块名.'的方式去使用这个模块中所有的全局变量
• from 模块名 import 全局变量1 as 新名1,全局变量2 as 新名2,... --- 带入指定模块中指定的全局变量，导入后直接使用全局变量
  注意: 重命名后，原名不能使用

# ===========导入方式1===========
# import keyword
# import random
# import math
# import test
#
# print(test.test1_a * 3)
# test.test1_a = 200
# print(test.test1_a)
#
# test.test1_func1()

# ============导入方式2==========
# from random import randint
# print(randint(10, 30))
#
# from test import test1_func1, test1_a
# test1_func1()
#
# print(test1_a)

# ============导入模块并重命名==========
# import test as TS
# print(TS.test1_a)
# TS.test1_func1()

# b = 'python'
# from test import b as t_b, test1_a as t_a
#
# print(b, t_b, t_a)

4.3 导入模块的原理

当代码执行到import或者from - import的时候，会自动将对应的模块中的代码全部执行一遍，同一个模块导入多次不会执行多次(放心的导入!)

# print('++++++++++++++')
# import test
# import test
# from test import test1_a
# import test2
#
# print(test1_a, test.test1_func1())
# print('++++++++++++++')
# print('mudule:', __name__)
# from test2 import yt_sum
# print(yt_sum(1, 1))

#import PIL
# import requests

4.4 阻止导入

将需要阻止被别的模块导入的代码放到以下if语句中

if __name__ == '__main__':
    #需要阻止导入的代码段

原理:
每个模块都有一个属于自己的name属性，用来保存当前模块的模块名。默认情况下name的值就模块对应的py文件的文件名。
当我们直接运行某个模块的时候，对应的模块的name会自动变成'main',其他模块是默认值。

5. 异常

5.1 异常 ： 程序错误、程序崩溃。程序中某条语句出现异常，那么从这条语句开始，后面的代码不会执行，程序直接结束

5.2 异常捕获：程序出现异常的时候，程序不崩溃

5.2.1 方式一： 捕获所有类型的异常

a.语法

try:
    代码段1
except:
    代码段2
finally:
    代码段N
其他语句

b.说明：先执行代码段1，如果代码段1不出现异常，直接执行后面的其他语句；
如果出现异常不崩溃直接执行代码段2，然后再接着其他语句

list1 = [1, 2, 3]

try:
    print(list1[10])
    print({'a': 10}['b'])
    print('~~~~')
except:
    print('出现异常')

print('======================')

5.2.2 方式2：捕获指定的一个或者多个异常，做相同的处理

try:
    代码段1
except 异常类型:
    代码段2
finally:
    代码段N
  
其他语句    

try:
    代码段1
except (异常类型1,异常类型2,...):
    代码段2
finally:
    代码段N
其他语句 

• 先执行代码段1，如果代码1没有出现异常，直接执行后面的其他语句；
• 如果代码段1出现异常，如果这个异常的类型和需要捕获的异常类型一致，程序不崩溃，直接执行代码段2，然后再执行其他语句；
• 如果代码段出现异常，异常类型和需要捕获的异常类型不一致，程序直接崩溃

注意：异常类型要求必须是直接或者间接继承Exception类的子类

print('==============方式二===============')
try:
    # print({'a': 10}['n'])
    # print([1, 2, 3][10])
    print('======')
    print(int('abc'))
except (KeyError, IndexError):
    print('出现异常!')
finally:
    print('写遗书！')

5.2.3 方式3：捕获不同类型的异常，并且可以对不同的异常做不同的处理

try:
    代码段1
except 异常类型1:
    代码段2
except 异常类型2:
    代码段3
finally:
    代码段N

print('==============方式3===============')
try:
    print({'a': 10}['b'])
    print([1, 2, 3][10])
except IndexError:
    print('下标越界')
except KeyError:
    print('key不存在')

finally后面的代码段，不管try中的代码发生了什么，都会执行

作业: 输入年龄并且将年龄值转换成整数，如果输入错误程序不崩溃，让其重新输入，直到输入无误为止...