WEBVTT

00:00.420 --> 00:02.740
Ciao e benvenuto a questa lotta ea torero.

00:03.030 --> 00:07.490
Per ora faremo la funzione push che farà due compiti.

00:07.620 --> 00:14.790
Innanzitutto dipenderà una nuova transizione o un nuovo evento nella memoria e poi secondo farà in

00:14.790 --> 00:18.150
modo che la memoria abbia sempre 100 transizioni.

00:18.150 --> 00:23.670
Sto vedendo 100 perché abbiamo dato l'esempio di 100 eventi nel tutorial precedente ma in realtà questo sarà

00:23.670 --> 00:25.050
molto più di 100.

00:25.050 --> 00:29.330
Questo sarà forse forse diecimila centomila vedremo.

00:29.490 --> 00:32.430
Ma comunque questo valore sarà la capacità.

00:32.850 --> 00:33.120
Tutto ok.

00:33.120 --> 00:35.630
Quindi facciamo questa funzione push.

00:35.670 --> 00:41.480
Così come al solito iniziamo con la morte per definire una nuova funzione e quindi diamo un

00:41.500 --> 00:46.500
nome a questa funzione, così la chiamiamo push e questa funzione avrà due argomenti.

00:46.500 --> 00:51.140
In primo luogo come il solito sé che si riferisce all'oggetto e al prossimo.

00:51.180 --> 00:52.710
Perché pensi che lo sarà.

00:52.930 --> 00:58.860
Ricorda che questa funzione push verrà utilizzata per aggiungere un nuovo evento alla memoria.

00:58.920 --> 01:00.510
Abbiamo già la memoria.

01:00.510 --> 01:08.010
Quindi ciò di cui abbiamo bisogno ora è che una variabile è un evento che sarà il nostro argomento

01:08.010 --> 01:13.180
o input e piegheremo questo input alla memoria che è una variabile dell'oggetto.

01:13.190 --> 01:13.490
Tutto ok.

01:13.490 --> 01:17.900
Quindi, puoi chiamarlo evento o transizione.

01:17.900 --> 01:20.820
È lo stesso e vedrai nelle prossime sezioni del codice.

01:20.870 --> 01:22.680
Cos'è esattamente questo evento.

01:22.700 --> 01:24.050
Che forma ha.

01:24.200 --> 01:29.810
ora questo evento questa transizione che stiamo aggiungendo alla memoria è un totale di quattro elementi.

01:29.810 --> 01:31.190
In realtà posso dirti

01:31.190 --> 01:34.050
Il primo è l'ultimo stato che è esty.

01:34.160 --> 01:37.410
Il secondo è il nuovo stato che ci è costato uno.

01:37.490 --> 01:41.000
Il terzo è l'ultima sezione che è 80.

01:41.180 --> 01:46.840
L'azione che è stata visualizzata e la quarta è l'ultima parola l'ultima parola ottenuta.

01:46.940 --> 01:47.960
Questo è il nostro.

01:48.200 --> 01:51.370
Quindi è esattamente la forma che questo evento avrà.

01:51.800 --> 01:52.490
Tutto ok.

01:52.700 --> 01:57.830
E questo è tutto ciò di cui abbiamo bisogno, perché vogliamo solo appuntare l'evento sulla memoria

01:57.830 --> 02:01.270
e quindi assicurarci che la memoria abbia elementi di capacità.

02:01.280 --> 02:03.840
Va bene, ora entriamo nella funzione.

02:03.860 --> 02:07.520
Quindi la prima cosa che faremo sarà occuparci poi della memoria.

02:07.640 --> 02:10.850
E questo è molto semplice perché useremo la funzione append.

02:10.850 --> 02:12.220
Quindi sarà diretto.

02:12.350 --> 02:18.200
E quando usiamo la funzione append dobbiamo iniziare con la lista a cui vogliamo spendere qualcosa

02:18.710 --> 02:20.830
e questa lista è ovviamente memoria.

02:21.050 --> 02:27.350
Quindi iniziamo con la memoria e dato che la memoria è una variabile dell'oggetto che iniziamo qui

02:27.650 --> 02:35.060
con la memoria autodidatta, andiamo ad impostare la memoria e poi dobbiamo farlo e quindi la funzione aperta che è

02:35.060 --> 02:35.690
la prima.

02:35.960 --> 02:43.310
Quindi è piegato e dentro la funzione aperta inseriamo ciò che vogliamo spendere nella memoria, che è ovviamente

02:43.640 --> 02:44.750
la nostra prova.

