WEBVTT

00:00.420 --> 00:02.740
Hola y bienvenidos a esta pelea y al torero.

00:03.030 --> 00:07.490
Ahora vamos a hacer la función push que hará dos tareas.

00:07.620 --> 00:14.790
Primero, dependerá de una nueva transición o un nuevo evento en la memoria y luego, se asegurará

00:14.790 --> 00:18.150
de que la memoria siempre tenga 100 transiciones.

00:18.150 --> 00:23.670
Veo 100 porque dimos el ejemplo de 100 eventos en el tutorial anterior, pero de hecho será

00:23.670 --> 00:25.050
mucho más que 100.

00:25.050 --> 00:29.330
Esto será más bien quizás diez mil cien mil ya veremos.

00:29.490 --> 00:32.430
Pero de todos modos este valor será la capacidad.

00:32.850 --> 00:33.120
Todo bien.

00:33.120 --> 00:35.630
Entonces hagamos esta función de empuje.

00:35.670 --> 00:41.480
Entonces, como de costumbre, comenzamos con la muerte para definir una nueva función y luego asignamos un nombre

00:41.500 --> 00:46.500
a esta función, por lo que la llamamos push y esta función tendrá dos argumentos.

00:46.500 --> 00:51.140
Primero como yo habitual que se refiere al objeto y al siguiente.

00:51.180 --> 00:52.710
¿Por qué crees que será?

00:52.930 --> 00:58.860
Bueno, recuerda que esta función de inserción se usará para añadir un nuevo evento a la memoria.

00:58.920 --> 01:00.510
Ya tenemos la memoria.

01:00.510 --> 01:08.010
Entonces, lo que necesitamos ahora es una variable, es un evento que será nuestro argumento o aporte y

01:08.010 --> 01:13.180
estaremos doblando esta entrada en la memoria que es una variable del objeto.

01:13.190 --> 01:13.490
Todo bien.

01:13.490 --> 01:17.900
Entonces el evento puede llamarlo evento o transición.

01:17.900 --> 01:20.820
Es lo mismo y verá en las próximas secciones de códigos.

01:20.870 --> 01:22.680
¿Qué es exactamente este evento?

01:22.700 --> 01:24.050
Qué forma tiene

01:24.200 --> 01:29.810
ahora este evento, esta transición que estamos agregando a la memoria es un total de cuatro elementos.

01:29.810 --> 01:31.190
De hecho, puedo decirte

01:31.190 --> 01:34.050
El primero es el último estado que es esty.

01:34.160 --> 01:37.410
El segundo es el nuevo estado que es Estep nosotros uno.

01:37.490 --> 01:41.000
El tercero es la última sección que es 80.

01:41.180 --> 01:46.840
La acción que se mostró y la cuarta es la última palabra que obtuvo la última palabra.

01:46.940 --> 01:47.960
Ese es nuestro.

01:48.200 --> 01:51.370
Así que esa es exactamente la forma que tendrá este evento.

01:51.800 --> 01:52.490
Todo bien.

01:52.700 --> 01:57.830
Y eso es todo, solo necesitamos el evento porque solo queremos fijar el evento en la memoria

01:57.830 --> 02:01.270
y luego asegurarnos de que la memoria tenga elementos de capacidad.

02:01.280 --> 02:03.840
Muy bien, ahora vamos a entrar en la función.

02:03.860 --> 02:07.520
Entonces, lo primero que haremos es atenderlo luego a la memoria.

02:07.640 --> 02:10.850
Y eso es muy simple porque vamos a usar la función de agregar.

02:10.850 --> 02:12.220
Entonces eso será directo.

02:12.350 --> 02:18.200
Y cuando usamos la función de agregar, debemos comenzar con la lista a la que queremos gastar algo

02:18.710 --> 02:20.830
y esta lista es, por supuesto, memoria.

02:21.050 --> 02:27.350
Entonces comenzamos con la memoria y dado que la memoria es una variable del objeto que comenzamos aquí

02:27.650 --> 02:35.060
con la memoria autodidacta, vamos a configurar la memoria y luego tenemos que hacer eso y luego la función abrir que es

02:35.060 --> 02:35.690
la primera.

02:35.960 --> 02:43.310
Entonces se dobló y dentro de la función abierta ingresamos lo que queremos gastar en la memoria, que es por

02:43.640 --> 02:44.750
supuesto nuestra evidencia.

02:44.780 --> 02:45.730
Así que incluso aquí.

