Operatori in Python: aritmetici, di confronto, logici, di appartenenza e di identità

Gli operatori sono solo simboli per delle azioni

Un operatore è un simbolo (o una breve parola chiave) che dice a Python di fare qualcosa con uno o due valori: sommarli, confrontarli, verificare se uno contiene l'altro. Ne conosci già qualcuno dalla matematica di base; Python ne ha qualcuno in più per la logica, l'appartenenza e l'identità.

Vediamo le categorie principali una alla volta.

Operatori aritmetici

Gli operatori matematici standard, più un paio di specialità di Python:

print(10 + 3)   # 13
print(10 - 3)   # 7
print(10 * 3)   # 30
print(10 / 3)   # 3.3333333...: / restituisce sempre un float
print(10 // 3)  # 3: divisione intera, scarta il resto
print(10 % 3)   # 1: modulo, il resto
print(10 ** 3)  # 1000: elevamento a potenza

Due elementi di questo elenco si dimenticano facilmente:

• / restituisce un float anche quando entrambi i lati sono interi. 10 / 2 ti dà 5.0. Per la divisione intera, usa //.
• % è il modulo. n % 2 == 0 è il modo più pulito per verificare se n è pari.

Python segue la precedenza standard della matematica: ** ha precedenza su * e /, che a loro volta hanno precedenza su + e -. Le parentesi scavalcano tutto:

print(2 + 3 * 4)      # 14, non 20
print((2 + 3) * 4)    # 20

Usa le parentesi senza risparmio quando hai anche solo un dubbio. Non costano nulla e rendono evidente l'intenzione.

Operatori di confronto

Sei confronti, ognuno dei quali restituisce un booleano:

print(5 == 5)    # True: sono uguali?
print(5 != 6)    # True: sono diversi?
print(5 < 6)     # True
print(5 <= 5)    # True
print(6 > 5)     # True
print(6 >= 6)    # True

Python ti permette di concatenare i confronti, cosa insolita e utile:

age = 25

if 18 <= age < 65:
    print("Working age")

Si legge "age è almeno 18 e minore di 65". Dietro le quinte equivale a 18 <= age and age < 65, ma si legge più come in matematica.

Operatori logici

Si scrivono come parole inglesi, non con simboli:

logged_in = True
is_admin = False

print(logged_in and is_admin)   # False: devono essere veri entrambi
print(logged_in or is_admin)    # True: almeno uno deve essere vero
print(not logged_in)            # False: inverte il booleano

Due dettagli da conoscere:

Valutazione in cortocircuito. and si ferma al primo valore falsy; or si ferma al primo valore truthy. Il lato destro non viene nemmeno valutato se il lato sinistro decide già la risposta. Questo ti permette di proteggerti dagli errori in modo sicuro:

name = None

# name.upper() esploderebbe se name fosse None,
# ma il cortocircuito ci salva.
if name is not None and name.upper() == "ADMIN":
    print("Admin access")
else:
    print("Not admin")

and/or restituiscono il valore, non sempre True/False. Restituiscono l'operando che ha deciso il risultato:

print(0 or "default")    # "default"
print("" or "default")   # "default"
print("value" or "fallback")  # "value"

print(1 and "end")       # "end"
print(0 and "never")     # 0

Nel codice reale vedrai name = user_input or "anonymous": è uno schema per i valori predefiniti basato proprio su questo comportamento.

Per le regole complete su questi tre operatori, compresi quali valori contano come falsy, come si ordinano tra loro not, and e or e perché and non è la stessa cosa di &, leggi and, or, not in Python.

Operatori di assegnazione

= assegna. Le forme composte uniscono un'operazione all'assegnazione:

n = 10

n += 5    # come n = n + 5
n -= 2    # n = n - 2
n *= 3    # n = n * 3
n //= 2   # n = n // 2
n %= 4    # n = n % 4
n **= 2   # n = n ** 2

print(n)

Le forme composte funzionano anche con le stringhe (s += "more") e con le liste (lst += [4, 5]). Non sono più veloci della forma estesa; sono solo più corte.

Appartenenza: in e not in

Verificano se un valore compare all'interno di un contenitore:

colors = ["red", "green", "blue"]

print("red" in colors)         # True
print("yellow" not in colors)  # True

text = "hello world"
print("world" in text)         # True
print("z" not in text)         # True

contacts = {"alice": 1, "bob": 2}
print("alice" in contacts)     # True (controlla le chiavi)

in funziona su qualsiasi iterabile: liste, tuple, set, stringhe, dict e altro ancora. Per le ricerche su grandi quantità di dati, in su una lista è O(n); in su un set o un dict è O(1). Fa la differenza quando controlli l'appartenenza molte volte.

Identità: is e is not

is verifica se due variabili puntano allo stesso oggetto in memoria, non solo a valori uguali:

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True: stesso contenuto
print(a is b)   # False: oggetti diversi
print(a is c)   # True: entrambi indicano la stessa lista

Quasi sempre ti serve ==. L'unico caso in cui is dà davvero il meglio è il confronto con None, True e False:

value = None

if value is None:
    print("no value")

La convenzione della comunità è netta: is None, non == None. Lo stesso vale per is True (anche se raramente ti serve).

Operatori bit a bit (saltali alla prima lettura)

Python ha anche operatori bit a bit (&, |, ^, ~, <<, >>) per manipolare i singoli bit di un intero. Sono utili in crittografia, nella programmazione di rete a basso livello e in certi algoritmi. Alla prima lettura puoi tranquillamente ignorarli.

L'operatore walrus (:=)

Python 3.8 ha aggiunto :=, che assegna e restituisce un valore in una sola espressione. È utile nelle condizioni in cui vuoi sia catturare sia verificare un risultato:

numbers = [1, 2, 3, 4, 5]

if (count := len(numbers)) > 3:
    print(f"Got {count} items - more than expected")

Senza il walrus, chiameresti len(numbers) due volte oppure aggiungeresti una riga in più. Non è indispensabile; usalo dove riduce le ripetizioni.

Promemoria sulla precedenza degli operatori

Dalla precedenza più alta alla più bassa, per gli operatori che userai davvero:

1. **: elevamento a potenza
2. *, /, //, %: moltiplicazione e divisione
3. +, -: addizione e sottrazione
4. <, <=, >, >=, ==, !=: confronti
5. not
6. and
7. or

Nel dubbio, metti le parentesi. La chiarezza batte l'astuzia.