WEBVTT

00:00.360 --> 00:07.160
Vamos falar sobre um tópico muito importante se você quer ser um grande programador, e isso é

00:07.710 --> 00:13.290
chamado de depuração, você vê que ninguém escreve programas perfeitos, é honestamente impossível.

00:13.500 --> 00:15.120
Sempre vamos cometer erros.

00:15.120 --> 00:17.270
E os programas são constantemente aprimorados.

00:17.820 --> 00:25.350
Melhoramos constantemente nosso código à medida que encontramos mais e mais erros porque os programas estão cheios de erros ou o que

00:25.380 --> 00:28.590
chamamos de bugs ou exceções em tempo de execução.

00:28.590 --> 00:36.810
Quando o código está em execução, você vê que o ato de localizar e remover esses bugs ou erros do nosso código

00:37.020 --> 00:38.610
é chamado de depuração.

00:39.120 --> 00:46.500
E uma grande parte do nosso tempo como programadores está depurando código, seja o nosso próprio código ou o código de outras pessoas

00:46.500 --> 00:49.410
e descobrindo, ei, por que isso não funciona?

00:50.070 --> 00:54.540
E os desenvolvedores seniores são muito, muito bons em depuração.

00:55.520 --> 01:01.370
Então, vamos falar neste vídeo sobre algumas das minhas recomendações para depuração e algumas

01:01.370 --> 01:02.210
boas práticas.

01:02.960 --> 01:07.400
Agora, lembre-se de que você obtém um código de depuração melhor à medida que codifica mais e mais.

01:07.400 --> 01:11.990
Portanto, a melhor coisa que você pode fazer é apenas continuar praticando, continuar escrevendo código Python.

01:13.370 --> 01:14.870
Então, quais são algumas das minhas dicas?

01:15.050 --> 01:22.250
Bem, primeiro, você definitivamente quer usar algum LINTANG e o que está limitando o que falamos

01:22.250 --> 01:30.500
sobre isso bem quando configuramos nosso ambiente de desenvolvedor, a limitação nos permite detectar enquanto codificamos alguns problemas com nosso

01:30.500 --> 01:31.050
código.

01:31.430 --> 01:40.340
Por exemplo, se eu faço NUM mais quatro aqui e obtenho um sublinhado vermelho e você vê aqui que a torta lasca linta percebe

01:40.340 --> 01:46.150
antes mesmo de eu executar meu código, que, ei, há um número nomeado indefinido.

01:46.640 --> 01:51.380
Portanto, o Lintang nos permite encontrar esses erros antes mesmo de executar nosso código.

01:51.980 --> 01:59.570
E vimos que podemos usar IDs como Pisar, que tem Lanting já embutido, ou usar um texto sublime ou

01:59.570 --> 02:06.850
código de estúdio visual e instalar pacotes e extensões como Pellant para realmente ter LINTANG em nosso código.

02:07.160 --> 02:09.410
Essa é uma ferramenta muito, muito importante.

02:09.740 --> 02:15.290
Em seguida, recomendo sempre usar algum tipo de ID ou.

02:16.370 --> 02:22.970
Ed, porque esses editores e IDs, especialmente aqueles que são específicos para Python, como Pixar, têm todas

02:23.210 --> 02:30.050
essas ferramentas integradas para usarmos, como a formatação automática baseada em Pep 8, lembre-se do guia de

02:30.170 --> 02:34.190
estilo oficial de estilo que a comunidade Python tem?

02:34.700 --> 02:42.440
Ele nos permite detectar erros em nosso código com, digamos, destaque e formatação de nosso código.

02:43.570 --> 02:47.510
Portanto, torna-se fácil para nós detectar qualquer erro antes mesmo de executar o código.

02:48.340 --> 02:51.880
Finalmente, você deseja aprender a ler os erros.

02:52.420 --> 02:58.720
E isso é algo que tento praticar com você à medida que aprendemos Python, por exemplo, se eu

02:58.930 --> 03:04.060
faço para mais, digamos algo sem sentido aqui e eu clico em executar.

03:06.310 --> 03:15.850
Imediatamente, vejo, ei, na linha seis, há um ar no meu arquivo DCPI principal, há um tipo ar e vejo aqui que estou

03:15.850 --> 03:23.860
tentando adicioná-lo e uma string para que possamos ler os erros e entender o que eles querem dizer.

03:25.520 --> 03:29.570
Talvez eu faça algo assim se clicar em correr.

