Esercitazione: Eseguire il codice nel debugger in Visual Studio

Articolo
2025-01-26

Questo articolo presenta il passaggio 4 della serie di esercitazioni Usare Python in Visual Studio.

Visual Studio offre funzionalità per gestire progetti, un'esperienza di modifica avanzata, la finestra interattiva e il debug completo per il codice Python. Nel passaggio 4 di questa serie di esercitazioni si usa il debugger per eseguire il codice in modo dettagliato, inclusa ogni iterazione di un ciclo. Nel debugger è possibile sospendere il programma ogni volta che sono soddisfatte determinate condizioni. In qualsiasi momento, quando il programma viene sospeso, è possibile esaminare l'intero stato del programma e modificare il valore delle variabili. Tali azioni sono essenziali per tenere traccia dei bug del programma e forniscono anche utili strumenti per seguire il flusso esatto del programma.

Nel passaggio 4 dell'esercitazione si apprenderà come:

Eseguire il codice Python nel debugger in Visual Studio
Impostare punti di interruzione e condizioni
Esaminare lo stato del programma e modificare le variabili
Esplora le finestre e le azioni del Debugger

Prerequisiti

Un progetto di applicazione Python con un file Python (.py) con codice creato in Passaggio 2: Scrivere ed eseguire codice Python ed Passaggio 3: Usare la finestra INTERATTIVA REPL di questa esercitazione.

Preparare il file Python

Per preparare l'esercizio di debug, seguire questa procedura per aggiornare il file di progetto Python in modo da includere codice più affidabile:

Aprire il file di progetto Python (.py) nell'editor.

Sostituire il codice nel file con il codice seguente. Questa versione del codice espande la funzione make_dot_string in modo da poter esaminare i passaggi discreti nel debugger. Sposta il ciclo for in una funzione main ed esegue in modo esplicito chiamando la funzione main:

from math import cos, radians

# Create a string with spaces proportional to a cosine of x in degrees
def make_dot_string(x):
    rad = radians(x)                             # cos works with radians
    numspaces = int(20 * cos(rad) + 20)          # Scale to 0-40 spaces
    st = ' ' * numspaces + 'o'                   # Place 'o' after the spaces
    return st

def main():
    for i in range(0, 1800, 12):
        s = make_dot_string(i)
        print(s)

main()

Avviare il debug

A questo punto è possibile iniziare a controllare il codice Python aggiornato nel debugger .

Verificare che il codice funzioni correttamente selezionando Debug>Avvia debug sulla barra degli strumenti o usando il tasto di scelta rapida F5. Questi comandi eseguono il codice nel debugger .

Il debugger non rileva problemi, quindi il programma viene eseguito correttamente. Si apre una finestra di output e vengono visualizzate alcune iterazioni del modello di onda coseno. Selezionare qualsiasi chiave per chiudere la finestra di output.

Suggerimento

Per chiudere automaticamente la finestra di output al termine del programma, selezionare Strumenti>Opzioni, espandere la schedaDebugging Python> e deselezionare l'opzione Attendere l'input quando il processo si chiude normalmente.
Impostare un punto di interruzione nell'istruzione ciclo for usando uno dei metodi seguenti:
- Selezionare nel margine sinistro la riga di codice.
- Fare clic con il pulsante destro del mouse sulla riga di codice e selezionare punto di interruzione>Inserisci punto di interruzione.
- Posizionare il cursore di inserimento nella riga di codice e selezionare Debug>Attiva/Disattiva punto di interruzione (o usare la scorciatoia da tastiera F9).
I punti di interruzione arrestano l'esecuzione del codice in un punto contrassegnato in modo da poter controllare lo stato del programma. Viene visualizzato un punto rosso su ogni riga con un punto di interruzione impostato.
Avvia di nuovo il debugger (F5). Il codice in esecuzione per il programma si arresta sulla riga con il punto di interruzione impostato. È ora possibile esaminare lo stack di chiamate ed esaminare le variabili per questo stato del codice del programma in esecuzione.

