Générateur de python

Dans ce sujet, nous apprendrons le générateur Python.

Définition: Un générateur est comme une fonction normale qui génère une gamme de valeurs en utilisant le rendement mot-clé. Il renvoie un objet à la fois. Il utilise en interne un itérateur. Pour accéder à l'élément suivant suivant() La fonction est utilisée, ou nous pouvons l'utiliser pour une boucle. Si nous essayons d'accéder à la valeur en dehors de la plage, cela soulève un Étape erreur.

Nous verrons un exemple pour mieux comprendre

Ex: Fonction du générateur pour la plage de valeurs

DEF Range_fun (n):
x = 0
tandis que x < n:
rendement x
x + = 1
y = range_fun (3)
#Pall Utilisation pour Loop
print ('générer des valeurs en utilisant la méthode suivante ()))
pour i dans range_fun (3):
Imprimer (i)
#Pall Générateur en utilisant la méthode suivante
Print («Générer des valeurs en utilisant la méthode de boucle»)
imprimer (suivant (y))
imprimer (suivant (y))
imprimer (suivant (y))
imprimer (Next (y)) # l'exception d'itération de l'arrêt sera soulevée

Ex: Fonction du générateur pour la série Fibonacci

def fib_fun (n):
x, y = 0, 1
tandis que x < n:
rendement x
x, y = y, x + y
z = fib_fun (6) #Generator Object
print ('générer des valeurs en utilisant la méthode suivante ()))
imprimer (suivant (z))
imprimer (suivant (z))
imprimer (suivant (z))
imprimer (suivant (z))
imprimer (suivant (z))
imprimer (suivant (z))
Print («Générer des valeurs en utilisant la méthode de boucle»)
pour i dans fib_fun (6):
Imprimer (i)

Ex: Fonction du générateur pour créer une plage de valeurs donnée des valeurs de démarrage et fin.

def my_range (début, fin):
courant = démarrer
tandis que le courant < end:
courant de rendement
courant + = 1
print ('générer des valeurs en utilisant la méthode suivante ()))
nums = my_range (1,5)
Imprimer (Suivant (NUMS))
Imprimer (Suivant (NUMS))
Imprimer (Suivant (NUMS))
Imprimer (Suivant (NUMS))
Print («Générer des valeurs en utilisant la méthode de boucle»)
pour num dans my_range (1,5):
imprimer (num)

Ex: Générateur pour multiplier chaque nombre (moins d'un nombre) par un nombre

def gen_mulby_num (max, num):
n = 0
tandis que n < max:
rendement n * num
n + = 1
pour i dans gen_mulby_num (5,3):
Imprimer (i)

Ex: Générateur pour trouver le cube pour la gamme de valeurs

def gen_mulby_num (max, num):
n = 0
tandis que n < max:
rendement n * num
n + = 1
pour i dans gen_mulby_num (5,3):
Imprimer (i)

Ex: plusieurs générateurs: trouvez le carré de nombres pair générés à partir d'un nombre

Générateur 1: générer des valeurs uniformes à partir d'un nombre donné

Générateur 2: générer des nombres carrés à partir des valeurs du générateur1

def gen_even (m):
n = 0
tandis que n < m:
Si n% 2 == 0:
rendement n
n + = 2
def gen_square (nums):
pour num en num:
rendement 2 * num
pour n dans gen_square (gen_even (15)):
Imprimer (n)

Ex: Plusieurs générateurs: créez une série Fibnacci et ajoutez la valeur 10 chaque numéro.

Generator1: génère des séries Fibonacci à partir d'un numéro donné

Générateur 2: Ajoutez chaque numéro par 10 de Generator1

def gen_fib (n):
x, y = 0, 1
tandis que x < n:
rendement x
x, y = y, x + y
DEF GEN_ADD_10 (NUMS):
pour num en num:
rendement 10 + num
pour n dans gen_add_10 (gen_fib (5)):
Imprimer (n)

Compréhension du générateur:

Les compréhensions des générateurs sont similaires aux compréhensions de la liste où la liste utilise des crochets; Cela utilise des parenthèses normales.

Ex:

nums = (i pour i dans la gamme (10))
imprimer (type (nums))
Imprimer (liste (NUMS))

Différence entre le générateur et la fonction normale:

1. Un générateur fournit des valeurs en utilisant rendement mot-clé où la fonction normale utilise le retour mot-clé
2. Le générateur part de l'endroit où il s'est arrêté lorsqu'il s'appelle la prochaine fois. La fonction normale exécute toutes les instructions à chaque fois.
3. Le générateur enregistre la mémoire car elle renvoie une valeur à la fois. Nous pouvons donc l'utiliser pour générer des valeurs infinies.

Conclusion:

Le générateur est très utile lorsque nous gérons des données énormes / grandes. À un moment donné, il ne contient qu'un seul morceau de données plutôt que des données entières. Le concept des générateurs est considéré comme un concept avancé dans Python.