03:30.470 --> 03:31.700
Recebo um erro de sintaxe.

03:33.130 --> 03:40.750
E um erro de sintaxe que eu conheço significa que, ei, o interpretador Python está tentando ler meu código, mas o que ela acabou

03:40.750 --> 03:42.460
de escrever não é Python.

03:42.470 --> 03:43.750
Eu não tenho ideia do que você está fazendo.

03:45.490 --> 03:51.310
Aqui eu vejo que é o fim da linha durante a varredura literal de string, então estou tentando ler esta string

03:51.310 --> 03:55.510
e de repente o programa termina como se você fosse terminar a string, lembra?

03:56.880 --> 04:03.330
Portanto, ser capaz de ler esses ares é muito, muito importante, e discutimos alguns deles neste curso, alguns dos

04:03.330 --> 04:08.640
mais comuns, como erro de sintaxe, em que você está apenas escrevendo algo que o

04:08.640 --> 04:10.250
interpretador Python não entende.

04:10.920 --> 04:16.530
Temos algo como erro, certo, onde usamos uma variável que não existe.

04:17.780 --> 04:22.640
Então Python não entende, ei, eu não tenho ideia que nome é qual é o valor de nome?

04:24.160 --> 04:31.330
Temos coisas como tipo air, que é quando combinamos o tipo de dados e fazemos, digamos, uma string mais quatro.

04:32.320 --> 04:34.540
Temos coisas como um valorizador.

04:35.550 --> 04:41.760
Temos coisas como Kierra, onde estamos tentando acessar uma chave que não existe ou erro de atributo,

04:41.880 --> 04:46.860
onde estamos tentando acessar o método do objeto e esse método não existe.

04:47.840 --> 04:53.430
Agora, esses erros são algo que temos visto ao longo do curso e veremos

04:53.430 --> 04:55.350
mais alguns fora disso.

04:55.350 --> 05:02.160
Existem cerca de 15 a 20 erros que são muito comuns e aparecem 90% das vezes.

05:03.340 --> 05:08.380
E se você se lembrar, você sempre pode consultar a documentação do Python para aprender sobre eles, mas isso só

05:08.380 --> 05:09.390
vem com a prática.

05:09.820 --> 05:14.440
Se você vir um erro que nunca viu antes, recomendo ir para a documentação e ler sobre

05:14.440 --> 05:14.950
ele.

05:15.370 --> 05:19.320
Depois de ver, geralmente tende a se lembrar quando surge a seguir.

05:20.200 --> 05:23.800
Mas deixe-me mostrar a você minha maneira favorita de depurar código.

05:25.100 --> 05:34.910
E é chamado de PDB ou Python Debugger, e PDB é um módulo embutido em Python bem aqui.

05:36.230 --> 05:43.130
Novamente, lembre-se de que nosso módulo integrado faz parte da biblioteca padrão com a qual Python vem e PDB

05:43.130 --> 05:46.040
é o depurador Python para interpretadores interativos.

05:47.410 --> 05:51.010
E você pode ler sobre isso aqui, mas deixe-me mostrar o que ele faz.

05:52.510 --> 06:00.130
Veja, o PTB é extremamente útil porque nos permite interagir com o código, então, anteriormente, quando

06:00.130 --> 06:10.000
tínhamos uma função, digamos que temos a função add e temos o número um, o número dois, e então esta função

06:10.000 --> 06:14.470
simplesmente retorna Namwon mais o número dois .

06:15.760 --> 06:18.940
Agora, antes, se quiséssemos, digamos, depurar esse código.

06:19.830 --> 06:24.780
E digamos que estamos adicionando quatro mais alguns rabiscos e isso está nos dando um ar.

06:26.840 --> 06:34.160
A primeira etapa que eu realizaria provavelmente seria adicionar uma impressão aqui para que eu pudesse dizer impressão, ei, o que

06:34.160 --> 06:35.170
está acontecendo?

06:35.180 --> 06:37.940
Deixe-me ver o número um e o número dois e o que isso está me dando.

06:38.950 --> 06:43.010
E imprimir é uma maneira muito, muito rápida e fácil de depurar seu código.

06:43.630 --> 06:48.340
Eu uso o tempo todo, mas o PDB nos dá um impulso extra.

06:49.920 --> 06:58.080
Então, podemos usá-lo assim, simplesmente importamos PDB e em vez de usar algo como uma função

