WEBVTT

00:00.360 --> 00:07.160
Parliamo di un argomento molto importante se vuoi essere un grande programmatore, e questo

00:07.710 --> 00:13.290
si chiama debugging, vedi nessuno scrive programmi perfetti, è onestamente impossibile.

00:13.500 --> 00:15.120
Faremo sempre errori.

00:15.120 --> 00:17.270
E i programmi vengono costantemente migliorati.

00:17.820 --> 00:25.350
Miglioriamo costantemente il nostro codice man mano che troviamo sempre più errori perché i programmi sono pieni di errori o quelli che

00:25.380 --> 00:28.590
chiamiamo bug o eccezioni in fase di esecuzione.

00:28.590 --> 00:36.810
Quando il codice è in esecuzione, l'atto di trovare e rimuovere questi bug o errori dal nostro codice

00:37.020 --> 00:38.610
è chiamato debug.

00:39.120 --> 00:46.500
E gran parte del nostro tempo come programmatori è eseguire il debug del codice, che sia il nostro codice o il codice di altre

00:46.500 --> 00:49.410
persone e capire, ehi, come mai questo non funziona?

00:50.070 --> 00:54.540
E gli sviluppatori senior sono davvero molto bravi a eseguire il debug.

00:55.520 --> 01:01.370
Quindi parliamo in questo video di alcuni dei miei consigli per il debug e di quali sono alcune

01:01.370 --> 01:02.210
buone pratiche.

01:02.960 --> 01:07.400
Ora, tieni presente che ottieni un codice di debug migliore man mano che codifichi sempre di più.

01:07.400 --> 01:11.990
Quindi la cosa migliore che puoi fare è continuare a esercitarti, continuare a scrivere codice Python.

01:13.370 --> 01:14.870
Allora quali sono alcuni dei miei consigli?

01:15.050 --> 01:22.250
Bene, in primo luogo, vuoi assolutamente usare un po' di LINTANG e ciò che sta limitando ciò di cui

01:22.250 --> 01:30.500
abbiamo parlato proprio quando configuriamo il nostro ambiente di sviluppo, la limitazione ci consente di rilevare mentre codifichiamo alcuni problemi con il nostro

01:30.500 --> 01:31.050
codice.

01:31.430 --> 01:40.340
Ad esempio, se eseguo NUM più quattro qui e ottengo una sottolineatura rossa e vedi qui che la torta si sfalda linta nota prima

01:40.340 --> 01:46.150
ancora che esegua il mio codice, che, ehi, c'è un numero con nome indefinito.

01:46.640 --> 01:51.380
Quindi Lintang ci consente di trovare questi errori prima ancora di eseguire il nostro codice.

01:51.980 --> 01:59.570
E abbiamo visto che possiamo usare ID come Pisar che ha Lanting già integrato o utilizzare un testo sublime o

01:59.570 --> 02:06.850
codice di Visual Studio e installare pacchetti ed estensioni come Pellan per avere effettivamente LINTANG nel nostro codice.

02:07.160 --> 02:09.410
Questo è uno strumento davvero, davvero importante.

02:09.740 --> 02:15.290
Successivamente, consiglio di utilizzare sempre una sorta di ID o.

02:16.370 --> 02:22.970
Ed, perché questi editor e ID, specialmente quelli specifici per Python, come Pixar, hanno tutti

02:23.210 --> 02:30.050
questi strumenti incorporati da usare, come la formattazione automatica basata su Pep otto, ricorda la guida

02:30.170 --> 02:34.190
di stile ufficiale che la comunità di Python ha?

02:34.700 --> 02:42.440
Ci consente di rilevare errori nel nostro codice, ad esempio evidenziando e formattando il nostro codice.

02:43.570 --> 02:47.510
Quindi diventa facile per noi rilevare eventuali errori prima ancora di eseguire il codice.

02:48.340 --> 02:51.880
Infine, vuoi essere in grado di imparare a leggere gli errori.

02:52.420 --> 02:58.720
E questo è qualcosa che cerco di praticare con te mentre abbiamo imparato Python, ad esempio,

02:58.930 --> 03:04.060
se lo faccio per più, diciamo senza senso qui e clicco su Esegui.

03:06.310 --> 03:15.850
Immediatamente, vedo, ehi, sulla riga sei, c'è un'aria nel mio file DCPI principale, c'è un tipo aria e vedo qui che sto

03:15.850 --> 03:23.860
cercando di aggiungerlo e una stringa così siamo in grado di leggere gli errori e capire cosa significano.

03:25.520 --> 03:29.570
Forse faccio qualcosa del genere se clicco su Esegui.

03:30.470 --> 03:31.700
Ottengo un errore di sintassi.

