python - decorator, iterators

table of Contents

1 decorator
2 iterators
3 iterables

1 decorator

1.1 Purpose, application scenarios:

purpose:

Without changing the original function of the internal code, before and after the customization function execution.
Scenario:

When you want to function as extensions, you can choose to use a decorator.

1.2 write decorators and applications

Basic decorator

# 装饰器的编写格式     （双层嵌套函数）
def 外层函数(参数):
   def 内层函数(*arg,**kwarg)
       return 参数(*arg,**kwarg)
   return 内层函数

#装饰器的应用格式
@外层函数
def 要装饰的函数()
   pass

# 执行函数，自动触发装饰器了
要装饰的函数()

Exercises

def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v 
    return inner 

def index():
    print('123')
    return '666'


# 示例一
v1 = index() # 执行index函数，打印123并返回666赋值给v1.

# 示例二
v2 = func(index) # v2是inner函数，arg=index函数
index = 666 
v3 = v2()

# 示例三
v4 = func(index)
index = v4  # index ==> inner 
index()

# 示例四
index = func(index)
index()

def func(arg):
    def inner():
        v = arg()
   return v 
    return inner 

# 第一步：执行func函数并将下面的函数参数传递，相当于：func(index)
# 第二步：将func的返回值重新赋值给下面的函数名。 index = func(index)
@func 
def index():
    print(123)
    return 666

print(index)

# 计算函数执行时间

def wrapper(func):
  def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        print(end_time-start_time)
        return v
    return inner

@wrapper
def func1():
    time.sleep(2)
    print(123)
@wrapper
def func2():
    time.sleep(1)
    print(123)

def func3():
    time.sleep(1.5)
    print(123)

func1()

Note: Question: Why should we increase * arg, ** kwarg

understanding:

Variable assignment

```python
def func():
print(1)

v1 = function
function = 666
`` `
- Return to see what in the end is?
- They have to find their own, they did not go to the previous scope

We will be back:

python @xx # index = xx(index) def index(): pass index()

About parameters

def x(func):
    def inner(a1):
        return func(a1)
    return inner 

@x
def index(a1):
   pass

def x(func):
    def inner(a1,a2):
        return func(a1,a2)
    return inner 

@x
def index(a1,a2):
   pass

# index = inner
index(1,2)

# ################################### 参数统一的目的是为了给原来的index函数传参
def x(func):
    def inner(a1,a2):
        return func()
    return inner 

@x
def index():
   pass
# func = 原来的index函数u
# index = inner
index(1,2)

If several functions to write a unified decorator, how do?

def x1(func):
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner 

@x1
def f1():
    pass

@x1
def f2(a1):
    pass
@x1
def f3(a1,a2):
    pass

Decorator recommended wording:

def x1(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return data
    return inner

Decorator with parameters

# 第一步：执行 v1 = uuu(9)
# 第二步：ret = v1(index)
# 第三步：index = ret 
@uuu(9)
def index():
    pass

# ################## 普通装饰器 #####################
def wrapper(func):
    def inner(*args,**kwargs):
        print('调用原函数之前')
        data = func(*args,**kwargs) # 执行原函数并获取返回值
        print('调用员函数之后')
        return data
    return inner 

@wrapper
def index():
    pass

# ################## 带参数装饰器 #####################
def x(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            data = func(*args,**kwargs) # 执行原函数并获取返回值
            return data
        return inner 
   return wrapper 

@x(9)
def index():
    pass

Exercises

# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，把每次结果添加到列表中，最终返回列表。
def xxx(counter):![](https://img2018.cnblogs.com/blog/1646753/201907/1646753-20190719213053775-1588807446.png)


    print('x函数')
    def wrapper(func):
        print('wrapper函数')
        def inner(*args,**kwargs):
            v = []
            for i in range(counter):
                data = func(*args,**kwargs) # 执行原函数并获取返回值
                v.append(data)
            return v
        return inner
    return wrapper

@xxx(5)
def index():
    return 8

v = index()
print(v)

# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回最后一次执行的结果
def xxx(counter):
    print('x函数')
    def wrapper(func):
        print('wrapper函数')
        def inner(*args,**kwargs):
            for i in range(counter):
                data = func(*args,**kwargs) # 执行原函数并获取返回值
            return data
        return inner
    return wrapper

@xxx(5)
def index():
    return 8

v = index()
print(v)
# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回执行结果中最大的值。
def xxx(counter):
    print('x函数')
    def wrapper(func):
        print('wrapper函数')
        def inner(*args,**kwargs):
            value = 0
            for i in range(counter):
                data = func(*args,**kwargs) # 执行原函数并获取返回值
                if data > value:
                    value = data 
            return value
        return inner
    return wrapper

@xxx(5)
def index():
    return 8

v = index()
print(v)

def x(counter):
    print('x函数')
    def wrapper(func):
        print('wrapper函数')
        def inner(*args,**kwargs):
            if counter:
                return 123
            return func(*args,**kwargs)
        return inner
    return wrapper

@x(True)
def fun990():
    pass

@x(False)
def func10():
    pass

2 iterators

He will not write an iterator, you will only need to use.

Task: Please show all of the data list

1. while + index + Counter
2. Iterator to certain objects (str / list / tuple / Object dict / set class created) - iteration elements can be individually acquired object
  
  Appearance: Next having _ _ _ _ The method of obtaining the element and each invocation object (acquired one by one from front to back) may be iterative.
  - 1. First an object (such as a list) into iterator
      
      traveling v1 = ([11,22,33,44])
      
      v1 = [11,22,33,44] _ _ _ _ travel ()
    2. Iterator want to get each value: repeatedly calling (val = v1._ _ next _ _ ())
```
v1 = [11,22,33,44]

# 列表转换成迭代器
v2 = iter(v1)
result1 = v2.__next__()
print(result1)
result2 = v2.__next__()
print(result2)
result3 = v2.__next__()
print(result3)
result4 = v2.__next__()
print(result4)
result5 = v2.__next__()   # v1只有4个元素，第五次获取就会报错：StopIteration
print(result5)

v1 = "alex"
v2 = iter(v1)
while True:
    try:
        val = v2.__next__()
        print(val)
    except Exception as e:
        break
```
    3. Until the error: StopIteration error, it said that it has completed iterations.
    4. How to determine whether an object is iterable: whether there is internal _ _ next _ _ methods.
3. for loop:
```
v1 = [11,22,33,44]

# 1.内部会将v1转换成迭代器
# 2.内部反复执行 迭代器.__next__()
# 3.取完不报错
for item in v1:
    print(item)
```

3 iterables

1. Having internal ITER _ _ _ _ () method returns an iterator and
```
v1 = [11,22,33,44]
result = v1.__iter__()
```
2. It may be for loop