Rendement en Python Tutoriel :Exemple de générateur et rendement vs retour

Qu'est-ce que le rendement Python ?

Le mot clé yield en python fonctionne comme un retour avec le seul

la différence est qu'au lieu de renvoyer une valeur, il renvoie un objet générateur à l'appelant.

Lorsqu'une fonction est appelée et que le thread d'exécution trouve un mot clé yield dans la fonction, l'exécution de la fonction s'arrête à cette ligne elle-même et renvoie un objet générateur à l'appelant.

Dans ce tutoriel Python, vous apprendrez :

Qu'est-ce que le rendement Python ?
Syntaxe
Que sont les générateurs en Python ?
Différence entre la fonction normale et la fonction générateur.
Comment lire les valeurs du générateur ?
Les générateurs sont à usage unique
Exemple :générateurs et rendement pour la série de Fibonacci
Exemple :appel d'une fonction avec Yield
Quand utiliser Yield au lieu de Return en Python
Rendement vs rendement

Syntaxe

yield expression

Description

Python yield renvoie un objet générateur. Les générateurs sont des fonctions spéciales qui doivent être itérées pour obtenir les valeurs.

Le mot clé yield convertit l'expression donnée en une fonction génératrice qui renvoie un objet générateur. Pour obtenir les valeurs de l'objet, il doit être itéré pour lire les valeurs données au rendement.

Exemple :Méthode de rendement

Voici un exemple simple de rendement. La fonction testyield() a un mot-clé yield avec la chaîne "Bienvenue dans les didacticiels Guru99 Python". Lorsque la fonction est appelée, la sortie est imprimée et donne un objet générateur au lieu de la valeur réelle.

def testyield():
  yield "Welcome to Guru99 Python Tutorials"
output = testyield()
print(output)

Sortie :

<generator object testyield at 0x00000028265EB9A8>

La sortie donnée est un objet générateur, qui a la valeur que nous avons donnée à yield.

Mais nous ne recevons pas le message que nous devons donner pour produire en sortie !

Pour imprimer le message donné à yield il faudra itérer l'objet générateur comme le montre l'exemple ci-dessous :

def testyield():
  yield "Welcome to Guru99 Python Tutorials"

output = testyield()
for i in output:
    print(i)

Sortie

Welcome to Guru99 Python Tutorials

Que sont les générateurs en Python ?

Les générateurs sont des fonctions qui renvoient un objet générateur itérable. Les valeurs de l'objet générateur sont récupérées une par une au lieu de la liste complète ensemble et donc pour obtenir les valeurs réelles, vous pouvez utiliser une boucle for, en utilisant la méthode next() ou list().

Utilisation de la fonction Générateur

Vous pouvez créer des générateurs en utilisant la fonction du générateur et en utilisant l'expression du générateur.

Une fonction génératrice est comme une fonction normale, au lieu d'avoir une valeur de retour, elle aura un mot-clé yield.

Pour créer une fonction génératrice, vous devrez ajouter un mot-clé yield. Les exemples suivants montrent comment créer une fonction de générateur.

def generator():
    yield "H"
    yield "E"
    yield "L"
    yield "L"
    yield "O"

test = generator()
for i in test:
    print(i)

Sortie :

H
E
L
L
O

Différence entre la fonction normale et la fonction générateur.

Comprenons en quoi une fonction génératrice est différente d'une fonction normale.

Il y a 2 fonctions normal_test() et generator_test().

Les deux fonctions sont supposées renvoyer la chaîne "Hello World". Le normal_test() utilise return et generator_test() utilise yield.

# Normal function
def normal_test():
    return "Hello World"
	
#Generator function
def generator_test():
	yield "Hello World"
print(normal_test()) #call to normal function
print(generator_test()) # call to generator function

Sortie :

Hello World
<generator object generator_test at 0x00000012F2F5BA20>