Visual Studio offre molti modi per osservare il codice del programma e i dati di esecuzione, incluse le finestre seguenti:
- Il stack di chiamate mostra la cronologia delle chiamate di funzione e metodo dal codice del programma.
- Le variabili definite nel contesto vengono visualizzate nella finestra auto.
- La vista Locals mostra tutte le variabili che Visual Studio trova nell'ambito attuale (incluse le funzioni), anche se non ancora definite nel codice.
Per visualizzare l'elenco completo delle finestre e delle azioni disponibili, selezionare Debug>Windows.

È possibile aprire le finestre Debugger per visualizzare lo stato del programma quando viene rilevato un punto di interruzione:

Usare le azioni del debugger

Quando Visual Studio arresta l'esecuzione del codice in un punto di interruzione, è possibile usare diversi comandi per scorrere il codice o eseguire blocchi di codice prima di interrompere di nuovo. I comandi sono disponibili in alcune posizioni in Visual Studio, tra cui la barra degli strumenti Debugger, il menu Debug, il menu contestuale del clic destro nell'editor di codice e tramite le scorciatoie da tastiera.

La barra degli strumenti debugger nella parte superiore della finestra di Visual Studio consente di accedere rapidamente ai comandi di debug più comuni:

La tabella seguente riepiloga questi comandi così come vengono visualizzati da sinistra a destra sulla barra degli strumenti:

Azione	Scorciatoia	Descrizione
Continua	F5	Eseguire il codice fino a raggiungere il punto di interruzione successivo o fino al completamento del programma.
interrompi tutto	Ctrl+Alt+Pausa	Sospendere un programma a esecuzione prolungata.
Arrestare il Debug	Shift+F5	Arresta il programma al punto corrente ed esci dal debugger .
Riavvia	CTRL+MAIUSC+F5	Fermare il programma al punto attuale e riavviare l'esecuzione del programma dall'inizio nel debugger .
Mostra dichiarazione successiva	Alt+Num+\	Tornare all'istruzione successiva da eseguire nel codice. Questo comando consente di individuare la posizione nel codice in cui il Debugger è arrestato.
Entra in	F11	Esegui l'istruzione successiva e fermati. Se l'istruzione successiva è una chiamata a una funzione, Debugger entra nella funzione e si arresta alla prima riga.
Passa sopra	F10	Eseguire l'istruzione successiva, inclusa l'esecuzione di una chiamata a una funzione (che esegue tutto il codice) e l'applicazione di qualsiasi valore restituito. Questo comando consente di ignorare facilmente le funzioni di cui non è necessario eseguire il debug.
Fai un passo fuori	Maiusc+F11	Eseguire il codice fino alla fine della funzione corrente, quindi passare all'istruzione chiamante e sospendere. Questo comando è utile quando non è necessario eseguire il debug del resto della funzione corrente.

Per usare Debugger azioni nel codice Python, seguire questa procedura:

Esegui il passaggio oltre l'istruzione del ciclo for utilizzando l'azione Passa Sopra.

L'esecuzione passo a passo fa sì che il debugger esegua la riga di codice corrente, inclusa qualsiasi funzione chiamata, e poi si sospenda immediatamente. Dopo aver effettuato il passaggio, notare che la variabile i è ora definita nelle finestre Variabili Locali e Variabili Automatiche.
Step Over la riga di codice successiva, che chiama la funzione make_dot_string.

In questo caso, Passaggio Su causa al debugger di eseguire la funzione make_dot_string completa e si sospenda dopo il ritorno dalla funzione. Il Debugger non si arresta all'interno della funzione, a meno che non esista un punto di interruzione separato.
Continua a far avanzare il codice alcune volte e osserva come cambiano i valori nella finestra Locals o Automatica.
Nella finestra Variabili locali o Variabili automatiche, fare doppio clic sulla colonna Valore per modificare il valore di una variabile. In questo esempio modificare il valore della variabile s in 'Hello, Python Application'. Assicurarsi di racchiudere il valore tra virgolette singole. Selezionare Immettere o qualsiasi area esterna al valore per applicare le modifiche.
Continuare a eseguire passo-passo il codice usando Step Into fino alla chiamata alla funzione make_dot_string.

Per una funzione, Esegui istruzione in fa sì che il Debugger chiami la funzione ed entri anche nel codice della funzione. Quando il processo di debug si trova all'interno di una funzione, è possibile esaminare le variabili locali ed eseguire il codice in modo specifico. In questo esempio, l'azione Passo in entra nella funzione make_dot_string.
Continuare a procedere con Entra in fino al ritorno dalla funzione make_dot_string.

