Dela via

Självstudie: Kör kod i felsökningsprogrammet i Visual Studio

  • Artikel

I den här artikeln beskrivs steg 4 i självstudieserien Arbeta med Python i Visual Studio.

Visual Studio innehåller funktioner för att hantera projekt, en omfattande redigeringsupplevelse, interaktivt fönsteroch fullständig felsökning för Python-kod. I steg 4 i den här självstudieserien använder du felsökningsprogrammet för att köra koden steg för steg, inklusive varje iteration av en loop. I felsökningsprogrammetkan du pausa programmet när vissa villkor är uppfyllda. När som helst när programmet pausas kan du undersöka hela programtillståndet och ändra värdet för variabler. Sådana åtgärder är viktiga för att spåra programbuggar och ger även användbara hjälpmedel för att följa det exakta programflödet.

I steg 4 i självstudien lär du dig att:

  • Kör Python-kod i Felsökningsprogram i Visual Studio
  • Ange brytpunkter och villkor
  • Granska programtillstånd och ändringsvariabler
  • Utforska felsökningsprogram fönster och åtgärder

Förutsättningar

Förbereda Python-filen

Du kan förbereda dig för felsökningsövningen genom att följa dessa steg för att uppdatera Python-projektfilen så att den innehåller mer robust kod:

  1. Öppna Python-projektfilen (.py) i redigeraren.

  2. Ersätt koden i filen med följande kod. Den här versionen av koden expanderar funktionen make_dot_string så att du kan undersöka dess diskreta steg i felsökningsprogrammet. Den flyttar for-loopen till en main funktion och kör den explicit genom att anropa funktionen 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()

Börja felsöka

Nu är du redo att börja kontrollera din uppdaterade Python-kod i felsökningsprogrammet.

  1. Bekräfta att koden fungerar korrekt genom att välja Felsök>Starta felsökning i verktygsfältet eller använd kortkommandot F5. Dessa kommandon kör koden i felsökningsprogrammet.

    Felsökaren identifierar inga problem, så programmet körs korrekt. Ett utdatafönster öppnas och du ser några iterationer av cosininvågmönstret. Välj valfri nyckel för att stänga utdatafönstret.

    Tips

    Om du vill stänga utdatafönstret automatiskt när programmet har slutförts väljer du Verktyg>Alternativ, expanderar fliken Python>Felsökning och avmarkerar alternativet Vänta på indata när processen avslutas normalt alternativet.

  2. Ange en brytpunkt för for-loop-instruktionen med någon av följande metoder:

    • Välj i vänstermarginalen för kodraden.
    • Högerklicka på kodraden och välj Brytpunkt>Infoga brytpunkt.
    • Placera insättningsreglaget i kodraden och välj Felsöka>Växla brytpunkt (eller använd kortkommandot F9).

    Brytpunkter stoppar körningen av kod vid en markerad punkt så att du kan kontrollera programtillståndet. En röd punkt visas på varje rad som har en angivet brytpunkt.

    Skärmbild som visar hur du anger en brytpunkt i felsökningsprogrammet i Visual Studio.

  3. Starta felsökaren igen (F5). Koden som körs för programmet stoppas på raden med den angivna brytpunkten. Nu kan du inspektera anropsstacken och undersöka variabler för det här tillståndet för programkoden som körs.

    Visual Studio innehåller många sätt att observera programkod och körningsdata, inklusive följande fönster:

    • -anropsstacken visar historiken för funktions- och metodanrop av programkoden.
    • Definierade variabler som ligger inom omfånget visas i fönstret Autos.
    • Vyn Locals visar alla variabler som Visual Studio hittar i det aktuella omfånget (inklusive funktioner), även innan de definieras i koden.

    Om du vill se en fullständig lista över tillgängliga fönster och åtgärder väljer du Felsöka>Windows.

    Du kan öppna felsökningsprogrammet fönster för att visa programtillståndet när en brytpunkt påträffas:

    Skärmbild av de felsökningsfönster som visar programtillståndet när Visual Studio stoppas vid en angivet brytpunkt.

