Feilsøking med IDLE: Finn og reparer feil i din Python -kode

Denne artikkelen ble publisert som en del av Data Science Blogathon

Introduksjon

Alle gjør feil - selv erfarne profesjonelle utviklere, og Python og flinke til å fange dem. La oss se hvordan det fungerer.

Å identifisere feil kalles feilsøking, og en feilsøking er et verktøy som hjelper til med å forstå årsaken til at de oppstår. Evnen til å finne og rette feil i koden er en viktig ferdighet i arbeidet til en programmerer, ikke forsøm det.

TOMGANG (Integrated Development and Learning Environment) er et integrert utviklings- og læringsmiljø på tvers av plattformer for Python, opprettet av Guido van Rossum.

Bruk vinduet for feilsøkingskontroll

Det viktigste feilsøkingsgrensesnittet i IDLE er vinduet Debug Control. Du kan åpne den ved å velge Debug → Debugger -elementet i den interaktive vindusmenyen.

Merk: Hvis feilsøking ikke er på menylinjen, må du kontrollere at det interaktive vinduet har fokus.

Oversikt over vinduer for feilsøkingskontroll

For å se hvordan feilsøkingsprogrammet fungerer, la oss skrive et enkelt program uten feil.

for i i området (1, 4): j = i * 2 utskrift (f "i er {i} og j er {j}")

Lagre alt, åpne et feilsøkingsvindu og trykk på F5 - utførelsen er ikke fullført.

Debug -vinduet vil se slik ut:

SOURCE

Vær oppmerksom på at linjen øverst i vinduet inneholder meldingen:

> '__main __'. (), linje 1: for i i området (1, 4):

La oss dechifrere koden for i i området (1, 4): har ikke blitt lansert ennå, men '__main __'. Modul () rapporterer at vi for øyeblikket er i hoveddelen av programmet, og ikke i definisjonen av funksjon.

Under stabelruten er ruten Lokalbefolkning, som viser rare ting: __annotasjoner__, __builtins__, __doc__, etc. er interne systemvariabler som kan ignoreres foreløpig. Når programmet kjører, vil variablene som er deklarert i koden og som vises i dette vinduet, hjelpe deg med å holde oversikt over verdiene.

I øvre venstre hjørne av vinduet er det fem knapper: Gå, Trinn, Over, Ut og Avslutt - de styrer bevegelsen av feilsøkingsprogrammet gjennom koden.

I de følgende avsnittene lærer du hva hver av disse knappene gjør.

Trinn -knapp

Trykk på Step og feilsøkingsvinduet vil se slik ut:

SOURCE

Legg merke til to forskjeller. Først har meldingen i stabelruten endret seg:

> '_ _ hoved _'. (), linje 2: j = i * 2:

På dette tidspunktet blir linje 1 utført og feilsøkingsprogrammet stopper før linje 2 utføres.

For det andre en ny variabel i med verdien 1 i lokalbefolkningspanelet. For -løkken på linje 1 opprettet en variabel og tildelte den verdien.

Fortsett å trykke på trinn -knappen for å gå gjennom koden linje for linje og se hva som skjer i feilsøkingsvinduet. Når du kommer til linjeutskriften (f ”i er {i} og j er {j}”), kan du se utgangen som vises i det interaktive vinduet en bit om gangen.

Det viktige her er at du kan holde oversikt over de økende verdiene til i og j når du går gjennom en loop. Dette er en nyttig funksjon for å finne kilden til feil i koden. Å kjenne betydningen av hver variabel i hver kodelinje kan hjelpe til med å finne problemområdet.

Brytepunkter og Go -knappen

Ofte vet du at en feil skal vises i et bestemt stykke kode, men du vet ikke nøyaktig hvor. Brytpunkter forteller debuggeren når kodeutførelsen skal settes på pause, slik at du kan ta en titt på programmets nåværende tilstand.

For å angi et brytpunkt, høyreklikk (Ctrl for Mac) på kodelinjen du vil sette på pause, og velg Angi brytepunkt-IDLE vil markere linjen med gult. For å fjerne det, velg Clear Breakpoint.

Sett et brytpunkt på linjen med utskriften (). Se nå redigeringsvinduet:

SOURCE

