day12 迭代器生成器和模块

一、变量作用域

1、全局变量

没有定义在函数或者类中的变量都是全局变量

全局变量的作用域是从定义开始到程序结束

# a是全局变量
a = 10

# b、i 是全局变量
for i in range(5):
    b = 20
    print(i, b)

print(b, i)         # 20 4


def func1():
    print(b, a, i)


func1()     # 20 10 4

2、局部变量

定义在函数中的变量是局部变量

局部变量的作用域是从定义开始到函数结束

局部变量默认保存在函数对应的临时栈区间中；函数对应的临时栈区间是开始调用函数的时候创建，函数调用结束会自动销毁

# c、d是局部变量
def func2(d):
    c = 30
    print(c, d)


func2(20)       # 30 20

# print(c)        # 报错
# print(d)        # 报错

3、global关键字

global只能在函数体中使用，用来改变函数中变量的存储方式（让局部变量保存到全局栈区间中）

1）在函数中定义全局变量，需要先用global进行声明

2）如果要在函数中修改全局变量的值，需要先用global进行声明，否则不会修改全局变量的值而是创建一个对应的局部变量

m = 100


def func3():
    global e
    e = 20
    # m = 200
    # print(m)    # 200

    global m
    m = 200
    print(m)    # 200


func3()
print(e, m)  # 20 100
print(m)    # 200

二、迭代器

1、迭代器

容器型数据类型

打印迭代器无法查看所有的元素，也不能统计元素的个数，如果需要使用迭代器中的元素必须将元素从迭代器中取出，而且取一个就少一个。

如果想要使用后面的数据，必须先前面的数据取完。

2、创建迭代器的方法

1）将其他序列转换成迭代器（所有序列都可以转换成迭代器）

2）创建生成器

注意：打印迭代器无法看到元素；迭代器无法统计个数

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

# 打印迭代器无法看到元素
print(i1)       # <str_iterator object at 0x000002D01451B700>
print(i2)       # <list_iterator object at 0x000002D01451B6D0>

# 迭代器无法统计个数
# print(len(i1))    # 报错

3、获取迭代器中的元素

不管以任何方式得到迭代器中的元素，对应的元素会从迭代器中消失

1）获取一个元素：next(迭代器)

2）遍历

# 1）获取一个元素
i1 = iter('abc')
i2 = iter([10, 20, 30, 40])

print(next(i1))     # a
print(next(i1))     # b
print(next(i1))     # c
# print(next(i1))     # 报错

print(next(i2))     # 10

print('~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~')

# 2）遍历
for i in i1:
    print(f'i:{i}')

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

    # i: 20
    # i: 30
    # i: 40

print('~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~')

i3 = iter('hello')
print(list(i3))     # ['h', 'e', 'l', 'l', 'o']
# print(next(i3))     # 报错

三、生成器

1、生成器

生成器是可以产生多个数据的容器，而不是保存多个数据的容器。

打印生成器无法查看所有的元素，也无法统计生成器中元素的个数。

每次需要获取生成器中的元素的时候，生成器就会创建一个数据，创建一个就少一个

2、创建生成器

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

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

def func1():
    print('-------')
    print('+++++++')
    yield


result = func1()
print(f'result:{result}')       
# result:<generator object func1 at 0x0000022C06D4BAC0>

3、控制生成器产生的数据

生成器能产生多少个数据，能产生哪些数据，由执行创建生成器的函数的函数体会遇到几次yield，每次遇到yield的时候后面的值决定

def func2():
    yield 100
    yield 200
    yield 300


gen2 = func2()
print(list(gen2))       # [100, 200, 300]


def func3():
    for i in range(5):
        yield i + 1


gen3 = func3()
print(list(gen3))   # [1, 2, 3, 4, 5]

4、获取生成器中的数据

生成器获取元素和迭代器获取元素的方式—样

打印生成器无法查看元素

生成器无法统计个数

# 生成器获取元素和迭代器获取元素的方式—样
gen4 = func3()

# 打印生成器无法查看元素
print(gen4)       # <generator object func3 at 0x0000028B6039CCF0>

# 生成器无法统计个数
# print(len(i1))    # 报错

# 1）获取一个元素
print(next(gen4))       # 1
print(next(gen4))       # 2

# 2）遍历
for i in gen4:
    print(f'i:{i}')
    # i:3
    # i:4
    # i:5

5、生成器产生数据的原理

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


gen5 = func4()
print(next(gen5))

# -------
# 100

print('-----下一次------')
print(next(gen5))

# -----下一次------
# +++++++
# 200

四、模块

1、模块

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

2、在模块中使模块

前提： 被使用的模块的模块名（文件名）必须是标识符，但不是关键字

使用方法： 被使用的模块必须先导入再使用

3、导入模块

1）import 模块名 —— 导入指定模块，导入后可以通过模块名.xxx的方式去使用这个模块中所有的全局变量（包括全局函数）

2）from 模块名 import 变量1, 变量2, 变量3, ... —— 导入指定的模块中指定内容，导入后可以直接使用导入的所有变量

3）from 模块名 import * —— 导入指定模块中的所有内容，导入后可以直接使用所有内容

4）重命名

import 模块名 as 新模块名 —— 对模块名进行重命名
from 模块名 import 变量1 as 新变量1, 变量2 as 新变量2, 变量3 —— 对变量名进行重命名

# --------------导入方式1--------------
import dome

print(dome.a)
print(dome.name)

dome.list1.append(100)
print(dome.list1)

print(dome.func1())

# ---------------导入方式2-------------
from dome import a, func1

print(a)
func1()

# ---------------导入方式3-------------
from dome import *

print(a)
print(name)
print(list1)
func1()

# ---------------导入方式4-------------
import dome as de

print(de.a)
print(de.name)
de.list1.append(1000)
de.func1()

# ---------------导入方式5-------------
from dome import a as a1, name

a = 3
print(a)

print(a1)
print(name)

五、包

1、包

包含__init__.py文件的文件夹（包的本质就是文件夹）

2、使用包中模块的内容

前提： 包名和模块名必须是标识符，不是关键字

使用方法： 先导入再使用

3、导入包

1）import 包名 —— 直接导入包，导入后可以通过包名.xxx的方式使用__init__.py文件中所有的内容

2）import 包名.模块名 —— 直接导入包中指定的模块，导入后可以通过包名.模块名.xxx的方式使用模块中的内容

3）from 包名 import 模块名1, 模块名2 —— 导入包中指定的模块

4）from 包名.模块名 import 变量1，变量2，变量3 —— 导入指定包中指定模块中的指定变量

# ---------------导入方式1---------------------
import tools
print(tools.xx)

# ---------------导入方式2---------------------
import tools.test1
print(tools.test1.x1)

# ---------------导入方式2优化------------------
import tools.test1 as test1
print(test1.x1)

# ---------------导入方式3---------------------
from tools import test1
from tools.files import test2
print(test1.x1)
print(test2.x2)

# ---------------导入方式4---------------------
from tools.test1 import x1
from tools.files.test2 import x2

print(x1, x2)

import tools.files
print(tools.files.yy)