python学习之路-day4-装饰器&json&pickle

本节内容

1. 迭代器&生成器
2. 装饰器
3. Json & pickle 数据序列化

一、生成器

1、列表生成式

>>> L = [x * x for x in range(10)]

>>> L

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2、生成器

只有在调用时才会生成相应的数据，只有一个方法：__next__()方法。next（），也就是又next方法的

生成器

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

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

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]

>>> L

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> g = (x * x for x in range(10))

>>> g

<generator object <genexpr> at 0x1022ef630> 

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

>>> next(g)

Traceback (most recent call last):

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

StopIteration

 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

普通函数：

 1 def fib(max):
 2     n,a,b = 0,0,1
 3     while  n<max:
 4         print(b)
 5         #yield b
 6         a,b=b,a+b
 7         n = n+1
 8     return 'done'
 9 t = fib(11)
10 print(t)
11 输出结果：
12 1
13 1
14 2
15 3
16 5
17 8
18 13
19 21
20 34
21 55
22 89
23 done

上面函数变成生成器，只需要把print(b)改为yield b就可以了：


def fib(max):

    n,a,b = 0,0,1

    while  n<max:

        #print(b)

        yield b

        a,b=b,a+b

        n = n+1

    return 'done'

t = fib(11)

print(t)

 

输出结果：

<generator object fib at 0x00000000010F59E8>

注：赋值语句：
a, b = b, a + b

相当于：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

变成生成器之后并没有运行，而是在要输出的时候才运行：（每次next，输出一次）

def fib(max):
    n,a,b = 0,0,1
    while  n<max:
        #print(b)
        yield b                #碰到yield，程序中断， 出到函数外面在遇到next的时候在回来接着往下走

        a,b=b,a+b
        n = n+1
    return 'done'
t = fib(11)
print(t)
print(t.__next__())
print(t.__next__())
print(t.__next__())
print("---------")
print(t.__next__())
输出结果：
1
1
2
---------
3

再来一例：

def consumer(name):
    print("%s 准备吃包子啦！" %name)
    while True:
        baozi =  yield       #碰到yield退出程序，遇到c.__next__()时在进来继续往下走
        print("包子[%s]来了，被【%s】吃了！" %(baozi,name))
c = consumer("lsp")
c.__next__()
c.__next__()
c.__next__()
c.__next__()

输出结果：
lsp 准备吃包子啦！
包子[None]来了，被【lsp】吃了！   
#yield是none值，可以通过send给yield传值，见下例
包子[None]来了，被【lsp】吃了！
包子[None]来了，被【lsp】吃了！

**最后一例**

import time
def consumer(name):
    print("%s 准备吃包子啦！" %name)
    while True:
        baozi =  yield      #碰到yield退出程序，遇到c.__next__()或者（send）时在进来继续往下走(只要有yield就是生成器)
        print("包子[%s]来了，被【%s】吃了！" %(baozi,name))
def producer(name):
    c=consumer('lw')       #因为是生成器，所以不会输出任何东西
    c2 = consumer('lsp')
    c.__next__()           #输出lw准备吃包子了
    c2.__next__()           #输出lsp准备吃包子了
    print("我开始准备做包子了！")   #输出我开始做包子了
    for i in range(3):              #循环
        time.sleep(1)               #sleep  1秒
        print("做了1个包子")        #做了一个包子
        c.send(i)          #将i的值传给yield
        c2.send(i)          #将i的值传给yield
producer("alex")            #调用函数
输出结果：
lw 准备吃包子啦！
lsp 准备吃包子啦！
我开始准备做包子了！
做了1个包子
包子[0]来了，被【lw】吃了！
包子[0]来了，被【lsp】吃了！
做了1个包子
包子[1]来了，被【lw】吃了！
包子[1]来了，被【lsp】吃了！
做了1个包子
包子[2]来了，被【lw】吃了！
包子[2]来了，被【lsp】吃了！

二、迭代器

 

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable

只要有next的方法，就一定是一个迭代器

for line in f：   #就是一个迭代器

接上面生成器的例子：

