day12装饰器生成器和模块

装饰器生成器和模块

1.装饰器

1.有参装饰器的功能
在给函数添加功能的时候可以通过参数控制具体的操作(操作不固定)
2.怎么写有参装饰器
def 函数名0(装饰器的参数列表):
def 函数名1(func):
def 函数名2(*args, **kwargs):
result = func(*args, **kwargs)
新功能代码
return func(*args, **kwargs)
return 函数名2
return 函数名1

等同于：
def 函数名0(装饰器的参数列表):
无参装饰器
return 无参装饰器名

有参装饰器的用法：
@装饰器0(装饰器实参列表)

# 写一个装饰器可以在函数结束后打印指定的任意提示信息


def print_message(msg):
    def new_func1(func):
        def new_func2(*args, **kwargs):
            result = func(*args, **kwargs)
            print(msg)
            return result
        return new_func2
    return new_func1


@print_message('===结束===')
def add(x, y):
    return x + y


print(add(1, 2))
# ===结束===

# 练习：写一个装饰器，在原函数返回值的基础上减去指定的值


def sub(num):
    def new_func1(func):
        def new_func2(*args, **kwargs):
            result = func(*args, **kwargs)
            if type(result) in (int, float, bool, complex):
                result -= num
            return result
        return new_func2
    return new_func1


@sub(10)
def ride(x, y):
    return x * y


print(ride(10, 20))    # 190

2.迭代器

1.什么是迭代器
迭代器是容器型数据类型(序列)
特点：
a.不能同时查看所有元素(打印看不到里面的元素)
b.不能统计个数
c.获取元素的时候只能一个一个的取(每次取最上层的那个)，每次获取元素该元素就会从迭代器中消失
2.创建迭代器
迭代器的创建有两种方式

1. 通过iter将其他序列转换成迭代器
2. 创建生成器

iter1 = iter([10, 20, 30, 40])    # 创建迭代器对象
print(iter1)    # <list_iterator object at 0x000002A2EECA7400>

iter2 = iter('hello')    # 创建迭代器对象
print(iter2)    # <str_iterator object at 0x000002A2EECA7B80>

3.获取元素
重点：不管通过什么样的方式获取到了迭代器的元素，对应的元素都会从迭代器中消失

1. 取单个元素
   next(迭代器) - 获取迭代器最上层的一个数据
2. 遍历
   for x in 迭代器：
   pass

iter3 = iter([1, 2, 3, 4])
print(next(iter3))  # 1
print(next(iter3))  # 2
next(iter3)
print(next(iter3))  # 4
# print(next(iter3))    取完了之后再获取会报错

iter4 = iter('i love you')
for x in iter4:
    print('x:', x)

3.生成器

1.什么是生成器(generator)
生成器的本质就是迭代器(迭代器的特点和获取元素的方式生成器都适用)
2.怎么创建生成器
调用一个带有yield关键字的函数就可以创建一个生成器对象
(如果被调用的函数里面有yield，不会执行函数体，也不会获取函数返回值)

def func1():
    print('====')
    print('++++')
    yield
    return 100


re = func1()
print(re)  # <generator object func1 at 0x000002630F000D60>

3.怎么确定生成器中产生的数据

产生数据的个数：看执行生成器对应的函数会遇到几次yield
产生数据的值：看每次遇到yield后面的数据是什么，没有数据就是None

def func2():
    yield '100'
    yield 'abc'
    for a in range(3):
        yield


gen1 = func2()
print(gen1)  # <generator object func2 at 0x00000131BBD30D60>
print(list(gen1))  # ['100', 'abc', 0, 1, 2]

4.生成器产生数据的原理

调用函数创建生成器对象的时候不会执行函数体，获取生成器中的元素的时候才会执行
第一次获取元素会从函数体开始的位置开始执行，执行到第一次yield就停下来，并且将yield后面的数据作为这次获取到的元素
后面每次获取元素的时候都是从上次结束的位置往后执行，执行到下一次yield又会停下来。如果从当前位置开始，执行到函数结束，没有遇到yield，如果是next，就会报StopIteration错误。

def func3():
    print('===1===')
    yield 100
    print('===2===')
    yield 200
    print('===3===')
    yield 300


gen2 = func3()
print(next(gen2))
# 注意：每调用一次函数就产生一个新的生成器
print(next(func3()))  # 100
print(next(func3()))  # 100


# ================================
# 练习：写一个产生学号的生成器，能够产生执行学科001~999的学生学号


def stu_id(subject):
    for i in range(1, 1000):
        yield f'{subject}{str(i).zfill(3)}'


java_id = stu_id('java')
print(next(java_id))
print(next(java_id))

# 练习：写一个生成器，能够产生所有的正的偶数


def even():
    n = 0
    while True:
        n += 2
        yield n


even_nums = even()
for x in range(10):
    print(next(even_nums))

4.生成式 - 生成器的推导式
将列表推导式的[]变成()就是生成器的推导式，即生成式

result = (x**2 for x in range(10))
for item in result:
    print(f'item:{item}', end=';')
# item:0;item:1;item:4;item:9;item:16;item:25;item:36;item:49;item:64;item:81;

4.模块的使用

1.什么是模块
python中一个py文件就是一个模块
可以在一个模块中去使用另外一个模块中的内容(广义上的全局变量)，但是需要提前导入模块
2.导入模块
1)import 模块名 - 导入能够使用指定模块中所有的全局变量
以 ‘模块名.变量’ 形式去使用变量

2)from 模块名 import 变量名1, 变量名2…
a.导入指定模块中指定的全局变量
b.直接使用对应的变量，不需要在前面加 ‘模块名’

3)import 模块名 as 新模块名
导入模块的时候对模块进行重命名，重命名后需要通过新模块名来使用被导入的模块

4)from 模块名 import 变量 as 新变量名,…
导入模块的时候对指定变量进行重命名

5)from 模块名 import *
导入模块中所有的变量
3.导入模块的原理
不管是通过import 还是 from import ，在导入模块的时候，系统会自动将被导入的模块中所有的代码都执行一遍

注意：import导入模块的时候，自带查重功能(如果被导入的模块已经被导入过，不会重复导入)

4.阻止导入
定义模块的时候，可以通过 (if name == ‘main’😃 这个if语句来阻止模块中指定代码被其他模块在导入的时候执行。
在if语句中的代码不会被其他模块执行，
不在if语句中的代码会被其他模块执行。

原理：
每个py文件中默认都有一个变量__name__用来保存当前模块的模块名，
当直接执行某个py文件的时候，这个文件中的__name__会自动变成’main’