day12-迭代器生成器和模块总结

变量作用域

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

# 1. 全局变量
"""
没有定义在函数或者类中的变量都是全局变量，全局变量的作用域是从定义开始到程序结束。
全局变量默认保存在全局栈区间，程序结束后才会自动销毁。
"""
# 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}')


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


func1()


# 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 0x7f9dd8166be0>
print(i2)       # <list_iterator object at 0x7f9dd8198a90>

# 迭代器无法统计格式
# 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}')


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)

生成器

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

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


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


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


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


# 4.怎么获取生成器中的数据
# 生成器获取元素和迭代器获取元素的方式一样
gen4 = func3()

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

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

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

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



# 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.导入模块
"""
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)

包

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