Day12-迭代器生成器和模块

一、变量作用域

1. 变量作用域 - 变量可以使用的范围

根据变量作用域的不同可以将变量分为：全局变量、局部变量

1) 全局变量

没有定义在函数(def)或者类(class)中的变量都是全局变量，全局变量的作用域是从定义开始到程序结束。
全局变量默认保存在全局栈区间，程序结束后才会自动销毁。

• a是全局变量

a = 10

• b是全局变量

for _ in range(5):
    b = 20
    print(f'循环中使用b：{b}')

print(f'外部使用a：{a}')
print(f'外部使用b：{b}')

• x是全局变量

for x in range(5):
    print(f'循环中使用a：{a}')
    print(f'循环中使用b：{b}')
    print(f'循环中使用x：{x}')

print(f'外部使用x: {x}')

• 使用a、b、x

def func1():
    print(f'函数中使用a：{a}')
    print(f'函数中使用b：{b}')
    print(f'函数中使用x：{x}')

2) 局部变量

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

• c、d是局部变量

def func2(d):
    c = 30
    print(f'函数内部使用c：{c}')
    print(f'函数内部使用d：{d}')


func2(29)

# print(f'函数外部使用c：{c}')       # 报错
# print(f'函数外部使用d：{d}')       # 报错

3. global关键字的作用

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

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

• 全局变量m

m = 100

def func3():
    # 在函数内定义全局变量
    global e
    e = 40

    # 在函数内修改全局变量
    global m
    m = 200
    print(f'函数内部m:{m}')

func3()
print(e)
print(f'函数外部m:{m}')

二、迭代器

1. 迭代器(iter)

容器型数据类型;
打印迭代器无法查看所有的元素，也不能统计元素的个数；
如果需要需要使用迭代器中的元素必须将元素从迭代器中取出，而且取一个就少一个；
如果想要使用后面的数据，必须先将前面的数据取完。

2. 创建迭代器的方法

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

2) 创建生成器

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

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

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

3. 怎么获取迭代器中的元素

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

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

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

print(next(i2))       # 10

2) 遍历（一个一个取完）

for x in i1:
    print(f'x:{x}')    # 无结果（已经取完）

for x in i2:
    print(f'x:{x}')    # 20, 30, 40

i3 = iter('hello')
print(list(i3))        # ['h', 'e', 'l', 'l', 'o']
# print(next(i3))      # 报错! (已经转换成列表)

result = map(lambda item: item*2,[10, 20, 30, 40])
print(result)
print(next(result))
for x in result:
    print('x:', x)

三、生成器

1. 什么是生成器

生成器是容器型数据类型；生成器是具有产生多个数据的能力的容器，而不是保存多个数据的容器
打印生成器无法查看所有的元素；也无法统计生成器中元素的个数。
每次需要获取生成器的中的元素的时候，生成器就会创建一个数据，创建一个就少一个。

2. 怎么创建生成器

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

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


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

3. 怎么控制生成器产生的数据的数量和值 - 控制yield次数

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

def func2():
    yield 100
    yield 200
    yield 300


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

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


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

4. 怎么获取生成器中的数据

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

gen4 = func3()

打印生成器无法查看元素

print(gen4)           # <generator object func3 at 0x10c7f4740>

无法获取生成器元素的个数

# print(len(gen4))    # 报错

获取一个元素

print(next(gen4))     # 1
print(next(gen4))     # 2

遍历生成器：

for x in gen4:
    print(f'x:{x}')   # 3、4、5

5. 生成器产生数据的原理 (了解)

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

#分开执行

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

四、模块

1. 什么是模块

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

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

• 前提：被使用的模块的模块名(文件名)必须是标识符并且不是关键字
• 使用方法：被使用的模块必须要先导入再使用。

3. 导入模块

from random import randint

1) import 模块名

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

2) from 模块名 import 变量1, 变量2, 变量3,…

导入指定模块中指定内容，导入后可以直接使用导入的所有变量

3) from 模块名 import *

导入指定模块中所有的内容，导入后可以直接使用所有内容

4) 对模块/变量重命名

import 模块名 as 新模块名 - 对模块重命名
from 模块名 import 变量1 as 新变量1, 变量2 as 新变量2, 变量3 as 新变量3,… - 对导入的变量重命名

----------导入方式1---------------

import demo

print(demo.a)
print(demo.name)

demo.list1.append(1000)
print(demo.list1)

demo.func1()

----------导入方式2---------------

from demo import a, func1

print(a)
func1()

----------导入方式3---------------

from demo import *
print(a)
print(name)
print(list1)
func1()

----------导入方式4---------------

import demo as de
print(de.a)
print(de.name)
de.list1.append(1000)
de.func1()

----------导入方式5---------------

from demo import a as a1, name
a = 3
print(a)

print(a1)
print(name)

4. 补充：导入模块的原理

不管是通过import导入模块还是from-import导入模块，导入模块的时候都会进入到对应的模块，将模块中的代码全部执行一遍

#将导入时不需要被别的模块执行的代码放在这个if语句中：
if __name__ == '__main__':

五、包

1. 什么是包

包含__int__.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 ts1
print(ts1.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
from tools.files.abc.test3 import x3
print(x1, x2, x3)

练习

from tools.files.files2.test4 import t4
print(t4)

from tools.files.files2 import test4
print(test4.t4)

import tools.files.files2.test4 as t4
print(t4.t4)