02:46.310 --> 02:53.300
Y eso agregará el nuevo evento compuesto por los últimos ocho nuevos estados, la última acción y la última

02:53.300 --> 02:54.580
palabra a la memoria.

02:54.590 --> 02:55.250
Todo bien.

02:55.250 --> 02:56.710
Entonces eso es lo primero que se hace.

02:56.870 --> 03:03.940
Y luego, lo segundo que tenemos que hacer es asegurarnos de que la memoria siempre contenga elementos de capacidad.

03:03.980 --> 03:07.360
Entonces digamos que la capacidad ahora es 100000.

03:07.520 --> 03:11.990
Esa es probablemente la capacidad que elegirá porque entonces un millón de elementos puede hacer que el tren

03:11.990 --> 03:12.640
sea más lento.

03:12.710 --> 03:15.140
Entonces digamos 100000

03:15.140 --> 03:22.150
vamos a asegurarnos de que nuestra memoria siempre contenga 100000 transiciones, 100000 eventos y nunca más.

03:22.160 --> 03:22.630
Ahora

03:22.850 --> 03:29.180
Así que, por supuesto, al principio tendrá uno, dos y tres, pero luego, una vez que llegue

03:29.540 --> 03:32.400
a 100000 eventos, siempre tendrá 100000 eventos.

03:32.420 --> 03:38.480
Para asegurarnos de ello, simplemente necesitamos hacer una condición IF con este límite superior que

03:38.480 --> 03:39.560
no queremos repasar.

03:39.590 --> 03:47.810
Entonces, si tenemos la idea que vamos a usar aquí, es que si rebasamos el límite Bueno, eliminaremos la primera transición del

03:48.020 --> 03:54.530
primer evento de la memoria y por lo tanto tomaremos la función principal para tomar la longitud del

03:54.650 --> 03:58.480
memoria que es la cantidad de elementos en la memoria.

03:58.490 --> 04:04.390
Entonces aquí en la función len podemos poner la memoria en la memoria.

04:04.400 --> 04:12.920
Entonces, si el número de elementos de esa memoria es mayor que la capacidad, en ese caso eliminaremos el primer elemento para asegurarnos de

04:13.070 --> 04:20.700
que la memoria siempre tenga el mismo número de elementos de capacidad y para hacer el primer elemento no hay nada más

04:20.800 --> 04:25.450
sencillo que van a usar otra función que sea tan centrada en el

04:25.460 --> 04:33.560
byte de la señal y por lo tanto queremos eliminar la primera transición que es la transición más antigua en la memoria porque

04:33.560 --> 04:38.490
las últimas transiciones son las que estamos tensas y, por lo tanto, esas son

04:38.570 --> 04:39.380
las nuevas transiciones.

04:39.560 --> 04:41.970
Entonces las primeras transiciones son las más antiguas.

04:42.380 --> 04:51.350
Y aquí queremos eliminar la memoria y los registros autodidácticos y tomamos el primer elemento de la memoria que tiene un

04:51.710 --> 04:59.000
cero en sí mismo que la memoria cero Ahora interesante, tengo una pequeña advertencia que dice que

04:59.000 --> 05:00.740
hay una capacidad indefinida.

05:01.010 --> 05:06.710
Esto se debe a que la capacidad aquí no es la entrada que debe ser la variable de

05:06.710 --> 05:11.590
capacidad adjunta al objeto y, por lo tanto, deberá agregarse uno mismo a esa capacidad.

05:11.660 --> 05:13.220
Y ahora la advertencia ha llegado.

05:13.310 --> 05:19.940
Ahora comprende aún más el uso del self que es realmente referir al objeto para tomar la capacidad

05:20.330 --> 05:26.180
del objeto que se creará que es una instancia de la clase de memoria de repetición.

05:26.190 --> 05:26.550
Todo bien.

05:26.550 --> 05:29.250
Así que hemos terminado con esta función de inserción.

05:29.250 --> 05:34.620
Y ahora podemos pasar a la siguiente función, que es la función simple que tomará

05:34.620 --> 05:40.440
algunas muestras aleatorias de esta memoria en los últimos elementos de capacidad y esto mejorará mucho.

05:40.470 --> 05:42.510
El proceso de limpieza profunda.

05:42.510 --> 05:42.790
Todo bien.

05:42.790 --> 05:44.540
Así que hagámoslo en el siguiente tutorial.

05:44.580 --> 05:46.200
Y hasta entonces yo