03:33.130 --> 03:40.750
E un errore di sintassi che conosco significa che, ehi, l'interprete Python sta cercando di leggere il mio codice, ma quello che ha

03:40.750 --> 03:42.460
appena scritto non è Python.

03:42.470 --> 03:43.750
Non ho idea di cosa stai facendo.

03:45.490 --> 03:51.310
Qui vedo che è la fine della riga durante la scansione della stringa letterale, quindi sto provando a leggere

03:51.310 --> 03:55.510
questa stringa e all'improvviso il programma finisce come dovresti terminare la stringa, ricordi?

03:56.880 --> 04:03.330
Quindi essere in grado di leggere queste arie è davvero, davvero importante, e ne abbiamo discusso alcune in questo

04:03.330 --> 04:08.640
corso, alcune delle più comuni come l'errore di sintassi, in cui stai semplicemente scrivendo qualcosa che

04:08.640 --> 04:10.250
l'interprete Python non capisce.

04:10.920 --> 04:16.530
Abbiamo qualcosa come errore, giusto, dove usiamo una variabile che non esiste.

04:17.780 --> 04:22.640
Quindi Python non capisce, ehi, non ho idea di che nome sia qual è il valore di nome?

04:24.160 --> 04:31.330
Abbiamo cose come il tipo aria, cioè quando non abbiniamo il tipo di dati e facciamo, diciamo una stringa più quattro.

04:32.320 --> 04:34.540
Abbiamo cose come un valore ehm.

04:35.550 --> 04:41.760
Abbiamo cose come Kierra, in cui stiamo cercando di accedere a una chiave che non esiste o attribuisce un

04:41.880 --> 04:46.860
errore, in cui stiamo cercando di accedere al metodo dell'oggetto e quel metodo non esiste.

04:47.840 --> 04:53.430
Ora, questi errori sono qualcosa che abbiamo visto durante il corso e ne vedremo altri

04:53.430 --> 04:55.350
al di fuori di questo.

04:55.350 --> 05:02.160
Ci sono circa 15-20 errori molto, molto comuni che si verificano il 90% delle volte.

05:03.340 --> 05:08.380
E se ricordi, puoi sempre andare alla documentazione di Python per conoscerli, ma questo viene solo

05:08.380 --> 05:09.390
con la pratica.

05:09.820 --> 05:14.440
Se vedi un errore che non hai mai visto prima, ti consiglio di andare alla documentazione e

05:14.440 --> 05:14.950
leggerlo.

05:15.370 --> 05:19.320
Una volta che lo vedi, di solito tendi a ricordare quando si presenta dopo.

05:20.200 --> 05:23.800
Ma lascia che ti mostri il mio modo preferito per eseguire il debug del codice.

05:25.100 --> 05:34.910
E si chiama PDB o Python Debugger, e PDB è un modulo integrato in Python proprio qui.

05:36.230 --> 05:43.130
Ancora una volta, ricorda, il nostro modulo integrato fa parte della libreria standard fornita con Python e PDB

05:43.130 --> 05:46.040
è il debugger Python per interpreti interattivi.

05:47.410 --> 05:51.010
E puoi leggerlo qui, ma lascia che ti mostri cosa fa.

05:52.510 --> 06:00.130
Vedete, PTB è estremamente utile perché ci permette di interagire con il codice, quindi in precedenza,

06:00.130 --> 06:10.000
quando avevamo una funzione, diciamo che abbiamo la funzione add e abbiamo il numero uno, il numero due, e quindi questa

06:10.000 --> 06:14.470
funzione restituisce semplicemente Namwon più il numero due .

06:15.760 --> 06:18.940
Ora, prima, se volessimo, diciamo, eseguire il debug di questo codice.

06:19.830 --> 06:24.780
E diciamo che stiamo aggiungendo quattro più un po' di incomprensioni e ci dà un'aria.

06:26.840 --> 06:34.160
Il primo passo che farei è molto probabilmente aggiungere una stampa qui, così potrei dire stampa, ehi, cosa

06:34.160 --> 06:35.170
sta succedendo?

06:35.180 --> 06:37.940
Fammi vedere il numero uno e il numero due e cosa mi sta dando.

06:38.950 --> 06:43.010
E la stampa è un modo davvero, molto veloce e semplice per eseguire il debug del codice.

06:43.630 --> 06:48.340
Lo uso sempre, ma PDB ci dà una piccola spinta in più.

06:49.920 --> 06:58.080
Quindi possiamo usarlo in questo modo, importiamo semplicemente PDB e invece di usare qualcosa come una funzione di stampa, possiamo

