生成器、迭代器、装饰器

装饰器

什么是装饰器?

在不修改源代码和调用方式的基础上给其增加新的功能，多个装饰器可以装饰在同一个函数上

def deco(func):                                 #func = index

    def wrapper():                               #wrapper() = index()

        func() #func() = index()

        print(‘增加新功能‘)

    return wrapper

 

@deco                                              #index = deco(index)

def index():

    print(‘欢迎来首页‘)

index() #index = wrapper

 

 

import time
def timer(func):
    def deco():
        start_time = time.time()
        res = func()
        end_time = time.time()
        print(‘cost‘, end_time-start_time)
        return res
    return deco
@timer
def bar():
    time.sleep(2)
    print(‘这是bar‘)
bar()

import time

def timer(func):
    def deco(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print(‘cost‘, end_time-start_time)
        return res
    return deco

@timer
def bar(a, b):
    time.sleep(2)
    print(‘这是bar‘)
    print(a)
    print(b)
bar(1,2)

 

def default_engine(engine=None):
    def auth(func):
        def deco(*args, **kwargs):
            user = input(‘user:‘)
            password = input(‘password:‘)
            if engine == ‘mysql‘:
                if user == ‘root‘ and password == ‘root‘:
                    res = func(*args, **kwargs)
                    return res
                else:
                    print(‘用户名或密码错误‘)
            else:
                print(‘没有这个引擎‘)
        return deco
    return auth

@default_engine(engine=‘mysql‘)
def index():
    print(‘welcome to home page‘)

# res = default_engine(engine=‘mysql‘)
# index = res(index)
index()

迭代器

　什么是迭代器？

　迭代是一个重复的过程，即每一次重复为一次迭代，并且每次迭代的结果都是下一次迭代的初始值

while True: #只是单纯的重复，因此不是迭代
    print(‘===>‘)

l = [1,2,3]
count=0
while count<len(l): #首先是重复动作，其次上一次的结果是下一次的初始值，因此，是迭代
    print(l[count])
    count+=1

为什么要有迭代器？什么是可迭代对象？什么是迭代器对象？

#1、为何要有迭代器？
对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

#2、什么是可迭代对象？
可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下:
‘world‘.__iter__
(4,5,6).__iter__
[1,2,3].__iter__
{‘a‘:1}.__iter__
{‘a‘,‘b‘}.__iter__
open(‘a.txt‘).__iter__

#3、什么是迭代器对象？
可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

#4、文件类型是迭代器对象
open(‘a.txt‘).__iter__()
open(‘a.txt‘).__next__()

#5、总结：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

 

生成器

什么是生成器？

生成器即迭代器（有iter和next）

只要函数里有yield关键字，那么函数名（）得到的结果就是生成器，并且不会执行函数内部代码

#return只能返回一个值，而yield可以返回多个值

#生成器优点:

    1. 同一时间只存储一个值

    2.节省内存空间

#生成器的缺点:

     只能向后取值，不能往前取值

def text():

    for i in range(100):

        yield i

text()

res=text()

for k in res:

    print(k）

 

（相同内存地址，返回同一个值）

def func():

    yield 1

    yield 2

    yield 3

    yield 4

func()

res=func()

print(res)

print(res)

print(res)

<generator object func at 0x01225BF0>

<generator object func at 0x01225BF0>

<generator object func at 0x01225BF0>