def fib(max):
    n,a,b = 0,0,1
    while  n<max:
        #print(b)
        yield b
        a,b=b,a+b
        n = n+1
    return 'done'
t = fib(11)
for i in t:
    print(i)
输出结果：
1
1
2
3
5
8
13
21
34
55
89

三、装饰器

装饰器：本质是函数（装饰其他函数），就是为其他函数添加附加功能

原则：

1. 不能修改被修饰的函数的源代码
2. 不能修改被装饰的函数的调用方式

原函数代码和调用方式 不变，不知道有装饰器在装饰他（一句话，源函数代码和调用方式一点都不变，实现改变功能的函数，即是装饰器）

例一：

import time
def bar():              #原函数
    time.sleep(3)
    print('in the bar')
def test1(func):
    start_time=time.time()
    func()                 #调用函数bar，因为func= bar，所以这里func（）== bar（），即调用上面的函数
    stop_time=time.time()
    print("the func time is %s" %(stop_time-start_time))

#bar()  #原函数调用方式
test1(bar)      #调用函数test1，func = bar ,这样虽然实现了修改原函数功能，但是调用方式改变了

例二：

    原函数：
import time
def test1():         # 原函数1
    print("this is test1")  
def test2():        #原函数2       
    print("this is test2")
test1()            #原函数调用方式
test2()              #原函数调用方式
-----------------------------
加装饰器(加功能：程序运行时间)
   
import time
def timer(func):
    def deco():
        start_time = time.time()
        func()    #test1 = func()--->test1() //#test2 = func()--->test2()
        stop_time = time.time()
        print("the func run time is %s" %(stop_time-start_time))
    return deco    #将deco的函数的内存地址返回，就是test1 == deco函数的内存地址！
@timer   #test1=timer(test1)    test1 == deco函数的内存地址！
def test1():   #test1 == deco函数的内存地址！test1（）即执行deco函数，真正的test1（）到deco函数里面遇到func（）才会执行
    time.sleep(1)
    print("this is test1")
@timer  #test2=timer(test1)
def test2():
    time.sleep(1)
    print("this is test2")
test1()
test2()

 终极装饰器：

# __author__ = 'lw'
import time
user,passwd = 'lw','lw123'
def auth(auth_type):
    print('auth_func:',auth_type)
    def outer_wrapper(func):
        def wrapper(*args,**kwargs):
            print("wrapper func args:",*args,**kwargs)
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("password:").strip()
                if username == user and passwd == password:
                    print("\033[32;1mUser has passwd authentication\033[0m")
                    res = func(*args,**kwargs)      #from home
                    print("---after authentication")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print("welcome to ldap")
        return wrapper
    return outer_wrapper
def index():
    print("welcome to index page")
@auth(auth_type="local")   #home = wrapper()
def home():
    print("welcome to home page")
    return  "from home"
def bbs():
    print("welcome to bbs page")
index()
print(home())  #wrapper()
bbs()

四、 json&&pickle

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。

 json在所以语言中通用

引用模块

 

import json

重要函数

• 编码：把一个Python对象编码转换成Json字符串   json.dumps()
• 解码：把Json格式字符串解码转换成Python对象   json.loads()

例子

序列化

将内存中的信息写入到文件

#!/usr/bin/python

import json
info = {

        'name':'alex',
        'age':'22'
}
f = open("test.txt","w")

f.write(json.dumps(info))

f.close()
[root@test1 python]# 

 反序列化

将文件中的信息读取出来

[root@test1 python]# cat fanxuliehua.py 
#!/usr/bin/python

import json
f = open("test.txt","r")

data = json.loads(f.read())

print(data)
print(data["name"])

[root@test1 python]# python fanxuliehua.py       
{u'age': u'22', u'name': u'alex'}
alex
[root@test1 python]#

 json只能序列化简单的数据类型，不能反序列化函数等复杂的数据类型，想要序列化复杂的数据，需要使用pickle，用法和json完全一样，只是序列化的时候变成二进制类型，即在打开文件的时候要用wb和rb

 pickle.dump(info,f) ==f.write(pickle.dumps(info))