Rendement dans le didacticiel Python : Generator & Exemple de rendement par rapport au rendement

Quel est le rendement de Python ?

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

la différence est qu'au lieu de renvoyer une valeur, il renvoie une generator s'opposer à l'appelant.

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

Syntaxe

yield expression

Description

Le rendement Python renvoie un generator objet. GeneratorLes s sont des fonctions spéciales qui doivent être itérées pour obtenir les valeurs.

Le mot clé rendement convertit l'expression donnée en un generator fonction qui restitue un generator objet. Pour obtenir les valeurs de l'objet, il faut le parcourir 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é rendement avec la chaîne « Bienvenue chez Guru99 Tutoriels Python« . Lorsque la fonction est appelée, la sortie est imprimée et donne un generator objet 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>

Le résultat donné est un generator objet, qui a la valeur que nous avons donnée à céder.

Mais nous ne recevons pas le message que nous devons transmettre pour produire des résultats !

Pour imprimer le message donné à rendement, il faudra itérer le generator objet comme indiqué dans 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

Quels sont Generatorest en Python ?

Generators sont des fonctions qui renvoient un itérable generator objet. Les valeurs du generator Les objets sont récupérés un par un 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().

En utilisant Generator fonction

Vous pouvez créer generators utilise generator fonction et utilisation generator expression.

A generator La fonction est comme une fonction normale, au lieu d'avoir une valeur de retour, elle aura un mot-clé rendement.

Créer un generator fonction, vous devrez ajouter un mot-clé de rendement. Le suiviwing des exemples montrent comment créer un generator la fonction.

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 v/s Generator la fonction.

Comprenons comment un generator la fonction est différente d’une fonction normale.

Il existe 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 le rendement.

# 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>

Le résultat montre que lorsque vous appelez la fonction normale normal_test(), elle renvoie la chaîne Hello World. Pour un generator fonction avec le mot-clé rendement qu'elle renvoiegenerator objet generator_test à 0x00000012F2F5BA20> et non la chaîne.

C'est la principale différence entre un generator fonction et une fonction normale. Maintenant, pour obtenir la valeur du generator objet, 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 différence supplémentaire à ajouter à la fonction normale v/s generator est que lorsque vous appelez une fonction normale, l'exécution démarre et s'arrête lorsqu'elle arrive à retourner 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é return.

Mais en cas de generator fonction une fois que l'exécution commence, lorsqu'elle obtient le premier rendement, elle arrête l'exécution et restitue le generator objet. Vous pouvez utiliser le generator objet pour obtenir les valeurs et également, faites une pause et reprenez selon vos besoins.

Comment lire les valeurs du generator?

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

En utilisant : list()

Une liste est un objet itérable qui contient ses éléments brackets.Utilisation de list() sur un generator l'objet donnera toutes les valeurs generator tient.

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 : pour-in

Dans l'exemple, il y a une fonction définie even_numbers() qui vous donnera tous les nombres pairs pour le n défini. L'appel à la fonction even_numbers() renverra un generator objet, qui est utilisé dans la boucle for.

Mise en situation :

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 :

0
2
4
6
8

Utiliser next()

La méthode next() vous donnera l’élément suivant de la liste, du tableau ou de l’objet. Une fois la liste vide, et si next() est appelé, elle renverra une erreur avec le signal stopIteration. Cette erreur, provenant 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

GeneratorLes s sont à usage unique

En cas de generators ils ne peuvent être utilisés 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 à nouveau utilisée, vous devrez effectuer l'appel pour fonctionner à nouveau.

Mise en situation : Generators et rendement pour la série de Fibonacci

Le following un exemple montre comment utiliser generators et 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é rendement. La sortie donne la valeur carrée 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 :

0
1
4
9
16
25
36
49
64
81

Quand utiliser le rendement au lieu du retour en Python

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

A retourner dans une fonction marque la fin de l’exécution de la fonction et une seule valeur est rendue à l’appelant.

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

  • Utilisez le rendement au lieu du retour lorsque la taille des données est importante
  • Le rendement est le meilleur choix lorsque vous avez besoin d'une exécution plus rapide sur de grands ensembles de données
  • Utilisez rendement 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
Le rendement renvoie un generator objet à l'appelant, et l'exécution du code ne démarre que lorsque le generator est itéré. Un retour dans une fonction marque la fin de l'exécution de la fonction, et une seule valeur est restituée à l'appelant.
Lorsque la fonction est appelée et qu'elle rencontre le mot-clé rendement, l'exécution de la fonction s'arrête. Il revient generator objecter à l'appelant. L'exécution de la fonction ne démarrera que lorsque le generator l'objet est exécuté. Lorsque la fonction est appelée, l'exécution démarre et la valeur est restituée à l'appelant s'il existe un mot-clé return. 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é rendement 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 données de très petite taille.
Les performances sont meilleures si le mot-clé rendement est utilisé pour des données de grande taille. Une grande quantité de mémoire est utilisée si la taille des données est énorme, ce qui nuira aux performances.
Le temps d'exécution est plus rapide en cas de rendement pour des données de grande taille. Le temps d'exécution utilisé est plus long car un traitement supplémentaire est effectué au cas où si la taille de vos données est énorme, cela fonctionnera bien pour des données de petite taille.

Résumé

  • Le mot clé rendement en python fonctionne comme un retour avec la seule différence qu'au lieu de renvoyer une valeur, il renvoie un generator fonction à l’appelant.
  • A generator 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 lors de leur appel.
  • Les valeurs du generator peut être lu en utilisant les méthodes for-in, list() et next().
  • La principale différence entre le rendement et le rendement est que le rendement renvoie un generator fonction à l’appelant et return donne une valeur unique à l’appelant.
  • Yield 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é rendement est utilisé en comparaison pour renvoyer des données de grande taille.