Operatorer och logiska uttryck

Efter denna lektion kommer du att behärska alla grundläggande aritmetiska och logiska operatorer i Python. Du kommer att kunna utföra komplexa beräkningar, jämföra värden och bygga sammansatta villkorsuttryck för styrning av programflöden.

Aritmetiska operatorer i Python

Aritmetiska operatorer används för att utföra matematiska beräkningar på numeriska datatyper (heltal `int` och flyttal `float`). Python stödjer alla standardmässiga räknesätt samt ett par särskilt användbara operatorer för heltalsräkning.

De grundläggande operatorerna är addition (`+`), subtraktion (`-`), multiplikation (`*`) och division (`/`). Notera att vanlig division i Python 3 alltid returnerar ett flyttal, vilket innebär att `6 / 3` ger `2.0` och inte heltalsvärdet `2`.

För utökad beräkning erbjuder Python tre specialiserade operatorer:

1. Heltalsdivision (`//`): Dividerar två tal och avrundar nedåt till närmaste heltal. Exempelvis ger `7 // 2` resultatet `3`.

2. Modulus (`%`): Returnerar resten som uppstår vid en heltalsdivision. Exempelvis ger `7 % 2` resultatet `1`, eftersom 2 går 3 hela gånger i 7 med resten 1. Modulus är mycket användbart för att kontrollera om ett tal är jämnt (dvs. `tal % 2 == 0`) eller för att skapa cykliska sekvenser.

3. Exponentiering (``): Upphöjer basen till exponenten. Exempelvis beräknas 2 upphöjt till 3 som `2 3`, vilket ger `8`.

När du kombinerar flera operatorer följer Python standardmässiga matematiska prioritetsregler (PEMDAS/BODMAS): exponentiering först, därefter multiplikation/division/modulus, och sist addition/subtraktion. Du kan använda parenteser `()` för att tvinga fram en specifik beräkningsordning.

Jämförelseoperatorer och booleska värden

Jämförelseoperatorer används för att ställa frågor om relationen mellan två värden. Resultatet av en jämförelse blir alltid ett booleskt värde: antingen `True` (sant) eller `False` (falskt).

Följande jämförelseoperatorer finns i Python:

• `==` Likhet (är värdena lika?)
• `!=` Olikhet (är värdena olika?)
• `<` Mindre än
• `>` Större än
• `<=` Mindre än eller lika med
• `>=` Större än eller lika med

En vanlig källa till fel för nybörjare är skillnaden mellan ett enskilt likhetstecken `=` och ett dubbelt likhetstecken `==`. Ett enskilt likhetstecken är en tilldelningsoperatör som sparar ett värde i en variabel (`x = 5`), medan dubbla likhetstecken är en jämförelseoperatör som prövar om två värden är lika (`x == 5`).

Du kan jämföra både tal och andra datatyper som strängar. Vid strängjämförelse jämförs tecknen utifrån deras Unicode-koder, vilket innebär att jämförelsen sker i alfabetisk ordning (exempelvis är `"apa" < "bep"` sant, och `"A" == "a"` är falskt eftersom Python är skiftlägeskänsligt).

Logiska operatorer: and, or, not

När du vill bygga mer komplexa beslutsregler behöver du kombinera flera jämförelser. Detta görs med de logiska operatorerna `and`, `or` och `not`.

• `and` (OCH): Returnerar `True` endast om *båda* delvillkoren är sanna. Om det vänstra villkoret är falskt behöver Python inte ens utvärdera det högra (så kallad *kortslutningsevaluering* eller short-circuit evaluation).
• `or` (ELLER): Returnerar `True` om *minst ett* av delvillkoren är sant. Det returnerar endast `False` om båda delvillkoren är falska.
• `not` (ICKE): Inverterar det booleska värdet. Om ett villkor är `True` blir `not villkor` istället `False`, och vice versa.

Prioritetsordning för operatorer

När ett uttryck innehåller flera typer av operatorer utvärderar Python dem i en bestämd ordning:

1. Parenteser `()`

2. Aritmetiska operatorer (`**`, `*`, `/`, `//`, `%`, `+`, `-`)

3. Jämförelseoperatorer (`==`, `!=`, `<`, `>`, `<=`, `>=`)

4. `not`

5. `and`

6. `or`

Att ha koll på att `not` utvärderas före `and`, och `and` före `or`, är avgörande för att undvika logiska fel i programmet.

Kedjade jämförelser och praktisk tillämpning

Python har en mycket elegant och unik funktion jämfört med många andra programmeringsspråk: kedjade jämförelser (chained comparisons).

I matematiska sammanhang skriver vi ofta att ett tal x ska ligga i ett visst intervall, exempelvis att x är större än eller lika med 5 och mindre än eller lika med 15: 5 ≤ x ≤ 15. I språk som C++ eller Java måste detta skrivas som två separata villkor hopkopplade med ett logiskt OCH: `5 <= x && x <= 15`.

I Python kan du skriva detta precis som i matematiken:

python

x = 10

if 5 <= x <= 15:

print("x ligger i intervallet [5, 15]")

Python översätter automatiskt `5 <= x <= 15` till `(5 <= x) and (x <= 15)`, men koden blir avsevärt lättare att läsa och skriva.

Du kan också kedja fler jämförelser efter varandra, t.ex. `a < b == c < d`, även om det kan bli svårt att läsa om det överdrivs. Att använda kedjade jämförelser för att kontrollera om ett värde befinner sig inom ett intervall är dock en mycket god och etablerad konvention i Python.