Instructeur: Hallo, en welkom terug.
In deze video
hebben we het over generatorklassen en iterators.
Hier ga ik je een klas laten zien
die de 100-nummergenerator implementeert die we in de laatste video hebben gedaan.
Dus ik ga het FirstHundredGenerator noemen.
Zoals zo, en dan gaan we een init-methode definiëren.
Waardoor het getal gewoon als nul begint,
en dan gaan we een volgende
underscore, underscore, volgende methode definiëren.
Wanneer u een volgende methode in een klasse definieert,
kunt u elk object dat u vervolgens van mijn object kunt noemen, zoals zo.
Dus dit is weer een dunder-methode waarmee
je er vervolgens een beroep op kunt doen.
Het vertelt Python ook iets heel belangrijks.
We gaan dat zo bekijken.
Dus als we 100 getallen willen genereren, hoeven we
alleen maar onszelf te krijgen. getal, retourneer het
en verhoog het met één.
Dus als het zelf. getal kleiner is dan
100, gebruiken we het yield-sleutelwoord hier
trouwens niet, omdat dat niet nodig is in een klassengenerator.
Sorry, in een van deze dingen. (lacht) Ik
ga gewoon niets zeggen dat mogelijk
verkeerd kan worden opgevat.
Zodat ik je niet in verwarring breng.
Wat je moet doen is, als het getal
kleiner is dan 100, dan
plaatsen we dat in een variabele, dan verhogen we het getal met één,
en dan retourneren we het huidige getal, dat
de vorige waarde was, dus dat
is nul.
We verhogen onszelf. nummer bij één, we geven nul terug.
Oke.
Nu belangrijk voor de klas,
we moeten, als we willen
stoppen met
het retourneren van getallen, zoals zo, we gebruiken hier
geen lus om ons te stoppen wanneer we 100 bereiken.
Dus als we 100 bereiken, moeten we
een speciale fout maken die Stop Iteratie wordt genoemd.
Stop Iteratie-fout vertelt Python dat
we het einde van deze generator hebben bereikt.
Ik zeg generator en ik kromp een beetje ineen, um hier.
Omdat dit in wezen een generator is, begin je bij
nul, dan beslis
je of je een nieuw nummer wilt retourneren, je krijgt dat nummer,
en dan geef je het terug,
en dan stopt het programma.
Maar je object blijft, en het herinnert zich zichzelf. nummer.
Dus, als we mijn gen hebben, en dat is onze eerste
honderd generator daar.
Mijn gen. getal is
natuurlijk nul aan het begin.
Rechts?
Laten we je dat laten zien.
Mijn gen het getal nul aan het begin.
Als je mijn gen. volgende zoals zo, en
druk
dan mijn gen. nummer opnieuw, je krijgt
er een.
Dat is toch logisch?
Omdat de volgende methode hier is om te controleren of het getal
kleiner is dan 100, en
het vervolgens met één te verhogen.
Dus deze zijn allemaal logisch.
Om het zich als een generator te
laten gedragen, zeggen we gewoon next of my gen, like
so.
Dan kunnen we dit opnieuw uitvoeren, en hetzelfde komt eruit.
Natuurlijk, de volgende van mijn
gen geeft eigenlijk het aantal terug dat het had voordat we het verhoogden.
Dus in plaats van mijn gen. nummer hier, we kunnen
gewoon de volgende van mijn gen afdrukken, en hier kunnen we
ook de volgende van mijn gen afdrukken, en
we krijgen dezelfde uitvoer, nul en één.
De eerste keer dat we de volgende keer bellen, krijgen we de huidige
waarde, die nul is, maar we hebben onszelf verhoogd. nummer voor één.
De volgende keer dat we
de volgende aanroepen, verhogen we dat getal opnieuw met
één, maar we geven de vorige waarde terug, namelijk één.
Dit gedraagt zich nu precies als
een generator, en inderdaad, dit is een generator.
Het slaat niet alle waarden tot 100 op in een lijst.
Het geeft je ze een voor een.
Het genereert ze terwijl je de volgende functie aanroept.
Sorry, de volgende methode.
Trouwens, dunder next is nieuw in Python drie.
Dus als je
Python twee gebruikt, moet je volgende definiëren zonder het onderstrepingsteken.
Dat is alleen voor Python twee.
Als je Python drie gebruikt, gebruik dan dunder.
Oké,
alle objecten die deze dunder next-methode hebben,
worden iterators genoemd.
Alle generatoren, zoals deze, zijn iteratoren,
maar niet andersom.
U kunt dus iterators hebben die geen getallen genereren.
Als u bijvoorbeeld uw eerste nummergenerator aanpast
om een deel van een lijst terug te
geven, zoals, eerste honderd iterator, niet generator, kunt
u hier een init-methode hebben, die
zelf zegt. getallen is,
één, twee, drie, vier, vijf.
Het is duidelijk niet, niet de
eerste honderd, dat is de eerste vijf iterator, zelf I is nul.
Dus dat is de index die je gaat teruggeven.
Nul, en de cijfers die we teruggeven
zijn van één tot vijf.
Aan de andere kant gaat de volgende methode hier alleen maar zeggen of ik minder
dan alleen van mezelf ben. nummers, keer zelf
terug. nummers ik.
Rechts?
Anders stop iteratie verhogen.
Sorry, dat kun je niet zo goed zien, maar
daar gaan we.
Dus alles wat we hier doen is, we genereren niets.
We zeggen dat als I
kleiner is dan, trouwens, we moeten natuurlijk dit doen, I
plus gelijk aan
één, en stroom teruggeven.
We moeten er één verhogen,
en we moeten I natuurlijk met één verhogen.
Nogmaals, we genereren geen nieuwe cijfers.
We houden I bij, de index waar we ons momenteel in bevinden, je
moet dat op de een of andere manier doen om, dit
zou zelf moeten zijn. ik trouwens.
Je kunt zien dat ik dit voorbeeld niet echt heb voorbereid,
maar ik wilde je snel
laten zien dat niet alle generatoren, niet alle iterators,
generatoren hoeven te zijn.
In dit geval genereer je de getallen niet,
je retourneert ze uit een lijst.
Dus, even een snel voorbeeld daar.
Je hebt dit in de voorbeeldcode voor de sectie, als ik het
me kan herinneren om het toe te voegen.
Dus wat we hier doen als we de volgende methode definiëren, is dat
we een iterator
definiëren, iets dat je één voor één kunt doorlopen
door de volgende functie aan te roepen.
Het hoeft niet per se al zijn nummers te genereren, maar het kan,
maar nogmaals, het kan ze ook terugsturen van een lijst, of
van een verzonden, of ergens anders.
Dus in Python is het belangrijk.
Iterators zijn die objecten die
een dunder next-methode hebben.
U kunt vervolgens een beroep op hen doen.
We hebben zelf een iterator, maar
we kunnen
niet doen voor ik
in mijn gen,
in mijn gen.
Je kan dit niet doen.
Laat me je dat nu vertellen.
Als we dit uitvoeren, krijg je een foutmelding dat het eerste
100 generatorobject niet itereerbaar is, maar ik
zei net dat het een iterator is, en het is een iterator.
Wat een iterator betekent, is dat je
de volgende functie erop kunt
aanroepen, en het zal je de volgende waarde geven.
Maar een iterator en een iterable zijn verschillende dingen.
U kunt een iteratie herhalen en
de iterator wordt gebruikt om de volgende waarde uit een
reeks of uit gegenereerde waarden te halen.
Dus wat we hier hebben, is
een iterator, geen iterabel.
We gaan in de volgende video
leren hoe we een
iterable kunnen maken, zodat we
eroverheen kunnen lopen, of inderdaad dingen kunnen doen zoals sum
of my gen, of weet je, wat je ook wilt doen.
Lijst van mijn gen.
Deze dingen hier hebben een iterable nodig, geen iterator.
Dus laten we dat doen in de volgende video.
Ik zie je daar.