day12有参装饰器迭代器生成器模块

最新推荐文章于 2021-04-07 21:36:42 发布

大田⺀十

最新推荐文章于 2021-04-07 21:36:42 发布

阅读量124

点赞数

文章标签： python 列表生成器

本文链接：https://blog.csdn.net/weixin_52901509/article/details/111598332

版权

写一个装饰器@tag要求满足如下功能:

@tag(name='p')
def render(text):
    # 执行其他操作
    return text

@tag(name='div')
def render2():
    return 'abc'

print(render('Hello'))   # 打印出: <p>Hello</p>
print(render2())     # 打印出: <div>abc</div>

def creat_tag(name):
    def tag(f):
        def new_f(*args,**kwargs):
            re = f(*args,**kwargs)
            if type(re)==str:
                return f'<{name}>{re}</{name}>'
            return re
        return new_f
    return tag
@creat_tag(name='div')
def f1():
    return 'hello'
print(f1())

为函数写一个装饰器，根据参数不同做不同操作。

flag为 True，则 让原函数执行后返回值加 100，并返回。
flag为 False，则 让原函数执行后返回值减 100，并返回。

def creat_re(flag):
    def re_num(f):
        def new_f(*args,**kwargs):
            result = f(*args,**kwargs)
            if (type(result) in (int,float,bool,complex)) and flag == True:
                return result+100
            elif (type(result) in (int,float,bool,complex)) and flag==False:
                return result-100
            return result
        return new_f
    return re_num
@creat_re(flag=False)
def f2():
    return 100
print(f2())

为函数写一个装饰器，根据不同的运算符和数据对原函数的返回值进行相应的数值操作

例如：
运算符是+，数据是 100， 就对原函数的返回值进行加100的处理
运算符是-, 数据是 20，就对原函数的返回值进行减20的处理
运算符是*, 数据是 3, 就对原函数的返回值进行乘3的处理
运算符是/, 数据是 2， 就对原函数的返回值进行除2的处理
其他情况的符号不做处理

def creat_num(stan,dat):
    def num_deal(f):
        def new_f(*args, **kwargs):
            re = f(*args, **kwargs)
            if stan == '+' and type(re) in (int, float,bool,complex):
                return re + dat
            elif stan == '-' and type(re) in (int, float,bool,complex):
                return re - dat
            elif stan == '*' and type(re) in (int, float,bool,complex):
                return re * dat
            elif stan == '/' and type(re) in (int, float,bool,complex):
                return re / dat
            return re
        return new_f
    return num_deal
@creat_num(stan='//',dat= 20)
def f3():
    return 100
print(f3())

写一个斗地主发牌器
```
def finght():
    for x in range(1, 1000000000000000):
        import random
        num = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A']
        num1 = num * 4 + ['big_jack', 'small_jack']
        list1 = []  # 手牌
        list2 = []  # 地主牌
        for j in range(3):
            num3 = random.choice(num1)
            list2.append(num3)
            num1.remove(num3)
        count = 3
        while True:
            for i in range(17):
                num2 = random.choice(num1)
                list1.append(num2)
                num1.remove(num2)
            print(list1)
            count -= 1
            list1 = []
            if count == 0:
                break
        print(list2)
        yield '尽情享受吧'


print(next(finght()))
```
有参装饰器

需不需要有参装饰器，看装饰器需不需要额外参数，需要多少个看装饰器需要多少额外参数

语法：def 函数名(参数列表)

定义无参装饰器

return 无参装饰器函数名
```
def creat_add(num): # def 函数名（参数列表）
	def add_num(f):
		def new_f(*args,**kwargs):
			re = f(*args,**kwargs)
			if type(num) in (int,float):
				return re+num
			return re
		return new_f
	return add_num # return 无参装饰器
@creat_add(200)
def func():
	return 100
print(func())
			
```
迭代器iter
1. 容器型数据，无论用什么方式获取其中元素，只要获取了该元素，该元素就从迭代器里消失
2. 特点：只出不进，只能一个一个元素取出，取出后就无法放回，并且在在迭代器里消失
  
  不能用len函数统计元素个数
3. 获取
  
  1）获取单个：next（迭代器）
  
  2）遍历：for 变量 in 迭代器
生成器generator
1. 特殊的迭代器，函数里面有yield关键字的函数调用的时候就会产生一个生成器，调用函数时不会执行函数体，只有获取生成器元素的时候才会执行函数体
2. 写法：def 函数名():
  
  代码
  
  yield 数据1（没数据，返回值为空）
  
  代码
  
  yield 数据2
  
  …
  
  执行过程：当获取生成器元素时，执行第一段代码，直到遇到yield时，将yield后面的数据作为结果（元素）返回，并记录结束的位置，再次获取元素时，从结束位置开始执行代码，遇到yield时，将yield后的数据作为结果返回，并记录结束位置。。。。如果用next一个一个取，如果遇到函数结束都没有遇到yield就报错。
模块

模块就是py文件

模块名要符合标识符的要求才能被调用
导入模块时，模块中的代码会被执行一遍，同一模块被导入多次，模块中的代码只执行一次

从其他模块调用变量：
1. import 模块名—调用另一个模块的所有变量，使用时用‘模块名.变量名’格式
2. from 模块名 import 变量1，变量2，变量3.。。。。。—调用另一个模块中的指定变量
3. 模块重命名：import 模块名 as 新模块名
4. 变量重命名：from 模块名 import 变量名 as 新变量名