WEBVTT

00:00.420 --> 00:02.740
Bonjour et bienvenue à ce combat et à torero.

00:03.030 --> 00:07.490
Bon maintenant nous allons faire la fonction push qui fera deux tâches.

00:07.620 --> 00:14.790
Tout d'abord, cela dépendra d'une nouvelle transition ou d'un nouvel événement dans la mémoire et ensuite, cela permettra de

00:14.790 --> 00:18.150
s'assurer que la mémoire a toujours 100 transitions.

00:18.150 --> 00:23.670
J'en vois 100 parce que nous avons donné l'exemple de 100 événements dans le didacticiel précédent, mais en réalité, ce

00:23.670 --> 00:25.050
sera beaucoup plus que 100.

00:25.050 --> 00:29.330
Ce sera plutôt peut-être dix mille cent mille que nous verrons.

00:29.490 --> 00:32.430
Mais de toute façon cette valeur sera la capacité.

00:32.850 --> 00:33.120
D'accord.

00:33.120 --> 00:35.630
Faisons donc cette fonction push.

00:35.670 --> 00:41.480
Donc, comme d'habitude, nous commençons par death pour définir une nouvelle fonction, puis nous donnons un nom

00:41.500 --> 00:46.500
à cette fonction, nous l'appelons donc push et cette fonction aura deux arguments.

00:46.500 --> 00:51.140
D'abord comme d'habitude qui se réfère à l'objet et au suivant.

00:51.180 --> 00:52.710
Pourquoi pensez-vous que ce sera.

00:52.930 --> 00:58.860
Souvenez-vous que cette fonction push sera utilisée pour ajouter un nouvel événement à la mémoire.

00:58.920 --> 01:00.510
Nous avons déjà la mémoire.

01:00.510 --> 01:08.010
Donc, ce dont nous avons besoin maintenant, c’est d’une variable, c’est d’un événement qui sera notre argument ou notre entrée et nous

01:08.010 --> 01:13.180
tiendrons compte de cette entrée dans la mémoire qui est une variable de l’objet.

01:13.190 --> 01:13.490
D'accord.

01:13.490 --> 01:17.900
Donc, vous pouvez appeler cela événement ou transition.

01:17.900 --> 01:20.820
C'est la même chose et vous verrez dans les prochaines sections de code.

01:20.870 --> 01:22.680
Quel est exactement cet événement?

01:22.700 --> 01:24.050
Quelle forme il a.

01:24.200 --> 01:29.810
En fait, je peux vous dire maintenant que cet événement a quatre éléments

01:29.810 --> 01:31.190
au total.

01:31.190 --> 01:34.050
Le premier est le dernier état qui est esty.

01:34.160 --> 01:37.410
Le second est le nouvel état qui est Estep nous un.

01:37.490 --> 01:41.000
La troisième est la dernière section qui est 80.

01:41.180 --> 01:46.840
L'action qui a été affichée et la quatrième est le dernier mot, le dernier mot obtenu.

01:46.940 --> 01:47.960
C'est notre.

01:48.200 --> 01:51.370
C'est donc exactement la forme que cet événement aura.

01:51.800 --> 01:52.490
D'accord.

01:52.700 --> 01:57.830
Et c’est tout ce dont nous avons besoin de l’événement car nous voulons simplement l’épingler dans la mémoire,

01:57.830 --> 02:01.270
puis nous assurer que la mémoire a des éléments de capacité.

02:01.280 --> 02:03.840
D'accord, allons maintenant dans la fonction.

02:03.860 --> 02:07.520
Donc, la première chose que nous ferons est de nous occuper de la mémoire.

02:07.640 --> 02:10.850
Et c'est très simple car nous allons utiliser la fonction append.

02:10.850 --> 02:12.220
Donc, ce sera direct.

02:12.350 --> 02:18.200
Et lorsque nous utilisons la fonction append, nous devons commencer par la liste pour laquelle nous voulons dépenser quelque chose et cette

02:18.710 --> 02:20.830
liste est bien sûr de la mémoire.

02:21.050 --> 02:27.350
Nous commençons donc avec la mémoire et comme la mémoire est une variable de l’objet, nous commençons

02:27.650 --> 02:35.060
ici avec la mémoire autodidacte que nous allons configurer puis nous devons le faire, puis la fonction open qui est la

02:35.060 --> 02:35.690
première.

02:35.960 --> 02:43.310
Nous avons donc décidé de saisir ce que nous voulons dépenser dans la fonction ouverte, ce qui est bien sûr

02:43.640 --> 02:44.750
notre preuve.

02:44.780 --> 02:45.730
Alors même ici.