Quando si raggiunge la fine del codice della funzione make_dot_string, il passaggio successivo riporta ilDebugger al ciclo for con il nuovo valore di ritorno nella variabile s.

Quando si torna all'istruzione print, si noti che l'azione Step Into sull'istruzione print non entra in quella funzione. Questo comportamento è dovuto al fatto che la funzione print non è scritta in Python. È codice nativo all'interno del runtime Python.
Continuare a usare Esegui istruzione in fino a quando non si sarà di nuovo all'interno della funzione make_dot_string, quindi usare Esegui uscita e notare che il Debugger ritorna al ciclo for.

Con Step Out, il Debugger esegue il resto della funzione e quindi si mette automaticamente in pausa nel codice chiamante. Questa azione è utile dopo aver eseguito una parte di una funzione lunga e si vuole terminare il monitoraggio della funzione. Uscita dalla funzione scorre attraverso il codice rimanente oppure fino a raggiungere un break point esplicito impostato nel codice chiamante.
Continuare a eseguire il programma fino a raggiungere il punto di interruzione successivo usando Continua (F5). Poiché nel ciclo di for è impostato un punto di interruzione, si interrompe l'iterazione successiva.

È possibile confermare che il programma continui a essere eseguito osservando il valore che cambia per la variabile s nella finestra Variabili Locali di .

Usare le condizioni del punto di interruzione

L'esecuzione di centinaia di iterazioni di un ciclo può essere noiosa, quindi Visual Studio consente di aggiungere una condizione di a un punto di interruzione. Quando si imposta una condizione del punto di interruzione, il debugger sospende il programma in corrispondenza del punto di interruzione solo quando viene soddisfatta la condizione.

I passaggi seguenti illustrano come definire una condizione del punto di interruzione nell'istruzione ciclo for in modo che il debugger sospende solo quando il valore della variabile i supera 1600:

Per impostare la condizione del punto di interruzione, fare clic con il pulsante destro del mouse sul punto di interruzione rosso e selezionare Condizioni oppure usare il tasto di scelta rapida ALT+F9>C.
Nella finestra di dialogo popup Impostazioni punto di interruzione , configurare le seguenti impostazioni per creare la Condizione :
1. Impostare il tipo di condizione su Espressione Condizionale.
2. Definire la valutazione della condizione per cui è vero.
3. Immettere i > 1600 come valore della condizione.
4. Selezionare Chiudi.
Selezionare F5 per continuare il debug e l'esecuzione del programma. Osservare che il programma esegue molte iterazioni prima che raggiunga il punto di interruzione condizionale.

È possibile verificare che il debugger sospende correttamente l'esecuzione del programma quando raggiunge il punto di interruzione condizionale. Quando la condizione è soddisfatta, nella finestra Locals viene visualizzato il valore della variabile i come 1608.
Per eseguire il programma fino al completamento, è possibile disabilitare il punto di interruzione e continuare l'esecuzione del programma.
1. Passare il puntatore del mouse sul punto rosso e selezionare Disabilitaoppure fare clic con il pulsante destro del mouse sul punto rosso e selezionare Disabilita punto di interruzione.
2. Selezionare Continua (oppure premere F5) per eseguire il programma.
Al termine del programma, Visual Studio arresta la sessione di debug e torna alla modalità di modifica.

È anche possibile eliminare un punto di interruzione. Selezionare il punto rosso o fare clic con il pulsante destro del mouse sul punto e selezionare Elimina punto di interruzione. Questa azione elimina anche tutte le condizioni definite.

Suggerimento

In alcune situazioni, come un errore di avvio dell'interprete Python, la finestra di output di Python potrebbe chiudersi immediatamente dopo il completamento del programma senza attendere di visualizzare il prompt Premere un tasto per continuare. Per forzare pausa e richiesta, aggiungere l'argomento -i nel campo Esegui>Argomenti interprete nella scheda Debug. Questo argomento inserisce l'interprete Python in modalità interattiva dopo l'esecuzione del codice. Il programma attende di selezionare CTRL+Z+Invio per chiudere la finestra.

Passaggio successivo

Passaggio 5: Installare i pacchetti e gestire gli ambienti Python

Condividi tramite