Inn- og utdata, strengformatering

Et program som snakker med brukeren

Tenk på et lite program som regner ut hvor mye en handletur koster. Du taster inn antall varer og prisen per vare, og programmet svarer med totalbeløpet. For at dette skal gå må programmet kunne to ting: ta imot noe utenfra, og vise noe tilbake. Det er nettopp dette inn- og utdata handler om — broen mellom mennesket foran skjermen og koden som kjører.

I Python henter vi inn tekst fra brukeren med input og viser resultater med print. Disse to funksjonene er de første du møter i nesten ethvert nybegynnerprogram, og de er enklere enn de ser ut. Men det ligger en felle i dem som feller mange: alt som kommer inn via input er tekst, alltid, uansett hva brukeren taster. Skriver brukeren 5, får programmet strengen "5", ikke tallet 5. Det skal vi rydde opp i.

print — å vise noe på skjermen

Den mest brukte funksjonen i Python er trolig print. Den tar det du gir den og skriver det ut i terminalen:

python
print("Hei, verden!")
print("Linje to")

Hver print avslutter med et linjeskift, så de to setningene over havner på hver sin linje. Du kan gi print flere ting på én gang ved å skille dem med komma — da setter Python et mellomrom mellom hver:

python
print("Pris:", 49, "kroner")

Dette skriver Pris: 49 kroner. Legg merke til at vi blander en streng, et tall og en streng til uten å tenke på det — print konverterer alt til tekst automatisk for visning. Vil du styre skilletegnet selv, finnes sep, og vil du droppe linjeskiftet, finnes end:

python
print("a", "b", "c", sep="-")
print("uten linjeskift", end=" ")
print("fortsetter her")

Den første linja skriver a-b-c, fordi sep="-" bytter ut standard-mellomrommet med en bindestrek. De to neste havner på samme linje — 2018-01-01 — fordi end=" " erstatter det vanlige linjeskiftet med et mellomrom, slik at neste print fortsetter der den forrige slapp. Disse to detaljene trenger du sjelden i starten, men det er greit å vite at de finnes, så du ikke tror utskriften er ute av kontroll når noe ser uventet sammensatt ut.

input — å ta imot tekst

Den motsatte veien går gjennom input. Den stopper programmet, viser en ledetekst, og venter til brukeren har tastet noe og trykket Enter:

python
navn = input("Hva heter du? ")
print("Hei,", navn)

Ledeteksten "Hva heter du? " er valgfri, men nesten alltid lur — uten den sitter brukeren foran en blinkende markør uten å vite hva som forventes. Det input returnerer, lagrer vi i en variabel slik at vi kan bruke det videre.

Her er den avgjørende detaljen igjen: returverdien fra input er alltid en streng. Det føles naturlig når vi spør om et navn, men det biter oss når vi spør om et tall.

Casting — fra tekst til tall og tilbake

Si at vi vil legge sammen to tall brukeren oppgir:

python
a = input("Første tall: ")
b = input("Andre tall: ")
print(a + b)

Taster brukeren 2 og 3, skriver programmet ut 23 — ikke 5. Hvorfor? Fordi a og b er strengene "2" og "3", og for strenger betyr + å skjøte dem sammen, ikke å regne. For å få ekte regning må vi gjøre om teksten til et tall. Det kalles casting, og vi gjør det med int(...) for heltall og float(...) for desimaltall.

1antall = int(input("Antall varer: "))2pris = float(input("Pris per vare: "))3total = antall * pris4print(f"Du kjøpte {antall} varer. Totalt: {total:.2f} kr.")

Mønsteret du vil bruke igjen og igjen er å pakke input direkte inn i en int eller float:

python
a = int(input("Første tall: "))
b = int(input("Andre tall: "))
print(a + b)

Nå tolkes "2" og "3" som tallene 2 og 3, og + regner. Resultatet blir 5. Casting går også andre veien: skal du sette et tall sammen med tekst på gammeldags vis, kan str(...) gjøre et tall om til en streng. Men det trengs sjelden — for vi har et bedre verktøy.

