目录:
1、装饰器
2、列表生成式
3、生成器
4、斐波那契额
4、迭代器
5、json & pickle 模块
一、装饰器:
装饰器:
定义:本质是函数,(功能:装饰其他函数)就是为其他函数添加附加功能
原则: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()
函数实现的,例如:
六、json & pickle 模块