Hallo en welkom bij deze Python-tutorial.
Oké, dus nu gaan we de push-functie maken, die twee taken zal doen.
Ten eerste zal het afhangen van een nieuwe overgang of een nieuwe gebeurtenis in het geheugen.
En ten tweede zorgt het ervoor dat het geheugen altijd 100 overgangen heeft.
Ik zie 100 omdat we het voorbeeld van honderd gebeurtenissen in de vorige tutorial hebben gegeven.
Maar in feite zullen dit er veel meer zijn dan honderd.
Dit zullen er misschien tienduizend zijn.
Honderdduizend.
We zullen zien.
Maar hoe dan ook, deze waarde zal de capaciteit zijn.
Oke.
Dus laten we deze push-functie maken.
Dus zoals gewoonlijk beginnen we met def om een nieuwe functie te definiëren en dan geven we deze functie een naam.
Dus we noemen het push en deze functie heeft twee argumenten.
Eerst, zoals gewoonlijk, het zelf dat verwijst naar het object en het volgende.
Wat denk je dat dat zal zijn?
Nou, onthoud, deze push-functie wordt gebruikt om een nieuw evenement in het geheugen bij te wonen.
We hebben het geheugen al.
Dus wat we nu nodig hebben, is een variabele, een gebeurtenis die onze argumenten zal zijn, onze invoer, en we zullen
deze invoer in het geheugen bijwonen, wat een variabele van het object is.
Oké, dus gebeurtenis, je kunt het eigenlijk gebeurtenis of overgang noemen.
Dat is hetzelfde en u zult zien in de volgende codesecties.
Wat is dit evenement precies, welke vorm heeft het?
Eigenlijk kan ik je nu vertellen dat deze gebeurtenis, deze overgang die we aan het geheugen toevoegen in totaal
vier elementen zijn.
De eerste is de laatste date.
Dat is ongeveer de tweede is de nieuwe staat die zonder rits is.
De derde is de laatste sectie bij de actie die werd weergegeven.
En de vierde is de laatste beloning, het laatst verkregen rapport dat uit is.
Dus dat is precies de vorm die dit evenement zal hebben.
Oke.
En dat is alles wat we gewoon nodig hebben voor het evenement, want we willen het evenement gewoon ter
herinnering bijwonen en er dan voor zorgen dat het geheugen capaciteitselementen heeft.
Oke.
Dus laten we nu naar binnen gaan in de functie.
Dus het eerste wat we zullen doen is het nieuwe evenement ter herinnering bijwonen.
En dat is heel eenvoudig, want we gaan de app-functie gebruiken.
Dus dat zal direct zijn.
En wanneer we de gebeurtenisfunctie gebruiken, moeten we beginnen met de lijst waaraan we iets willen vastpinnen.
En deze lijst is natuurlijk geheugen.
We beginnen dus met het geheugen.
En aangezien het geheugen een veranderlijk object is, beginnen we hier met zelf dat geheugen.
Daar gaan we.
Dus zelf die herinnering.
En dan hadden we een punt en dan de open functie, dat is het eerste sorptiemiddel.
En binnen de evenementfunctie voeren we in wat we willen bijwonen in het geheugen, wat natuurlijk ons evenement is.
Evenement hier dus.
En dat zal de nieuwe gebeurtenis, bestaande uit de laatste datum, nieuwe staat, laatste actie en als beloning, aan de herinnering
toevoegen.
Oke.
Dus dat is het eerste wat gedaan wordt.
En dan is het tweede dat we moeten doen ervoor zorgen dat het geheugen altijd capaciteitselementen bevat.
Dus laten we zeggen dat de capaciteit nu honderdduizend is.
Dat is waarschijnlijk de capaciteit die zal kiezen, want dan kunnen een miljoen elementen de training vertragen.
Dus laten we zeggen honderdduizend.
Nu gaan we ervoor zorgen dat ons geheugen altijd honderdduizend overgangen, honderdduizend gebeurtenissen
en nooit meer bevat.
Dus in het begin zal het er natuurlijk één hebben dan twee en drie.
Maar als het eenmaal honderdduizend evenementen heeft bereikt, wel, dan zal het altijd honderdduizend evenementen
hebben.
Dus om er zeker van te zijn, hoeven we alleen maar een voorwaarde te stellen met deze bovengrens die we
niet willen overschrijden.
Dus als het goed is, is het idee dat we hier zullen gebruiken, dat als we over de limiet gaan, we de
eerste overgang, de eerste gebeurtenis van het geheugen zullen verwijderen, en daarom gaan we de landfunctie naar neem
de lengte van het geheugen.
Dat zijn een aantal elementen in het geheugen.
Dus hier in de landfunctie voeren we zelf dat geheugen in.
Dat is het geheugen.
Dus als het aantal elementen in dat geheugen groter is dan de capaciteit, dan zullen we het eerste element
verwijderen om ervoor te zorgen dat het geheugen altijd hetzelfde aantal capaciteitselementen heeft en om het eerste
element te verwijderen.
Er is niets eenvoudiger.
We gaan een andere functie gebruiken, namelijk de Del Python-truc.
Dus Del en daarom willen we de eerste overgang verwijderen, de oudste overgang in het geheugen, omdat de
laatste overgangen degene zijn die we bijwonen en daarom zijn dat de nieuwste overgangen.
De eerste overgangen zijn dus de oudste.
Dus hier willen we zichzelf wissen, dat geheugen en die haakjes, en we nemen het eerste element van het geheugen
dat geen nul heeft.
Dus geheugen nul opgediend.
Interessant, ik heb een kleine waarschuwing die zegt dat er een ongedefinieerde capaciteit is, dat komt omdat
de capaciteit hier niet de invoer is, dat moet de capaciteitsvariabele zijn die aan het object is gekoppeld.
En daarom moet u een zelfvoorzienende capaciteit toevoegen.
En nu is de waarschuwing weg.
Dus nu begrijp je nog meer het gebruik van het zelf dat werkelijk naar het object verwijst, om de capaciteit van het
object dat zal worden gecreëerd te nemen.
Dat is een instantie van de replay memory-klasse.
Oké, dus we zijn klaar met deze push-functie, en nu kunnen we doorgaan naar
de volgende functie, de eenvoudige functie, die enkele willekeurige steekproeven zal nemen uit dit geheugen van de laatste
capaciteitselementen.
En dit zal veel verbeteren, het diepe reinigingsproces.
Oke.
Dus laten we dit doen in de volgende tutorial.
En tot die tijd, geniet van I.