Operatori Python: aritmetica, divisione // e %, confronto, and/or/not e python round

Gli operatori Python sono simboli che trasformano valori in nuovi valori: + somma, // esegue la divisione intera, and combina condizioni. Qui sotto trovate l'elenco completo degli operatori con esempi, la differenza tra / e //, la logica di and, or, not e le funzioni di arrotondamento: python round, math.ceil, math.floor e abs. Tutti gli esempi si possono incollare nella REPL e verificare.

Elenco degli operatori Python

Gli operatori si dividono in gruppi in base allo scopo. Non serve memorizzare l'intera tabella: nel codice reale si incontrano più spesso l'aritmetica, i confronti e i connettivi logici.

Operatori aritmetici

Addizione, sottrazione e moltiplicazione funzionano come a scuola. Se nell'espressione compare almeno un float, anche il risultato sarà float: 2 + 1.0 dà 3.0. I numeri interi in Python non vanno in overflow — 2 ** 100 viene calcolato con precisione, qualunque sia il numero di cifre.

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Potenza in Python: l'operatore **

L'elevamento a potenza si scrive con due asterischi, non con ^: in Python il simbolo ^ è lo XOR bit a bit, quindi 2 ^ 3 restituisce 1, non 8. Una potenza frazionaria dà la radice: 9 ** 0.5 è 3.0. Esiste anche la funzione pow(x, y), uguale all'operatore, con un terzo argomento per il resto: pow(2, 10, 1000) restituisce 24.

Attenzione alla precedenza: ** viene eseguito prima del meno unario, quindi -2 ** 2 è -4. Se serve il quadrato di un numero negativo, usate le parentesi: (-2) ** 2.

Divisione in Python: /, // e %

In Python ci sono due tipi di divisione, ed è la fonte principale di sorprese per i principianti. La divisione normale / restituisce sempre un float, anche quando la divisione è esatta. La divisione intera // scarta la parte decimale, mentre % restituisce il resto.

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

Divisione intera // e resto %: esempi pratici

La coppia // e % risolve i problemi del tipo «quante unità intere e quanto avanza». Nel corso il tracker delle spese conserva il denaro in centesimi per non perdere precisione e scompone l'importo in euro e centesimi:

cents = 125050            # conserviamo il denaro in centesimi
eur = cents // 100        # 1250 — euro interi
cent = cents % 100        # 50 — resto
print(eur, cent)          # 1250 50

