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()]

 >>> L

 [, , , , , , , , , ]

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

 >>> 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))