2.3. Wiskundige bewerkingen

Python werkt standaard als een rekenmachine. Deze pagina behandelt de operatoren die je het vaakst zult gebruiken: rekenkunde met getallen, vergelijkingen die booleans opleveren, logische operatoren die voorwaarden combineren, en bitsgewijze operatoren voor werk op hardwareniveau.

2.3.1. Rekenkunde

De standaard rekenkundige operatoren op int- en float-waarden:

  • + – optelling

  • - – aftrekking (of negatie, als voorvoegsel: -x)

  • * – vermenigvuldiging

  • / – deling. Geeft altijd een float terug, zelfs wanneer beide operanden gehele getallen zijn.

  • // – gehele deling. Geeft het gehele quotiënt terug, naar beneden afgerond richting min-oneindig.

  • % – modulo (rest).

  • ** – machtsverheffing (2 ** 10 is 1024).

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

Rekenkunde met gemengde typen promoveert gehele getallen automatisch naar floats:

>>> 3 + 0.5
3.5

Samengestelde toewijzing combineert de operator met = voor een compacte update ter plaatse:

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

De operatorvolgorde volgt de gebruikelijke regels: eerst **, dan unaire -, dan *, /, // en %, dan + en -. Gebruik haakjes als je twijfelt – ze kosten niets tijdens de uitvoering.

2.3.2. Vergelijking

Vergelijkingsoperatoren geven een bool terug (True of False):

  • == en != – gelijk / niet gelijk.

  • <, <=, >, >= – ordening.

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

Het laatste voorbeeld is een geketende vergelijking en is precies equivalent aan 3 < 5 and 5 <= 5.

Waarschuwing

= wijst toe; == vergelijkt. De expressie if x = 5: is een syntaxisfout, juist omdat Python weigert de twee stilletjes door elkaar te halen.

2.3.3. Booleaanse logica

Drie operatoren combineren booleans:

  • and – True alleen wanneer beide zijden waar zijn.

  • or – True wanneer een van beide zijden waar is.

  • not – keert een enkele boolean om.

and en or doen aan kortsluiting: ze stoppen met evalueren zodra het resultaat bekend is. False and slow_check() roept slow_check nooit aan.

and en or geven bovendien een van hun operanden terug in plaats van een letterlijke True of False, waardoor je standaardwaarden compact kunt schrijven:

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

2.3.4. Bitsgewijze operatoren

Voor hardwarewerk – het inpakken van registervelden, het maskeren van bits, het ontleden van protocolheaders – grijp je naar de bitsgewijze operatoren. Ze werken op de binaire weergave van een int:

  • & – bitsgewijze AND

  • | – bitsgewijze OR

  • ^ – bitsgewijze XOR

  • ~ – bitsgewijze NOT (één-complement)

  • << – naar links verschuiven

  • >> – naar rechts verschuiven

De hexadecimale en binaire literalvormen zijn handig bij het lezen en schrijven hiervan:

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

Voor elk bestaat er een samengestelde vorm: |=, &=, ^=, <<=, >>=.

Notitie

and / or werken op booleans (of op waarheidsgehalte); & / | werken op bits. Haal ze niet door elkaar. 0b1100 and 0b1010 evalueert tot 0b1010 omdat beide operanden waarheidsgetrouw zijn – niet wat je gewoonlijk wilt bij het manipuleren van bits.

2.3.5. Handige ingebouwde getalfuncties

Een handvol ingebouwde functies dekt veelvoorkomende numerieke bewerkingen die de operatoren alleen niet aankunnen:

  • round() – het dichtstbijzijnde gehele getal, of het dichtstbijzijnde aantal ndigits decimalen wanneer een tweede argument wordt opgegeven. Geeft een int terug voor round(x) en een float voor round(x, n). Gelijke gevallen (0.5, 1.5, …) worden afgerond naar het dichtstbijzijnde even getal, niet altijd naar boven.

  • divmod() – geeft in één aanroep (quotient, remainder) terug. Handig om één hoeveelheid in eenheden te splitsen (seconden in minuten-en-seconden, bytes in pagina’s-en-offsets).

  • pow() – hetzelfde als ** in de vorm met twee argumenten. De vorm met drie argumenten pow(base, exp, mod) berekent (base ** exp) % mod zonder ooit de gigantische tussenwaarde te materialiseren, wat de enige praktische manier is om modulaire machtsverheffing voor grote exponenten uit te voeren.

>>> 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

Conversies van geheel getal naar string in verschillende grondtallen (bin, oct, hex) worden behandeld in String-methoden en formattering.

2.3.6. De math-module

Veelvoorkomende wiskundige functies leven in de math-module. Importeer hem één keer en roep zijn functies aan via een naam met punt:

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

De MicroPython-math-module dekt de gebruikelijke verdachten (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Voor willekeurige getallen, zie de random-module; voor bitmanipulatie met vaste komma zijn de bovenstaande operatoren meestal voldoende.

2.3.7. Complexe getallen

Voor numeriek werk dat imaginaire componenten nodig heeft, heeft Python een complex-type met literals met j-achtervoegsel (1 + 2j). De cmath-module weerspiegelt math voor complexe invoer. Beide zijn aanwezig op de meeste MicroPython-builds, maar zelden nodig voor camerawerk; ze worden hier vooral genoemd zodat ze geen verrassing zijn als je code overzet die ze gebruikt.