我的Python分析成长之路5

一、装饰器：

　　本质是函数，装饰其他函数，为其他函数添加附加功能。

　　原则：

　　　　1.不能修改被装饰函数的源代码。　

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

　　装饰器用到的知识：

　　　　　　　　　　1.函数即变量   （把函数体赋值给函数名）

　　　　　　　　　　2.高阶函数 （1.一个函数接受另一个函数名作为实参2.返回值中含有函数名）

　　　　　　　　　　3.嵌套函数（一个函数嵌套这另一个函数）　　

　　　　先看高阶函数 ：

　　　　　　　　　　　1。要实现不修改被装饰函数的源代码，就要使用一个函数接受另一个函数名作为实参

 

　　　　　　　　　　

 

　　　　　　　　　　　　2.要实现不修改源代码的调用方式，使用返回值中包含函数名

　

 

　　　　嵌套函数：

def test1():
    print("in the test1")
    def test2():
        print("in the test2")
    test2()
test1()           #一个函数中包含另一个函数，而且内部的函数只能在内部调用

 　　　　　装饰器的实现

#给计算test的运行时间
def timer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print("函数运行时间：%s"%(end_time-start_time))
    return wrapper
@timer
def test():
    time.sleep(1)
# test = timer(test)
test()       

import time
def timer(func):
    def wrapper(n):
        start_time = time.time()
        func(n)
        end_time = time.time()
        print("函数运行时间：%s"%(end_time-start_time))
    return wrapper
@timer
def test(n):       #当函数中含有参数时
    time.sleep(1)
    print("打印的值为：%s"%n)
# test = timer(test)
test(5)  

import time
def timer(func):
    def wrapper(*args,**kwargs):     #当函数中含有任意多个参数参数时
        start_time = time.time()
        func(*args,**kwargs)
        end_time = time.time()
        print("函数运行时间：%s"%(end_time-start_time))
    return wrapper
@timer
def test(age,name):       
    time.sleep(1)
    # print("打印的值为：%s")
    print("年龄是%s,名字是%s"%(name,age))
# test = timer(test)
test(24,name='小明')

二、迭代器与生成器

　　列表生成式     [i *2 for i in range(10)]

　　生成器    　　1.只有在调用的时候才会生成数据。2.只记录当前位置。3.只有next方法，直到最后抛出stopiteration才终止

　　　　　　第一种形式

[i *2 for i in range(10)]   #列表生成式
x = (i *2 for i in range(10))    #生成器
print(x.__next__())
print(x.__next__())  
print(next(x))   

　　　　　　　第二种形式

def f(maxiter):
    n,a,b = 0,0,1
    while n<maxiter:
        yield b       #用函数形成生成器 含有 yield
        a,b = b,a+b
        n += 1
x = f(10)
print(x.__next__())    #要想生成数据，需要调用next方法
print(x.__next__())

 

　　　　　　

　　　　如果要获取生成器的值，就要捕获stopiteration异常

def f(maxiter):
    n,a,b = 0,0,1
    while n<maxiter:
        yield b
        a,b = b,a+b
        n += 1
    return "done"     #如果要获取函数的返回值，就要捕获stopiteration异常
x = f(3)
while True:
    try:
        print("x:",x.__next__())
    except StopIteration as e:
        print("生成器返回值:",e.value)
        break          

#最简单的生产者消费者模型
import time
def consumer(name):
    print("%s要准备吃包子了"%name)
    while True:
        baozi = yield
        print("%s包子被%s吃了"%(baozi,name))
def produser(name):
    c1 = consumer('A')
    c2 = consumer('B')
    c1.__next__()
    c2.__next__()
    for  i in range(10):
        time.sleep(1)
        print("%s做了2个包子"%name)
        c1.send(i)
        c2.send(i)
produser('xiaoming')

　　可迭带对象iterable：可以直接用for循环的对象称为可迭代对象   可以用isinstance()函数判断是不是可迭代对象

　　迭代器iterator：可以调用next方法，并不断返回下一个值的对象   　　生成器都是迭代器，list、dict、str 都是可迭代对象，但不是迭代器。可用iter方法使之称为迭代器

　　　　　　　　　　

三、map、filter、reduce函数

　　

print(map(lambda x:x*2,range(10)))
print(list(map(lambda x:x*2,range(10))))
#map（func,iterable）对iterable调用func 得到的是
print(list(filter(lambda x:x>5,range(10))))
#filter(func,iterable)  #对可迭代对象进行筛选
print(list(filter(lambda x:x.startswith('m'),['mn','mb','b'])))
from functools import reduce
print(reduce(lambda x,y:x+y,range(10)))     #进行累加操作
# reduce(func,iterable) 

四、json和pickle模块

　　

data ={'name':'zqq','age':8,'sex':"boy"}
f = open("file.json","r")
# f.write(str(data))
import json
x = json.dumps(data)   #序列化  或 json.dump(data,f)    dump可以多次，load只能一次
f.write(x)
data = json.loads(f.read())       #反序列化 或json.load(f)
print(data)
f.close()       
  
f = open("ddd.txt","wb")
import pickle
x = pickle.dumps(data)        #序列化   pickle.dump(data,f)
f.write(x)
f.close()
f = open("ddd.txt","rb")
import pickle
data = pickle.loads(f.read())     #反序列化    pickle.load(f)
print(data)