python装饰器
定义：本质是函数，（装饰其他函数）就是为其他函数添加附加功能
原则：1。不能修改被装饰的函数源代码
2.不能修改被装饰的函数的调用
def test1():
pass
def test2():
pass
这是两个函数想为两个函数添加打印功能,那就在写一个打印函数然后再调用
def logger():
print(‘logging‘)
def test1():
pass
logger()
def test2():
pass
logger()test1（）test2（）
装饰器通过@装饰器名来调用
def timer(func):
def warpper(*args,**kwargs):
start_time = time - time()
func()
stop_time=time.time()
print(‘the func run time is%s‘%(stop_time-start_time)
return warpper
@timmer #装饰器的调用方式
def test1():
time.sleep(3)
print(‘in the test1‘)
test()
实现装饰器的知识：
1.函数即变量（定义一个函数就等于把函数体给了函数名）
2.高阶函数
a.把函数名当做一个实参传给另外一个函数（不修改被装饰函数源代码为函数添加功能）
b.返回之中包含函数名(不修改函数的调用方式)
3.嵌套函数
高阶函数+嵌套函数=装饰器
列表生成式
列表直接生成以后在赋值给a
a= [i*2 for i in rnge(10)] [0,2,4,6,8,10,12,14,16,18]
生成器：只有在调用时才会生成相应的数据 ，只有一个__next__()方法
b是内存地址
b=[i*2 for i in range(10)]
for i in b:
print(i)
实现斐波那契的生成器
def fib(max):
n,a,b = 0,0,1
while n<max:
# print(b)
yield b
a,b = b,a+b
#a= b a =1,b=2, a=b, a=2
# b = a+b b= 2+2 = 4
n= n+1
return ‘-----------done---------------‘
# f=fib(10)
g= fib(6)
print(g.__next__())
print("======star loop=====")for i in g: print (i)#如果数据过大无法知道长度需要异常处理
while True: try: x= next(g) print(‘g:‘,x) except StopIteration as e: print(‘Generator return value:‘,e.value) break
生成器的并行
# Author:Zhiyu Su
import time
def consumer(name):
print(‘%s 准备吃孢子啦！‘%name)
while True:
baozi = yield
print(‘包子[%s]来了，被[%s]吃了‘%(baozi,name))
c= consumer(‘chengronghua‘)
# c.__next__()
# b1= ‘韭菜馅‘
# c.send(b1)
# c.__next__()
def producer(name):
c= consumer(‘A‘)
c2 = consumer(‘B‘)
c.__next__()
c2.__next__()
print(‘老子包子做好了‘)
for i in range(10):
time.sleep(1)
print(‘做了1个包子分了两半‘)
c.send(i)
c2.send(i)
producer(‘alex‘)
迭代器
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象：
>>> from collections import Iterable >>> isinstance([], Iterable) True
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
python的内置方法
# Author:Zhiyu Su
#print(all([1,-5,3]))#判断数据是否为真 是返回True 否者返回fale
# print(any[1])
# a = (ascii([1,2,‘说‘])) #把内存对象变成可打印字符串模式
# print(type(a))
# print(bin(1)) #把数字十进制转二进制
# bool(90)#判断真假
# a = bytes(‘abcde‘,encoding=‘utf-8‘) #二进制
# b = bytearray(‘abcde‘,encoding=‘utf-8‘) #可修改的二进制
# print(b[1])
# print(a.capitalize(),a) #首字母大写
# def ggg():pass
# print(callable(ggg))
# print(chr(88)) #把数字对应的acsii表反映出来
# print(ord(‘w‘)) #与chr相反
# code = ‘for i in range(10):print(i)‘ #把字符转换换代码
# c=compile(code,‘‘,‘exec‘)
# exec(c)
# exec(code)
# dir(x)#查取方法
# divmod()#底板除
# enumerate
# seasons = [‘Spring‘,‘Sunner‘,‘Fall‘,‘winter‘]
#
# print(list(enumerate(seasons)))
#[(0, ‘Spring‘), (1, ‘Sunner‘), (2, ‘Fall‘), (3, ‘winter‘)]
# eval()#数据字典变字符串
# def sayhi(n):
# print(n)
#
# sayhi(3)
#
# # lambda n:print(n)(5)
# calc = lambda n:3 if n<4 else n #匿名函数只能进行三元运算
# print(calc(5))
# res= filter(lambda n:n>5,range(10)) #一组数据过滤出你想要的来
# res = map(lambda n:n*2,range(10))
# res=[lambda i:i*2 for i in range(10)]
# import functools
# res = functools.reduce(lambda x,y:x+y,range(10))#45
# res = functools.reduce(lambda x,y:x*y,range(1,10))#362880
#
# print(res)
# a = frozenset([1,3,4,5,64,2,5,23,4])#不可变集合
# print(globals()) #整个文件的变量值
# hash( )
# print(hex(255)) #将数字转为16进制
# def test():
# local_var = 333
# print(locals())
# test()
# print(globals())
# print(globals().get(‘local_var‘))
# oct()#转八进制
# print(pow(3,5)) #3的5次方
# print(round(1.33555,2)) #保留两位数字
# a = {6:2,8:0,1:4,-5:6,99:11,4:22}
# # print(sorted(a.items()))
# print(sorted(a.items(),key = lambda x:x[1]))
#
# print(a)
# a= [1,2,3,4]
# b= [‘a‘,‘b‘,‘c‘,‘d‘]
# for i in zip(a,b):
# print(i)
json和pickle数据序列化：把内存的对象变成字符串
json序列化
# Author:Zhiyu Su
import pickle
def sayhi(name):
print(‘hello‘,name)
info = {
‘name‘:‘alex‘,
‘age‘:22,
‘func‘:sayhi
}
f=open(‘test.text‘,‘wb‘)
f.write(pickle.dumps( info))
# print(json.dumps(info))
f.close()
json反序列化
# Author:Zhiyu Su
import json
def sayhi(name):
print(‘hello‘,name)
f = open(‘test.text‘,‘rb‘)
# data =eval( f.read())
data = json.loads(f.read())
print(data[‘age‘])
pickle序列化
# Author:Zhiyu Su
import pickle
def sayhi(name):
print(‘hello‘, name)
info = {
‘name‘: ‘alex‘,
‘age‘: 22,
‘func‘: sayhi
}
f = open(‘test.text‘, ‘wb‘)
pickle.dump(info, f) # 等同于f.write(pickle.dumps(info))
f.close()
pickle反序列化
# Author:Zhiyu Su
import pickle
def sayhi(name):
print(‘hello‘,name)
f = open(‘test.text‘,‘rb‘)
data = pickle.load(f) # data = pickle.loads(f.read())
print(data[‘func‘](‘alex‘))