**一、装饰器**

**装饰，顾名思义就是在原来的基础上进行美化及完善，器这里指函数，所以说装饰器就是装饰函数，也就是在不改变原来函数的代码及调用方式的前提下对原函数进行功能上的完善。其核心原理其实是利用闭包。**

**格式 @关键字+装饰函数**

**被装饰函数（）**

**注意：@行必须顶头写而且是在被装饰函数的正上方**

**按照形式可以分为：无参装饰器和有参装饰器，有参装饰器即给装饰器加上参数**

**以下示例是一个无参装饰器，为原函数添加了统计运行时间的功能**

```
import time
#定义装饰器 
def timer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        stop_time = time.time()
        print("run time is %s" %(stop_time-start_time))
        return res
    return wrapper

#调用装饰器
@timer
def index():
    l = []
    for i in range(10000000):
        l.append(i)
#调用阶段 
index()
```

**以下是一个有参装饰器，实现简单的认证功能，#数字表示程序依次执行顺序**

```
def auth2(auth_type): #1 #3
    def auth(func): #4 #6
        def wrapper(*args,**kwargs): #7 #10
            if auth_type == 'file': #11
                name=input('username: ')
                password=input('password: ')
                if name == 'zhejiangF4' and password == '666':
                    print('auth successfull')
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('auth error')
            elif auth_type == 'sql': #12
                print('nothing！') #13
        return wrapper #8
    return auth #5

@auth2(auth_type='sql') #2
def index():
    print('welcome to inex page')

index() #9
```

**二、迭代器**

**迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址****。------百度百科**

**可迭代的：只要对象本身有__iter__方法，那它就是可迭代的**

**执行对象下的__iter__方法，得到的结果就是迭代器如果你依然在编程的世界里迷茫，不知道自己的未来规划可以加入我们的Python秋秋裙去784掉758文214字看看前辈们如何学习的！交流经验！自己是一名高级python开发工程师，从基础的python脚本到web开发、爬虫、django、数据挖掘等，零基础到项目实战的资料都有整理。送给每一位python的小伙伴！分享一些学习的方法和需要注意的小细节**

**为什么要用迭代器：
    优点
    1：迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索 引的可迭代对象了（字典，集合，文件）
    2：迭代器与列表比较，迭代器是惰性计算的，更节省内存**

**缺点：
    1：无法获取迭代器的长度，使用不如列表索引取值灵活
    2**：**一次性的，只能往后取值，不能倒着取值**

**查看s对象是否是迭代器：print(isinstance(s,Iterator)) 返回True就是迭代器**

```
from collections import Iterable,Iterator
s='hello'
l=[1,2,3]
t=(1,2,3)
d={'a':1}
set1={1,2,3,4}
f=open('a.txt')
```

```
s.__iter__()
l.__iter__() 
t.__iter__()
d.__iter__()
set1.__iter__()
f.__iter__()
print(isinstance(s,Iterable))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))

print(isinstance(s,Iterator))
print(isinstance(l,Iterator))
print(isinstance(t,Iterator))
print(isinstance(d,Iterator))
print(isinstance(set1,Iterator))
print(isinstance(f,Iterator))
```

**运行结果如下：**

**![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xNzg4NTgxNS0xNWQxNjk3YzBkZWNiODVjLnBuZw)**

**可以看出，字符串、列表、字典、集合、元组、文件都是可迭代的，但是只有文件是迭代器**

**三、生成器**

**通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。**

**所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。**

**函数中包含yield语句的我们称其为生成器函数**

**yield与return有何区别？
        return只能返回一次函数就彻底结束了，而yield能返回多次值
    yield到底干了什么事情：
        yield把函数变成生成器（生成器就是迭代器）
        函数在暂停以及继续下一次运行时的状态是由yield保存**

**下例是两个生成器的应用，一个用来不断的输入url，不断的解析，另外一个则模仿Linux中的管道命令（实质是将一个函数的运行结果传给下一个函数做处理，实现的比较简单粗暴，多包涵，哈哈）**

**例1：**

```
from urllib.request import urlopen
def get(url):
    while True:
        def index():
            return urlopen(url).read()
        url = yield index()
g = get('http://www.baidu.com')
next(g)
def run():
    while True:
        url = input("请输入URL：")
        if 'http://' not in url:
            print(g.send('http://'+url))
        else:
            print(g.send(url))
run()
```

**例2：**

```
def cat(filename):
    with open(filename,'r') as f:
        while True:
            line = f.readline()
            if not line:
                break
            else:
                yield line
def grep(string,lines):
    for line in lines:
        if string in line:
            yield line
g1 = cat('a.txt')
g2 = grep('mac',g1)
if __name__ == '__main__':
    m = input("请输入命令：").strip()
    if m == "cat a.txt |grep mac":
        for i in g2:
            print(i)
```

**补充：协程**

**如果在一个函数内部yield的使用方式是表达式形式的话，如x=yield，那么该函数成为协程函数**

**直接看例子吧**

```
def hello(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        next(res)
        return res
    return wrapper

@hello
def eater(name):
    print('%s start to eat food' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s get %s ,to start eat' %(name,food))
        food_list.append(food)
    print('done')
e=eater("somebody")
print(e.send('巧克力'))
print(e.send("香蕉"))
```

ITPub博客

Python学习之三大名器-装饰器、迭代器、生成器

最新文章