Använd felsökningsåtgärder

När Visual Studio stoppar kodkörningen vid en brytpunkt finns det flera kommandon som du kan använda för att gå igenom koden eller köra kodblock innan du bryter igen. Kommandona är tillgängliga på några platser i Visual Studio, inklusive verktygsfältet för Felsökningsprogram, menyn Felsöka, snabbmenyn vid högerklick i kodredigeraren, och via kortkommandon.

Verktygsfältet Felsökningsprogram längst upp i Visual Studio-fönstret ger snabb åtkomst till de vanligaste felsökningskommandona:

Skärmbild av felsökningsverktygsfältet i Visual Studio.

I följande tabell sammanfattas dessa kommandon så som de visas från vänster till höger i verktygsfältet:

Åtgärd Genväg Beskrivning
Fortsätt F5 Kör kod tills du når nästa brytpunkt eller tills programmet har slutförts.
Bryt Alla Ctrl+Alt+Break Pausa ett tidskrävande program.
Sluta felsöka Shift+F5 Stoppa programmet vid den aktuella punkten och avsluta felsökningsprogrammet.
Starta om Ctrl+Shift+F5 Stoppa programmet vid den aktuella tidpunkten och starta om programkörningen från början i felsökningsprogrammet.
Visa nästa instruktion Alt+Num+\ Gå tillbaka till nästa sats som ska köras i koden. Det här kommandot hjälper dig att hitta den plats i koden där Debuggern stoppas.
Kliv in i F11 Kör nästa instruktion och stoppa. Om nästa instruktion är ett anrop till en funktion stegar felsökningsprogrammet in i funktionen och stannar vid den första raden.
steg över F10 Kör nästa instruktion, inklusive att göra ett anrop till en funktion (köra all dess kod) och använda dess returvärde. Med det här kommandot kan du enkelt hoppa över funktioner som du inte behöver felsöka.
Steg Ut Shift+F11 Kör koden till slutet av den aktuella funktionen och gå sedan till anropande instruktion och pausa. Det här kommandot är användbart när du inte behöver felsöka resten av den aktuella funktionen.

Följ dessa steg för att arbeta med felsökningsprogrammet åtgärder i Python-koden:

  1. Stega över for-loop-instruktionen med hjälp av åtgärden Steg över.

    Att stega gör att felsökningsprogrammet att köra den aktuella kodraden, inklusive alla som kallas funktion, och omedelbart pausa igen. När du har stegat över ser du att variabeln i nu har definierats i Locals och Autos windows.

  2. Step Over nästa kodrad, som anropar funktionen make_dot_string.

    I det här fallet gör Step Over så att felsökningsprogrammet kör hela make_dot_string-funktionen och pausar när den återvänder från funktionen. felsökningsprogrammet stoppas inte i funktionen om inte en separat brytpunkt finns där.

  3. Fortsätt att stega över koden några gånger till och se hur värdena i fönstret Locals eller Autos ändras.

  4. I fönstret Locals eller Autos dubbelklickar du på kolumnen Value för att redigera värdet. I det här exemplet ändrar du värdet för variabeln s till 'Hello, Python Application'. Se till att omsluta värdet med enkla citattecken. Välj Ange eller ett område utanför värdet för att tillämpa ändringarna.

    Skärmbild som visar hur du ändrar värdet för en variabel i fönstret Lokalt under felsökning i Visual Studio.

  5. Fortsätt att gå igenom koden med hjälp av Step Into tills anropet till funktionen make_dot_string.

    För en funktion Steg in i gör Debuggern att den både anropar funktionen och går in i funktionskoden. När felsökningsprocessen finns i en funktion kan du undersöka dess lokala variabler och gå igenom koden specifikt. I det här exemplet flyttas åtgärden Step into till funktionen make_dot_string.

  6. Fortsätt att stega med Step Into tills returen från funktionen make_dot_string.

    När du når slutet av make_dot_string-funktionskoden returnerar nästa steg *felsökningsprogrammet till for-loopen med det nya returvärdet i variabeln s.

    När du går tillbaka till print-instruktionen ser du att åtgärden Step Into på print-instruktionen inte ingår i den funktionen. Det här beteendet beror på att funktionen print inte är skriven i Python. Det är inbyggd kod i Python-körningen.

  7. Fortsätt att använda Step Into tills du återigen går in i funktionen make_dot_string och använd sedan Step Out och observera att Felsökningsprogrammet återgår till for-loopen.

    Med Step Outkör Felsökningsprogrammet resten av funktionen och pausar sedan automatiskt i den anropande koden. Den här åtgärden är användbar när du har gått igenom steg för steg av en del av en lång funktion och vill avsluta observationen av den. Steg ut steg genom den återstående koden eller tills den når en explicit brytpunkt som angetts i den anropande koden.

  8. Fortsätt att köra programmet tills nästa brytpunkt nås med hjälp av Fortsätt (F5). Eftersom du har en brytpunkt i for-loopen kommer du att avbryta nästa iteration.

    Du kan bekräfta att programmet fortsätter att köras genom att observera det ändrade värdet för variabeln s i fönstret Locals.

