WEBVTT

00:00.420 --> 00:02.740
Olá e seja bem vindo a essa luta e ao torero.

00:03.030 --> 00:07.490
Tudo agora, vamos fazer a função push que fará duas tarefas.

00:07.620 --> 00:14.790
Primeiro, dependerá de uma nova transição ou de um novo evento na memória e, em seguida, segundo, ele

00:14.790 --> 00:18.150
assegurará que a memória tenha sempre 100 transições.

00:18.150 --> 00:23.670
Estou vendo 100 porque damos o exemplo de 100 eventos no tutorial anterior, mas na verdade isso será

00:23.670 --> 00:25.050
muito mais do que 100.

00:25.050 --> 00:29.330
Isso será talvez dez mil cem mil que veremos.

00:29.490 --> 00:32.430
Mas, de qualquer forma, esse valor será a capacidade.

00:32.850 --> 00:33.120
Tudo bem.

00:33.120 --> 00:35.630
Então, vamos fazer essa função de empurrar.

00:35.670 --> 00:41.480
Então, como de costume, começamos com a morte para definir uma nova função e, em seguida, damos

00:41.500 --> 00:46.500
um nome a essa função, por isso chamamos push e esta função terá dois argumentos.

00:46.500 --> 00:51.140
Primeiro como eu habitual que se refere ao objeto e ao próximo.

00:51.180 --> 00:52.710
Por que você acha que isso será.

00:52.930 --> 00:58.860
Bem, lembre-se que esta função de pressão será usada para anexar um novo evento à memória.

00:58.920 --> 01:00.510
Nós já temos a memória.

01:00.510 --> 01:08.010
Então, o que precisamos agora é uma variável é um evento que será nossos argumentos ou entrada

01:08.010 --> 01:13.180
e quebraremos essa entrada na memória, que é uma variável do objeto.

01:13.190 --> 01:13.490
Tudo bem.

01:13.490 --> 01:17.900
Então, você pode realmente chamá-lo de evento ou de transição.

01:17.900 --> 01:20.820
Isso é o mesmo e você verá as próximas seções de código.

01:20.870 --> 01:22.680
Qual é exatamente esse evento.

01:22.700 --> 01:24.050
Que forma tem.

01:24.200 --> 01:29.810
agora este evento, esta transição que estamos adicionando à memória é um total de quatro elementos.

01:29.810 --> 01:31.190
Na verdade, posso dizer-lhe

01:31.190 --> 01:34.050
O primeiro é o último estado que está a ser.

01:34.160 --> 01:37.410
O segundo é o novo estado que é Estep nós um.

01:37.490 --> 01:41.000
O terceiro é a última seção que é 80.

01:41.180 --> 01:46.840
A ação que foi exibida e a quarta é a última palavra a última palavra obtida.

01:46.940 --> 01:47.960
Esse é o nosso.

01:48.200 --> 01:51.370
Então, essa é exatamente a forma que esse evento terá.

01:51.800 --> 01:52.490
Tudo bem.

01:52.700 --> 01:57.830
E isso é tudo o que precisamos do evento, porque queremos apenas encerrar o evento na memória

01:57.830 --> 02:01.270
e depois certificar-se de que a memória tenha elementos de capacidade.

02:01.280 --> 02:03.840
Tudo bem, então, vamos dentro da função.

02:03.860 --> 02:07.520
Então, a primeira coisa que faremos é cuidar de você, então, para a memória.

02:07.640 --> 02:10.850
E isso é muito simples porque vamos usar a função de anexar.

02:10.850 --> 02:12.220
Então, isso será direto.

02:12.350 --> 02:18.200
E quando usamos a função de anexar, devemos começar com a lista para a qual queremos gastar algo

02:18.710 --> 02:20.830
e esta lista é, naturalmente, memória.

02:21.050 --> 02:27.350
Então, começamos com a memória e, como a memória é uma variável do objeto, começamos aqui com a

02:27.650 --> 02:35.060
memória autodidata que vamos configurar a memória e então temos que fazer isso e depois a função aberta, que é a

02:35.060 --> 02:35.690
primeira.

02:35.960 --> 02:43.310
Então, curvado e dentro da função aberta, nós inserimos o que queremos gastar na memória, que é

02:43.640 --> 02:44.750
claro, nossa evidência.

