Explication détaillée d'exemples de décorateurs, itérateurs et générateurs en Python

L'éditeur suivant vous présentera un cliché sur les décorateurs, les itérateurs et les générateurs en Python. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur et jetons un coup d'œil

Lors de l'apprentissage de python, les trois "outils célèbres" doivent être considérés comme une petite difficulté pour les personnes qui n'ont aucune expérience en programmation dans d'autres langages. Ce blog concerne le blogueur lui-même Decorators. , les itérateurs et la compréhension du générateur sont expliqués.

Pourquoi utiliser des décorateurs

Que sont les décorateurs ? « Décoration » signifie littéralement l'acte d'embellir un bâtiment spécifique selon une certaine idée et un certain style. Le soi-disant « décorateur » est un outil pour Python, un décorateur est une méthode qui peut être utilisée sans modifier le code original. de nouvelles fonctions. Par exemple, une fois qu'un logiciel est en ligne, nous devons ajouter périodiquement de nouvelles fonctions sans modifier le code source ni la façon dont il est appelé. En Python, nous pouvons utiliser des décorateurs pour y parvenir, également lors de l'écriture du code. nous devons également considérer l'évolutivité ultérieure. Examinons étape par étape les décorateurs de Python.

Un exemple simple présente un décorateur sans paramètre

Regardons d'abord quelques lignes de code simples. Le résultat du code est de dormir. pendant 2 secondes, puis imprimez "hello boy!" :

import time
def foo():
 """打印"""
 time.sleep(2)
 print("Hello boy!")
foo()

Nous devons maintenant y ajouter une fonction de synchronisation du programme, mais le code d'origine ne peut pas être modifié :

import time
def timmer(func):
 def wrapper():
  """计时功能"""
  time_start=time.time()
  func()
  time_end=time.time()
  print("Run time is %f "%(time_end-time_start))
 return wrapper
def foo():
 """打印"""
 time.sleep(2)
 print("Hello boy!")
foo=timmer(foo)
foo()
#运行结果
Hello boy!
Run time is 2.000446

Regardez ! Nous avons implémenté cette fonction sans modifier le code d'origine. Comme les fonctions sont aussi des objets, nous pouvons passer la fonction foo comme paramètre à la fonction timmer.

En python, il existe une manière plus concise de remplacer foo=timmer(foo), en utilisant @timmer, qui est appelé sucre syntaxique en python.

import time
def timmer(func):
 def wrapper():
  """计时功能"""
  time_start=time.time()
  func()
  time_end=time.time()
  print("Run time is %f "%(time_end-time_start))
 return wrapper
@timmer  #等于 foo=timmer(foo)
def foo():
 """打印"""
 time.sleep(2)
 print("Hello boy!")
foo()

Analysons le processus d'exécution de la fonction étape par étape :

1. Importez le module horaire

import time

2. Définir la fonction timer La définition de la fonction n'exécutera pas le code dans la fonction

def timmer(func):

3. decorator, tout à fait Pour foo=timer(foo), la fonction foo est passée en paramètre à la fonction timmer

@timmer

4. paramètre func=foo

def timmer(func):

5. Dans la fonction timmer, le wrapper de fonction est défini, le code à l'intérieur de la fonction wrapper n'est pas exécuté, puis le wrapper de fonction. est renvoyé comme valeur de retour

return wrapper

6. Attribuez la valeur de retour à foo À l'étape 3, foo=timmer(foo), souvenez-vous-en

<.>

7. Exécutez la fonction foo(), mais la fonction ici n'est plus celle d'origine. Vous pouvez imprimer foo Oui, car nous avons passé le wrapper à foo. valeur de retour avant, donc ici Exécuter foo exécute le wrapper Pour confirmer cela, vous pouvez également imprimer le wrapper Leurs adresses mémoire sont les mêmes, donc elles pointent toutes vers le même espace d'adressage :

@timmer #等于 foo=timmer(foo)

