1.2 Betingelser og boolske uttrykk

Sammenligner to verdier og gir True hvis de er like:

print(3 == 3)
print(3 == 4)

Utskrift:

True
False

Legg merke til de to likhetstegnene. Ett likhetstegn er en tilordning som endrer en variabel; to likhetstegn er et spørsmål som gir et svar. Det er to helt forskjellige ting, og å blande dem er en klassisk feil.

== sammenligner verdier, ikke typer, men typene må kunne sammenlignes: 3 == 3 er True, mens 3 == "3" er False — et tall er aldri lik en tekst.

Det motsatte av ==: gir True når verdiene er forskjellige.

print(3 != 4)
print("ja" != "ja")

Utskrift:

True
False

Utropstegnet leses som «ikke». a != b betyr «a er ikke lik b», og er nøyaktig det samme som not (a == b).

De fire størrelsessammenligningene: mindre enn, større enn, mindre enn eller lik, større enn eller lik.

print(5 < 5)
print(5 <= 5)

Utskrift:

False
True

Forskjellen mellom de to linjene er hele kapitlets viktigste detalj. < slipper ikke gjennom når verdiene er like; <= gjør det.

På eksamen er dette kanten: en oppgave som sier «18 år eller eldre», krever
>=, ikke >. Å teste med en verdi som ligger nøyaktig på kanten, er den raskeste måten å avsløre feilen på.

Et uttrykk som gir True eller False. Alle sammenligninger er boolske uttrykk, og det samme er en variabel som holder på en boolsk verdi.

alder = 20 er_myndig = alder >= 18 print(er_myndig)

Utskrift:

True

Legg merke til at resultatet kan lagres i en variabel, akkurat som et tall. Det er ofte den ryddigste måten å skrive kode på: gi den boolske verdien et beskrivende navn, og bruk navnet i betingelsen etterpå.

Strenger kan også sammenlignes. == og != gjør det du forventer: to strenger er like når de har nøyaktig de samme tegnene, i samme rekkefølge, med samme store og små bokstaver.

print("Ada" == "Ada")
print("Ada" == "ada")

Utskrift:

True
False

Størrelsessammenligning virker også, og følger tegnenes rekkefølge — omtrent som i en ordbok: "ape" < "bil" er True. Men vær forsiktig: store bokstaver kommer før alle små, så "Ø" < "a" er True. På eksamen dukker størrelsessammenligning av tekst sjelden opp; det er likhetstesten du bruker.

Kjører linjene under, men bare hvis betingelsen er sann:

alder = 20 if alder >= 18:
    print("myndig")
print("ferdig")

Utskrift:

myndig ferdig

Tre formkrav som Python er ubøyelig på:

- Kolon etter betingelsen.
- Innrykk på linjene som hører til. Boka bruker fire mellomrom.
- Linjer uten innrykk hører ikke til, og kjøres uansett — som print("ferdig")
over.

Er betingelsen usann, hoppes hele den innrykkede blokken over, og programmet fortsetter på første linje uten innrykk.

Python bruker innrykk der andre språk bruker klammeparenteser. Alle linjene med samme innrykk under en if utgjør én blokk, og blokken kjøres samlet eller ikke i det hele tatt.

sum_poeng = 12 if sum_poeng > 10:
    sum_poeng = sum_poeng + 5 print(sum_poeng)
print("slutt")

Utskrift:

17 slutt

Begge de innrykkede linjene hørte til betingelsen. Den siste gjorde ikke.

Regelen er absolutt: innrykket er ikke pynt, det er betydning. Flytter du en linje inn eller ut, endrer du hva programmet gjør — ikke bare hvordan det ser ut.

Kjører når betingelsen er usann:

alder = 15 if alder >= 18:
    print("myndig")
else:
    print("mindrearig")

Utskrift:

mindrearig

else har ingen egen betingelse — den fanger opp alt som ikke traff. Nøyaktig én av de to blokkene kjøres, aldri begge og aldri ingen.

else er valgfri. En if uten else betyr rett og slett «gjør ingenting hvis betingelsen er usann».

En ekstra betingelse som bare prøves hvis den forrige var usann:

poeng = 72 if poeng >= 90:
    print("A")
elif poeng >= 60:
    print("C")
else:
    print("F")

Utskrift:

C

Ordet er en sammentrekning av «else if». Du kan ha så mange elif-grener du vil mellom if og else.

Rekkefølgen betyr alt: grenene prøves ovenfra og ned, og den første som er sann, vinner. Derfor må den strengeste betingelsen stå øverst. Hadde `poeng >=
60 stått først i eksempelet over, ville alle med 90 poeng også fått C`.

I en kjede av if, elif og else kjøres nøyaktig én blokk: den første grenen som er sann. Resten hoppes over, selv om de også ville vært sanne.

x = 100 if x > 10:
    print("over ti")
elif x > 50:
    print("over femti")

Utskrift:

over ti

Verdien er både over ti og over femti, men bare den første grenen kjørte.

Dette skiller elif skarpt fra å skrive to selvstendige if-setninger etter hverandre. To if-er er to uavhengige spørsmål, og begge kan slå til.