02:44.780 --> 02:45.730
Então, até aqui.

02:46.310 --> 02:53.300
E isso irá anexar o novo evento composto dos últimos oito novos estados de última ação e última palavra

02:53.300 --> 02:54.580
para a memória.

02:54.590 --> 02:55.250
Tudo bem.

02:55.250 --> 02:56.710
Então é a primeira coisa feita.

02:56.870 --> 03:03.940
E então a segunda coisa que precisamos fazer é certificar-se de que a memória sempre contém elementos de capacidade.

03:03.980 --> 03:07.360
Então, digamos que a capacidade é agora 100000.

03:07.520 --> 03:11.990
Essa é provavelmente a capacidade que você escolherá porque, em seguida, um milhão de elementos podem tornar

03:11.990 --> 03:12.640
o trem lento.

03:12.710 --> 03:15.140
Então, digamos 100000.

03:15.140 --> 03:22.150
vamos nos certificar de que nossa memória sempre contém 100 000 transições 100 000 eventos e nunca mais.

03:22.160 --> 03:22.630
Agora,

03:22.850 --> 03:29.180
Então, é claro, no início, terá um, então, dois e três, mas, uma vez que ele atinja

03:29.540 --> 03:32.400
100000 eventos. Bem, ele sempre terá 100000 eventos.

03:32.420 --> 03:38.480
Então, para ter certeza disso, precisamos simplesmente fazer uma condição IF com este limite superior que

03:38.480 --> 03:39.560
não queremos passar.

03:39.590 --> 03:47.810
Então, se tivermos a ideia de que usaremos aqui, é que se superarmos o limite. Bem, vamos excluir a primeira transição

03:48.020 --> 03:54.530
do primeiro evento da memória e, portanto, vamos assumir a função principal para levar o comprimento

03:54.650 --> 03:58.480
do memória que é o número de elementos na memória.

03:58.490 --> 04:04.390
Então, aqui na função len, podemos colocar a própria memória na memória.

04:04.400 --> 04:12.920
Então, se o número de elementos dessa memória for maior do que a capacidade, nesse caso, removeremos o primeiro elemento para garantir

04:13.070 --> 04:20.700
que a memória tenha sempre o mesmo número de elementos de capacidade e para fazer o primeiro elemento não há

04:20.800 --> 04:25.450
nada mais simples que nós vai usar outra função que é tão

04:25.460 --> 04:33.560
central para o "byte centric" e, portanto, queremos remover a primeira transição que é a transição mais antiga na memória porque

04:33.560 --> 04:38.490
as últimas transições são as que estamos tensas e, portanto, essas são as

04:38.570 --> 04:39.380
novas transições.

04:39.560 --> 04:41.970
Assim, as primeiras transições são as mais antigas.

04:42.380 --> 04:51.350
E então, aqui, queremos apagar a memória e os registros autodidacta e nós levamos o primeiro elemento da memória que tem

04:51.710 --> 04:59.000
um zero em si que a memória zero. Agora interessante eu tenho um pequeno aviso que diz

04:59.000 --> 05:00.740
que existe uma capacidade indefinida.

05:01.010 --> 05:06.710
Isso porque a capacidade aqui não é a entrada que deve ser a variável de

05:06.710 --> 05:11.590
capacidade anexada ao objeto e, portanto, você precisará adicionar uma auto-capacidade dessa.

05:11.660 --> 05:13.220
E agora o aviso veio.

05:13.310 --> 05:19.940
Agora você entende ainda mais o uso de si mesmo que é realmente se referir ao objeto para assumir

05:20.330 --> 05:26.180
a capacidade do objeto que será criado que é uma instância da classe de memória de repetição.

05:26.190 --> 05:26.550
Tudo bem.

05:26.550 --> 05:29.250
Então, terminamos com esta função de envio.

05:29.250 --> 05:34.620
E agora podemos avançar para a próxima função, que é a função simples que

05:34.620 --> 05:40.440
levará algumas amostras aleatórias desta memória nos últimos elementos de capacidade e isso vai melhorar muito.

05:40.470 --> 05:42.510
O processo de limpeza profunda.

05:42.510 --> 05:42.790
Tudo bem.

05:42.790 --> 05:44.540
Então vamos fazer isso no próximo tutorial.

05:44.580 --> 05:46.200
E até então eu.