迭代器生成器和装饰器

迭代器

class Counter:
    def __init__(self,low,high):
        self.low = low
        self.high = high
        print('c')

    def __iter__(self):
        print('a')
        return self

    def __next__(self):
        if self.low > self.high:
            raise StopIteration
        else:
            self.low += 1
            print('abcd')
            return self.low - 1
c = Counter(1,3)
print('-'*10)
for i in c:
    print('*',end=' ')
    print(i)

$ python test.py                 # 运行结果 (pycharm中代码结束不可以用空格，需要在最后面添加print())
c                                # 运行c = Counter(1,3)时调用__init__()
----------
a                                # for i in c:之后会调用__iter__()和__next__()
abcd
* 1                              # __next()__返回的值为1
abcd                             # 迭代器迭代后调用__next()__
* 2                              # 输出__next()__返回的值 2
abcd
* 3

生成器

def generator(low,high):
    print("-"*20)
    while(low<high):
        yield low
        low += 1

for i in generator(1,10):
    print(i,end=" ")  
print()
for y in g:
    print(y,end=' ')
print()
--------------------             # 输出结果
1 2 3 4 5 6 7 8 9 

生成器也是不可重复使用的,下面创建一个可重复使用的生成器

class generator():
    def __init__(self,low,high):
        self.low = low
        self.high = high

    def __iter__(self):
        counter = self.low
        while self.high >= counter:
            yield counter
            counter += 1

g = generator(1,10)
for x in g:
    print(x,end=' ')
print()
for y in g:
    print(y,end=' ')
print()

闭包

def add_number(num):
    def adder(number):
        print('1 ',num)
        return num +number
    def sub(number):
        print('2 ',number)
        return num-number
    print('3 ',adder, sub)
    return adder,sub   

# 输出结果
>>>a,b=add_number(10)  
3  <function add_number.<locals>.adder at 0x7f6bf8672a60> <function add_number.<locals>.sub at 0x7f6bf7222b70>
>>>a(10)
1  10
20
>>>b(10)
2  10
0

a、b是函数add_number()运行后return的结果，return了两个函数

调试deep_sort_pytorch代码时遇到一个类，感觉和闭包有点像，基本构成如下:

class Counter:
    def __init__(self,fun):
        self.fun = fun

    def __call__(self,a,b):
        print("Hello World!")
        print(self.fun)
        print(a + b)

>>>c = Counter("function")   # 输出结果
>>>c(1,2)
Hello World!
function
3

装饰器

装饰器不带参数

def decorator(fun):                # 输入被装饰的函数
    def innter(*arg,**k):
        print("Hello World!")
        print(arg,type(arg))
        print(k,type(k))
        fun(*arg,**k)              # fun中的参数是def he()中的参数
    return innter                  # 返回装饰过的函数  

@decorator                         # 装饰下面的函数he()
def he(a,b,c,d):
    print('-'*30)
    print(a,b,c,d)
    print("Goodbye World!")

>>>he(1,2,3,d=1)                    # he()中的参数实质上是innter()的参数
Hello World!
(1, 2, 3) <class 'tuple'>
{'d': 1} <class 'dict'>
------------------------------
1 2 3 1
Goodbye World!

装饰器带参数

给输入的字符串加上标签 string tag与string均自定义

def settag(tag):
    def decorator(func):
        def inner(*a,**k):
            nonlocal tag       # 默认tag是不允许被修改的
            tag = '<'+tag+'>'
            return tag+func(*a,**k)+tag
        return inner
    return decorator

@settag("div")
def hello(name):
    return "Hello "+name

>>>hello("World")              # 输出结果
'<div>Hello World<div>'

基于类封装的装饰器

• 装饰器不带参数

class decorator():
    def __init__(self,func):
        self.func = func
    def __call__(self,*arg,**k):
        print("Hello World!")
        return self.func(*arg,**k)
@decorator
def he(a,b,c,d):
    print('-'*30)
    print(a,b,c,d)
    print("Goodbye World!")

>>>he(1,2,3,4)
Hello World!
------------------------------
1 2 3 4
Goodbye World!

• 装饰器带参数

class decorator:
    def __init__(self,tag):
        self.tag = '<'+tag+'>'

    def __call__(self,func):
        def inner(*arg,**k):
            return self.tag + func(*arg,**k) + self.tag
        return inner

@decorator("div")
def hello(name):
    return "Hello " + name

>>>hello("World!")
'<div>Hello World!<div>'

Python自带的修饰器

• classmethod

装饰器参考链接