python第六章：三大利器（装饰器，迭代器，生成器）--小白博客

python装饰器

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

# 原理（个人理解）：将原函数（bar）的内存地址重新赋值，进行覆盖。新值为装饰器目标函数内存地址，
# 再进行调用，从而实现修改的目的。

无参装饰器*************************

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                                #将过渡函数的返回值(即目标函数的内存地址）赋予初始函数
                                      # 并将初始函数当作参数传人目标函数中bar = timer(bar)
def bar():                                   #初始函数
    time.sleep(2)
    print('这是bar')
bar()                                        #调用函数。此时的内存地址已经改变

有参装饰器

import time

def timer(func):
    def deco(x,y):
        start_time = time.time()
        res = func(x,y)
        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()

Python迭代器(Iterator)

概述

　　迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

延迟计算或惰性求值 (Lazy evaluation)

　　迭代器不要求你事先准备好整个迭代过程中所有的元素。仅仅是在迭代至某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合。

可迭代对象

　　迭代器提供了一个统一的访问集合的接口。只要是实现了__iter__()或__getitem__()方法的对象，就可以使用迭代器进行访问。

　　序列：字符串、列表、元组

　　非序列：字典、文件

　　自定义类：用户自定义的类实现了__iter__()或__getitem__()方法的对象

迭代器对象

什么是迭代器对象？
目标有.__iter__()方法并且有.__next__方法的叫做迭代器对象
f.__next__()

创建迭代器对象

　　使用内建的工厂函数iter(iterable)可以获取迭代器对象：

　　语法：

　　　　iter(collection) -> iterator

　　　　iter(callable,sentinel) -> iterator

　　说明：

　　　　Get an iterator from an object.

　　　　In the first form, the argument must supply its own iterator, or be a sequence.

　　　　In the second form, the callable is called until it returns the sentinel.

　　实例展示：

 1 使用对象内置的__iter__()方法生成迭代器
 2 >>>L1 = [1,2,3,4,5,6]
 3 >>>I1 = L1.__iter__()
 4 >>>print I1
 5 <listiterator object at 0x7fe4fd0ef550>
 6 >>> I1.next()
 7 1
 8 >>> I1.next()
 9 2
10 >>> I1.next()
11 3

 1 使用内置工厂函数生成迭代器
 2 >>> L1 = [1,2,3,4,5,6]
 3 >>> I2 = iter(L1)
 4 >>> print I2
 5 <listiterator object at 0x7fe4fd0ef610>
 6 >>> I2.next()
 7 1
 8 >>> I2.next()
 9 2
10 >>> I2.next()
11 3

说明：

　　for循环可用于任何可迭代对象

　　for循环开始时，会通过迭代协议传输给iter()内置函数，从而能够从迭代对象中获得一个迭代器，返回的对象含有需要的next()方法。

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

python生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

以下实例使用 yield 实现斐波那契数列：

实例(Python 3.0+)

#!/usr/bin/python3 import sys def fibonacci(n): # 生成器函数 - 斐波那契

#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55