1装饰器

1.1基本结构

def 外层函数(参数):

def 内层函数(*args,**kwargs);

return 参数(*args,**kwargs)

return 内层函数

@外层函数

def index()

pass

#示例:

def func(arg):

def inner():

v = arg()

return v

return inner

@func

def index():

print(123)

return 666

print(index)

@func :执行func函数把下面色函数当做参数传递,相当于：func(index)

将外层函数的返回值(内层函数)重新赋值给下面的函数名index,index = func(index)

1.2装饰器基本应用

应用场景:想要为函数扩展功能时,使用装饰器

计算运行时间

时间模块:time.time()获取当前时间

time.sleep('秒数')睡眠

# 计算函数执行时间

def wrapper(func):

def inner():

start_time = time.time()

v = func()

end_time = time.time()

print(end_time-start_time)

return v

return inner

@wrapper

def func1():

time.sleep(2)

print(123)

@wrapper

def func2():

time.sleep(1)

print(123)

func1()

1.3 带参数的装饰器

#普通装饰器基本格式

def wrapper(func):

def inner():

pass

return func()

return inner

def func():

pass

func = wrapper(func)

func()

#带参数装饰器基本格式

def w(counter):

def wrapper(func):

def inner(*args,**keargs):

lis = []

for i in range(0,counter):

a=func(*args,**keargs)

lis.append(a)

return lis

return inner

return wrapper

def func(*args,**keargs):

return 8

#面试题

# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回最后一次执行的结果【面试题】

def xxx(counter):

print('x函数')

def wrapper(func):

print('wrapper函数')

def inner(*args,**kwargs):

for i in range(counter):

data = func(*args,**kwargs) # 执行原函数并获取返回值

return data

return inner

return wrapper

@xxx(5)

def index():

return 8

v = index()

print(v)

2生成器

函数中存在yield,那么该函数为生成器函数,调用生成器函数会返回一个生成器,生成器只有被for循环时,生成器函数内部的代码才会执行,每次驯化都会获取yield返回的值.

基本格式:

##生成器函数存在yield

def func(*args)

*args=1

yield 1

yield 2

func('a')

#函数内部代码不会执行,返回一个生成器对象

v = func('a')

#生成器是可以被for循环,一旦开始循环name函数内部代码就会开始执行.

for item in v:

print(item) #循环开始,函数运行,yield 返回值,停止第一次循环,再次循环时从上一次yield的位置开始运行

生成数字:

return 可以做终止命令,不会返回值

def func():

count = 1

while True:

yield count

count += 1

val = func()

for item in val:

print(item)

3迭代器

3.1 迭代器

迭代:迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”

迭代器:帮助对某种对象(str/list/tuple类所创建的对象..)中的y元素一一获取.表象:具有__next__方法,每次迭代都返回一个值

列表转换成迭代器:

lis = iter([1,2,4,2])

lis= [1,2,4,2]._ _ iter __()

迭代器想要获取每个值就要反复调用:val = lis.__ next __()

直到报错Stopinteration取到最后一个元素

判断一个对象是否是迭代器:内部是否有__ next __方法.

v1 = [11,22,33,44]

# 列表转换成迭代器

v2 = iter(v1)

result1 = v2.__next__()

print(result1)

result2 = v2.__next__()

print(result2)

result3 = v2.__next__()

print(result3)

result4 = v2.__next__()

print(result4)

result5 = v2.__next__()

print(result5)

"""

# v1 = "alex"

# v2 = iter(v1)

# while True:

# try:

# val = v2.__next__()

# print(val)

# except Exception as e:

# break

3.2 可迭代对象

具有__inter__方法的就是可迭代对象,并且返回一个迭代器,才成为可迭代对象

v1= [11,22,33,44]

result= v1.__iter__()

能被for循环的就是可迭代对象

小结

迭代器，对可迭代对象中的元素进行逐一获取，迭代器对象的内部都有一个 __next__方法，用于以一个个获取数据。

可迭代对象，可以被for循环且此类对象中都有 __iter__方法且要返回一个迭代器(生成器)。

生成器，函数内部有yield则就是生成器函数，调用函数则返回一个生成器，循环生成器时，则函数内部代码才会执行。

生成器是特殊的迭代器(**)