06:58.620 --> 07:06.840
semplicemente dire lasciami lo spazio qui dentro, possiamo semplicemente dire PDB per il debugger Python e poi dire set, trace

07:06.870 --> 07:14.850
e trace, io direi che è il metodo più utile che abbiamo su questo oggetto PDB che lo

07:14.850 --> 07:15.300
importiamo.

07:16.500 --> 07:18.690
Vedi, quando eseguo il metodo set.

07:22.290 --> 07:28.920
Ora mi dà un debugger Python interattivo che ora posso digitare i comandi qui e testare effettivamente sul mio

07:28.920 --> 07:29.430
codice.

07:30.310 --> 07:37.300
Ed ecco la parte interessante in questo momento in questo PDB, sono proprio all'interno della riga otto, quindi il mio codice ha provato a essere

07:37.450 --> 07:41.660
eseguito, ma poi si è fermato non appena ha detto PDB, ha detto Trace.

07:41.680 --> 07:47.530
E ora sono in questo mondo e posso testare cosa sta succedendo così posso davvero dire, ehi, Namwon, che

07:47.560 --> 07:48.040
cos'è?

07:48.280 --> 07:50.250
Bene, il numero uno è per il numero due?

07:50.860 --> 07:52.570
Bene, il numero due è una stringa.

07:52.570 --> 07:56.410
E potrei essere tipo, oh, sto cercando di aggiungere una stringa e una fine a questo.

07:56.620 --> 07:57.340
Questo non funziona.

07:57.670 --> 07:59.890
Quindi posso rilevare gli errori anche in questo modo.

08:00.760 --> 08:06.070
Ora, questo PDB interattivo ha davvero un sacco di cose utili.

08:06.250 --> 08:08.110
Quindi se scrivo aiuto qui.

08:09.760 --> 08:17.890
Vedete che ho comandi che posso usare nel PDB, quindi ho un sacco di cose a cui ho accesso, cosa che

08:17.890 --> 08:22.870
presumo mi entusiasmerà da questo debugger Python PDB, ma ce l'ho anche.

08:23.790 --> 08:24.540
Cose come.

08:25.460 --> 08:31.280
Diciamo elenco, vediamo cosa fa l'elenco quando digito elenco qui e in questo momento, il sito web è

08:31.280 --> 08:31.760
davvero.

08:32.900 --> 08:35.780
Non mi mostra troppo, ma spero che possa ancora vedere l'elenco.

08:37.210 --> 08:44.350
E immagino una sorta di output, vedo che ottengo un elenco del mio codice e OK, ma diciamo che non so

08:44.350 --> 08:45.820
esattamente cosa fa l'elenco.

08:45.850 --> 08:46.240
Bene.

08:47.350 --> 08:50.830
PDB ci permette di digitare help e poi list.

08:51.770 --> 08:57.530
E quando lo facciamo, in realtà ci fornisce la documentazione, proprio come abbiamo qui.

08:58.730 --> 09:00.650
Se andiamo, diciamo, alla lista.

09:03.300 --> 09:10.530
Vediamo, facciamo una lista svogliata proprio qui, mi dà la documentazione proprio qui, quindi dice list source per

09:10.530 --> 09:11.760
la corrente.

09:12.640 --> 09:12.900
Destra.

09:12.910 --> 09:15.750
Quindi elenca solo il codice sorgente che abbiamo scritto.

09:16.080 --> 09:16.990
OK, va bene.

09:17.130 --> 09:18.030
Cosa altro c'è?

09:19.160 --> 09:25.160
Bene, abbiamo anche qualcosa come Step o S in breve e step è davvero, davvero fantastico.

09:27.090 --> 09:33.150
In realtà usiamo Clear per portarlo in alto, quindi dirò clear in modo che cancelli tutte le

09:33.150 --> 09:33.540
interruzioni.

09:35.450 --> 09:36.050
Facciamo.

09:37.420 --> 09:40.920
Rendiamolo un po' più grande così puoi vedere che ci sei, è meglio, giusto?

09:40.950 --> 09:47.140
Quindi ora posso effettivamente fare qualcosa come Step and Step ci permetterà di passare alla riga successiva.

09:47.170 --> 09:49.660
Quindi, di nuovo, se lo rendiamo un po' più grande.

09:50.950 --> 09:55.510
Step dirà, ehi, vai alla riga nove, quindi vediamo cosa succede, digiterò il passaggio.

09:57.530 --> 09:59.750
Oh, e sono stato accoltellato due volte, un passaggio necessario.

10:01.780 --> 10:08.740
E guarda questo, vado alla riga successiva nel mio cappotto e mi viene, ehi, hai un errore di battitura, l'errore che

10:08.740 --> 10:09.450
abbiamo ottenuto.

