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

URL: https://skillaria.top/it/guides/python/operatori-python-round

L'operatore / in Python restituisce sempre un float, // dà la parte intera con arrotondamento verso il basso, % il resto, ** la potenza. La funzione round(x, n) arrotonda a n cifre con il metodo bancario: round(2.5) dà 2, round(3.5) dà 4; per arrotondare verso l'alto o il basso a un intero si usano math.ceil e math.floor, il valore assoluto si ottiene con abs.

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.

| Gruppo | Operatori | Esempio |
| --- | --- | --- |

| Aritmetici | `+ - * / // % **` | `7 // 2` → 3 |

| Confronto | `== != < > <= >=` | `3 < 5` → True |

| Logici | `and or not` | `not True` → False |

| Identità | `is`, `is not` | `x is None` |

| Appartenenza | `in`, `not in` | `"ca" in "caffè"` → True |

| Assegnazione | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus | `:=` | `if (n := len(s)) > 10:` |

| Bit a bit | `& | ^ ~ << >>` | `5 & 3` → 1 |

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

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

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.

| Funzione | Che cosa fa | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | al più vicino, la metà va al pari | 2 | -2 | 3 |

| `math.floor(x)` | verso il basso, verso meno infinito | 2 | -3 | 2 |

| `math.ceil(x)` | verso l'alto, verso più infinito | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | scarta la parte decimale, verso lo zero | 2 | -2 | 2 |

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

| Errore | Che cosa succede | Come va scritto |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: è un'assegnazione | `if x == 5:` |

| `2 ^ 3` al posto della potenza | XOR bit a bit, risultato 1 | `2 ** 3` |

| si aspetta un intero da `8 / 2` | ottiene `4.0` | `8 // 2` |

| `x == 1 or 2` | sempre vero: `or 2` | `x in (1, 2)` |

| si aspetta 3 da `round(2.5)` | l'arrotondamento bancario dà 2 | `Decimal` con `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

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

## FAQ

**Come arrotondare un numero a due cifre decimali in Python?**

Usate round(x, 2); se vi serve solo stampare il numero in modo leggibile, usate la f-string f"{x:.2f}", che non modifica il valore.

**Perché round(0.5) in Python restituisce 0?**

Perché round arrotonda la metà al numero pari più vicino, e 0 è pari; allo stesso modo round(1.5) e round(2.5) danno 2.

**Come ottenere la parte intera di una divisione in Python?**

Con l'operatore //: 17 // 5 restituisce 3. Con i numeri negativi arrotonda verso il basso, quindi -17 // 5 dà -4; se volete scartare la parte decimale verso lo zero, usate int(-17 / 5).

**Python ha l'operatore ternario?**

Sì, è l'espressione condizionale: valore_se_vero if condizione else valore_se_falso, per esempio "pari" if n % 2 == 0 else "dispari".

**Qual è la differenza tra & e and in Python?**

and è un operatore logico con valutazione pigra, mentre & è l'AND bit a bit per i numeri e l'intersezione per gli insiemi; nelle condizioni if usate and.


---
Source: Skillaria.Top (https://skillaria.top)