.

8. Exécutez le wrapper de fonction, enregistrez l'heure de début et exécutez la fonction func. À l'étape 4, func se voit attribuer une valeur par foo. L'exécution de func exécute la fonction d'origine foo, dort pendant. 2 secondes, et imprime la chaîne ;

<function timmer.<locals>.wrapper at 0x00000180E0A8A950> #打印foo的结果
<function timmer.<locals>.wrapper at 0x000001F10AD8A950> #打印wrapper的结果
foo()

9. Enregistrez l'heure de fin, imprimez la durée d'exécution et le programme se termine.

time_start=time.time()
 time.sleep(2)
 print("Hello boy!")

Hello boy!
Run time is 2.000161

Décorateur de paramètresDans l'exemple précédent, la fonction originale n'a pas de paramètres , Voyons comment modifier la fonction décorateur lorsque la fonction d'origine a des paramètres ?

Lorsque la fonction d'origine doit transmettre des paramètres, dans cet exemple, my_max a deux positions qui doivent être transmises. Il vous suffit d'ajouter deux paramètres à le wrapper. Paramètres formels, dans cet exemple il est également possible d'utiliser des paramètres variables (*args, **kwargs) Il s'agit de @timmer qui est égal à my_max(1,2)=timmer(my_max)

import time
def timmer(func):
 def wrapper(*args,**kwargs):
  """计时功能"""
  start_time=time.time()
  res=func(*args,**kwargs)
  end_time=time.time()
  print("Run time is %f"%(end_time-start_time))
  return res
 return wrapper
@timmer 
def my_max(x,y):
 """返回两个值的最大值"""
 res=x if x > y else y
 time.sleep(2)
 return res
res=my_max(1,2)
print(res)
#运行结果
Run time is 2.000175

Faisons-le ensuite Regardez un

décorateur avec des paramètres :

Si le décorateur lui-même a des paramètres, un plus de fonctions intégrées dans la couche, analysons le processus d'exécution étape par étape :

def auth(filetype):
 def auth2(func):
  def wrapper(*args,**kwargs):
   if filetype == "file":
    username=input("Please input your username:")
    passwd=input("Please input your password：")
    if passwd == '123456' and username == 'Frank':
     print("Login successful")
     func()
    else:
     print("login error!")
   if filetype == 'SQL':
    print("No SQL")
  return wrapper
 return auth2
@auth(filetype='file') #先先返回一个auth2 ==》@auth2 ==》 index=auth2(index) ==》 index=wrapper
def index():
 print("Welcome to China")
index()

1 Définissons la fonction auth

2. Exécutez d'abord la fonction auth(filetype='file')

def auth(filetype):

3. Exécutez la fonction auth, définissez une fonction auth2 et renvoyez-la comme valeur de retour, alors ce @auth (filetype='file') est équivalent à @auth2, qui équivaut à index=auth2(index)

@auth(filetype='file')

4. Exécution auth2(index), func=index, définissez le wrapper de fonction et renvoyez-le. À ce stade, index est en fait égal au wrapper

def auth(filetype):
 def auth2(func):
  def wrapper(*args,**kwargs):
  return wrapper
 return auth2

5. Lors de l'exécution. index, c'est-à-dire exécuter le wrapper, exécuter la fonction Code interne, filetype=="file", invite l'utilisateur à afficher le nom d'utilisateur et le mot de passe et détermine si l'entrée est correcte. Si elle est correcte, la fonction func() est exécutée. , ce qui équivaut à exécuter l'index original et à imprimer

def wrapper(*args,**kwargs):
return wrapper

Exécutez le test de résultat

if filetype == "file":
    username=input("Please input your username:")
    passwd=input("Please input your password：")
    if passwd == '123456' and username == 'Frank':
     print("Login successful")
     func()

Please input your username:Frank
Please input your password：123456
Login successful
Welcome to China

装饰器也是可以被叠加的：

