Formateur : Bonjour et bienvenue.
Dans cette vidéo, nous parlons
des classes de générateurs et des itérateurs.
Ici, je vais vous montrer une classe qui implémente le générateur
de 100 nombres que nous avons fait dans la dernière vidéo.
Je vais donc l'appeler FirstHundredGenerator.
Comme ça, et ensuite nous allons définir une méthode init.
Ce qui va juste démarrer le nombre à zéro, et ensuite
nous allons définir un underscore suivant, underscore,
méthode suivante.
Lorsque vous définissez une méthode next dans une classe,
n'importe quel objet, vous pouvez appeler next de mon objet, comme suit.
Il s'agit donc à nouveau d'une méthode dunder
qui vous permet d'appeler la méthode suivante.
Il indique également à Python quelque chose d'assez important.
Nous allons nous pencher sur cette question dans un instant.
Ainsi, si nous voulons générer 100 nombres, tout ce que nous avons
à faire, c'est d'obtenir le self. le renvoie et l'incrémente
d'une unité.
Donc, si le soi. est inférieur à 100, nous n'allons
pas utiliser le mot clé yield ici, d'ailleurs, parce
que vous n'en avez pas besoin dans un générateur de classe.
Désolé, dans l'une de ces choses. (rires) Je vais juste
éviter de dire quoi que ce soit qui pourrait
être mal interprété.
Juste pour ne pas vous embrouiller.
Si le nombre est inférieur à 100, nous le
plaçons dans une variable,
nous incrémentons le nombre d'une unité et nous renvoyons
le nombre actuel, qui était la valeur
précédente, c'est-à-dire
zéro.
Nous nous incrémentons nous-mêmes. par un, nous renvoyons zéro.
D'accord.
Maintenant, ce qui est important
pour la classe, c'est que nous devons,
si nous voulons arrêter
de renvoyer des nombres, comme par exemple, nous n'utilisons pas
de boucle ici pour nous arrêter lorsque nous atteignons 100.
Ainsi, lorsque nous atteignons 100, nous devons déclencher
une erreur spéciale appelée Stop Iteration.
L'erreur Stop Iteration indique à Python
que nous avons atteint la fin de ce générateur.
Je dis générateur et je tressaille légèrement, hum ici.
En effet, il s'agit essentiellement d'un générateur
: on part de zéro,
on décide si l'on veut renvoyer un nouveau nombre, on obtient
ce nombre, on le renvoie et le programme
s'arrête.
Mais votre objet demeure, et il se souvient de lui-même. nombre.
Donc, si nous avons mon générateur, et c'est notre premier
générateur de cent.
Ma gén. est bien sûr
nul au départ.
C'est vrai ?
Nous allons vous le montrer.
My gen le chiffre zéro au début.
Si vous faites ma gén. comme suit, puis
j'imprime
mon gén. Encore une fois, vous avez
droit à un numéro.
C'est logique, non ?
Car la méthode suivante consiste à vérifier si le nombre est
inférieur à 100, puis à l'incrémenter
d'une unité.
Tout cela est donc logique.
Pour qu'il se comporte comme un générateur,
il suffit de dire next of my gen, comme suit.
Nous pouvons ensuite relancer l'opération et obtenir le même résultat.
Bien sûr, next of my gen renvoie
en fait le nombre qu'il avait avant d'être incrémenté.
Ainsi, au lieu d'imprimer ma gén. ici, nous pouvons simplement
imprimer le prochain de ma gen, et ici nous pouvons également
imprimer le prochain de ma gen, et nous obtiendrons
la même sortie, zéro et un.
La première fois que nous appelons next, nous obtenons la valeur actuelle,
qui est zéro, mais nous avons incrémenté self. numéro par un.
La prochaine fois que nous appellerons
next, nous incrémenterons à nouveau ce nombre de un, mais
nous renverrons la valeur précédente, c'est-à-dire un.
Il se comporte donc exactement comme un générateur,
et il s'agit bien d'un générateur.
Il ne s'agit pas de stocker toutes les valeurs jusqu'à 100 dans une liste.
Il vous les donne un par un.
Il les génère lorsque vous appelez la fonction suivante.
Désolé, la méthode suivante.
D'ailleurs, dunder next est une nouveauté de Python 3.
Ainsi, si vous utilisez Python
2, vous devrez définir next sans le trait de soulignement.
C'est seulement pour Python 2.
Si vous utilisez Python 3, utilisez dunder ensuite.
Tous les objets
qui ont cette méthode next sont appelés des itérateurs.
Tous les générateurs, comme celui-ci, sont des itérateurs,
mais pas l'inverse.
Il est donc possible d'avoir des itérateurs qui ne génèrent pas de nombres.
Par exemple, si vous modifiez votre générateur
de premiers nombres pour qu'il renvoie une partie d'une
liste comme, first hundred iterator, not generator,
vous pouvez avoir une méthode init ici, qui
dit self. Les chiffres sont les suivants
: un, deux, trois, quatre, cinq.
De toute évidence, ce n'est pas le premier
cent, c'est le premier cinq itérateur, le self I est zéro.
C'est donc l'index que vous allez commencer à renvoyer.
Zéro, et les chiffres que nous renvoyons
vont de un à cinq.
Par ailleurs, la méthode suivante consistera à dire si I est inférieur
à len of self. nombres, retour
self. chiffres I.
C'est vrai ?
Dans le cas contraire, l'itération s'arrête.
Désolé, cela ne se voit pas très bien, mais
c'est ainsi.
Tout ce que nous faisons ici, c'est que nous ne générons rien.
Nous disons que si I est inférieur
à, d'ailleurs nous devons, bien sûr nous devons le faire,
I plus égal à un, et nous
retournons le courant.
Nous devons incrémenter un, et nous
devons incrémenter I d'un bien sûr.
Encore une fois, nous ne produisons pas de nouveaux chiffres.
Nous suivons le I, l'indice auquel nous sommes actuellement, vous
devez le faire d'une manière ou d'une autre afin de, cela devrait
être le self. D'ailleurs, j'en profite pour dire que je ne suis pas le seul.
Vous pouvez voir que je n'ai pas vraiment préparé cet exemple, mais je voulais
juste vous montrer rapidement que
tous les générateurs, tous les itérateurs, n'ont pas besoin
d'être des générateurs.
Dans ce cas, vous ne générez pas les nombres,
vous les renvoyez à partir d'une liste.
Voici donc un petit exemple.
Vous trouverez cela dans l'exemple de code de la section,
si je me souviens de l'ajouter.
Donc, ici, ce que nous faisons lorsque nous définissons la méthode next, c'est
que nous définissons un
itérateur, quelque chose que vous pouvez parcourir
un par un, en appelant la fonction next.
Il ne doit pas nécessairement générer tous ses nombres, mais il peut le faire,
mais il peut aussi les renvoyer à partir d'une liste, d'un fichier ou de
n'importe quel autre endroit.
En Python, c'est donc important.
Les itérateurs sont des objets qui possèdent
une méthode next dunder.
Vous pouvez les appeler ensuite.
Nous avons nous-mêmes un itérateur,
mais nous ne pouvons
pas faire pour I in my gen, in my gen.
Vous ne pouvez pas faire cela.
Permettez-moi de vous le dire tout de suite.
Si nous l'exécutons, nous obtenons une erreur qui dit que
l'objet générateur 100 n'est pas itérable,
mais je viens de dire que c'est un itérateur, et c'est bien le cas.
Un itérateur signifie que vous pouvez
appeler la fonction next sur lui
et qu'il vous donnera la valeur suivante.
Mais un itérateur et un itérable sont deux choses différentes.
Vous pouvez itérer sur un itérable, et l'itérateur
est utilisé pour obtenir la valeur suivante à partir d'une séquence
ou de valeurs générées.
Il s'agit donc d'un itérateur
et non d'un itérable.
Dans la prochaine vidéo, nous allons
apprendre à créer un itérable,
afin de pouvoir faire des boucles
dessus, ou bien faire des choses comme la somme de mes gènes,
ou bien tout ce que vous voulez faire.
Liste de mes gènes.
Ces choses ont besoin d'un itérable et non d'un itérateur.
C'est ce que nous allons faire dans la vidéo suivante.
Je vous y verrai.