Sann bare når begge sidene er sanne:

alder = 20 print(alder >= 18 and alder < 67)
print(alder >= 18 and alder < 20)

Utskrift:

True
False

Andre linje er usann fordi høyre side er usann, selv om venstre side er sann.
and krever begge.

Slik skrives et intervall i denne boka: to hele sammenligninger med and mellom, som alder >= 18 and alder < 67. Python tillater også kortformen
18 <= alder < 67, men den fulle formen er tydeligere å spore og er stilen i fagets egne løsningsforslag.

Sann når minst én av sidene er sann:

dag = "lordag" print(dag == "lordag" or dag == "sondag")
print(dag == "mandag" or dag == "sondag")

Utskrift:

True
False

Merk at or også er sann når begge sidene er sanne — det er «minst én», ikke
«nøyaktig én».

En vanlig feil er å skrive dag == "lordag" or "sondag". Det er ikke en sammenligning på høyre side, og uttrykket gir ikke det du tror. Skriv hele sammenligningen på begge sider av or.

Snur en boolsk verdi:

er_ledig = False print(not er_ledig)

Utskrift:

True

not står foran uttrykket det snur, og binder sterkere enn både and og or.

Bruk not når det gjør setningen lettere å lese, ikke som en vane. not (a == b) bør skrives a != b, og not (x > 5) bør skrives x <= 5 — begge er kortere og lettere å spore.

Når flere av dem står i samme uttrykk, gjelder denne rekkefølgen, fra sterkest til svakest:

1. not
2. and
3. or

Sammenligninger som >= og == regnes ut før alle tre.

Det betyr at a or b and c leses som a or (b and c), ikke som
(a or b) and c. De to gir ulikt svar, og forskjellen er en fast kilde til sporingsoppgaver.

Som med regnerekkefølgen i kap. 1.1: er du i tvil, sett parenteser. De koster ingenting og fjerner all tvil.

En if kan stå inne i en annen. Da må den ytre være sann for at den indre i det hele tatt skal prøves:

alder = 20 har_bevis = True if alder >= 18:
    if har_bevis:
        print("kan kjore")
    else:
        print("mangler bevis")
else:
    print("for ung")

Utskrift:

kan kjore

Innrykket viser hvem som hører til hvem: den indre else hører til den indre
if, fordi de har samme innrykk.

Nøsting er nyttig når det andre spørsmålet bare gir mening dersom det første er besvart. Men to nivåer er som regel nok — trenger du tre, er and ofte et ryddigere valg.

Tester om noe forekommer i noe annet, og gir True eller False:

navn = "Aleksander" print("eks" in navn)
print("ø" in navn)

Utskrift:

True
False

På en tekst spør in om en delstreng finnes.

Den samme testen virker på de datastrukturene du møter i Del 3: if tall in tallene: spør om en verdi finnes i en liste, og if navn in ordbok: spør om en nøkkel finnes i en ordbok. Da blir in en av de viktigste konstruksjonene i faget — den er selve inngangen til teller-mønsteret i
kap. 3.2. Her nøyer vi oss med teksten.

not in finnes også, og betyr det motsatte.

De to mest forvekslede tegnene i faget:

- = er en tilordning: x = 3 endrer x.
- == er en sammenligning: x == 3 spør, og gir True eller False.

Skriver du if x = 3: stopper Python med en feilmelding — heldigvis, for da oppdager du det med en gang.

Den motsatte forvekslingen er farligere: skriver du x == 3 der du mente en tilordning, skjer det ingenting i det hele tatt. Uttrykket regnes ut, svaret kastes, og x er uendret. Programmet kjører videre og gir feil svar uten å si fra.

Et boolsk uttrykk som styrer om en blokk med kode skal kjøres. Betingelsen står mellom if (eller elif) og kolonet.

En betingelse er alltid et uttrykk med en verdi, ikke en handling. Derfor kan du regne den ut for seg selv, skrive den ut med print, eller lagre den i en variabel — noe som er en god teknikk når betingelsen blir lang.

En av de mulige veiene gjennom en if-elif-else-kjede. Hver gren har sin egen blokk med kode.

Ordet er nyttig når du sporer: «hvilken gren traff?» er alltid det første spørsmålet, og svaret er alltid nøyaktig én i en kjede.

Verdien som ligger nøyaktig på grensen i en betingelse: 18 når kravet er «minst
18», 67 når det er «67 eller eldre».

Kant-tilfeller er der nesten alle logiske feil viser seg, og de er derfor det sensor tester med. Vanen som lønner seg: når du har skrevet en betingelse med en grense i, sett inn grenseverdien og regn ut for hånd før du går videre. Det tar ti sekunder og fanger en hel feilklasse.

Når venstre side av en or er sann, er hele uttrykket sant uansett hva som står til høyre — og Python bryr seg da ikke om å regne ut høyre side i det hele tatt.
Det samme gjelder and når venstre side er usann.

For sporing betyr det at rekkefølgen kan spille en rolle. I praksis trenger du sjelden å tenke på det i IN1000, men det forklarer hvorfor et uttrykk kan gi svar selv når høyre side ville ha krasjet.