Python_04

本节内容

• 装饰器
• 迭代器
• 生产器
• 序列化与反序列化

 1、装饰器 

装饰器的本质是函数，目的是为（装饰其他的函数）为其它函数添加附加功能。

原则：

1、不能修改本装饰的函数的源代码

2、不能修改被装饰的函数的调用方式

实现装饰器的知识储备：

1、函数即“变量”

def bar():
    print('in the bar')
def foo():
    print('in the foo')
    bar()

foo()
# 输出
in the foo
in the bar


def foo():
    print('in the foo')
    bar()
def bar():
    print('in the bar')

foo()
# 输出
in the foo
in the bar


def foo():
    print('in the foo')
    bar()

foo()

def bar():
    print('in the bar')

# 输出
in the foo
NameError: name 'bar' is not defined #出现报错

上述代码中，bar和foo表示函数名，相当于函数变量的门牌号，每个门牌号对应一个内存地址，地址里面包含了对应的函数内容。

bar()和foo()表示执行函数，执行函数的过程就是先找到函数名（门牌号），然后通过门牌号找到其对应的内存地址并执行地址中的函数内容。

所以当我们在执行foo()的过程中，首先要满足函数已经被定义，即存在，并存入了相应的内存地址，准备被调用。所以找到内存地址中对应的函数内容：

print('in the foo')

bar()

会调用，并依次执行。此时，会先打印出，内容in the foo；其次，会执行bar()，这时就需要函数bar已存在，如果在执行bar()时函数还未生成，则会出现报错。

这也是为什么第一组和第二组中foo()可以成功执行，而第三组不能执行。因为在执行foo()的过程中，调用内容的过程中，bar()对应的函数bar还未被定义。

另：插播一则内容——匿名函数

匿名函数就是不需要显式的指定函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

匿名函数主要是和其它函数搭配使用的呢，如下：

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

# 输出
1
25
49
16
64

2、高阶函数：

• 把一个函数名当做一个实参传递给另外一个函数（在不修改被装饰函数的情况下为其添加功能）
• 返回值中包含函数名（不修改函数的调用方式）

import time

def bar():
    time.sleep(3)
    print('in the bar')

def func_2(fun):
    print(fun)
    return fun

print(bar)
# 输出
<function bar at 0x100662e18>

bar = func_2(bar)
# 输出
<function bar at 0x100662e18>

bar()  # run bar
in the bar #三秒后显示

3、嵌套函数

# 嵌套函数
def foo():
    print('in the foo')
    def bar():
        print('in the bar')
    bar()

foo()
# 输出
in the foo
in the bar

高阶函数+嵌套函数==>>装饰器

import time

def bar():
    time.sleep(3)
    print('in the bar')

def func(fun):
    start_time = time.time()
    fun()  # run bar
    stop_time = time.time()
    print('the running time of fun is %s' %(stop_time - start_time))

func(bar)
# 输出
in the bar
the running time of fun is 3.0043821334838867

以上代码已经是一个简单的高阶函数+嵌套函数版的弱鸡装饰器了，但是：

写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

• 封闭：已实现的功能代码块
• 开放：对扩展开发

so。。。

import time

def timer(func):
    def warpper():
        start_time = time.time()
        func()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time-start_time))
    return warpper


@timer # time1 = timer(time1)
def time_1():
    time.sleep(3)
    print('in the time_1')

time_1()
# 输出
in the time_1
the func run time is 3.0014379024505615

# 也可以传入参数
import time

