目录：
1、装饰器
2、列表生成式
3、生成器
4、斐波那契额
4、迭代器
一、装饰器：
装饰器：
定义：本质是函数，（功能：装饰其他函数）就是为其他函数添加附加功能
原则：1、不能修改被装饰的函数的源代码
2、不能改变被装饰的函数的调用方式
实现装饰器知识储备：
1、函数即“变量”
2、高阶函数
a、把一个函数名当作实参传给另外一个函数（在不修改被装饰函数源代码的情况下为其添加功能）
b、返回值中包含函数名(不修改函数的调用方式)
3、嵌套函数
高阶函数 + 嵌套函数 ==》 装饰器
test:
def foo():
print(‘in the foo‘)
bar()
foo()
cale = lambda x:x*3 #匿名函数 直接赋值给变量 没有函数名
cale(3) # 调用
‘‘‘
def foo():
print(‘in the foo‘)
bar()
foo() #肯定会报错，因为在定义之前bar()函数还未定义
def bar():
print(‘in the bar‘)
‘‘‘
‘‘‘
#定义一个高阶函数
import time
def bar():
time.sleep(3)
print(‘in the bar‘)
def test1(func):
start_time = time.time()
func()
stop_time = time.time()
print(‘the func run time is %s‘ %(stop_time - start_time))
test1(bar) #在不改变bar的情况下 添加了新的功能，但是bar的调用方式改变了
‘‘‘
‘‘‘
import time
def bar():
time.sleep(3)
print(‘in the bar‘)
def test1(func):
print(func)
return func
#print(test1(bar))
bar = test1(bar)
bar() # run bar
‘‘‘
‘‘‘
#嵌套函数
def foo():
print(‘in the fooo‘)
def bar(): #相当与定义了一个bar的局部变量，只能在函数内部调用
print(‘in the bar‘)
bar() #只能在函数内部调用
foo()
‘‘‘
‘‘‘
#初级
#定义装饰器
import time
def timer(func): #timer(test1) 就是func=test1 #嵌套
def deco():
start_time = time.time()
func() # 运行test1()
stop_time = time.time()
print(‘the func run time is %s‘ %(stop_time - start_time))
return deco #高阶函数
@timer # 就相当于 test1 = timer(test1)
def test1():
time.sleep(3)
print(‘in the test1‘)
@timer
def test2():
time.sleep(3)
print(‘in the test2‘)
#test1 = timer(test1) #当不希望出现这个时 用上面的@timer
test1() # ------>deco
test2()
‘‘‘
‘‘‘
#当调用的函数有参数时
#大部分环境使用如下方式
import time
def timer(func): #timer(test1) func=test1 #嵌套
def deco(*args,**kwargs): #接受多个参数
start_time = time.time()
func(*args,**kwargs) # 运行test1()
stop_time = time.time()
print(‘the func run time is %s‘ %(stop_time - start_time))
return deco #高阶函数
@timer # 就相当于 test1 = timer(test1)
def test1():
time.sleep(2)
print(‘in the test1‘)
@timer
def test2(name,age):
time.sleep(2)
print(‘in the test2‘)
#test1 = timer(test1) #当不希望出现这个时
test1() # ------>deco
test2(‘laiang‘,18)
‘‘‘
为多个函数添加认证功能：
import time
user,passwd = ‘laiand‘,‘abc123‘
def auth(func):
def wrapper(*args,**kwargs):
username = input("Username:").strip() #去掉左右空格
password = input("Password:").strip()
if user == username and passwd == password:
print(‘\033[35;1mUser has passwd authentication\033[0m‘)
func(*args,**kwargs)
else:
exit(‘033[35;1mInvalid username or password\033[0m‘)
return wrapper
@auth
def index():
print(‘welcom to index page‘)
@auth
def home():
print(‘welcom to index home‘)
@auth
def bbs():
print(‘welcom to index bbs‘)
index()
home()
bbs()
二、列表生成式
现有列表a = [0,11,22,33,44,55,66,77,88,99,110]，把列表里的每个值加1，如何操作：
方式一：
a = [0,11,22,33,44,55,66,77,88,99,110]
b = [] #定义一个空列表
for i in a: #循环a 里的每一个元素
b.append(i+1) #把每一个元素加1扩展到b 里面
a = b
print(a)
方式二：
在原列表基础上修改
a = [0,11,22,33,44,55,66,77,88,99,110]
for index,i in enumerate(a):
a[index] += 1
print(a)
方式三：
a = [0,11,22,33,44,55,66,77,88,99,110] a = map(lambda x:x+1,a) for i in a:print(i)
列表生成式： 作用就是 使代码更简洁
a = [i+1 for i in range(10)] #循环每一个数 再加一 print(a)
三、生成器
当列表包含大量元素时，读取的时候会占用大量内存，造成空间浪费，
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素？这样就不必创建完整的list，从而节省大量的空间。
在Python中，这种一边循环一边计算的机制，称为生成器：generator
1、创建一个generator
方法一：
把一个列表生成式的[]改成()，就创建了一个generator：
>>> a = [x*x for x in range(11)] >>> a [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>> >>> b = (x*x for x in range(11)) >>> b <generator object <genexpr> at 0x7f6d80711870> >>>
可以直接打印出list的每一个元素
如果要打印生成器的每一个元素 通过next()函数来实现：
>>> b = (x*x for x in range(11)) >>> b <generator object <genexpr> at 0x7f6d80711870> >>> >>> next(b) 0 >>> >>> next(b) 1 >>> next(b) 4 >>> next(b) 9 >>> next(b) 16 >>> next(b) 25
生成器 只是给你准备了一个生成算法 需要的时候才生成 从而节省内存，只有在调用的时候才会生成相应数据
只记录当前的位置 只有一个__next__()方法 ,在2.x里是next()
四、斐波拉契数列
def fib(max):
n,a,b = 0,0,1
while n < max:
print(b)
a,b = b,a + b
n = n + 1
return ‘done‘
fib(7)
只需要把print(b)改为yield b就可以，把fib函数变成generator
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‘
f = fib(7)
print(f)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
<generator object fib at 0x000001D052442BA0> 1 1 2 3
如果一个函数定义中包含yield关键字，那么这个函数就是一个generator，每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行
把函数改成generator后，基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代
for i in fib(9):
print(i)
但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
g = fib(5)
while True:
try:
x=next(g)
print(‘g:‘,x)
except StopIteration as e:
print(‘Generator return value:‘,e.value)
break
g: 1 g: 1 g: 2 g: 3 g: 5 Generator return value: done Process finished with exit code 0
五、迭代器
可以直接作用于for循环的数据类型有以下几种：一类是集合数据类型，如list、tuple、dict、set、str等，一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象：
*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
isinstance(iter([]), Iterator) isinstance(iter(‘abc‘), Iterator)
小结
凡是可作用于for循环的对象都是Iterable类型；（可迭代类型）
凡是可作用于next()函数的对象都是Iterator类型，（迭代器类型）它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的，例如：