La sortie montre que lorsque vous appelez la fonction normale normal_test(), elle renvoie la chaîne Hello World. Pour une fonction génératrice avec le mot clé yield, elle renvoie et non la chaîne.

C'est la principale différence entre une fonction génératrice et une fonction normale. Maintenant, pour obtenir la valeur de l'objet générateur, nous devons soit utiliser l'objet à l'intérieur de la boucle for, soit utiliser la méthode next() ou utiliser list().

print(next(generator_test()))  # will output Hello World

Une autre différence à ajouter à la fonction normale par rapport à la fonction génératrice est que lorsque vous appelez une fonction normale, l'exécution démarre et s'arrête lorsqu'elle arrive à revenir et la valeur est renvoyée à l'appelant. Ainsi, lorsque l'exécution démarre, vous ne pouvez pas arrêter la fonction normale entre les deux et elle ne s'arrêtera que lorsqu'elle rencontrera le mot-clé de retour.

Mais dans le cas d'une fonction de générateur, une fois que l'exécution démarre lorsqu'elle obtient le premier rendement, elle arrête l'exécution et renvoie l'objet générateur. Vous pouvez utiliser l'objet générateur pour obtenir les valeurs et également faire une pause et reprendre selon vos besoins.

Comment lire les valeurs du générateur ?

Vous pouvez lire les valeurs d'un objet générateur en utilisant une liste(), une boucle for et en utilisant la méthode next().

Avec :liste()

Une liste est un objet itérable dont les éléments sont entre parenthèses. L'utilisation de list() sur un objet générateur donnera toutes les valeurs que contient le générateur.

def even_numbers(n):
    for x in range(n):
       if (x%2==0): 
           yield x       
num = even_numbers(10)
print(list(num))

Sortie :

[0, 2, 4, 6, 8]

Utilisation :for-in

Dans l'exemple, il y a une fonction définie even_numbers() qui vous donnera tous les nombres pairs pour les n définis. L'appel à la fonction even_numbers() renverra un objet générateur, qui est utilisé à l'intérieur de la boucle for.

Exemple :

def even_numbers(n):
    for x in range(n):
       if (x%2==0): 
           yield x       
num = even_numbers(10)
for i in num:
    print(i)

Sortie :

Utiliser suivant()

La méthode next() vous donnera l'élément suivant dans la liste, le tableau ou l'objet. Une fois la liste vide, et si next() est appelée, elle renverra une erreur avec le signal stopIteration. Cette erreur, de next() indique qu'il n'y a plus d'éléments dans la liste.

def even_numbers(n):
    for x in range(n):
       if (x%2==0): 
           yield x       
num = even_numbers(10)
print(next(num))
print(next(num))
print(next(num))
print(next(num))
print(next(num))
print(next(num))

Sortie :

0
2
4
6
8
Traceback (most recent call last):
  File "main.py", line 11, in <module>
    print(next(num))
StopIteration

Les générateurs sont à usage unique

En cas de générateurs, ils ne sont disponibles qu'une seule fois. Si vous essayez de les utiliser à nouveau, il sera vide.

Par exemple :

def even_numbers(n):
    for x in range(n):
       if (x%2==0): 
           yield x       
num = even_numbers(10)
for i in num:
    print(i)

print("\n")
print("Calling the generator again: ", list(num))

Sortie :

0
2
4
6
8
Calling the generator again:  []

Si vous souhaitez que la sortie soit réutilisée, vous devrez refaire l'appel pour fonctionner à nouveau.

Exemple :générateurs et rendement pour la série de Fibonacci

L'exemple suivant montre comment utiliser les générateurs et le rendement en Python. L'exemple générera la série de Fibonacci.

def getFibonnaciSeries(num):
    c1, c2 = 0, 1
    count = 0
    while count < num:
        yield c1
        c3 = c1 + c2
        c1 = c2
        c2 = c3
        count += 1
fin = getFibonnaciSeries(7)
print(fin)
for i in fin:
    print(i)

Sortie :

