Hola y bienvenidos a esta pelea y al torero.
Ahora vamos a hacer la función push que hará dos tareas.
Primero, dependerá de una nueva transición o un nuevo evento en la memoria y luego, se asegurará
de que la memoria siempre tenga 100 transiciones.
Veo 100 porque dimos el ejemplo de 100 eventos en el tutorial anterior, pero de hecho será
mucho más que 100.
Esto será más bien quizás diez mil cien mil ya veremos.
Pero de todos modos este valor será la capacidad.
Todo bien.
Entonces hagamos esta función de empuje.
Entonces, como de costumbre, comenzamos con la muerte para definir una nueva función y luego asignamos un nombre
a esta función, por lo que la llamamos push y esta función tendrá dos argumentos.
Primero como yo habitual que se refiere al objeto y al siguiente.
¿Por qué crees que será?
Bueno, recuerda que esta función de inserción se usará para añadir un nuevo evento a la memoria.
Ya tenemos la memoria.
Entonces, lo que necesitamos ahora es una variable, es un evento que será nuestro argumento o aporte y
estaremos doblando esta entrada en la memoria que es una variable del objeto.
Todo bien.
Entonces el evento puede llamarlo evento o transición.
Es lo mismo y verá en las próximas secciones de códigos.
¿Qué es exactamente este evento?
Qué forma tiene
ahora este evento, esta transición que estamos agregando a la memoria es un total de cuatro elementos.
De hecho, puedo decirte
El primero es el último estado que es esty.
El segundo es el nuevo estado que es Estep nosotros uno.
El tercero es la última sección que es 80.
La acción que se mostró y la cuarta es la última palabra que obtuvo la última palabra.
Ese es nuestro.
Así que esa es exactamente la forma que tendrá este evento.
Todo bien.
Y eso es todo, solo necesitamos el evento porque solo queremos fijar el evento en la memoria
y luego asegurarnos de que la memoria tenga elementos de capacidad.
Muy bien, ahora vamos a entrar en la función.
Entonces, lo primero que haremos es atenderlo luego a la memoria.
Y eso es muy simple porque vamos a usar la función de agregar.
Entonces eso será directo.
Y cuando usamos la función de agregar, debemos comenzar con la lista a la que queremos gastar algo
y esta lista es, por supuesto, memoria.
Entonces comenzamos con la memoria y dado que la memoria es una variable del objeto que comenzamos aquí
con la memoria autodidacta, vamos a configurar la memoria y luego tenemos que hacer eso y luego la función abrir que es
la primera.
Entonces se dobló y dentro de la función abierta ingresamos lo que queremos gastar en la memoria, que es por
supuesto nuestra evidencia.
Así que incluso aquí.
Y eso agregará el nuevo evento compuesto por los últimos ocho nuevos estados, la última acción y la última
palabra a la memoria.
Todo bien.
Entonces eso es lo primero que se hace.
Y luego, lo segundo que tenemos que hacer es asegurarnos de que la memoria siempre contenga elementos de capacidad.
Entonces digamos que la capacidad ahora es 100000.
Esa es probablemente la capacidad que elegirá porque entonces un millón de elementos puede hacer que el tren
sea más lento.
Entonces digamos 100000
vamos a asegurarnos de que nuestra memoria siempre contenga 100000 transiciones, 100000 eventos y nunca más.
Ahora
Así que, por supuesto, al principio tendrá uno, dos y tres, pero luego, una vez que llegue
a 100000 eventos, siempre tendrá 100000 eventos.
Para asegurarnos de ello, simplemente necesitamos hacer una condición IF con este límite superior que
no queremos repasar.
Entonces, si tenemos la idea que vamos a usar aquí, es que si rebasamos el límite Bueno, eliminaremos la primera transición del
primer evento de la memoria y por lo tanto tomaremos la función principal para tomar la longitud del
memoria que es la cantidad de elementos en la memoria.
Entonces aquí en la función len podemos poner la memoria en la memoria.
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
que la memoria siempre tenga el mismo número de elementos de capacidad y para hacer el primer elemento no hay nada más
sencillo que van a usar otra función que sea tan centrada en el
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
las últimas transiciones son las que estamos tensas y, por lo tanto, esas son
las nuevas transiciones.
Entonces las primeras transiciones son las más antiguas.
Y aquí queremos eliminar la memoria y los registros autodidácticos y tomamos el primer elemento de la memoria que tiene un
cero en sí mismo que la memoria cero Ahora interesante, tengo una pequeña advertencia que dice que
hay una capacidad indefinida.
Esto se debe a que la capacidad aquí no es la entrada que debe ser la variable de
capacidad adjunta al objeto y, por lo tanto, deberá agregarse uno mismo a esa capacidad.
Y ahora la advertencia ha llegado.
Ahora comprende aún más el uso del self que es realmente referir al objeto para tomar la capacidad
del objeto que se creará que es una instancia de la clase de memoria de repetición.
Todo bien.
Así que hemos terminado con esta función de inserción.
Y ahora podemos pasar a la siguiente función, que es la función simple que tomará
algunas muestras aleatorias de esta memoria en los últimos elementos de capacidad y esto mejorará mucho.
El proceso de limpieza profunda.
Todo bien.
Así que hagámoslo en el siguiente tutorial.
Y hasta entonces yo