10:09.640 --> 10:11.280
Quindi aggiungiamo un'altra riga qui.

10:11.290 --> 10:19.660
Diciamo che stiamo cercando di aggiungere quattro più cinque qui o quattro moltiplicare per cinque e

10:19.660 --> 10:22.180
assegnarlo a una variabile.

10:24.220 --> 10:26.260
Se lo fermo e lo eseguo di nuovo.

10:28.590 --> 10:30.660
Ora sono qui dentro.

10:32.670 --> 10:40.350
Se digito T, ottengo un nome T non definito perché, beh, sono all'interno del codice qui sulla riga otto, ma abbiamo

10:40.350 --> 10:42.480
ancora una riga rossa nove.

10:42.750 --> 10:44.010
Quindi facciamo un passo.

10:45.190 --> 10:46.620
E ora sono dalla parte successiva.

10:48.040 --> 10:56.680
Quindi se non lo faccio ora mi avvicino a 20, fantastico, quindi passo passo passo attraverso il codice, che è davvero, davvero

10:56.680 --> 10:57.380
utile.

10:58.120 --> 11:03.130
Ho anche cose come continue, che mi consente di continuare attraverso il codice fino a quando non

11:03.490 --> 11:06.790
restituisco qualcosa e continuo ed esco da PDB e guardo questo.

11:06.790 --> 11:07.450
Ho il pronto soccorso.

11:10.150 --> 11:17.260
Eseguiamolo di nuovo, un altro comando utile è a e A in realtà mi fornisce tutti gli argomenti della funzione corrente in

11:17.260 --> 11:18.500
cui ci troviamo.

11:18.640 --> 11:19.720
Quindi guarda quello.

11:19.720 --> 11:22.460
Ricevo tutti gli argomenti, il che, ancora una volta, è davvero utile.

11:23.380 --> 11:25.000
C'è anche il comando W.

11:26.000 --> 11:30.890
Il che mi mostra il contesto della riga corrente che sta eseguendo.

11:32.310 --> 11:35.520
Quindi puoi vedere qui dove siamo, siamo nell'annuncio.

11:36.320 --> 11:36.860
Funzione.

11:38.270 --> 11:43.610
L'abbiamo chiamato con questi argomenti e ora stiamo per eseguire questa linea.

11:46.050 --> 11:51.450
E poi finalmente, mentre ne stiamo discutendo, va bene, penso di aver finalmente

11:51.450 --> 11:59.300
capito che abbiamo un'aria, avremmo dovuto dargli un numero così ora posso uscire da qui e aggiustarlo semplicemente a cinque.

11:59.790 --> 12:05.280
Quindi ora posso semplicemente rimuovere il mio PDB e tutto dovrebbe funzionare correttamente con il mio codice.

12:06.670 --> 12:07.070
Stupendo.

12:07.900 --> 12:14.020
Quindi PDB è fantastico per passare attraverso il codice, eseguire il debug e provare cose diverse,

12:14.020 --> 12:20.420
richiede un po' di pratica, ma dopo una giornata passata a giocare con PDB, diventerai davvero molto bravo.

12:21.100 --> 12:28.750
Quindi, dopo questo video, ti consiglio di scrivere PDB e si spera che tu abbia un file Python abbastanza grande.

12:28.750 --> 12:35.500
Possono semplicemente scavalcare e sperimentare diversi comandi, usando l'aiuto, usando l'elenco per vedere cosa hai

12:35.530 --> 12:36.840
a disposizione.

12:37.960 --> 12:44.010
In realtà voglio mostrarti un'ultima cosa, quindi diciamo che torniamo al nostro codice, il nostro PDB ha detto Trace, faccio clic

12:44.830 --> 12:45.640
su Esegui.

12:47.720 --> 12:56.390
Potrei fare qualcosa del genere in cui noto che scrivo e ho tutto scritto, il mio codice funziona, ma potrei cambiare il numero due in

12:56.390 --> 13:00.160
modo che ora sia uguale a un po' di incomprensioni?

13:02.310 --> 13:04.140
Bene, vediamo se lo faccio adesso.

13:06.060 --> 13:08.550
E facciamo il prossimo per eseguire questa riga finale.

13:10.140 --> 13:18.810
Ci entro, quindi sono anche in grado di cambiare le variabili qui e scrivere codice Python per forse testare le mie

13:18.810 --> 13:19.570
funzioni.

13:19.770 --> 13:21.180
Questo ora funziona.

13:21.180 --> 13:25.140
Posso provare, ehi, cosa succede se cambiamo questa variabile con un altro valore?

13:26.180 --> 13:27.890
Ancora una volta, molto, molto utile.