import time
#
def timmer(func):
 def wrapper():
  """计时功能"""
  time_start=time.time()
  func()
  time_end=time.time()
  print("Run time is %f "%(time_end-time_start))
  # print("---",wrapper)
 return wrapper
def auth(filetype):
 def auth2(func):
  def wrapper(*args,**kwargs):
   if filetype == "file":
    username=input("Please input your username:")
    passwd=input("Please input your password：")
    if passwd == '123456' and username == 'Frank':
     print("Login successful")
     func()
    else:
     print("login error!")
   if filetype == 'SQL':
    print("No SQL")
  return wrapper
 return auth2
@timmer
@auth(filetype='file') #先先返回一个auth2 ==》@auth2 ==》 index=auth2() ==》 index=wrapper
def index():
 print("Welcome to China")
index()

#测试结果
Please input your username:Frank
Please input your password：123456
Login successful
Welcome to China
Run time is 7.966267

注释优化

import time
def timmer(func):
 def wrapper():
  """计算程序运行时间"""
  start_time=time.time()
  func()
  end_time=time.time()
  print("Run time is %s:"%(end_time-start_time))
 return wrapper
@timmer
def my_index():
 """打印欢迎"""
 time.sleep(1)
 print("Welcome to China!")
my_index()
print(my_index.__doc__)

#运行结果
Welcome to China!
Run time is 1.0005640983581543:
计算程序运行时间

当我们使用了装饰器的时候，虽然没有修改代码本身，但是在运行的时候，比如上面这个例子，运行my_index其实在运行wrapper了，如果我们打印my_index的注释信息，会打印wrapper()的注释信息，那么该怎么优化？

可以在模块functools中导入wraps，具体见以下：

import time
from functools import wraps
def timmer(func):
 @wraps(func)
 def wrapper():
  """计算程序运行时间"""
  start_time=time.time()
  func()
  end_time=time.time()
  print("Run time is %s:"%(end_time-start_time))
 return wrapper
@timmer
def my_index():
 """打印欢迎"""
 time.sleep(1)
 print("Welcome to China!")
my_index()
print(my_index.__doc__)
#运行结果
Welcome to China!
Run time is 1.0003223419189453:
打印欢迎

这样，在表面看来，原函数没有发生任何变化。

为什么要用迭代器

从字面意思，迭代就是重复反馈过程的活动，其目的通常是为了比较所需目标或结果，在python中可以用迭代器来实现，先来描述一下迭代器的优缺点，如果看不懂可以先略过，等看完本博客再回头看，相信你会理解其中的意思：

优点：

迭代器在取值的时候是不依赖于索引的，这样就可以遍历那些没有索引的对象，比如字典和文件

迭代器与列表相比，迭代器是惰性计算，更节省内存

缺点：

无法获取迭代器的长度，没有列表灵活

只能往后取值，不能倒着取值

什么是迭代器

那么在python什么才算是迭代器呢？

只要对象有__iter__()，那么它就是可迭代的，迭代器可以使用函数next()来取值

下面我们来看一个简单的迭代器：

my_list=[1,2,3]
li=iter(my_list)  #li=my_list.__iter__()
print(li)
print(next(li))
print(next(li))
print(next(li))
#运行结果
<list_iterator object at 0x000002591652C470>
2

可以看到，使用内置函数iter可以将列表转换成一个列表迭代器，使用next()获取值，一次值取一个值，当值取完了，再使用一次next()的时候，会报异常StopIteration，可以通过异常处理的方式来避免，try-except-else就是一个最常用的异常处理结构：

my_list=[1,2,3]
li=iter(my_list)
while True:
 try:
  print(next(li))
 except StopIteration:
  print("Over")
  break
 else:
  print("get!")
#运行结果
get!
get!
get!
Over

查看可迭代对象和迭代器对象

使用Iterable模块可以判断对象是否是可迭代的：

