5.1 DRILL — Kodesporing: «hva skrives ut / returneres?»
Systematisk drill i å kjøre kode mekanisk i hodet og angi resultatet nøyaktig — kjernen i kodeforståelsesoppgaven.
Sjangeren heter B — kodesporing, altså «hva skriver dette programmet ut?» eller «hva returnerer dette kallet?». Du får en kort kodesnutt på papir, uten maskin, og skal skrive svaret nøyaktig — tegn for tegn, med hakeparenteser, komma og linjeskift der Python setter dem.
- 4–6 deloppgaver per sett, 1–3 % hver. Til sammen er det mer enn en hel karakter.
- Hver deloppgave er liten nok til å løses på to–tre minutter — hvis du har en metode. Uten metode gjetter du, og gjetting treffer sjelden på utskriftsformat.
- Sensor gir delvis uttelling for delvis riktig sporing: har du ført løkka riktig, men bommet på ett tegn i utskriften, mister du ikke alt.
Prioritet: må sitte — det høyeste av bokas tre nivåer, som er «må sitte», «må kunne» og «bør kjenne til».
Dette er et rent drillkapittel. Du møter ingen ny Python her; du lærer å kjøre den du allerede kan, i hodet, uten å ta feil. Kapitlet tar ~90 minutter og er delt i sju små økter med tidsanslag. Ta det gjerne over to kvelder — det naturlige skillet er etter økt 4.
Dette kapitlet kommer sent i boka, så i stedet for en ren lenkeliste får du de tre konstruksjonene drillen faktisk hviler på, kjørt og ferdig oppfrisket. Kjenner du deg igjen i alle tre, er du klar.
1. Løkkegrensene (kap. 1.3). range(start, stopp, steg) stopper FØR stopp:
tall = [4, 7, 2, 9]
for i in range(1, len(tall), 2):
tall[i] = tall[i] * 10
print(tall)Utskrift:
[4, 70, 2, 90]Indeks 1 og 3 ble truffet, ikke 0 og 2.
2. Utsnitt av lister og strenger (kap. 3.1 og kap. 3.3). Et utsnitt gir alltid en ny sekvens, aldri ett enkelt element:
navn = 'Bergen'
print(navn[::-1])
print(navn[1::2])
print(navn[2])Utskrift:
negreB
egn
r3. Ordbok-telleren (kap. 3.5). d.get(k, 0) gir standardverdien når nøkkelen mangler, og setter den ikke inn:
tekst = 'bananas'
teller = {}
for bokstav in tekst:
teller[bokstav] = teller.get(bokstav, 0) + 1
print(teller)Utskrift:
{'b': 1, 'a': 3, 'n': 2, 's': 1}Du trenger dessuten if/elif/else og boolsk presedens fra kap. 1.2, funksjoner og returverdier fra kap. 2.1 og tabeller fra kap. 3.2.
Vil du ha enda mer sporingsdrill i en annen innpakning, finnes DRILL — Kodesporing: «hva skrives ut?» i IN1000-boka.
Dette er kapitlets oppskrift, og den brukes uendret i hver eneste oppgave under. Den tar 30 sekunder å sette opp og sparer deg for feilsvaret som kommer av å regne i hodet.
1. Før en tavle. Tegn én kolonne per variabel som endrer seg, og én kolonne til høyre som heter «Utskrift så langt». Én rad per linje eller per løkkerunde.
2. Tell løkkerundene nøyaktig. Skriv opp hvilke verdier løkkevariabelen faktisk tar — range(1, 5, 2) gir 1 og 3, ikke 1, 2, 3, 4. Stoppverdien er alltid utenfor.
3. Noter hva hvert print faktisk skriver, ikke hva du tror det betyr. Flere argumenter skilles av ett mellomrom; sep og end endrer det; strenger skrives uten fnutter, men inni en liste får de fnutter.
4. Hold styr på element mot struktur. x[2] er ett element. x[2:3] er en liste med ett element. De skrives forskjellig, og det er det du får trekk for.
5. For return: finn både verdien og typen. Faller kjøringen ut nederst i funksjonen uten return, er svaret None — som skrives ut som None.
6. Skriv sluttsvaret tegn for tegn fra tavla. Ikke fra hukommelsen om hva koden «gjør».
Om tidsbruken: en deloppgave er verdt 1–3 %. Bruker du mer enn tre–fire minutter på én, gå videre og kom tilbake. Et halvferdig, korrekt ført sporingsoppsett gir uttelling; et blankt svar gir ingen.
Økt 1 — metoden i arbeid (~10 min)
Før du driller selv, se metoden brukt på en oppgave av samme type og størrelse som den du møter på settet. Margnotatene sier hva sensor ser etter i hvert steg.
En kommune registrerer prisen på fem lademaster i kroner per time. Hva skriver programmet ut?
priser = [120, 85, 200, 45, 160]
resultat = []
for i in range(len(priser)):
if i % 2 == 0:
resultat.append(priser[i] // 10)
print(resultat)
print(len(resultat), sum(resultat))i og lista resultat. Vi trenger også en kolonne for testen.i | i % 2 == 0 | priser[i] | resultat etterpå |
|---|---|---|---|
| 0 | sann | 120 | [12] |
| 1 | usann | — | [12] |
| 2 | sann | 200 | [12, 20] |
| 3 | usann | — | [12, 20] |
| 4 | sann | 160 | [12, 20, 16] |
Margnotat: selve tavla gir uttelling. Har du ført den riktig og bare bommet på siste linje, mister du en brøkdel, ikke hele deloppgaven.
Steg 2 — tell rundene.
range(len(priser)) er range(5), altså 0, 1, 2, 3, 4. Fem runder, ikke seks. Her ryker mange: de teller «fem elementer, altså opp til 5» og får med en indeks som ikke finnes.Steg 3 — hva skriver hvert
print? Første print skriver hele lista, med hakeparenteser og komma-mellomrom. Andre print har to argumenter, og de skilles av ett mellomrom.Steg 4 — element eller struktur?
priser[i] er ett tall, og // 10 er heltallsdeling: 120 blir 12, 85 ville blitt 8 (men indeks 1 hoppes over), 200 blir 20, 160 blir 16.Steg 6 — svaret, tegn for tegn:
Utskrift:
[12, 20, 16]
3 48Margnotat: 3 48 på én linje, med ett mellomrom. Skriver du 3, 48 eller setter dem på hver sin linje, er svaret feil selv om tallene stemmer. Det er den billigste feilen i hele sjangeren.
Fellenote: fellen her er #5 — av-med-én i løkkegrensene og indekseringen. i % 2 == 0 treffer indeks 0, 2 og 4, altså det første, tredje og femte elementet. Leser du det som «annethvert fra det andre», får du [8, 4] og null poeng.
Økt 2 — løkkegrenser og av-med-én (~12 min)
Den vanligste feilkilden i hele sjangeren er range. Tre spørsmål avgjør hver eneste gang: hvor starter den, hvor stopper den, og hvor stort er steget? Skriv verdiene ned før du gjør noe annet.
En sporingstavle er en tabell du fører på kladdearket mens du leser koden: én kolonne per variabel som endrer seg, én kolonne for utskriften så langt, og én rad per løkkerunde.
Poenget er ikke ryddighet. Poenget er at hjernen ikke klarer å holde tre variabler og en teller samtidig, og at sensor gir uttelling for et riktig ført oppsett selv når sluttsvaret har en skrivefeil.
Gir tallrekka som starter på start, øker med steg, og stopper før stopp — stoppverdien er aldri med.
- range(4) gir 0, 1, 2, 3.
- range(1, 5) gir 1, 2, 3, 4.
- range(1, 6, 2) gir 1, 3, 5.
- range(5, 0, -1) gir 5, 4, 3, 2, 1.
- range(3, 3) er tom, og løkka kjører null ganger.
I en sporing skriver du alltid ned rekka først. range(1, len(x), 2) over en liste med fem elementer gir 1 og 3 — to runder, ikke tre.
- Å ta med stoppverdien i en range (fem elementer gir indeks 0 til 4, ikke 0 til 5).
- Å tro at «annethvert» starter på det andre elementet når koden sier range(0, n, 2), eller motsatt.
- Å telle løkkerundene i hodet i stedet for å skrive rekka ned.
Feilen gir ikke krasj. Programmet svarer bare feil, og du oppdager det aldri uten tavla.
(Innstegsoppgave, sjanger B — kodesporing, altså «hva skriver dette programmet ut?».) Skriv de tre linjene nøyaktig slik terminalen viser dem.
for i in range(3):
print(i * 2)En treningsapp har lagret ukens løpedistanser. Hva skriver programmet ut?
meter = [5, 8, 13, 21, 34]
for i in range(1, len(meter), 2):
meter[i] = meter[i] + 100
print(meter)Løkka teller nedover. Hva skriver programmet ut?
total = 0
for i in range(10, 0, -3):
total = total + i
print(i, total)Tre feil står for de fleste tapte poengene i økt 2, og de er alle varianter av #5 — av-med-én:
- Å ta med stoppverdien. range(1, 5) gir 1, 2, 3, 4. Aldri 5.
- Å telle runder i stedet for å skrive rekka. «Fem elementer, altså fem runder» er sant for range(len(x)), men usant for range(1, len(x), 2).
- Å glemme at listemutasjon er varig. Endrer løkka x[i], gjelder endringen resten av programmet. Skriv lista på nytt i tavla etter hver runde.
Motgiften er den samme for alle tre: skriv rekka ned først, som en eksplisitt liste med tall.
Økt 3 — utsnitt: element eller struktur? (~12 min)
Nesten annenhver kodesporing på settet inneholder et utsnitt. Fellen er sjelden hvilke elementer du får — den er hvilken form svaret har. x[2] gir tallet 9. x[2:3] gir lista [9]. Skriver du feil form, er svaret feil.
Gir en ny sekvens av samme type som originalen: fra og med indeks a, til men ikke med b, i sprang på s. Originalen er uendret.
- x[2:5] gir elementene på plass 2, 3 og 4.
- x[:3] starter fra begynnelsen, x[3:] går til slutten.
- x[::2] gir indeks 0, 2, 4 … og x[1::2] gir 1, 3, 5 …
- x[-2:] gir de to siste.
Utsnitt av ei liste er ei liste; utsnitt av en streng er en streng. Et utsnitt med ett element er fortsatt en liste: [9], ikke 9.
Gir en ny sekvens med elementene i motsatt rekkefølge. Originalen er uendret — det er forskjellen fra x.reverse(), som snur lista på plass og returnerer None.
På en streng er s[::-1] den vanligste palindromtesten: s == s[::-1]. På ei liste er den den raskeste måten å lese bakfra uten en løkke med negative indekser.
Det avgjørende spørsmålet i enhver sporing: har du fått én verdi eller en samling?
| Uttrykk | Du får | Skrives som |
|---|---|---|
x[2] | ett element | 9 |
x[2:3] | liste med ett element | [9] |
s[0] | en streng med ett tegn | B |
s[0:1] | en streng med ett tegn | B |
x[:] | en kopi av hele lista | [3, 6, 9] |
Merk den ene forskjellen mellom lister og strenger: et enkelt tegn ER en streng i Python, så for strenger ser
s[0] og s[0:1] like ut når de skrives ut.Hva skriver programmet ut? Pass på formen på hvert av de fire svarene.
bokstaver = ['a', 'b', 'c', 'd', 'e', 'f']
print(bokstaver[2:5])
print(bokstaver[2])
print(bokstaver[::2])
print(bokstaver[-2:])En billett har en kode med tre felt. Hva skriver programmet ut?
kode = 'BUSS-2026-OSLO'
print(kode[:4])
print(kode[-4:])
print(kode[::-1][:4])
print(len(kode.split('-')))Hva skriver programmet ut?
verdier = [3, 6, 9, 12]
kopi = verdier[:]
alias = verdier
alias.append(15)
print(verdier)
print(kopi)
print(len(alias))Økt 4 — nøstede løkker og tabeller (~14 min)
En 2D-liste er en tabell: ei liste der hvert element selv er ei liste, altså en rad. Sporingen av nøstede løkker har én fast felle — antall runder er produktet, ikke summen. En ytre løkke på 3 og en indre på 4 gir 12 runder.
— naturlig pausepunkt —
En løkke inne i en annen kjører den indre kroppen én gang for hver kombinasjon: er den ytre range(3) og den indre range(4), kjøres kroppen ganger.
I sporingen fører du den som to kolonner, i og j, og lar j gå hele veien rundt før i øker med 1. Er den indre grensa avhengig av den ytre — for eksempel range(len(tabell[i])) — må du lese den på nytt for hver ytre runde.
tabell[i] er hele rad nummer i — ei liste. tabell[i][j] er cellen i den raden, kolonne j — én verdi.- len(tabell) er antall rader.
- len(tabell[0]) er antall kolonner i første rad.
Rekkefølgen er alltid rad først, kolonne etterpå. Bytter du dem, får du enten feil verdi eller IndexError — og på papiret ser koden helt riktig ut.
Legg merke til de to print-kallene: det ene har end, det andre er tomt. Hva skriver programmet ut?
tabell = [[1, 2, 3], [4, 5, 6]]
for rad in tabell:
for v in rad:
print(v, end=' ')
print()Hva returnerer og skriver programmet ut?
tabell = [[1, 2], [3, 4], [5, 6]]
ny = []
for j in range(len(tabell[0])):
rad = []
for i in range(len(tabell)):
rad.append(tabell[i][j])
ny.append(rad)
print(ny)
print(len(ny), len(ny[0]))Et rutenett viser hvilke returpunkter som er fulle (1) og tomme (0). Hva skriver programmet ut?
rutenett = [[0, 1, 0], [1, 1, 0], [0, 0, 1]]
antall = 0
for i in range(len(rutenett)):
for j in range(len(rutenett[i])):
if rutenett[i][j] == 1 and i != j:
antall = antall + 1
print(antall)- Rad og kolonne byttet om. tabell[i][j] er rad i, kolonne j. Alltid. På transponeringsoppgaver er dette den eneste fellen som betyr noe.
- Antall runder lagt sammen i stedet for ganget. To nøstede løkker over 3 og 4 gir 12 runder.
- Den indre lista gjenbrukt. Står rad = [] utenfor den ytre løkka, samler alle radene seg i én liste. Se nøye på innrykket.
- Navnet rad brukt om to ting. I bokas kode er rad alltid hele raden (ei liste). Bruker en oppgave rad om ett element, må du lese ekstra nøye — det er en varslet navnekollisjon.
Økt 5 — ordbøker: teller og gruppering (~12 min)
Ordboka dukker opp i sporingssjangeren i én av to former: som teller («hvor mange av hver?») eller som gruppering («hvilke hører til hver?»). Fellen er den samme begge steder — utskriftsformen.
Slår opp nøkkelen k i ordboka d. Finnes den, returneres verdien; finnes den ikke, returneres standardverdien — uten at nøkkelen settes inn i ordboka.
Det er nettopp derfor telleren d[k] = d.get(k, 0) + 1 virker: første gang en nøkkel dukker opp, gir get verdien 0, og tilordningen setter den inn med verdien 1. Uten get ville oppslaget gitt KeyError.
En ordbok skrives med krøllparenteser, kolon mellom nøkkel og verdi, og komma-mellomrom mellom parene: {'buss': 3, 'trikk': 2}.
To ting avgjør poenget ditt:
- Rekkefølgen er innsettingsrekkefølgen i Python 3.7 og nyere — ikke alfabetisk. Nøkkelen som dukket opp først i dataene, står først.
- Strenger som nøkler og verdier får fnutter når ordboka skrives ut, akkurat som inne i ei liste. Tall får det ikke.
Hva skriver programmet ut?
linjer = ['buss', 'trikk', 'buss', 'tog', 'buss', 'trikk']
teller = {}
for t in linjer:
teller[t] = teller.get(t, 0) + 1
print(teller)
print(teller.get('ferge', 0))
print(len(teller))En treningslogg er lagret som en tabell med dag og antall minutter. Hva skriver programmet ut?
logg = [['mandag', 40], ['tirsdag', 25], ['mandag', 70]]
grupper = {}
for rad in logg:
dag = rad[0]
if dag not in grupper:
grupper[dag] = []
grupper[dag].append(rad[1])
print(grupper)
print(sorted(grupper))
print(sum(grupper['mandag']))Økt 6 — boolske uttrykk og returverdier (~12 min)
Den andre halvparten av kodeforståelsesoppgaven spør ikke «hva skrives ut», men «hva returnerer myst(4, 4)?». Da er det to ting som avgjør: presedensen i det boolske uttrykket, og hva som skjer når ingen return blir nådd.
Rekkefølgen er fast: sammenligninger først, så not, så and, så or.
Det betyr at x > 0 and y > 0 or x == y leses som (x > 0 and y > 0) or (x == y). and binder sterkere enn or, akkurat som gange binder sterkere enn pluss.
I sporingen setter du parentesene inn på kladdearket FØR du regner. Det tar fem sekunder og fjerner hele fellen.
Faller kjøringen ut nederst i en funksjon uten å møte en return, returneres None. Det skjer oftere enn man tror: en if/elif-kjede uten else har alltid en vei ut som ingen har tenkt på.
print(None) skriver None — med stor N og uten fnutter. Det er et helt legitimt svar på «hva returnerer kallet?», og det er det svaret sporingsoppgavene oftest er ute etter.
Hva skriver programmet ut?
def test(x, y):
return x > 0 and y > 0 or x == y
print(test(4, 4))
print(test(-2, -2))
print(test(3, -1))
print(test(0, 5))En poengskala er kodet slik. Hva skriver programmet ut?
def nivaa(poeng):
if poeng >= 90:
return 'topp'
elif poeng >= 60:
return 'midt'
elif poeng >= 40:
return 'nede'
print(nivaa(95))
print(nivaa(60))
print(nivaa(39))Økt 7 — while, heltallsdeling og utskriftsform (~14 min)
Siste økt samler tre feller som gjerne kommer sammen på de tyngste deloppgavene: en while-løkke der du må finne termineringsbetingelsen selv, heltallsdeling på negative tall, og print med sep og end.
En while-løkke kjører så lenge betingelsen er sann, og sjekker den på nytt før hver runde. I sporingen fører du én rad per runde og skriver betingelsens verdi i en egen kolonne.
To ting må du alltid sjekke:
- Endres noe i kroppen som gjør betingelsen usann til slutt? Gjør den ikke det, løper løkka evig, og det er et gyldig svar på en sporingsoppgave.
- Hva er verdiene ETTER siste runde? Det er dem print etter løkka skriver ut, ikke verdiene inni.
// er heltallsdeling og avrunder nedover, altså mot minus uendelig — ikke mot null. % gir resten, og den har alltid samme fortegn som divisoren.- 125 // 60 er 2, og 125 % 60 er 5.
- -125 // 60 er −3, ikke −2, og -125 % 60 er 55.
Sammenhengen som alltid holder, er at (a // b) * b + (a % b) er lik a. Sjekk svaret ditt med den når fortegnet er negativt: -3 * 60 + 55 er -125.
print gjør to ting du må kunne gjengi nøyaktig:- Den skiller argumentene med ett mellomrom. sep='-' bytter det ut, så print('a', 'b', sep='-') skriver a-b.
- Den avslutter med ett linjeskift. end=' ' bytter det ut, så neste utskrift fortsetter på samme linje. print() uten argumenter skriver bare linjeskiftet.
Overser du end, blir svaret ditt riktig i innhold og feil i form — og sjangeren spør etter formen.
Løkka bruker den samme regnemåten som Euklids algoritme, som du møter igjen i kap. 5.2. Hva skriver programmet ut?
a = 84
b = 36
runder = 0
while b != 0:
a, b = b, a % b
runder = runder + 1
print(a, runder)En sensor har logget en tidsavvik i sekunder, og det kan være negativt. Hva skriver programmet ut?
avvik = -125
print(avvik // 60, avvik % 60)
print(abs(avvik) // 60, abs(avvik) % 60)
print(7500 // 3600, (7500 % 3600) // 60, 7500 % 60)Fire linjer, fire forskjellige utskriftsformer. Hva skriver programmet ut?
felt = ['NO', '2026', '07']
print(felt[0], felt[1], sep='-')
print('rad', 1, end=' | ')
print('rad', 2)
print('-'.join(felt))Når du har jobbet deg gjennom de seksten oppgavene over, kjenner du igjen sjangeren på tre sekunder. Se etter disse signalene i oppgaveteksten:
| Ser du dette | Da testes |
|---|---|
range( med tre argumenter | grensene og steget — felle #5 |
To hakeparenteser etter hverandre, x[i][j] | rad mot kolonne |
Kolon inne i hakeparentesene, x[a:b] | element mot struktur |
.get( | ordbok-telleren og at nøkkelen ikke settes inn |
and og or i samme uttrykk | presedens |
En if/elif-kjede uten else | None som returverdi |
end= eller sep= | utskriftsformen, ikke innholdet |
// eller % med negative tall | avrundingsretningen — felle #9 |
while uten teller | termineringen |
Signalet forteller deg hva du skal føre i tavla. Det er hele forskjellen mellom to minutter og ti på en deloppgave.
De ni fellene i sjangeren, i den rekkefølgen de koster mest:
1. #5 — av-med-én i range og indeksering. Skriv rekka ned.
2. Utsnitt lest som element. x[2:3] er [9], ikke 9.
3. Utskriftsformen. Hakeparenteser, komma-mellomrom, fnutter inne i lister, ingen fnutter alene.
4. end= og sep= oversett. Innholdet riktig, formen feil, poenget tapt.
5. Presedens i and/or. Sett parentesene inn først.
6. None glemt når en if/elif-kjede mangler else.
7. #9 — // på negative tall avrunder nedover, ikke mot null.
8. Nøstede løkkegrenser ganges, ikke legges sammen.
9. #15 — aliasing. b = a er ikke en kopi.
Alle ni forsvinner med den samme vanen: før tavla, og skriv svaret av fra den.
Dette kapitlet er skrevet av Anthropics toppmodeller (Claude Opus og Claude Fable) og er foreløpig ikke manuelt gjennomgått — kvalitetskontrollen gjøres av uavhengige KI-agenter, og innmeldte feil rettes fortløpende. Funnet en feil? Meld fra, så retter vi den. Les mer om hvordan innholdet lages.
Skolesaga er en uavhengig læringsressurs og er ikke tilknyttet eller godkjent av Norges teknisk-naturvitenskapelige universitet. Dette er ikke offisielt studiemateriell. Les mer.