Lagre og kjør. Som før indikerer den stablede linjen at feilsøkingsprogrammet kjører og venter på linje 1. For å gå videre trykker du bare på Go -knappen:

SOURCE

Nå på stabelpanelet er det informasjon om utførelsen av linje 3:

> '_main _'. (), linje 3: print (f "i er {i} og j er {j}")

I lokalbefolkningspanelet vil vi se at variablene i og j har henholdsvis verdiene 1 og et par. Klikk på Go -knappen og be debuggeren om å kjøre koden til breakpointet eller toppen av programmet. Trykk på retur - feilsøkingsvinduet ser nå slik ut:

SOURCE

Stabelruten viser samme melding som før - feilsøkingsprogrammet venter på linje 3. Verdiene til i og j er nå 2 og 4. Trykk på knappen en tredje gang. Nå er i og j 3 og 6. Trykk på Go igjen for å avslutte programmet.

Over og ut

Over -knappen fungerer som en kombinasjon av Step and Go - den går over en funksjon eller loop. Med andre ord, hvis du skal gå inn i en funksjon ved hjelp av feilsøkingsprogrammet, trenger du ikke å kjøre koden til denne funksjonen - Over -knappen vil føre direkte til resultatet av utførelsen.

På samme måte, hvis du allerede er inne i en funksjon eller sløyfe, kjører Out -knappen resten av koden inne i funksjonen eller sløyfen.

I den neste delen vil vi utforske noen av feilene og lære hvordan du fikser dem ved å bruke IDLE.

Bekjempelse av insekter

La oss ta eksemplet på et enkelt og buggy program.

Metoden add_underscores () definerer nedenfor som å godta en streng som et argument og returnere en ny streng besto av understrek før og etter hvert tegn. For eksempel vil den add_underscores ("python") returnere «_p_y_t_h_o_n_».

Her er den ødelagte koden:

def add_underscores (word): new_word = "_" for i in range (len (word)): new_word = word [i] + "_" return new_word phrase = "hallo" print (add_underscores (setning))

Skriv inn denne koden i editoren, lagre og trykk F5. Forventet utskrift er _h_e_l_l_o_, men o_ skrives ut i stedet.

Hvis du finner ut hva problemet er, må du ikke fikse det. Målet vårt er å lære å bruke IDLE til dette.

La oss vurdere fire stadier av feilsøk:

• gjett hvor feilen kan være;

• sett et brytpunkt og sjekk kodelinjen om gangen;

• definere linjen og gjøre endringer;

• gjenta trinn 1-3 til koden fungerer.

Trinn 1: Gjett

Du vil ikke kunne finne den nøyaktige plasseringen av feilen først, men det er vanligvis lettere å logisk forestille deg hvilken del av koden du skal se på.

Vær oppmerksom på at programmet er delt inn i to seksjoner: definisjonen av funksjonen add_underscores () og hovedblokken, som definerer en variabel med verdien “hei” og sender ut resultatet.

La oss nå se koden for hovedseksjonen:

phrase = "hallo" print (add_underscores (phrase)) Selvfølgelig er alt bra her, og problemet bør ligge i definisjonen av funksjonen: def add_underscores (word): new_word = "_" for i in range (len (word) ): new_word = word [i] + "_" returner new_word

Den første linjen oppretter varianten new_word med verdien "_". Frøken, problemet er et sted i kroppen for en sløyfe.

Trinn 2: breakpoint

Når du har identifisert hvor feilen kan være, setter du et brytpunkt i begynnelsen av for -løkken for å holde oversikt over hva som skjer inne i koden:

SOURCE

La oss begynne. Utførelsen stopper på linjen med funksjonsdefinisjonen.

Klikk på Go -knappen for å utføre koden opp til brytpunktet:

SOURCE

Koden stopper før for -løkken i add_underscores () -funksjonen. Vær oppmerksom på at lokalbefolkningspanelet viser to lokale variabler - et ord med verdien "hei" og nytt_ord med verdien "_"

Klikk på trinn -knappen for å gå inn for en loop. Debug -vinduet endres, og derfor vises den nye i -variabelen med verdien 0 i lokalbefolkningspanelet:

Variabelen i er en teller for for loop som du kan bruke til å holde oversikt over den gjeldende aktive iterasjonen.