from collections import Iterable
s="hello" #定义字符串
l=[1,2,3,4] #定义列表
t=(1,2,3) #定义元组
d={'a':1} #定义字典
set1={1,2,3,4} #定义集合
f=open("a.txt") #定义文本
# 查看是否都是可迭代的
print(isinstance(s,Iterable))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))
#运行结果
True
True
True
True
True
True

通过判断，可以确定我们所知道的常用的数据类型都是可以被迭代的。

使用Iterator模块可以判断对象是否是迭代器：

from collections import Iterable,Iterator
s="hello"
l=[1,2,3,4]
t=(1,2,3)
d={'a':1}
set1={1,2,3,4}
f=open("a.txt")
# 查看是否都是可迭代的
print(isinstance(s,Iterator))
print(isinstance(l,Iterator))
print(isinstance(t,Iterator))
print(isinstance(d,Iterator))
print(isinstance(set1,Iterator))
print(isinstance(f,Iterator))
#运行结果
False
False
False
False
False
True

可知只有文件是迭代器，所以可以直接使用next()，而不需要转换成迭代器。

什么是生成器

生产器就是一个是带有yield的函数

下面来看一个简单的生成器

def my_yield():
 print('first')
 yield 1
g=my_yield()
print(g)
#运行结果
<generator object my_yield at 0x0000024366D7E258>

生成器也是一个迭代器

from collections import Iterator
def my_yield():
 print('first')
 yield 1
g=my_yield()
print(isinstance(g,Iterator))
#运行结果
True

那就可以用next()来取值了

print(next(g))
#运行结果
first
1

生成器的执行过程

我们来看以下下面这个例子，了解生产的执行流程

def my_yield():
 print('first')
 yield 1
 print('second')
 yield 2
 print('Third')
 yield 3
g=my_yield()
next(g)
next(g)
next(g)
#运行结果
first
second
Third

1.定义生成器my_yield，并将其赋值给了g

def my_yield():
g=my_yield()

2.开始第一次执行next()，开始执行生产器函数 ，打印第一语句，遇到yileld的时候暂停，并返回一个1，如果你想打印返回值的话，这里会显示1

 print('first')
 yield 1

3.再执行2次，打印字符串（每执行一次都会暂停一下）

 print('second')
 yield 2
 print('Third')
 yield 3

4.如果再加一次next()就会报出StopIteration异常了

生成器在每次暂停的时候，函数的状态将被保存下来，来看下面的例子：

def foo():
 i=0
 while True:
  yield i
  i+=1
g=foo()
for num in g:
 if num < 10:
  print(num)
 else:
  break
#运行结果

for循环中隐含next()，每next一次，暂停一次，if语句判断一次，然后执行下一次next，可以看到我们的while循环并没有无限循环下去，而是状态被保存下来了。

协程函数

我们来看下面这个生成器和执行结果

def eater(name):
 print('%s start to eat food'%name)
 while True:
  food=yield
  print('%s get %s ,to start eat'%(name,food))
 print('done')
e=eater('Frank')
next(e)
e.send('egg') #给yield送一个值，并继续执行代码
e.send('tomato')
#运行结果
Frank start to eat food
Frank get egg ,to start eat
Frank get tomato ,to start eat

send可直接以向yield传值，含有yield表达式的函数我们也称为协程函数，

这运行程序的时候，不可以直接send，必须先使用next()初始化生成器。

如果存在多个这样的函数，那么我们每次执行的时候都要去next()一下，为了防止忘记这一步操作，可以使用装饰器初始化：

def init(func):
 def wrapper(*args):
  res = func(*args)
  next(res)  # 在这里执行next
  return res
 return wrapper
@init
def eater(name):
 print('%s start to eat food'%name)
 while True:
  food=yield
  print('%s get %s ,to start eat'%(name,food))
 print('done')
e=eater('Frank')
e.send('egg') 
e.send('tomato')

所以在程序中有更多的生成器需要初始化的时候，直接调用这个装饰器就可以了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!