Samouczek: uruchamianie kodu w debugerze w programie Visual Studio

Artykuł
2025-01-26

W tym artykule przedstawiono krok 4 z serii samouczków Praca z językiem Python w programie Visual Studio.

Program Visual Studio umożliwia zarządzanie projektami, rozbudowane środowisko edycji, Interaktywne oknoi pełne debugowanie kodu w języku Python. W kroku 4 tej serii samouczków użyjesz debugera , aby uruchomić kod krok po kroku, w tym każdą iterację pętli. W debugerze można wstrzymać program, gdy zostaną spełnione pewne warunki. W dowolnym momencie wstrzymania programu można sprawdzić cały stan programu i zmienić wartość zmiennych. Takie działania są niezbędne do śledzenia błędów w programie i stanowią pomocne narzędzia do śledzenia dokładnego przebiegu programu.

W kroku 4 samouczka dowiesz się, jak wykonywać następujące czynności:

Uruchamianie kodu Python w debugerze w programie Visual Studio
Ustawianie punktów przerwania i warunków
Sprawdzanie stanu programu i zmienianie zmiennych
Eksplorowanie okien i akcji debugera

Warunki wstępne

Projekt aplikacji języka Python z plikiem języka Python (.py) z kodem utworzonym w Krok 2. Pisanie i uruchamianie kodu w języku Python oraz Krok 3. Użyj okna interaktywnego REPL tego samouczka.

Przygotowywanie pliku języka Python

Aby przygotować się do ćwiczenia debugowania, wykonaj następujące kroki, aby zaktualizować plik projektu w języku Python, aby uwzględnić bardziej niezawodny kod:

Otwórz plik projektu języka Python (.py) w edytorze.

Zastąp kod w pliku następującym kodem. Ta wersja kodu rozszerza funkcję make_dot_string, aby można było zbadać jego dyskretne kroki w debugerze. Przenosi pętlę for do funkcji main i uruchamia ją jawnie, wywołując funkcję 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()

Rozpocznij debugowanie

Teraz możesz rozpocząć sprawdzanie zaktualizowanego kodu języka Python w Debugger.

Upewnij się, że kod działa prawidłowo, wybierając pozycję Debuguj>Rozpocznij debugowanie na pasku narzędzi lub użyj skrótu klawiaturowego F5 F5. Te komendy uruchamiają kod w Debugger.

Debuger nie wykrywa żadnych problemów, więc program działa pomyślnie. Zostanie otwarte okno danych wyjściowych i zostanie wyświetlonych kilka iteracji wzorca fali cosinusowej. Wybierz dowolny klucz, aby zamknąć okno danych wyjściowych.

Napiwek

Aby zamknąć okno danych wyjściowych automatycznie po zakończeniu działania programu, wybierz pozycję narzędzia>Options, rozwiń kartę Python>Debugowanie i wyczyść opcję Czekaj na dane wejściowe, gdy proces zakończy się normalnie.
Ustaw punkt przerwania w instrukcji pętli for przy użyciu jednej z następujących metod:
- Wybierz lewy margines wiersza kodu.
- Kliknij prawym przyciskiem myszy wiersz kodu i wybierz Punkt przerwania>Wstaw punkt przerwania.
- Umieść daszek wstawiania w wierszu kodu i wybierz pozycję Debuguj>Przełącz punkt przerwania (lub użyj skrótu klawiaturowego F9 F9).
Punkty przerwania zatrzymują wykonywanie kodu w oznaczonym punkcie, aby można było sprawdzić stan programu. Czerwona kropka pojawia się w każdym wierszu z ustawionym punktem przerwania.
Uruchom ponownie debuger (F5). Uruchomiony kod programu zatrzymuje się w wierszu z ustawionym punktem przerwania. Teraz możesz sprawdzić stos wywołań i sprawdzić zmienne dla tego stanu uruchomionego kodu programu.

Program Visual Studio udostępnia wiele sposobów obserwowania kodu programu i danych wykonywania, w tym następujących okien:
- Stos wywołań pokazuje historię wywołań funkcji i metod według kodu programu.
- Zdefiniowane zmienne, które znajdują się w zakresie, są wyświetlane w oknie Autos.
- Widok Locals pokazuje wszystkie zmienne, które Visual Studio znajduje w bieżącym zakresie (w tym funkcje), nawet zanim zostaną zdefiniowane w kodzie.
Aby wyświetlić pełną listę dostępnych okien i akcji, wybierz pozycję Debugowanie>Windows.