Använd brytpunktsvillkor

Det kan vara tråkigt att gå igenom hundratals iterationer av en loop, så med Visual Studio kan du lägga till ett villkor till en brytpunkt. När du anger ett brytpunktsvillkor pausar felsökningsprogrammet programmet endast vid brytpunkten när villkoret uppfylls.

Följande steg visar hur du definierar ett brytpunktsvillkor för for-loop-instruktionen så att felsökningsprogrammet pausar endast när värdet för variabeln i överskrider 1600:

  1. Om du vill ange brytpunktsvillkoret högerklickar du på den röda brytpunktspunkten och väljer Villkor eller använder kortkommandot Alt+F9>C.

  2. I popup-fönstret Brytpunktsinställningar konfigurerar du följande inställningar för att skapa Villkor:

    1. Ange villkorstypen till villkorsuttryck.

    2. Definiera villkorsutvärderingen till Är sant.

    3. Ange i > 1600 som villkorsvärde.

    4. Välj Stäng.

    Skärmbild som visar hur du anger en villkorlig brytpunkt i felsökningsprogrammet i Visual Studio.

  3. Välj F5 för att fortsätta felsökningen och programkörningen. Observera att programmet kör många iterationer innan det når den villkorliga brytpunkten.

    Du kan bekräfta att felsökaren pausar programmet korrekt när det når den villkorliga brytpunkten. När villkoret uppfylls visar variabelvärdet i som 1608i fönstret Locals.

  4. Om du vill köra programmet till slutförande kan du inaktivera brytpunkten och fortsätta programkörningen.

    1. Hovra över den röda punkten och välj Inaktiveraeller högerklicka på den röda punkten och välj Inaktivera brytpunkt.

    2. Välj Fortsätt (eller tryck på F5) för att köra programmet.

    När programmet är slut stoppar Visual Studio felsökningssessionen och återgår till redigeringsläge.

    Du kan också ta bort en brytpunkt. Välj den röda punkten eller högerklicka på punkten och välj Ta bort brytpunkt. Den här åtgärden tar också bort alla definierade villkor.

Tips

I vissa situationer, till exempel om python-tolken inte kan startas, kan Python-utdatafönstret stängas omedelbart efter att programmet har avslutats utan att pausa och visa uppmaningen Tryck på valfri tangent för att fortsätta. För att framtvinga en paus och en prompt, lägg till argumentet -i i fältet Kör>tolkningsargument på fliken Felsökning. Detta argument sätter Python-tolken i interaktivt läge efter att koden har körts. Programmet väntar på att du ska välja Ctrl+Z+Retur för att stänga fönstret.

Nästa steg

Steg 5: Installera paket och hantera Python-miljöer