02:44.780 --> 02:45.730
Quindi anche qui.

02:46.310 --> 02:53.300
E questo aggiungerà il nuovo evento composto dagli ultimi otto nuovi stati ultima azione e ultima

02:53.300 --> 02:54.580
parola alla memoria.

02:54.590 --> 02:55.250
Tutto ok.

02:55.250 --> 02:56.710
Quindi questa è la prima cosa che si fa.

02:56.870 --> 03:03.940
E poi la seconda cosa che dobbiamo fare è assicurarsi che la memoria contenga sempre elementi di capacità.

03:03.980 --> 03:07.360
Quindi diciamo che la capacità è ora 100000.

03:07.520 --> 03:11.990
Probabilmente è la capacità che sceglierai perché un milione di elementi potrebbero rallentare

03:11.990 --> 03:12.640
il treno.

03:12.710 --> 03:15.140
Quindi diciamo 100000.

03:15.140 --> 03:22.150
faremo in modo che la nostra memoria contenga sempre 100000 transizioni 100000 eventi e mai più.

03:22.160 --> 03:22.630
Ora

03:22.850 --> 03:29.180
Quindi ovviamente all'inizio ne avrà uno poi due e tre, ma poi una volta che avrà

03:29.540 --> 03:32.400
raggiunto 100000 eventi, avrà sempre 100000 eventi.

03:32.420 --> 03:38.480
Quindi, per essere sicuri di ciò, abbiamo semplicemente bisogno di creare una condizione IF con questo limite superiore che

03:38.480 --> 03:39.560
non vogliamo superare.

03:39.590 --> 03:47.810
Quindi se abbiamo l'idea che useremo qui è che se superiamo il limite, elimineremo la prima transizione dal primo

03:48.020 --> 03:54.530
evento della memoria e quindi prenderemo la funzione lead per prendere la lunghezza del memoria

03:54.650 --> 03:58.480
che è il numero di elementi nella memoria.

03:58.490 --> 04:04.390
Quindi qui nella funzione len possiamo mettere in memoria la memoria personale.

04:04.400 --> 04:12.920
Quindi se il numero di elementi di quella memoria è più grande della capacità in quel caso rimuoveremo il primo elemento per

04:13.070 --> 04:20.700
assicurarci che la memoria abbia sempre lo stesso numero di elementi di capacità e per fare il primo elemento non

04:20.800 --> 04:25.450
ci sia nulla di più semplice noi useremo un'altra funzione che è

04:25.460 --> 04:33.560
il tell byte centric così bene e quindi vogliamo rimuovere la prima transizione che è la transizione più vecchia nella memoria

04:33.560 --> 04:38.490
perché le ultime transizioni sono quelle che siamo tese e quindi quelle sono

04:38.570 --> 04:39.380
le nuove transizioni.

04:39.560 --> 04:41.970
Quindi le prime transizioni sono le più vecchie.

04:42.380 --> 04:51.350
E così qui vogliamo cancellare la memoria e i dischi autodidatti e prendiamo il primo elemento della memoria che ha

04:51.710 --> 04:59.000
uno zero stesso che la memoria zero. Ora interessante ho un piccolo avvertimento che dice che

04:59.000 --> 05:00.740
c'è una capacità indefinita.

05:01.010 --> 05:06.710
Questo perché la capacità qui non è l'input che deve essere la variabile

05:06.710 --> 05:11.590
di capacità associata all'oggetto e pertanto sarà necessario aggiungere una capacità autonoma.

05:11.660 --> 05:13.220
E ora l'avvertimento è arrivato.

05:13.310 --> 05:19.940
Ora comprendi ancora di più l'uso del sé che è davvero riferirsi all'oggetto per prendere la

05:20.330 --> 05:26.180
capacità dell'oggetto che verrà creato che è un'istanza della classe di memoria di replay.

05:26.190 --> 05:26.550
Tutto ok.

05:26.550 --> 05:29.250
Quindi abbiamo finito con questa funzione push.

05:29.250 --> 05:34.620
E così ora possiamo passare alla funzione successiva che è la semplice funzione che prenderà

05:34.620 --> 05:40.440
alcuni campioni casuali da questa memoria agli ultimi elementi di capacità e facendo ciò migliorerà molto.

05:40.470 --> 05:42.510
Il processo di pulizia profonda.

05:42.510 --> 05:42.790
Tutto ok.

05:42.790 --> 05:44.540
Quindi facciamolo nel prossimo tutorial.

05:44.580 --> 05:46.200
E fino ad allora I.
