闭包函数 装饰器 迭代器 列表、字典、生成器表达式 递归
目录
闭包函数
def f1(url):#f1就叫闭包函数
def spider():
print(url)
rerurn spider# 函数对象
taoao=f1('www.taobao.com')
taobao()
baidu=f1('www.baidu.com')
baidu()
闭包函数：闭包函数 把闭包函数内部的变量+闭包函数内部的函数 这两者包裹在一起 然后通过返回值的形式返回出来
闭包函数至少要符合函数嵌套
装饰器
装饰器的本质就是一个 给函数增加功能的函数
装饰器给 函数 增加功能时需要注意一下两点：
1.不改变原函数的源代码
2.不改变原函数的调用方式
import time
def index():
'''被装饰的函数'''
print('index')
time.sleep(1)
# time_count装饰器：对被装饰函数计时
def time_count(func):
def wrapper():
s=time.time
func()
e=time.time
print(e-s)
return wrapper
index=time_count(index)
index()
带返回值
import time
def index():
'''被装饰的函数'''
print('index')
time.sleep(1)
return 'index'
# time_count装饰器：对被装饰函数计时
def time_count(func):
def wrapper():
s=time.time
res=func()
e=time.time
print(e-s)
return res
return wrapper
index=time_count(index)
res=index()
print(res)
加参数
import time
def index(x,y,z=10):
'''被装饰的函数'''
print('index')
time.sleep(1)
return 'index'
# time_count装饰器：对被装饰函数计时
def time_count(func):
def wrapper(*args,**kwargs):
s=time.time
res=func(*args,**kwargs)
e=time.time
print(e-s)
return res
return wrapper
index=time_count(index)
res=index(10,20)
print(res)
装饰器模板
def deco(func):
def wrapper(*args,**kwargs):
'''加功能'''
res=func(*args,**kwargs)
return res
return wrapper
语法糖
让代码变得更简单
import time
# time_count装饰器：对被装饰函数计时
def time_count(func):
def wrapper(*args,**kwargs):
s=time.time
res=func(*args,**kwargs)
e=time.time
print(e-s)
return res
return wrapper
@time_count()
def index(x,y,z=10):
'''被装饰的函数'''
print('index')
time.sleep(1)
return 'index'
三层装饰器
由于两层的装饰器，参数必须得固定位func，但是三层的装饰器解除了这个限制。我们不仅仅可以使用上述单个参数的三层装饰器，多个参数的只需要在三层装饰器中多加入几个参数即可。也就是说装饰器三层即可，多加一层反倒无用
迭代器
可迭代对象：含有__item__方法的就叫做可迭代对象
迭代器：含有__item__和__next__方法的叫做迭代器
生成器：含有yield关键字的函数叫做生成器
迭代器
可迭代对象
有__iter--()方法的对象就是可迭代对象，除了数字类型之外都是可迭代对象。
迭代器对象
具有__iter__()和__next__()方法的叫迭代器对象，只有文件是迭代器对象
迭代器对象提供了不依赖索引取值的手段
for循环原理
for循环本质就是一个while循环，只不过是一个可控的while循环
lt = [1,2,3]
for i in lt: # 可迭代对象;迭代器对象 # 不依赖索引取值,而是迭代取值
print(i)
lt=[1,2,3]
lt_iter=lt.__iter__()
while Ture:
try:
print(lt_iter.__next__())
except StopIteration:
break
1.首先使用iter把lt变成迭代器对象，对于文件也要使用iter方法把文件iter下
2.然后使用next方法进行迭代取值
3.判断stopiteration异常，遇到异常终止
迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象
三元表达式
print(x) if x>y else print(y)
条件成立走这里 if 条件 else 条件不成立走这里
列表推导式
lt=[i for i in range(10)]
print(lt)
lt=[i**2(可以做运算) for i in range(10)]
字典生成式
lt1=['a','b','c']
lt2=[1,2,3]
dic={k:v**2 for k,v in zip(lt1,lt2)}
print(dic)#{'a': 1, 'b': 4, 'c': 9}
生成器表达式
g=(i for i in range(10))
print(g)
for i in g:
print(i)
#<generator object <genexpr> at 0x000002D0F10E6BA0>
0
1
2
3
4
5
6
7
8
9
生成器
生成器：含有yield关键字的函数叫做生成器
def ge():
yield 3#一个yield相当于一个next：暂停函数
yield 4
print(ge())#<generator object ge at 0x00000246292A6BA0>
g=ge()
print(g.__next__())#3
print(g.__next__())#4
yield的函数
1.暂停函数
2.通过next取值
return的特性
1.终止函数
2.通过调用函数拿到值
def range(start):
count=0
while count<start:
yield count
count+=1
for i in range(10):
print(1)
#0
#1
#2
#3
#4
#5
#6
#7
#8
#9
递归
递归：函数a内部直接调用函数a本身
每次递归都不会结束函数，每一次递归都会开辟内存空间，如果一直开辟内存就炸掉了，所以最多递归1000次
真正的递归必须要有 退出条件的
count=0
def a():
global count
count+=1
print(count)
if count==5:
return
a()
a()
def age(x):
if x==0:
return 18
x-=1
return age(x)+2
res=age(6)
print(res)#32