SOURCE

Trykk på trinn -knappen igjen og se på lokalbefolkningspanelet - variabelen new_word er satt til "h_":

SOURCE

Dette er feil, og årsaken til dette er først new_word verdien er “_”, på den andre iterasjonen er verdien “_h_”. Hvis vi trykker på Step noen ganger til, ser vi at new_word inneholder verdien e_, deretter l_, og så videre.

Trinn 3: Identifiser feilen og fikse den

Som vi allerede har funnet ut, overskrives new_word med hver iterasjon av løkken med det neste tegnet i linjen "hei" og en understreking. Siden det bare er en kodelinje inne i løkken, bør problemet være der:

new_wor = ord [i] + "_"

Koden forteller Python å få det neste ordtegnet, legge ved en understreking og tilordne newline til variabelen new_word. Dette er akkurat feil oppførsel som vi har observert.

For å fikse alt må du kombinere ordet [i] + “_” med den eksisterende verdien new_word. Klikk på Avslutt -knappen i feilsøkingsvinduet, men ikke lukk den. Åpne et redigeringsvindu og endre linjen inne i for -sløyfen til følgende:

nytt_ord = nytt_ord + ord [i] + "_"

Debugger byttet bare når den var inaktiv!

Trykk alltid på Gå eller Avslutt -knappen når du er ferdig med feilsøking, ellers kan du få problemer med å starte den på nytt.

Trinn 4: Gjenta trinn 1-3 til feilen forsvinner

Lagre endringer i programmet og kjør det igjen. I feilsøkingsvinduet klikker du på Go -knappen for å utføre koden opp til brytepunktet. Trykk på trinn flere ganger og se hva som skjer med varianten new_word ved hver iterasjon - alt fungerer unødvendig å si. Noen ganger er det nødvendig å gjenta denne prosessen flere ganger før feilen er løst.

Alternative måter å finne feil på

Å bruke feilsøkingsprogrammet kan være vanskelig og tidkrevende, men det er den mest pålitelige måten å finne feil i koden din. Debuggere er imidlertid ikke alltid tilgjengelige. I slike situasjoner bruker du utskriftsfeilsøking for å finne feil i koden din. PD bruker funksjonen print () til å vise tekst til konsollen som angir hvor programmet kjøres og variabelenes tilstand.

Bare som et eksempel kan koden nedenfor legges til på slutten av løkken for feilsøking:

print (f "i = {i}; new_wor = {new_wor}")

Den endrede koden vil se slik ut:

def add_underscores (word): new_wor = "_" for i in range (len (word)): new_wor = word [i] + "_" print (f "i = {i}; new_word = {new_wor}") return new_wor phrase = "hei" -utskrift (add_underscores (setning))

Utgangen skal se slik ut:

i = 0; new_wor = h_ i = 1; new_wor = e_ i = 2; new_wor = l_ i = 3; new_wor = l_ i = 4; ny_verden = o_ o_

PD fungerer, men har flere ulemper sammenlignet med feilsøking med en feilsøkingsprogram. Du bør kjøre hele programmet hver gang du vil kontrollere verdiene til variabler, og husk å fjerne anrop til funksjoner for utskrift ().

En måte å forbedre sløyfen vår på er å iterere over tegn i et ord:

def add_underscores (word): new_wor = "_" for bokstav i word: new_wor = new_wor + bokstav + "_" return new_wor

konklusjonen

Nå vet du alt om DLE -feilsøking. Du kan bruke dette prinsippet med forskjellige feilsøkere.

I denne teksten dekket vi de påfølgende emnene:

• bruk av feilsøkingsvinduet;

• sette et brytpunkt for en dyp forståelse av hvordan koden fungerer;

• bruk av knappene Step, Go, Over og Out;

Ikke slutte å lære og øve på feilsøking - det er gøy! og nå meg på LinkedIn på https://www.linkedin.com/in/shivani-sharma-aba6141b6/

Media vist i denne artikkelen eies ikke av Analytics Vidhya og brukes etter forfatterens skjønn.

I slekt

Kilde: https://www.analyticsvidhya.com/blog/2021/08/debugging-with-idle-find-and-fix-bugs-in-your-python-code/