Możesz otworzyć okna debugera, aby wyświetlić stan programu po napotkaniu punktu przerwania:

Korzystanie z akcji debugera

Gdy program Visual Studio zatrzymuje wykonywanie kodu w punkcie przerwania, istnieje kilka poleceń, których można użyć, aby przejść przez kod lub uruchomić bloki kodu przed ponownym przerwaniem. Polecenia są dostępne w kilku miejscach w programie Visual Studio, w tym na pasku narzędzi debugera, menu Debug, menu kontekstowego dostępnego po kliknięciu prawym przyciskiem myszy w edytorze kodu oraz za pomocą skrótów klawiaturowych.

Pasek narzędzi debugera w górnej części okna programu Visual Studio zapewnia szybki dostęp do najczęściej używanych poleceń debugowania:

W poniższej tabeli przedstawiono podsumowanie tych poleceń, które pojawiają się od lewej do prawej na pasku narzędzi:

Akcja	Skrót	Opis
kontynuuj	F5	Uruchom kod do momentu osiągnięcia następnego punktu przerwania lub do momentu ukończenia programu.
Przerwij wszystkie	Ctrl+Alt+Break	Wstrzymaj długotrwały program.
zatrzymaj debugowanie	Shift+F5	Zatrzymaj program w bieżącym punkcie i zamknij Debugger.
uruchom ponownie	Ctrl+Shift+F5	Zatrzymaj program w bieżącym punkcie i uruchom ponownie wykonywanie programu od początku w Debugger.
Pokaż następną instrukcję	Alt++\	Wróć do następnej instrukcji, aby uruchomić kod. To polecenie ułatwia zlokalizowanie miejsca w kodzie, w którym zatrzymano debugera.
Wejdź do	F11	Uruchom następną instrukcję i zatrzymaj. Jeśli następna instrukcja jest wywołaniem funkcji, Debugger wchodzi do funkcji i zatrzymuje się na pierwszej linii.
Krok po	F10	Uruchom następną instrukcję, w tym wywołanie funkcji (uruchamiając cały kod) i stosując dowolną wartość zwracaną. To polecenie umożliwia łatwe pomijanie funkcji, których nie trzeba debugować.
Wyjdź	Shift+F11	Uruchom kod do końca bieżącej funkcji, a następnie przejdź do instrukcji wywołującej i wstrzymaj. To polecenie jest przydatne, gdy nie trzeba debugować pozostałej części bieżącej funkcji.

Wykonaj następujące kroki, aby pracować z akcjami debugera w kodzie Pythona.

Aby przejść do instrukcji pętli for, użyj akcji Krok nad.

Przejście powoduje, że debugger uruchamia bieżący wiersz kodu, w tym dowolną wywoływaną funkcję, i natychmiast wstrzymuje. Po przejściu zwróć uwagę, że zmienna i jest teraz zdefiniowana w oknach Locals i Autos.
Przejdź do następnego wiersza kodu, który wywołuje funkcję make_dot_string.

W tym przypadku powoduje, że debugera uruchomić pełną funkcję make_dot_string i wstrzymać działanie po powrocie z funkcji. Debuger nie zatrzymuje się wewnątrz funkcji, chyba że istnieje tam oddzielny punkt przerwania.
Kontynuuj przechodzenie przez kod jeszcze kilka razy i obserwuj zmianę wartości w oknie Locals lub Autos.
W oknie Locals lub Autos, kliknij dwukrotnie kolumnę Wartość zmiennej, aby edytować jej wartość. W tym przykładzie zmień wartość zmiennej s na 'Hello, Python Application'. Pamiętaj, aby ująć wartość w pojedynczy cudzysłów. Wybierz pozycję Wprowadź lub dowolny obszar poza wartością, aby zastosować zmiany.
Kontynuuj przechodzenie przez kod przy użyciu funkcji Step Into do momentu wywołania funkcji make_dot_string.

W przypadku funkcji Step Into powoduje, że Debugger zarówno wywołuje funkcję, jak i wchodzi w jej kod. Gdy proces debugowania znajduje się wewnątrz funkcji, możesz zbadać jego zmienne lokalne i przejść przez jego kod w szczególności. W tym przykładzie akcja Step into przechodzi do funkcji make_dot_string.
Kontynuuj wykonywanie kroków z Step Into aż do momentu powrotu z funkcji make_dot_string.

Po osiągnięciu końca kodu funkcji make_dot_string, następny krok przekazujeDebugger do pętli for z nową wartością zwrotną w zmiennej s.

