学习简述：装饰器，生成器，迭代器, json序列化
装饰器
定义：本质是函数，（装饰其他函数）就是为其他函数添加附加功能
原则： 1.不能修改被装饰的函数的源代码 2.不能修改被装饰函数的调用方式
实现装饰器的知识储备：
1.函数即‘变量’
2.高阶函数 a:把一个函数名当作实参传给另外一个函数（在不修改被装饰函数源代码的情况下）
b:返回值中包含函数名（不修改被装饰函数的调用方式）
满足a,b之一就称为高阶函数
3.嵌套函数：在函数体内，用一个def去定义另一个函数
高阶函数+嵌套函数=》装饰器
import time
def timer(func):
def deco(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs) #run test1
stop_time = time.time()
print('the func runs %s'%(stop_time-start_time))
return deco
@timer #test1 = timer(test1):就是返回值deco test1 = deco
def test1():
time.sleep(1)
print('in the test1')
@timer #test2=timer(test2) test2=deco test2()=deco()
def test2(name):
print('test2:',name)
test1()
test2('niu')列表生成式user,passwd = 'alex','abc123' 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 user == username and passwd == password: print("\033[32;1mUser has passed authentication\033[0m")res = func(*args, **kwargs) # from home print("---after authenticaion ") return res else: exit("\033[31;1mInvalid username or password\033[0m") elif auth_type == "ldap": print("我不会") 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" @auth(auth_type="ldap") def bbs(): print("welcome to bbs page") index() print(home()) #wrapper() bbs()
列表生成式,使代码更简洁，比如我想给range(10)内的数乘以2
t = [i*2 for i in range(10)]
print(t)
否则，我们之前的做法是这样的：
a = []
for i in range(10):
w=i*2
a.append(w)
print(a)
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator
（蓝色段落摘自我的偶像：Alex）
注意：生成器在创建的时候已经决定了能计算出的个数，调用next的次数超过这个值就会报StopIteration
遍历所有元素可以通过for循环：
for 循环内部做了三件事：
1.调用对象的iter()方法，返回一个迭代器对象
2.while
i = next(list_interator)
3.异常处理
b.send(None),相当于b.__next__(),第一次send前如果没有next，只能传一个send（None）
只有一个__next__（）方法，输入一次出一个值，这样如果有100个，就需要输入100个next，你一定觉得要疯了，所以大部分情况下我们使用for循环。
t = (i*2 for i in range(8))
print(next(t))
>>0 #不能像切片一样
print(t.__next__())
>>2
print(t.__next__())
4
print(t.__next__())
6
print(t.__next__())
8
print(t.__next__())
10
print(t.__next__())
12
print(t.__next__())
14
用for循环
t = (i*2 for i in range(8))
for i in t:
print(i)
>>>0
2
4
6
8
10
12
14
generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。
比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
def math(max):
n,a,b =0,0,1
while n<max:
print(b)
a ,b=b,a+b
n=n+1
return 'ok'
math(10)
a ,b=b,a+b 不是相当于a=b,b=a+b,而是s=(b,a+b),a=s[0],b=s[1] return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用
next()的时候执行，遇到
yield语句返回，再次执行时从上次返回的
yield语句处继续执行。
也可以使用for循环直接输出
for i in math(6):
print(i)
for循环调用generator时，发现拿不到generator的
return语句的返回值。如果想要拿到返回值，必须捕获
StopIteration错误，返回值包含在
StopIteration的
value中：
def math(max):
n,a,b =0,0,1
while n<max:
yield b
a ,b=b,a+b
n=n+1
return 'ok'
m = math(6)
while True:
try:
x = next(m)
print('m:', x)
except StopIteration as e:
print('Generator return value:', e.value)
break
>>>m: 1
m: 1
m: 2
m: 3
m: 5
m: 8
Generator return value: ok
import time
def student(name):
print('%s该上课啦：'%name)
while True:
数学= yield
print('数学%s,%s该准备了'%(数学,name))
def teacher(name):
s= student('A')
s1=student('B')
s.__next__()
s1.__next__()
print('老师准备上课啦')
for i in range(3):
time.sleep(1)
print('写一道计算题')
s.send(i)
s1.send(i)
teacher('niu')我们已经知道，可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。(生成器都是迭代器，迭代器不一定是生成器)
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象：
from collections import Iterable
s = isinstance([], Iterable)
print(s)
>>>True
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
什么是迭代器？
满足两个条件：1）有iter方法 2）有next方法
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
from collections import Iterator
s = isinstance([], Iterator)
print(s)
w = isinstance(iter([]),Iterator)
print(w)注意：生成器在创建的时候已经决定了能计算出的个数，调用next的次数超过这个值就会报StopIteration
遍历所有元素可以通过for循环：
for i in [1,2,3]:
print(i)
for循环内部做了三件事：
1.调用对象的iter（）方法，返回一迭代器对象
2.while:
i = next(list_interator)
3.异常处理list、
dict、
str等数据类型不是
Iterator？
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
总结：
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的，只不过被封装好了而已。
json序列化
json只能处理简单的数据类型，比如列表，字典，但是函数就不可以了
json序列化
import json
info ={
'name':'niu',
'age':22
}
f = open('test.text','w')
f.write(json.dumps(info))
f.close()
json反序列化
import json
f = open('test.text','r')
data = json.loads(f.read())
print(data['age'])
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