06:58.620 --> 07:06.840
de impressão, podemos simplesmente dizer deixe-me outerspace aqui, podemos simplesmente dizer PDB para depurador Python e, em seguida,

07:06.870 --> 07:15.300
definir, rastrear e rastrear, diria que é o método mais útil que temos neste objeto PDB que o importamos.

07:16.500 --> 07:18.690
Você vê, quando eu executo o método definido.

07:22.290 --> 07:28.920
Ele agora me dá um depurador Python interativo no qual posso digitar comandos aqui e realmente testar meu

07:28.920 --> 07:29.430
código.

07:30.310 --> 07:37.300
E aqui está a parte interessante neste PDB, estou bem dentro da linha oito, então meu código

07:37.450 --> 07:41.660
tentou rodar, mas parou assim que disse PDB, disse Trace.

07:41.680 --> 07:47.530
E agora estou neste mundo e posso testar o que está acontecendo, então posso realmente dizer, ei, Namwon, o que

07:47.560 --> 07:48.040
é?

07:48.280 --> 07:50.250
Bem, o número um é para o número dois?

07:50.860 --> 07:52.570
Bem, o número dois é uma corda.

07:52.570 --> 07:56.410
E eu poderia ficar tipo, oh, estou tentando adicionar uma string e um fim a isso.

07:56.620 --> 07:57.340
Isso não funciona.

07:57.670 --> 07:59.890
Portanto, também posso detectar erros dessa maneira.

08:00.760 --> 08:06.070
Agora, este PDB interativo realmente tem uma tonelada de coisas úteis.

08:06.250 --> 08:08.110
Então, se eu digitar ajuda aqui.

08:09.760 --> 08:17.890
Você vê que tenho comandos que posso usar no PDB, então tenho uma tonelada aqui aos quais tenho acesso, que suponho que

08:17.890 --> 08:22.870
vai me excitar fora deste depurador PDB Python, mas eu também tenho.

08:23.790 --> 08:24.540
Coisas como.

08:25.460 --> 08:31.280
Digamos lista, vamos ver o que a lista faz quando eu digito lista aqui e agora, o site é

08:31.280 --> 08:31.760
realmente.

08:32.900 --> 08:35.780
Não me mostrando muito, mas espero que ainda possa ver a lista.

08:37.210 --> 08:44.350
E acho que algum tipo de saída, vejo que recebo uma lista do meu código e OK, mas digamos que não sei exatamente o

08:44.350 --> 08:45.820
que a lista faz.

08:45.850 --> 08:46.240
Nós vamos.

08:47.350 --> 08:50.830
O PDB nos permite digitar help e listar.

08:51.770 --> 08:57.530
E quando fazemos isso, ele realmente nos fornece a documentação, assim como temos aqui.

08:58.730 --> 09:00.650
Se formos, digamos, lista.

09:03.300 --> 09:10.530
Vamos ver, vamos listar sem lista aqui, ele me dá a documentação bem aqui, então diz a fonte da lista

09:10.530 --> 09:11.760
para o atual.

09:12.640 --> 09:12.900
Direito.

09:12.910 --> 09:15.750
Portanto, ele apenas lista o código-fonte que escrevemos.

09:16.080 --> 09:16.990
OK, pronto.

09:17.130 --> 09:18.030
O que mais está lá?

09:19.160 --> 09:25.160
Bem, também temos algo como Step ou S para abreviar e step é muito, muito legal.

09:27.090 --> 09:33.150
Na verdade, vamos usar Clear para trazer isso para o topo, então direi claro para que ele apague todas as

09:33.150 --> 09:33.540
quebras.

09:35.450 --> 09:36.050
Vamos fazer.

09:37.420 --> 09:40.920
Vamos deixar isso um pouco maior para que você possa ver lá vai, está melhor, certo?

09:40.950 --> 09:47.140
Agora posso fazer algo como Step e Step vai nos permitir ir para a próxima linha.

09:47.170 --> 09:49.660
Então, novamente, se tornarmos isso um pouco maior.

09:50.950 --> 09:55.510
A etapa dirá, ei, vá para a linha nove, então vamos ver o que acontece, vou digitar na etapa.

09:57.530 --> 09:59.750
Ah, e fui apunhalado duas vezes em um passo necessário.

10:01.780 --> 10:08.740
E olhe para isso, eu vou para a próxima linha em meu casaco e isso me pega, ei, você recebe um erro de digitação, o erro que

