装饰器、迭代器、生成器

def outer(func):
    #func =原来f1函数
    def inner():
        print('hio')
        print('hio')
        print('hio')
        print('hio')
        r=func()
        print('1234214o')
        print('1234214o')
        print('1234214o')
        print('1234214o')
        
        return r
    return inner

@outer
def f1():
    print('123')


#执行outer函数，并且将下面的函数名单做参数
    #将outer 的返回值重新给f1=outer 的返回值
    新f1函数=inner

装饰器再函数执行前后做修饰

=============================================================

装饰器简单调用

def outer(func):
   
    return 'LH'

@outer
def index():
    return True

>>> print(index) #index变成了一个字符串

装饰器返回函数名

def outer(func):
   
    def inner():
        print('123')
        ret=func()
        print('234')
        return ret
    return inner


@outer
def index():
    print('feichangfuzahn ')
    return True

>>> index()
123
feichangfuzahn 
234

只要装饰器被应用，那么函数就会被重新定义，定义为装饰器的内层函数。

 

装饰器含N个参数的函数

def outer(func):
    def inner(*arg,**kwargs):
        print('123')
        r=func(*arg,**kwargs)
        print('457')
        return r
    return inner
@outer
def index(x1,x2):
    print(x1+x2)
    return x1+x2

 

多个装饰器应用同一个函数例子

def out_0(func):
    def inner(*arg,**kwargs):
        print(3.5)
        ret=func(*arg,**kwargs)
        print('656')
        return ret
    return inner

def out(func):
    def inner(*arg, **kwargs):
        print('123')
        ret = func(*arg, **kwargs)
        print('456')
        return ret

    return inner
@out_0
@out
def index(a1,a2):
    print('buzhidao ')
    return a1+a2
index(1,2)

 

 

 

生成器

一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器；

def func():
    yield 1
    yield 2
    yield 3
    yield 4

 

利用生成器自定义range

def xrange(num):
    temp = -1
    while True:
        temp = temp + 1
        if temp >= num:
            return
        else:
            yield temp
>>> r=xrange(6)
>>> r.__next__()
0
>>> r.__next__()
1
>>> r.__next__()
2
>>> r.__next__()
3
>>> r.__next__()
4
>>> r.__next__()
5
>>> r.__next__()

>>> for i in xrange(6):

print(i)

 

迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存

>> a = iter([1,2,3,4,5])

>>> a

<list_iterator object at 0x101402630>

>>> a.__next__()

1

>>> a.__next__()

2

>>> a.__next__()

3

>>> a.__next__()

4

>>> a.__next__()

5

>>> a.__next__()

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration