2.3. Operazioni matematiche

Python funziona come una calcolatrice fin da subito. Questa pagina copre gli operatori che userai più spesso: aritmetica sui numeri, confronti che producono valori booleani, operatori logici che combinano condizioni e operatori bit a bit per il lavoro a livello hardware.

2.3.1. Aritmetica

Gli operatori aritmetici standard sui valori int e float:

  • + – addizione

  • - – sottrazione (oppure negazione, come prefisso: -x)

  • * – moltiplicazione

  • / – divisione. Restituisce sempre un float, anche quando entrambi gli operandi sono interi.

  • // – divisione intera. Restituisce il quoziente intero arrotondato verso meno infinito.

  • % – modulo (resto).

  • ** – elevamento a potenza (2 ** 10 è 1024).

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

L’aritmetica a tipi misti promuove automaticamente gli interi a float:

>>> 3 + 0.5
3.5

L’assegnazione aumentata combina l’operatore con = per un aggiornamento compatto sul posto:

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

La precedenza degli operatori segue l’ordine convenzionale: prima **, poi il - unario, poi *, /, // e %, infine + e -. Usa le parentesi quando hai dubbi – non costano nulla in fase di esecuzione.

2.3.2. Confronto

Gli operatori di confronto restituiscono un bool (True o False):

  • == e != – uguale / diverso.

  • <, <=, >, >= – ordinamento.

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

L’ultimo esempio è un confronto concatenato ed è esattamente equivalente a 3 < 5 and 5 <= 5.

Avvertimento

= assegna; == confronta. L’espressione if x = 5: è un errore di sintassi proprio perché Python si rifiuta di confondere silenziosamente i due.

2.3.3. Logica booleana

Tre operatori combinano i booleani:

  • and – True solo quando entrambi i lati sono veri.

  • or – True quando uno dei due lati è vero.

  • not – inverte un singolo booleano.

and e or operano in cortocircuito: smettono di valutare non appena il risultato è noto. False and slow_check() non chiama mai slow_check.

and e or restituiscono inoltre uno dei loro operandi anziché un letterale True o False, il che ti consente di scrivere valori predefiniti in modo compatto:

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

2.3.4. Operatori bit a bit

Per il lavoro hardware – impacchettare campi di registro, mascherare bit, analizzare intestazioni di protocollo – ricorrerai agli operatori bit a bit. Agiscono sulla rappresentazione binaria di un int:

  • & – AND bit a bit

  • | – OR bit a bit

  • ^ – XOR bit a bit

  • ~ – NOT bit a bit (complemento a uno)

  • << – scorrimento a sinistra

  • >> – scorrimento a destra

Le forme letterali esadecimali e binarie sono comode per leggere e scrivere questi valori:

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

Per ciascuno esistono le forme aumentate: |=, &=, ^=, <<=, >>=.

Nota

and / or operano sui booleani (o sulla veridicità); & / | operano sui bit. Non confonderli. 0b1100 and 0b1010 si valuta come 0b1010 perché entrambi gli operandi sono veri – non quello che di solito vuoi quando manipoli i bit.

2.3.5. Funzioni integrate utili per i numeri

Una manciata di funzioni integrate copre operazioni numeriche comuni che i soli operatori non coprono:

  • round() – l’intero più vicino, oppure il numero più vicino con ndigits cifre decimali quando viene fornito un secondo argomento. Restituisce un int per round(x) e un float per round(x, n). I casi di parità (0.5, 1.5, …) vengono arrotondati al numero pari più vicino, non sempre per eccesso.

  • divmod() – restituisce (quotient, remainder) in un’unica chiamata. Comodo per suddividere una quantità in unità (secondi in minuti-e-secondi, byte in pagine-e-offset).

  • pow() – equivale a ** nella forma a due argomenti. La forma a tre argomenti pow(base, exp, mod) calcola (base ** exp) % mod senza mai materializzare il gigantesco valore intermedio, il che è l’unico modo pratico per eseguire l’esponenziazione modulare con esponenti di grandi dimensioni.

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

Le conversioni da intero a stringa in basi diverse (bin, oct, hex) sono trattate in Metodi e formattazione delle stringhe.

2.3.6. Il modulo math

Le funzioni matematiche comuni risiedono nel modulo math. Importalo una volta e chiama le sue funzioni tramite un nome puntato:

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

Il modulo math di MicroPython copre i soliti noti (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Per i numeri casuali, vedi il modulo random; per la manipolazione di bit in virgola fissa, gli operatori sopra sono di solito sufficienti.

2.3.7. Numeri complessi

Per il lavoro numerico che richiede componenti immaginarie, Python ha un tipo complex con letterali a suffisso j (1 + 2j). Il modulo cmath rispecchia math per gli input complessi. Entrambi sono presenti nella maggior parte delle build di MicroPython ma raramente necessari per il lavoro con la camera; li menzioniamo principalmente affinché non siano una sorpresa se porti codice che li utilizza.