Strengformatering med f-strenger

Tenk deg at vi vil skrive en pen setning som blander tekst og beregnede verdier: «Du kjøpte 3 varer til 49 kr, totalt 147 kr.» Den klønete måten er å sette sammen biter med komma i print eller med + og masse str(...). Den moderne, lesbare måten er en f-streng (formatert streng-literal).

En f-streng er en vanlig streng med bokstaven f rett foran den første hermetegnet. Inni strengen kan du sette krøllparenteser { }, og det som står inne i dem blir regnet ut og satt inn:

python
antall = 3
pris = 49
print(f"Du kjøpte {antall} varer til {pris} kr, totalt {antall * pris} kr.")

Legg merke til at vi til og med kan regne antall * pris rett inne i krøllparentesen. Python evaluerer uttrykket og limer resultatet inn i teksten. Dette gjør koden langt lettere å lese enn alternativene, fordi setningen står slik den faktisk skal se ut, med hullene fylt på plass.

F-strenger kan også styre hvordan tall vises. Et vanlig behov er å vise penger med nøyaktig to desimaler. Da legger du til et kolon og et format-spesifikasjon etter uttrykket:

python
sum = 147.5
print(f"Totalt: {sum:.2f} kr")

Her betyr .2f «vis som desimaltall med to desimaler», så utskriften blir Totalt: 147.50 kr. Du kan også styre bredde og justering, men .2f for penger er det du vil møte oftest.

Format-spesifikasjonen løser også et problem som ellers irriterer mange nybegynnere. Et regnestykke som 0.1 + 0.2 gir i Python 0.30000000000000004 på grunn av måten desimaltall lagres på i maskinen — det møtte du i kapittelet om datatyper. Skriver du tallet ut rått, ser det stygt ut. Med f"{0.1 + 0.2:.2f}" får du derimot pene 0.30, fordi formateringen runder av til to desimaler ved visning. Verdien i variabelen er fortsatt den lange, men det brukeren ser, er ryddig.

Krøllparentesene kan inneholde mer enn bare variabelnavn. Du kan kalle funksjoner, slå opp i lister, eller bruke metoder rett inne i dem:

python
navn = "ada"
print(f"Velkommen, {navn.upper()}!")

Dette skriver Velkommen, ADA!, fordi navn.upper() gjøres ferdig før resultatet limes inn. Poenget er at alt mellom krøllparentesene er et vanlig Python-uttrykk som regnes ut akkurat som ellers.

Et helt lite program

La oss sette alt sammen. Et program som spør om antall og pris, og skriver ut totalen pent formatert:

python
antall = int(input("Antall varer: "))
pris = float(input("Pris per vare: "))
total = antall * pris
print(f"Du kjøpte {antall} varer. Totalt: {total:.2f} kr.")

Fire linjer, og hele bruer-fra-menneske-til-maskin-mønsteret er der: vi tar inn med input, gjør teksten om til tall med int og float, regner, og viser resultatet med en print og en f-streng. Dette grunnmønsteret — les inn, behandle, skriv ut — gjentar seg i nesten alle programmer du kommer til å skrive, fra de minste øvingene til store systemer.

Vanlige feller

Den hyppigste feilen er å glemme castingen og lure på hvorfor 2 + 3 ble 23. Den nest hyppigste er å caste noe som ikke er et tall: skriver brukeren to i stedet for 2, krasjer int("to") med en ValueError. Foreløpig lever vi med at programmet stopper ved slik feil-input; senere, i kapittelet om unntak, lærer du å fange feilen og spørre på nytt.

En tredje felle er å glemme f-en foran f-strengen. Skriver du print("Totalt: {total} kr") uten f, skriver Python ut krøllparentesene bokstavelig: Totalt: {total} kr. Det er ikke en feilmelding, bare et resultat som ser rart ut — så når en variabel ikke ser ut til å bli satt inn, sjekk først om f-en er der.

Med input, print, casting og f-strenger på plass har du alt du trenger for å la programmene dine kommunisere. I neste kapittel lar vi dem ta valg ut fra det de leser inn.