3.1 Introduksjon til programmering

Maskinen som gjør akkurat det du sier

En datamaskin er på en måte verdens dummeste geni. Den kan utføre milliarder av operasjoner i sekundet -- men bare hvis du forteller den nøyaktig hva den skal gjøre, steg for steg. Den gjetter aldri, tar aldri initiativ, og gjør akkurat det du ber om, ikke det du mente. Å programmere er å lære seg å gi disse nøyaktige instruksjonene, og et program er rett og slett en samling slike ordre.

Hvorfor lære det? Fordi programmering lar deg automatisere kjedelige oppgaver, styre elektroniske systemer, løse kompliserte problemer og forstå teknologien rundt deg. I dette kapittelet skal vi bygge opp programmeringens grunnmur fra bunnen. Vi starter med variabler -- der vi lagrer data -- og de ulike datatypene. Deretter lærer vi operatorene som lar oss regne og sammenligne, før vi gir programmet evnen til å velge med if-setninger. Til slutt møter vi løkkene, som lar maskinen gjenta seg selv tusenvis av ganger uten å klage. Med disse byggeklossene kan du allerede løse overraskende mange oppgaver.

Variabler, datatyper og operatorer

La oss begynne med det aller mest grunnleggende: variabelen. Tenk på den som en navngitt boks i datamaskinens minne der du kan legge noe. Boksen har et navn (for eksempel temperatur), en verdi (for eksempel 22.5), og en datatype. I Python lager du en variabel ganske enkelt: temperatur = 22.5. Python skjønner selv hvilken type det er ut fra verdien du gir den.

Nettopp datatypen er viktig. Det finnes fire grunnleggende slag. Heltall (int) er tall uten desimaler, som -2, 0 eller 42. Desimaltall (float) har desimaler, som 3.14 eller 22.7. Tekst (string) skrives i anførselstegn, som "Arduino". Og boolske verdier (bool) er enten sanne eller usanne -- True eller False. Skriver du navn = "Arduino", aktivert = True og teller = 0, har du laget tre variabler av tre ulike typer.

Med variabler på plass kan vi begynne å regne med dem ved hjelp av operatorer. De aritmetiske operatorene er kjente: + adderer, - subtraherer, * multipliserer og / dividerer. En litt spesiell en er %, modulo, som gir resten etter en divisjon: $7 \% 3 = 1$, fordi 7 delt på 3 er 2 med rest 1. Vil du regne ut arealet av et rektangel, skriver du bare areal = lengde * bredde.

Men operatorer kan også sammenligne. Med == (er lik), != (er ulik), >, <, >= og <= kan du stille spørsmål som gir svaret sant eller usant. Og logiske operatorer kombinerer slike sammenligninger: and er sann bare hvis begge deler er sanne, or er sann hvis minst én er sann, og not snur verdien. Tenk på spørsmålet «kan personen kjøre bil?»: kan_kjore = (alder >= 18) and har_lappen. Er alderen 17, blir resultatet False -- uansett om personen har lappen eller ikke.

Å la programmet velge

Hittil har programmene våre bare fulgt en rett linje fra topp til bunn. Men ekte programmer må kunne velge -- gjøre én ting under én betingelse, og noe annet under en annen. Det er nettopp dette if-setningen gir oss: evnen til å ta beslutninger.

Strukturen er enkel. Du skriver if etterfulgt av en betingelse, og koden under kjøres bare hvis betingelsen er sann. Vil du sjekke flere muligheter, bruker du elif (else if) for neste betingelse, og else for «hvis ingen av de andre stemmer». Tenk på en temperatursjekk:

if temperatur > 30:
    print("Veldig varmt!")
elif temperatur > 20:
    print("Behagelig")
else:
    print("Kaldt")

Med temperatur = 25 hopper programmet over den første betingelsen (25 er ikke over 30), treffer den andre (25 er over 20), og skriver «Behagelig». Legg merke til at betingelsene sjekkes ovenfra og ned, og at programmet stopper ved den første som er sann.

Dette er utrolig kraftig fordi det lar programmet reagere på omverdenen. En sensor måler en verdi, og en if-setning bestemmer hva som skal skje. Skal en vifte slå seg på over 25 grader? En if-setning. Skal en alarm gå hvis en dør åpnes? En if-setning. Et lite eksempel som sjekker om et tall er positivt, negativt eller null, viser mønsteret: if tall > 0 gir «Positivt», elif tall < 0 gir «Negativt», og else fanger opp det siste tilfellet -- null. Med if-setninger har programmet ditt plutselig fått dømmekraft.

Løkkene -- å gjenta uten å bli sliten

Det siste store verktøyet er løkken. Datamaskinens superkraft er at den kan gjøre den samme tingen om og om igjen, lynraskt og uten å bli lei. Men da må vi fortelle den at den skal gjenta seg -- og det gjør vi med løkker. Det finnes to hovedtyper, og forskjellen handler om hva vi vet på forhånd.

En for-løkke bruker vi når vi vet hvor mange ganger koden skal gjentas. Skriver du for i in range(5): print(i), skrives tallene 0, 1, 2, 3, 4 ut -- altså fem ganger. range(5) lager tallene fra 0 til og med 4. Du kan også styre den mer presist med range(start, stopp, steg). Vil du telle ned fra 10 til 1, skriver du for i in range(10, 0, -1), der steget -1 gjør at den går bakover. Og vil du skrive ut partallene fra 0 til 10, kan du bruke range(0, 11, 2), som hopper to og to.

En while-løkke bruker vi derimot når vi ikke vet på forhånd hvor mange ganger -- vi vil bare gjenta så lenge en betingelse er sann. For eksempel:

teller = 0
while teller < 5:
    print(teller)
    teller = teller + 1

Denne fortsetter så lenge teller er mindre enn 5, og inni løkka øker vi telleren med 1 hver runde. Glemmer du den linja, kjører løkka i det uendelige!

Forskjellen er altså viktig å huske: for-løkken passer når antallet er kjent, while-løkken når det avhenger av en betingelse. Med løkker kan du gjøre store ting med lite kode. Vil du for eksempel summere alle tall fra 1 til 100, trenger du ikke skrive 100 addisjoner -- du skriver en løkke som legger sammen tallene ett etter ett, og får svaret 5050. Det er denne evnen til å gjenta som gjør datamaskinen så ufattelig mye raskere enn et menneske.

Oppsummering

Vi har bygget programmeringens grunnmur. Variabler er navngitte bokser i minnet, med en verdi og en av fire datatyper: int, float, string og bool. Operatorene lar oss regne (med blant annet modulo % for rest), sammenligne (==, >, <) og kombinere logisk (and, or, not).

Med if-setninger fikk programmet dømmekraft -- evnen til å velge mellom alternativer med if, elif og else, slik at det kan reagere på omverdenen. Og med løkker ga vi det utholdenhet: for-løkken når antallet gjentakelser er kjent, og while-løkken så lenge en betingelse er sann. Med disse fire byggeklossene -- variabler, operatorer, beslutninger og gjentakelser -- har du alt du trenger for å skrive programmer som løser ekte problemer, fra å summere tall til å styre sensorer.