day12迭代器生成器和模块

1.变量作用域

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

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

1.全局变量

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

# b是全局变量
for _ in range(3):
    b = 20
    print(f'循环中使用b: {b}')


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


# x是全局变量
for x in range(3):
    print(f'循环中使用a: {a}')
    print(f'循环中使用b: {b}')
    print(f'循环中使用x: {x}')


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


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

2.局部变量

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


# c、d是局部变量
def func2(d):
    c = 11
    print(f'函数中使用c: {c}')
    print(f'函数中使用d: {d}')


func2(8)

# 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}')

2.迭代器

Python的三大神器：迭代器、生成器、装饰器

1.迭代器(iter)

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

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

2.创建迭代器的方法

# 1)将其他的序列转换成迭代器(所有的序列都可以转换成迭代器)
# 2)创建生成器
i1 = iter('abc')
i2 = iter([10, 20, 30, 40])

# 迭代器无法查看元素
print(i1)   # <str_iterator object at 0x000001A843EE6290>
print(i2)   # <list_iterator object at 0x000001A843D87C70>

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

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

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

# 1）获取一个元素：next(迭代器)
print(next(i1))   # a
print(next(i1))   # b
print(next(i1))   # c
# print(next(i1))   # 报错！ 里面的3个元素已经取完 再取会报错

print(next(i2))   # 10


# 2）遍历
for x in i2:
    print(f'x:{x}')

print(list(i1))   # []

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)

3.生成器

1.什么是生成器

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

2.怎么创建生成器

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

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


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

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

"""
生成器能产生多少个数据，能产生哪些数据，由执行创建生成器的函数的函数体的时候会遇到几次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]
# print(len(list(gen3)))  # 0

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

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

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

# 无法获取生成器中元素的个数
# print(len(gen4))   # 报错

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

# 遍历生成器
for x in gen4:
    print(f'x:{x}')

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

def func4():
    print('===')
    yield 10
    print('+++')
    yield 20
    print('---')
    yield 30


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

4.模块

# 1.什么是模块
"""
python中一个py文件就是一个模块。
"""

# 2.怎么在一个模块中使用另外一个模块中的内容
"""
前提：被使用的模块的模块名(py的文件名)必须是标示符并且不是关键字
使用方法：被使用的模块必须先导入再使用
"""

# 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 demo
#
# print(demo.a)   # 100
# print(demo.name)   # demo
#
# print(demo.list1)   # [10, 20, 30]
# demo.list1.append(50)
# print(demo.list1)   # [10, 20, 30, 50]
#
# demo.func1()    # demo中的函数

# -------------导入方式2-----------------
# from demo import a, func1, list1
#
# print(a)      # 100
# func1()       # demo中的函数
# print(list1)  # [10, 20, 30]

# -------------导入方式3-----------------
# from demo import *
# print(a)
# print(name)
# print(list1)
# func1()

# -------------导入方式4-----------------
# import demo as de
# print(de.a)
# print(de.name)
# print(de.list1)
# de.func1()

# -------------导入方式5-----------------
from demo import a as a1, name
a = 3
print(a)

print(a1)
print(name)

5.包

# 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 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)

# 方式2
import bao1.text1 as bt1
print(bt1.func1('4295ds'))
import bao1.files1.text3 as bft
print(bft.g)

# 方式3
from bao1 import text1, text2
print(text1.func1('5236sf'), text2.result)

# 方式4
from bao1.files1.text3 import e, f, g
print(e, f, g)