python100day - day12 - 装饰器生成器和模块

python100day - 12day - 装饰器生成器和模块

有参数装饰器：

1.有参装饰器的功能 - 在给函数添加功能的时候可以通过参数控制具体的操作（操作不固定)

2.怎么写有参装饰器

"""
def 函数名0(装饰器的参数列表):
	def 函数名1(func):
		def 函数名2(*args, **kwargs):
			result = func(*args, **kwargs)
			新功能
			return result
		return 函数名2
	return 函数名1
	

def 函数名(装饰器的参数列表)
	无参装饰器
	return 无参装饰器的函数名
		
有参装饰器的用法:
@函数名0(装饰器实参列表)
"""

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

def add_message(msg):
    def test1(func):
        def new_func(*args, **kwargs)
        	result = func(*args, **kwargs)
            print(msg)
            return new_func
        return test1

@add_message('结束')
def func1(x, y):
    print(x+y)
    
func1(10, 20)  # 30  结束

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

def sub(num):
    def test2(func):
        def new_func(*args, **kwargs):
            result = func(*args, **kwargs)
            if type(result) == int:
                result - num
             return result   
        retuan new_func
    return test2 

@sub(10)
def func2():
    return 90

print(func2())   # 80

迭代器：

1.什么是迭代器（iter）

"""
迭代器是容器型数据类型(序列)
特点：a.不能同时查看所有元素（打印看不到里面的元素）
     b.不能统计个数
     c.获取元素的时候只能一个一个的取（每次取最上层的那个），
     每次获取元素该元素就会从迭代器中小时（取一个就少一个）

"""

2.创建迭代器

"""
迭代器的创建有两种方式
1）通过iter将其他序列转换成迭代器
2）创建生成器
"""

iter1 = iter([10, 20, 30, 40])
print(iter1)   # <list_iterator object at 0x00000274302BCF48>
# print(len(iter1))   #报错

iter2 = iter('hello')
print(iter2)   # <str_iterator object at 0x000001A08F6A2A48>

3.获取元素

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

"""

1）取单个元素
next(迭代器) - 获取迭代器最上层的一个数据(如果迭代器为空，就会报StopIteration错误)

2）遍历
for 变量 in 迭代器:
    pass
"""

print(next(iter1))   # 10
print(next(iter1))   # 20
next(iter1)
print(next(iter1))   # 40
# print(next(iter1))   #  报错  StopIteration！


for x in iter2:
    print(x)
# h
# e
# l
# l
# o

# print(next(iter2))   # StopIteration


iter3 = iter('python!')
list1 = list(iter3)
print(list1)   # ['p', 'y', 't', 'h', 'o', 'n', '!']
# print(next(iter3))  #  报错  StopIteration


iter4 = iter('python123')
next(iter4)
for x in iter4:
    print('x:', x)
    
# x: y
# x: t
# x: h
# x: o
# x: n
# x: 1
# x: 2
# x: 3

生成器：

1.什么是生成器（generator）

"""
生成器的本质就是迭代器（迭代器的特点和获取元素的方式生成器都适用）
"""

2.怎么创建生成器

"""
调用一个带有yield关键字的函数就可以创建一个生成器对象
(如果被调用的函数里面有yield，不会执行函数体，也不会获取函数返回值)
"""

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

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

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

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

def func2():
    yield 100
    yield 'abc'
    for x in range(3):
        yield x
gen1 = func2()
print(gen1)
print(list(gen1))   # [100, 'abc', 0, 1, 2]

def func3(x):
    yield 10
    if x & 1:
        yield 20
    return 30
    yield 30

gen2 = func3(5)
gen3 = func3(4)
print(list(gen2))   # [10, 20]
print(list(gen3))   # [10]

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

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

"""

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

gen4 = func4()
print(next(gen4))   #  =====1===== 100
print(next(gen4))   #  =====2===== 200
for x in range(5):
    print('``````')   # ``````````````````````````````
print(next(gen4))   # =====3===== 300
# print(next(gen4))   # StopIteration

gen5 = func4()
gen6 = func4()
print(next(gen5))   # =====1===== 100
print(next(gen5))   # =====2===== 200
print(next(gen6))   # =====1===== 100

def func5():
    for x in range(5):
        yield x*2

print(next(func5()))   # 0
print(next(func5()))   # 0

练习：写一个产生学号的生成器，能够产生指定学科001~999的学生学号

python学生：python001~python999

java学生：java001 ~ java999

def ids(subject):
    for x in range(1, 1000):
        yield subject + ('{:0>3}.format(x)')
        # yield f'{subject}{x:0>3}'
        
gen7 = ids('python')
for s in range(1, 1000):
    print(next(gen7))

gen8 = ids('java')
for x in range(1, 1000):
    print(next(gen8))        

4.生成式 - 生成器的推导式

"""
将列表推导式的[]变成() 就是生成器的推导式即生成式

"""
result = (x**2 for x in range(10))
# print(list(result))   # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

print(next(result))
print(next(result))
for item in result:
    print(f'item:{item}')

模块的使用：

1.什么是模块

"""
python中一个py文件就是一个模块。
可以再一个模块中去使用另外一个模块中的内容（全局变量），倒是需要提前导入模块

"""

2.导入模块

"""
1)import 模块名 - 导入后能够使用指定模块中所有的全局变量；
                以'模块名.变量'形式去使用
2)from 模块名 import 变量1,变量2,...
a.导入模块,能使用模块中指定的全局变量；
b.直接使用对应的变量，不需要在前面加'模块名.'       

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

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

5) from 模块名 import *
导入模块所有的全局变量
"""

# 导入方式一： import 模块名
# import test1
# print(test1.A)
# text1.func1()
# print(test1.x)

# 导入方式二：from 模块名 import 变量
# from test1 import A, func1
# print(A)
# func1()

# 导入方式三：模块重命名
# import test1 as ts1
#
# test1 = 10
# test2 = 200
# for x in range(test1):
#     print(x)

# # 调用func1
# ts1.func1()
# print(ts1.A)
# print(ts1.x)

# 导入方式四：对变量重命名
# from test1 import func1 as ts_func1, A, x as ts_x

# def func1():
#     print('本模块中的func1')
#
# func1()
# ts_func1()
# print(A, ts_x)

3.导入模块的原理

"""
不管通过import还是from-import，在导入模块的时候，系统会自动将被导入的模块
中所有的代码都执行一遍

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

"""

# from test1 import A
# print('A', A)

4.阻止导入

"""
定义模块的时候，可以通过'if__name__=="__main__"'这个if语句来阻止模块中的
指定代码被其他模块在导入的执行。（在这个if语句中的代码不会被其他模块执行，不在
这个if语句中的代码就会被其他模块执行）

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

import test2

print('06:', __name__)

功能（如果被导入的模块已经被导入过，不会重复导入）

“”"

```python
# from test1 import A
# print('A', A)

4.阻止导入

"""
定义模块的时候，可以通过'if__name__=="__main__"'这个if语句来阻止模块中的
指定代码被其他模块在导入的执行。（在这个if语句中的代码不会被其他模块执行，不在
这个if语句中的代码就会被其他模块执行）

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

import test2

print('06:', __name__)