print(40 // 7, "settimane e", 40 % 7, "giorni")   # 5 settimane e 5 giorni

Entrambe le operazioni insieme le restituisce la funzione integrata divmod: divmod(125050, 100) dà la tupla (1250, 50). Il resto serve anche per verificare la parità: n % 2 == 0 è vero per i numeri pari.

Numeri negativi: // arrotonda verso il basso

L'operatore // non si limita a scartare la parte decimale, ma arrotonda verso il basso, cioè verso meno infinito. Per i numeri positivi non c'è differenza, per i negativi sì. Il segno del resto % in Python coincide con il segno del divisore, quindi vale sempre l'uguaglianza a == (a // b) * b + a % b.

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # scarta la parte decimale, non arrotonda verso il basso
-3

Divisione per zero: quale errore

La divisione per zero con uno qualsiasi dei tre operatori genera l'eccezione ZeroDivisionError. Vale sia per i numeri interi sia per quelli decimali. Si può intercettarla con try/except oppure controllare prima il divisore.

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0

Operatori di confronto

I confronti restituiscono True oppure False. L'uguaglianza si verifica con due segni ==, mentre un singolo = è un'assegnazione. Le stringhe si confrontano carattere per carattere in base ai codici dei simboli, quindi "B" < "a" è vero: le maiuscole vengono prima delle minuscole.

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # catena: 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

Le catene di confronto come 0 <= x < 100 sono una comodità di Python: non serve scrivere and. L'ultima riga ricorda l'errore di precisione dei numeri decimali: 0.1 + 0.2 dà 0.30000000000000004. I numeri decimali si confrontano con math.isclose(a, b), mentre il denaro va conservato in centesimi o in Decimal.

Operatori logici and, or, not

Gli operatori logici in Python si scrivono con parole, non con i simboli && e || degli altri linguaggi. and è vero quando sono veri entrambi gli operandi, or quando è vero almeno uno, not inverte il valore.

Precedenza: prima not, poi and, poi or. L'espressione True or False and False è True, perché and viene valutato per primo. Nelle condizioni complesse usate le parentesi: così è più chiaro sia a voi sia ai colleghi.

Che cosa restituiscono davvero and e or

and e or non restituiscono necessariamente True o False, ma uno dei due operandi. or dà il primo valore vero (o l'ultimo, se non ce ne sono), and il primo falso (o l'ultimo). Sono considerati falsi 0, 0.0, la stringa vuota, le collezioni vuote, None e False.

>>> name = ""
>>> name or "Ospite"
'Ospite'
>>> 5 and 0
0
>>> not ""
True

La valutazione è pigra: se il risultato è chiaro dalla parte sinistra, quella destra non viene calcolata. Per questo count and total / count non genera un errore di divisione per zero quando count == 0. L'operatore not, a differenza degli altri due, restituisce sempre un bool.

Operatori is e in

== confronta i valori, mentre is verifica che due nomi puntino allo stesso oggetto. Due carrelli vuoti diversi sono uguali, ma non sono lo stesso oggetto. L'unico uso in cui is serve sempre è il controllo di None: if x is None.

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

Non confrontate numeri e stringhe con is: a volte «funziona» grazie alla cache interna degli oggetti, ma il risultato dipende dall'implementazione, e Python segnala con SyntaxWarning costrutti come x is 5.

L'operatore in verifica l'appartenenza: una sottostringa in una stringa, un elemento in una lista, una chiave in un dizionario. not in è la verifica inversa.

>>> "caffè" in "caffè con latte"
True
>>> "cibo" in {"cibo": 450, "taxi": 300}
True
>>> 5 not in [1, 2, 3]
True

Operatori di assegnazione e operatore walrus :=

Gli operatori composti +=, -=, *=, //= e gli altri sono una scorciatoia: total += 250 significa total = total + 250. In Python non esistono gli operatori ++ e --: x++ provoca un errore di sintassi.

L'operatore walrus := (chiamato così per la somiglianza con il muso e le zanne del tricheco) assegna un valore direttamente dentro un'espressione. È utile quando il valore serve sia per la verifica sia per l'uso successivo:

items = ["caffè", "taxi", "pranzo", "cinema"]
if (n := len(items)) > 3:
    print(f"Troppe spese: {n}")

while (line := input("Importo: ")) != "":
    print(int(line) * 2)

Senza il walrus bisognerebbe chiamare len due volte oppure mettere l'assegnazione su una riga separata. Non abusatene: se la riga diventa illeggibile, meglio una normale assegnazione.

Arrotondamento in Python: round, ceil, floor

Per arrotondare in Python ci sono la funzione integrata round e le funzioni del modulo math. Risolvono compiti diversi, e confonderle è un errore frequente.

La funzione round in Python e l'arrotondamento bancario

La funzione round(x, n) arrotonda a n cifre dopo la virgola; senza il secondo argomento restituisce un int. La trappola principale: python round arrotonda con il metodo «bancario», cioè la metà va al pari più vicino. Per questo round(2.5) dà 2, mentre round(3.5) dà 4. Così, nei calcoli su grandi quantità, gli errori di arrotondamento non si accumulano in un'unica direzione.

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # alle centinaia
1200
>>> round(2.675, 2)     # non 2.68: in binario è 2.67499...
2.67

Se serve l'arrotondamento scolastico «la metà verso l'alto», per esempio in uno scontrino, usate Decimal con la modalità ROUND_HALF_UP. Passate il numero come stringa, per non ereditare l'errore del float:

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

E ancora una regola dal corso: arrotondate solo in fase di output. Per la stampa elegante non serve round — basta una f-string: f"{amount:.2f}" mostra due cifre, mentre il valore resta esatto.

math.ceil e math.floor: arrotondamento verso l'alto e verso il basso

math.ceil serve quando arrotondare per difetto non è ammesso: quanti autobus ordinare, quante pagine di risultati. math.floor serve quando si contano solo le unità complete. Entrambe restituiscono un int.

import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 autobus
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil senza math, trucco con //

Nel modulo math ci sono altre funzioni utili: math.sqrt (radice), math.isclose (confronto di decimali), math.pi, math.gcd. In Python 3.15 è comparso il sottomodulo math.integer (PEP 791) per la matematica intera: contiene comb, factorial, gcd, isqrt, lcm, perm, mentre le vecchie math.gcd e le altre continuano a funzionare.

Funzione abs: valore assoluto

abs(x) restituisce il valore assoluto — la distanza dallo zero senza segno. Non serve importare nulla, la funzione è integrata. Funziona con interi, decimali e perfino con numeri complessi: per 3+4j restituisce la lunghezza del vettore, cioè 5.0.

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # di quanto abbiamo sforato
320

L'uso tipico è la differenza senza considerare la direzione e il confronto con una tolleranza: abs(a - b) < 0.001. Per i decimali è più affidabile math.isclose, perché tiene conto della scala dei numeri.

Precedenza degli operatori

Quando in un'espressione ci sono più operatori, Python li esegue in base alla precedenza, dalla più alta alla più bassa:

1. **
2. unari -x, +x, ~x
3. * / // %
4. + -
5. shift e operazioni bit a bit
6. confronti, in, is
7. not
8. and
9. or
10. :=

Quindi 2 + 3 * 4 vale 14, mentre (2 + 3) * 4 vale 20. Nel dubbio mettete le parentesi: quelle in più non costano nulla, mentre un errore di precedenza si cerca a lungo.

Errori frequenti con gli operatori

Riepilogo

Ricordate l'essenziale: / dà sempre un float, // arrotonda verso il basso, % restituisce il resto con il segno del divisore, e la potenza è **. I logici and, or, not si scrivono come parole e si valutano in modo pigro, is serve per il controllo di None. La funzione python round arrotonda al pari, per l'arrotondamento verso l'alto e verso il basso ci sono math.ceil e math.floor, il valore assoluto si ottiene con abs. Nel corso questi operatori si esercitano sul campo, nel tracker delle spese dove il denaro è conservato in centesimi.