02:46.310 --> 02:53.300
Et cela va ajouter le nouvel événement composé des huit dernières nouvelles actions dernière action et du dernier mot

02:53.300 --> 02:54.580
à la mémoire.

02:54.590 --> 02:55.250
D'accord.

02:55.250 --> 02:56.710
C'est donc la première chose à faire.

02:56.870 --> 03:03.940
Et la deuxième chose à faire est de s’assurer que la mémoire contient toujours des éléments de capacité.

03:03.980 --> 03:07.360
Donc, disons que la capacité est maintenant de 100 000.

03:07.520 --> 03:11.990
C'est probablement la capacité que vous choisirez, car un million d'éléments pourraient ralentir le

03:11.990 --> 03:12.640
train.

03:12.710 --> 03:15.140
Alors disons 100000.

03:15.140 --> 03:22.150
Maintenant, nous allons nous assurer que notre mémoire contient toujours 100 000 transitions, 100 000 événements et jamais

03:22.160 --> 03:22.630
plus.

03:22.850 --> 03:29.180
Donc bien sûr au début, il y aura un, puis deux et trois, mais une fois que cela aura atteint 100

03:29.540 --> 03:32.400
000 événements, il y aura toujours 100 000 événements.

03:32.420 --> 03:38.480
Donc, pour en être sûr, nous devons simplement créer une condition IF avec cette limite supérieure que nous ne

03:38.480 --> 03:39.560
voulons pas dépasser.

03:39.590 --> 03:47.810
Donc, si nous avons l’idée que nous allons utiliser ici, c’est que si nous dépassons la limite Eh bien, nous allons supprimer la première transition

03:48.020 --> 03:54.530
du premier événement de la mémoire et, par conséquent, nous allons prendre la fonction de tête pour prendre la longueur

03:54.650 --> 03:58.480
de la mémoire qui est le nombre d'éléments dans la mémoire.

03:58.490 --> 04:04.390
Donc ici, dans la fonction len, nous pouvons mettre la mémoire de soi en mémoire.

04:04.400 --> 04:12.920
Donc, si le nombre d’éléments de cette mémoire est supérieur à la capacité bien, dans ce cas, nous supprimerons le premier élément pour nous

04:13.070 --> 04:20.700
assurer que la mémoire a toujours le même nombre d’éléments de capacité et pour faire le premier élément, il n’ya rien

04:20.800 --> 04:25.450
de plus simple. allons utiliser une autre fonction qui est si bien

04:25.460 --> 04:33.560
centrée sur l'octet tell et nous voulons donc supprimer la première transition qui est la transition la plus ancienne de la mémoire

04:33.560 --> 04:38.490
car les dernières transitions sont celles que nous sommes tendus et donc les

04:38.570 --> 04:39.380
nouvelles transitions.

04:39.560 --> 04:41.970
Les premières transitions sont donc les plus anciennes.

04:42.380 --> 04:51.350
Et donc ici nous voulons supprimer la mémoire et les enregistrements autodidacte et nous prenons le premier élément de la mémoire qui

04:51.710 --> 04:59.000
a un zéro lui-même que la mémoire zéro. Maintenant, intéressant, j'ai un petit avertissement qui dit qu'il y

04:59.000 --> 05:00.740
a une capacité indéfinie.

05:01.010 --> 05:06.710
En effet, la capacité ici n'est pas l'entrée qui doit être la variable de capacité attachée

05:06.710 --> 05:11.590
à l'objet et vous devrez donc ajouter un self à cette capacité.

05:11.660 --> 05:13.220
Et maintenant l'avertissement est venu.

05:13.310 --> 05:19.940
Maintenant, vous comprenez encore plus l’utilisation de self qui fait en réalité référence à l’objet pour utiliser la capacité

05:20.330 --> 05:26.180
de l’objet à créer qui est une instance de la classe de mémoire de relecture.

05:26.190 --> 05:26.550
D'accord.

05:26.550 --> 05:29.250
Nous en avons donc terminé avec cette fonction push.

05:29.250 --> 05:34.620
Nous pouvons donc passer à la fonction suivante, qui consiste en une fonction simple qui prélève

05:34.620 --> 05:40.440
des échantillons aléatoires dans cette mémoire aux derniers éléments de capacité, ce qui permettra d’améliorer considérablement la situation.

05:40.470 --> 05:42.510
Le processus de nettoyage en profondeur.

05:42.510 --> 05:42.790
D'accord.

05:42.790 --> 05:44.540
Faisons cela dans le prochain tutoriel.

05:44.580 --> 05:46.200
Et jusque là je
