2.3. Matematiska operationer

Python fungerar som en miniräknare direkt ur lådan. Den här sidan tar upp de operatorer du kommer att använda mest: aritmetik på tal, jämförelser som ger booleska värden, logiska operatorer som kombinerar villkor och bitvisa operatorer för arbete på hårdvarunivå.

2.3.1. Aritmetik

De vanliga aritmetiska operatorerna på int- och float-värden:

  • + – addition

  • - – subtraktion (eller negation, som prefix: -x)

  • * – multiplikation

  • / – division. Returnerar alltid en float, även när båda operanderna är heltal.

  • // – heltalsdivision. Returnerar den heltalskvot som avrundats mot minus oändligheten.

  • % – modulo (rest).

  • ** – exponentiering (2 ** 10 är 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

Aritmetik med blandade typer befordrar automatiskt heltal till flyttal:

>>> 3 + 0.5
3.5

Förkortad tilldelning kombinerar operatorn med = för en kompakt uppdatering på plats:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

Operatorprecedensen följer den konventionella ordningen: ** först, sedan unär -, sedan *, /, // och %, sedan + och -. Använd parenteser när du är osäker – de kostar ingenting vid körning.

2.3.2. Jämförelse

Jämförelseoperatorer returnerar en bool (True eller False):

  • == och != – lika med / inte lika med.

  • <, <=, >, >= – ordning.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

Det sista exemplet är en kedjad jämförelse och är exakt likvärdigt med 3 < 5 and 5 <= 5.

Varning

= tilldelar; == jämför. Uttrycket if x = 5: är ett syntaxfel just för att Python vägrar att tyst förväxla de två.

2.3.3. Boolesk logik

Tre operatorer kombinerar booleska värden:

  • and – True endast när båda sidor är sanna.

  • or – True när endera sidan är sann.

  • not – inverterar ett enskilt booleskt värde.

and och or kortsluter: de slutar utvärdera så snart resultatet är känt. False and slow_check() anropar aldrig slow_check.

and och or returnerar dessutom en av sina operander snarare än ett bokstavligt True eller False, vilket låter dig skriva standardvärden kompakt:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Bitvisa operatorer

För hårdvaruarbete – att packa registerfält, maska bitar, tolka protokollhuvuden – kommer du att ta till de bitvisa operatorerna. De verkar på den binära representationen av en int:

  • & – bitvis AND

  • | – bitvis OR

  • ^ – bitvis XOR

  • ~ – bitvis NOT (ettkomplement)

  • << – vänsterskift

  • >> – högerskift

De hexadecimala och binära litteralformerna är praktiska när man läser och skriver dessa:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Förkortade former finns för var och en: |=, &=, ^=, <<=, >>=.

Anteckning

and / or verkar på booleska värden (eller på sanningshalt); & / | verkar på bitar. Förväxla dem inte. 0b1100 and 0b1010 utvärderas till 0b1010 eftersom båda operanderna är sanna – inte vad du vanligtvis vill ha när du manipulerar bitar.

2.3.5. Användbara inbyggda funktioner för tal

En handfull inbyggda funktioner täcker vanliga numeriska operationer som operatorerna ensamma inte gör:

  • round() – närmaste heltal, eller närmaste ndigits decimaler när ett andra argument anges. Returnerar en int för round(x) och en float för round(x, n). Lika fall (0.5, 1.5, …) avrundas till närmaste jämna tal, inte alltid uppåt.

  • divmod() – returnerar (quotient, remainder) i ett enda anrop. Praktiskt för att dela upp en kvantitet i enheter (sekunder i minuter-och-sekunder, byte i sidor-och-offset).

  • pow() – samma sak som ** i tvåargumentsformen. Treargumentsformen pow(base, exp, mod) beräknar (base ** exp) % mod utan att någonsin materialisera det gigantiska mellanvärdet, vilket är det enda praktiska sättet att göra modulär exponentiering för stora exponenter.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

Baskonverteringar från heltal till sträng (bin, oct, hex) tas upp i Strängmetoder och formatering.

2.3.6. Modulen math

Vanliga matematiska funktioner finns i modulen math. Importera den en gång och anropa dess funktioner genom ett punktnoterat namn:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

MicroPython-modulen math täcker de vanliga misstänkta (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). För slumptal, se modulen random; för bitmanipulering med fast decimalkomma räcker operatorerna ovan oftast.

2.3.7. Komplexa tal

För numeriskt arbete som behöver imaginära komponenter har Python en complex-typ med litteraler med j-suffix (1 + 2j). Modulen cmath speglar math för komplexa indata. Båda finns i de flesta MicroPython-byggen men behövs sällan för kameraarbete; vi nämner dem främst för att de inte ska komma som en överraskning om du porterar kod som använder dem.