2.5 Funksjoner og modularisering

Den late programmererens dyd

Det finnes et godt prinsipp blant programmerere: ikke gjenta deg selv. Hvis du finner deg selv skrivende den samme koden om og om igjen, gjør du sannsynligvis noe feil. Tenk deg at du skal hilse på ti personer, og hver gang skriver de samme tre linjene kode på nytt. Det blir langt, kjedelig, og hvis du senere vil endre hilsenen, må du rette den ti steder. En liten feil ett sted, og du har en bug.

Løsningen er en av de vakreste ideene i programmeringen: funksjoner. En funksjon er en navngitt kodeblokk som utfører en bestemt oppgave, og som du kan kalle så mange ganger du vil. Du skriver oppskriften én gang, gir den et navn, og bruker den igjen og igjen. Det er den late programmererens dyd -- og latskap er her en god ting, for den fører til ryddig, vedlikeholdbar kode.

I denne fortellingen skal vi lære å lage våre egne funksjoner. Vi skal se hvordan de tar imot informasjon gjennom parametere og sender svar tilbake gjennom returverdier. Vi skal forstå forskjellen på lokale og globale variabler, og til slutt skal vi oppdage modularisering -- kunsten å dele et stort program opp i små, oversiktlige biter som hver gjør én ting godt.

Å lage din egen oppskrift

Du har allerede brukt funksjoner -- print() og input() er funksjoner andre har laget. Nå skal du lage dine egne. I Python definerer du en funksjon med nøkkelordet def, etterfulgt av et navn og et par parenteser. Den enkleste hilsefunksjonen ser slik ut: def hilsen(navn): med en print(f"Hei, {navn}!") under. Når du så skriver hilsen("Kari"), kjøres koden inni funksjonen med navnet «Kari», og du får «Hei, Kari!». Kall den med «Ola», og du får «Hei, Ola!». Samme oppskrift, ulike ingredienser.

Legg merke til ordet navn inni parentesen. Det er en parameter -- en variabel som tar imot en verdi når funksjonen kalles. Parametere er måten du sender informasjon inn i funksjonen på, slik at den kan jobbe med ulike data hver gang.

Du kan også gi parametere en standardverdi, som brukes hvis du ikke oppgir noe. Definerer du def hilsen(navn, ord="Hei"):, kan du kalle hilsen("Kari") og få «Hei, Kari!» -- standardverdien «Hei» brukes automatisk. Men kaller du hilsen("Ola", "God dag"), overstyrer du standarden og får «God dag, Ola!». Standardverdier gjør funksjonene dine fleksible: enkle å bruke i det vanlige tilfellet, men mulige å tilpasse når du trenger det.

Når funksjonen svarer tilbake

Så langt har funksjonene våre bare gjort noe, som å skrive ut tekst. Men ofte vil vi at en funksjon skal regne ut noe og gi oss svaret tilbake, slik at vi kan bruke det videre. Til det har vi nøkkelordet return og det vi kaller en returverdi.

Tenk deg en addisjonsfunksjon: def adder(a, b): med return a + b under. Når du skriver adder(3, 7), regner funksjonen ut summen og sender tallet 10 tilbake til der den ble kalt. Du kan da skrive print(adder(3, 7)) for å vise det, eller lagre svaret i en variabel for å bruke det senere. Forskjellen er viktig: en funksjon som bare print-er, viser noe på skjermen og er ferdig med det, mens en funksjon som return-er, gir deg en verdi du kan jobbe videre med.

Dette åpner for å bygge nyttige verktøy. Du kan lage en funksjon kvadrat(tall) som returnerer tall ** 2, eller en er_partall(tall) som returnerer tall % 2 == 0 -- altså True eller False. Den siste kan du bruke rett i en if-setning eller løkke. Du kan til og med la en funksjon returnere ulike verdier basert på betingelser, som en karakter(poeng)-funksjon som returnerer «A», «B», «C» og så videre etter hvor mange poeng som sendes inn. Med return blir funksjonene dine til små maskiner som tar inn data og leverer resultater.

Hvor variablene bor

Nå må vi forstå et viktig begrep: hvor en variabel «bor», eller det vi kaller dens virkeområde. Det handler om hvor i programmet en variabel er synlig og kan brukes.

En variabel som opprettes inne i en funksjon, kalles lokal. Den finnes bare der, inni funksjonen, og forsvinner i det funksjonen er ferdig. Det er litt som et privat notat på arbeidsbordet ditt -- bare du på rommet ser det. En variabel som opprettes utenfor alle funksjoner, kalles global, og kan ses fra hele programmet, omtrent som en oppslagstavle i gangen alle kan lese.

La oss se det i praksis. Hvis x = 10 er global, og vi inni en funksjon lager y = 5 som lokal, så kan funksjonen lese begge og skrive ut «10 5». Men prøver vi å bruke y utenfor funksjonen, får vi en feilmelding -- for y eksisterer ikke der ute; den bor inni funksjonen og kommer ikke ut. Dette kan virke tungvint i starten, men det er faktisk en stor fordel: lokale variabler hindrer at funksjoner roter til hverandres data. Hver funksjon får sitt eget private rom å jobbe i, og det gjør programmer langt tryggere og lettere å forstå.

Å bygge med byggeklosser

Nå kommer vi til den store ideen: modularisering. Dette betyr å dele et helt program opp i mindre, selvstendige funksjoner, der hver gjør én klart avgrenset oppgave. I stedet for én lang, uoversiktlig kodemasse, får du et sett med ryddige byggeklosser du kan sette sammen.

Tenk deg at du skal regne på sirkler. I stedet for å blande alt sammen, lager du én funksjon sirkel_areal(radius) som returnerer math.pi * radius ** 2, og en annen sirkel_omkrets(radius) som returnerer 2 * math.pi * radius. Legg merke til at vi her bruker import math for å hente inn ferdige matematiske verktøy, som math.pi. Nå kan hovedprogrammet bare spørre om en radius og kalle de to funksjonene -- ryddig, lesbart og lett å teste hver for seg.

Dette er enda kraftigere når du bygger større programmer. Du kan lage en funksjon les_tall(nr) som henter et tall fra brukeren, en gjennomsnitt(liste) som regner ut snittet, og en hovedprogram() som binder alt sammen. Hver funksjon er liten og forståelig, og hvis noe går galt, vet du raskt hvor du skal lete. Modularisering gjør koden mer oversiktlig, lettere å gjenbruke, og enklere å vedlikeholde. Det er forskjellen på et rotete skrivebord og et velorganisert verksted -- og det er kjennetegnet på en moden programmerer.

Oppsummering

Vi har lært å gi koden orden gjennom funksjoner -- navngitte kodeblokker, definert med def, som vi kan kalle igjen og igjen i stedet for å gjenta oss selv. Funksjoner tar imot informasjon via parametere (gjerne med standardverdier for fleksibilitet) og sender svar tilbake via returverdier med return, slik at de blir til små maskiner som omdanner inndata til resultater.

Vi forsto også hvor variabler bor: lokale variabler finnes bare inne i sin funksjon, mens globale ses fra hele programmet -- og at lokale variabler beskytter funksjoner mot å rote til hverandres data. Til slutt møtte vi modularisering, kunsten å bygge programmer av små, selvstendige byggeklosser som hver gjør én ting godt. Resultatet er kode som er oversiktlig, gjenbrukbar og enkel å vedlikeholde.