10:08.740 --> 10:09.450
nós cometemos.

10:09.640 --> 10:11.280
Então, vamos adicionar outra linha aqui.

10:11.290 --> 10:19.660
Digamos que estejamos tentando somar quatro mais cinco aqui ou quatro multiplicar por cinco e

10:19.660 --> 10:22.180
atribuí-lo a uma variável.

10:24.220 --> 10:26.260
Se eu parar isso e executar novamente.

10:28.590 --> 10:30.660
Agora estou aqui dentro.

10:32.670 --> 10:40.350
Se eu digitar T, recebo um nome que T não está definido porque, bem, estou dentro do código aqui na linha oito, mas

10:40.350 --> 10:42.480
ainda temos uma linha nove vermelha.

10:42.750 --> 10:44.010
Então vamos dar um passo.

10:45.190 --> 10:46.620
E agora estou do outro lado.

10:48.040 --> 10:56.680
Então, se eu fizer isso agora, chego perto de 20, incrível, então passo eu posso percorrer o código, o que é muito, muito

10:56.680 --> 10:57.380
útil.

10:58.120 --> 11:03.130
Eu também tenho coisas como continue, o que me permite continuar através do código até retornar algo

11:03.490 --> 11:06.790
e continuar e sair do PDB e olhar para isso.

11:06.790 --> 11:07.450
Eu pego o pronto-socorro.

11:10.150 --> 11:17.260
Vamos executar novamente, outro comando útil é a e A realmente me dá todos os argumentos da função atual

11:17.260 --> 11:18.500
em que estamos.

11:18.640 --> 11:19.720
Então, olhe para isso.

11:19.720 --> 11:22.460
Recebo todos os argumentos, o que, novamente, é muito útil.

11:23.380 --> 11:25.000
Também existe o comando W.

11:26.000 --> 11:30.890
O que me mostra o contexto da linha atual que está executando.

11:32.310 --> 11:35.520
Então você pode ver aqui onde estamos, estamos no anúncio.

11:36.320 --> 11:36.860
Função.

11:38.270 --> 11:43.610
Chamamos com esses argumentos e agora estamos prestes a executar esta linha.

11:46.050 --> 11:51.450
E então, finalmente, enquanto estamos debatendo isso, tudo bem, acho que finalmente vejo que

11:51.450 --> 11:59.300
temos um ar, deveríamos ter dado um número para que eu possa simplesmente sair daqui e simplesmente corrigir isso para cinco.

11:59.790 --> 12:05.280
Agora posso apenas remover meu PDB e tudo deve estar funcionando bem com meu código.

12:06.670 --> 12:07.070
Incrível.

12:07.900 --> 12:14.020
Então PDB é incrível para percorrer seu código e depurar e tentar coisas diferentes, requer um pouco

12:14.020 --> 12:20.420
de prática, mas depois de um dia apenas brincando com PDB, você se tornará muito, muito bom nisso.

12:21.100 --> 12:28.750
Então, após este vídeo, eu recomendo que você escreva PDB e esperançosamente você tem um arquivo Python grande o suficiente.

12:28.750 --> 12:35.500
Eles podem simplesmente passar por cima e experimentar diferentes comandos, usando a ajuda, usando a lista para ver o que

12:35.530 --> 12:36.840
você tem disponível.

12:37.960 --> 12:44.010
Na verdade, quero mostrar uma última coisa, então vamos dizer que voltemos ao nosso código, nosso PDB disse Trace, eu clico

12:44.830 --> 12:45.640
em executar.

12:47.720 --> 12:56.390
Eu poderia fazer algo assim onde eu observo que eu digito e tenho tudo escrito, meu código está funcionando, mas eu poderia mudar

12:56.390 --> 13:00.160
o número dois para agora ser igual a algum jargão?

13:02.310 --> 13:04.140
Bem, vamos ver se eu faço a seguir agora.

13:06.060 --> 13:08.550
E vamos fazer a seguir para executar esta linha final.

13:10.140 --> 13:18.810
Eu chego lá, então também posso mudar variáveis aqui e escrever código Python para talvez testar minhas

13:18.810 --> 13:19.570
funções.

13:19.770 --> 13:21.180
Isso agora está funcionando.

13:21.180 --> 13:25.140
Posso testar, ei, o que acontece se mudarmos essa variável para outro valor?

13:26.180 --> 13:27.890
Novamente, muito, muito útil.