Po ponownym kroku do instrukcji print zwróć uwagę, że akcja Step Into w instrukcji print nie wchodzi w tę funkcję. To zachowanie jest spowodowane tym, że funkcja print nie jest napisana w języku Python. Jest to kod natywny wewnątrz środowiska uruchomieniowego języka Python.
Kontynuuj korzystanie z Step Into, aż ponownie znajdziesz się w funkcji make_dot_string, a następnie użyj Step Out i zauważ, że Debugger powraca do pętli for.

W przypadku wybrania komendy Step Out, debugger uruchamia pozostałą część funkcji, a następnie automatycznie wstrzymuje się w obrębie kodu wywołującego. Ta akcja jest przydatna, gdy przejdziesz przez część długiej funkcji i chcesz zakończyć jej obserwację. Krok Wyjścia wykonuje krok po pozostałym kodzie lub do momentu osiągnięcia jawnego punktu przerwania ustawionego w kodzie wywołującym.
Kontynuuj uruchamianie programu do momentu osiągnięcia następnego punktu przerwania przy użyciu Kontynuuj (F5). Ponieważ w pętli for ustawiono punkt przerwania, przerywasz przy następnej iteracji.

Możesz potwierdzić, że program jest nadal wykonywany, obserwując zmianę wartości zmiennej s w oknie Locals.

Użyj warunków punktu przerwania

Przechodzenie przez setki iteracji pętli może być żmudne, więc program Visual Studio umożliwia dodanie warunku do punktu przerwania. Po ustawieniu warunku punktu przerwania Debuger wstrzymuje program w punkcie przerwania tylko wtedy, gdy warunek zostanie spełniony.

W poniższych krokach pokazano, jak zdefiniować warunek punktu przerwania w instrukcji pętli for, aby Debuger wstrzymał się tylko wtedy, gdy wartość zmiennej i przekracza 1600:

Aby ustawić warunek punktu przerwania, kliknij prawym przyciskiem myszy czerwoną kropkę punktu przerwania i wybierz Warunki lub użyj skrótu klawiaturowego Alt+F9>C.
W oknie podręcznym Ustawienia punktu przerwania skonfiguruj następujące ustawienia, aby utworzyć warunek:
1. Ustaw typ warunku na wyrażenie warunkowe.
2. Zdefiniuj ocenę warunku, czy jest prawdziwy.
3. Wprowadź i > 1600 jako wartość warunku.
4. Wybierz Zamknij.
Wybierz pozycję F5, aby kontynuować debugowanie i wykonywanie programu. Zwróć uwagę, że program uruchamia wiele iteracji przed dotarciem do warunkowego punktu przerwania.

Możesz potwierdzić, że Debuger prawidłowo wstrzymuje wykonywanie programu po osiągnięciu warunkowego punktu przerwania. Gdy warunek zostanie spełniony, w oknie Locals zostanie wyświetlona wartość zmiennej i jako 1608.
Aby uruchomić program do ukończenia, możesz wyłączyć punkt przerwania i kontynuować wykonywanie programu.
1. Umieść kursor na czerwonej kropce i wybierz pozycję Wyłącz, lub kliknij prawym przyciskiem myszy czerwoną kropkę i wybierz pozycję Wyłącz punkt przerwania.
2. Wybierz pozycję Kontynuuj (lub naciśnij F5), aby uruchomić program.
Po zakończeniu programu program Visual Studio zatrzymuje sesję debugowania i wraca do trybu edycji.

Można również usunąć punkt przerwania. Wybierz czerwoną kropkę lub kliknij prawym przyciskiem myszy kropkę i wybierz pozycję Usuń punkt przerwania. Ta akcja powoduje również usunięcie wszystkich zdefiniowanych warunków.

Napiwek

W niektórych sytuacjach, takich jak niepowodzenie uruchomienia interpretera języka Python, okno danych wyjściowych języka Python może zostać zamknięte natychmiast po zakończeniu programu bez wstrzymywania i wyświetlania Naciśnij dowolny klawisz, aby kontynuować monitu. Aby wymusić wstrzymanie i monit, dodaj argument -i do pola Run>Interpreter Arguments na karcie Debug. Ten argument umieszcza interpreter języka Python w trybie interaktywnym po uruchomieniu kodu. Program czeka na wybranie ctrl+Z+Enter, aby zamknąć okno.

Następny krok

Krok 5. Instalowanie pakietów i zarządzanie środowiskami języka Python

Udostępnij za pośrednictwem