def timer(func):
    def deco(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time = time.time()
        print('the func run time is %s' % (stop_time - start_time))
    return deco

@timer  # time2 = timer(time2) = deco time2()=deco()
def time2(*args,**kwargs):
    print('time2:',args,kwargs)

time2('XMY',age=22,job='IT')
print(timer(time1))
# 输出
time2: ('XMY',) {'age': 22, 'job': 'IT'}
the func run time is 9.608268737792969e-05
<function timer.<locals>.deco at 0x102693e18>

 2、迭代器 

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

特点：

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

# 可以直接作用于for循环的对象统称为可迭代对象: Iterable

from collections import Iterable
isinstance([], Iterable)

# 可以被next()函数调用并不断返回下一个值的对象称为迭代器: Iterator
# Iterator可以表示一个无限大的数据流
from collections import Iterator
isinstance([], Iterator)
isinstance(iter([]), Iterator)

print(globals())

 3、生成器 

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

yield的主要效果是可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。

# 列表生成式
l = [i ** 2 for i in range(10)]
print(l)
# 输出
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

'''
相当于
a = []
for i in range(10):
    a.append(i**2)

print(a)
'''

# 生成器
# 只有在调用时才回生产相应的数据
# 只记录当前位置
# 只有一个__next__()方法
g = (i ** 2 for i in range(10))
print(g)
# 输出
<generator object <genexpr> at 0x102155620>

for i in g:  # g.__next__()
    print(i)
# 输出
0
1
4
9
16
25
36
49
64
81

# Fibonacci
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        # print(b)
        yield b
        a, b = b, a + b
        '''
        相当于
        t = (b, a + b)
        a = t[0]
        b = t[1]
        '''
        n = n + 1
    return 'done'


f = fib(10)
while True:
    try:
        x = next(f)
        print('f:',x)
    except StopIteration as e: 当生成器取完时中断、避免报错
        print('Generator return value:', e.value)
        break
# 输出
f: 1
f: 1
f: 2
f: 3
f: 5
f: 8
f: 13
f: 21
f: 34
f: 55
Generator return value: done

另外，还可通过yield实现在单线程的情况下实现并发运算的效果

# 协程
import time
def consumer(name):
    print('%s 准备吃包子了' %name)
    while True:
        baozi = yield
        print('包子[%s]来了,被[%s]吃了' %(baozi,name))

def producer(name):
    c1 = consumer('A')
    c2 = consumer('B')
    c1.__next__()
    c2.__next__()
    print('老子要开始做包子了！')
    for i in range(10):
        time.sleep(1)
        print('做了2个包子！')
        c1.send(i)
        c2.send(i)

producer('Xmy')

 4、序列化&反序列化 

如果我们要存储和读取一个列表或字典类型的文件，根据之前所学的知识，只能通过如下方法：

info = {
    'name':'xmy',
    'age':24,
} 5  6 
f = open('test.txt','w')
f.write(str(info)) # 以字符串格式写入文件
f.close()

f = open('test.txt','r')
data = eval(f.read()) # 读入文件,并转为对应dict格式
f.close

除了这种比较麻烦的蠢办法以外，我们还可以用json和pickle两种方法，将对文件进行读取操作

1. json

import json

info = {
    'name':'xmy',
    'age':24,
}

f = open('test.txt','w')
json.dump(info,f) #写入文件，等同于f.write(json.dumps(info))
f.close()

f = open('test.txt','rb')
data = json.load(f)  #读取文件，等同于data = json.loads(f.read())
f.close()

2. pickle

pickle的操作和json是一致的，唯一的区别在于，pickle是将原文件内容转为二进制写入文件中，在文件读取中也是从二进制转回。因此在文件操作时，需要标注'rb'、'wb'、'ab'。

此外，json无法对函数进行文件存储，而pickle可以.

import pickle

def sayhi(name):
    print('hello',name)

info = {
    'name':'xmy',
    'age':24,
    'func':sayhi,
}

f = open('test.txt','wb')
pickle.dump(info,f)  # f.write(pickle.dumps(info))
f.close()

但是，在读取的过程中，我们是否可以直接调用该函数呢？

import pickle

f = open('test.txt','rb')

data = pickle.load(f)  # data = pickle.loads(f.read())

f.close()

# 输出
AttributeError: Can't get attribute 'sayhi' on <module '__main__' #出现报错

可见，当初存入后，文件内只是存在了函数形式的字符串，当读取时，由于不存在该函数，所以会产生报错，但如果我们读取之前，再次定义一下sayhi函数，情况就不一样了。

import pickle

def sayhi(name):
    print('hello world',name)


f = open('test.txt','rb')

data = pickle.load(f)  # data = pickle.loads(f.read())

f.close()
print(data['func']('Xmy'))

# 输出
hello world Xmy
None