<generator object getFibonnaciSeries at 0x0000007F39C8BA20>
0
1
1
2
3
5
8

Exemple :appel d'une fonction avec Yield

Dans cet exemple, nous verrons comment appeler une fonction avec rendement.

L'exemple ci-dessous a une fonction appelée test() qui renvoie le carré du nombre donné. Il existe une autre fonction appelée getSquare() qui utilise test() avec le mot clé yield. La sortie donne la valeur au carré pour une plage de nombres donnée.

def test(n):
    return n*n

def getSquare(n):
    for i in range(n):
        yield test(i)

sq = getSquare(10)
for i in sq:
    print(i)

Sortie :

Quand utiliser Yield au lieu de Return en Python

Rendement Python3 Le mot-clé renvoie un générateur à l'appelant et l'exécution du code ne démarre que lorsque le générateur est itéré.

Un retour dans une fonction est la fin de l'exécution de la fonction, et une seule valeur est renvoyée à l'appelant.

Voici la situation dans laquelle vous devez utiliser Yield au lieu de Return

Utilisez yield au lieu de return lorsque la taille des données est importante
Le rendement est le meilleur choix lorsque vous avez besoin que votre exécution soit plus rapide sur de grands ensembles de données
Utilisez yield lorsque vous souhaitez renvoyer un grand ensemble de valeurs à la fonction appelante
Le rendement est un moyen efficace de produire des données volumineuses ou infinies.

Rendement vs rendement

Voici les différences entre le rendement et le rendement

Rendement	Retour
Yield renvoie un objet générateur à l'appelant, et l'exécution du code ne démarre que lorsque le générateur est itéré.	Un retour dans une fonction est la fin de l'exécution de la fonction, et une seule valeur est renvoyée à l'appelant.
Lorsque la fonction est appelée et qu'elle rencontre le mot clé yield, l'exécution de la fonction s'arrête. Il renvoie l'objet générateur à l'appelant. L'exécution de la fonction ne démarrera que lorsque l'objet générateur sera exécuté.	Lorsque la fonction est appelée, l'exécution démarre et la valeur est renvoyée à l'appelant s'il y a un mot clé de retour. Le retour à l'intérieur de la fonction marque la fin de l'exécution de la fonction.
expression de rendement	expression de retour
Aucune mémoire n'est utilisée lorsque le mot clé yield est utilisé.	La mémoire est allouée pour la valeur renvoyée.
Très utile si vous devez gérer une taille de données énorme car la mémoire n'est pas utilisée.	Pratique pour les très petites tailles de données.
Les performances sont meilleures si le mot-clé yield est utilisé pour les données de grande taille.	Une grande quantité de mémoire est utilisée si la taille des données est énorme, ce qui entravera les performances.
Le temps d'exécution est plus rapide en cas de rendement pour une grande taille de données.	Le temps d'exécution utilisé est supérieur car il y a un traitement supplémentaire effectué au cas où si la taille de vos données est énorme, cela fonctionnera bien pour une petite taille de données.

Résumé :

Le mot clé yield en python fonctionne comme un retour avec la seule différence qu'au lieu de renvoyer une valeur, il renvoie une fonction génératrice à l'appelant.
Un générateur est un type spécial d'itérateur qui, une fois utilisé, ne sera plus disponible. Les valeurs ne sont pas stockées en mémoire et ne sont disponibles que lorsqu'elles sont appelées.
Les valeurs du générateur peuvent être lues en utilisant les méthodes for-in, list() et next().
La principale différence entre yield et return est que yield renvoie une fonction génératrice à l'appelant et return donne une valeur unique à l'appelant.
Le rendement ne stocke aucune des valeurs en mémoire, et l'avantage est qu'il est utile lorsque la taille des données est importante, car aucune des valeurs n'est stockée en mémoire.
Les performances sont meilleures si le mot-clé yield est utilisé par rapport au retour pour une grande taille de données.

Python Timeit() avec des exemples File d'attente Python :exemple FIFO, LIFO

Python