Operatori logici in Python: and, or, not, cortocircuito e truthiness

Tre parole al posto dei simboli

Gli operatori logici di Python sono le parole inglesi and, or e not. Altri linguaggi li scrivono &&, || e !. In Python && e || sono un SyntaxError, e ! compare solo all'interno di != ("diverso da").

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: devono essere veri entrambi
print(has_ticket or is_adult)    # True: almeno uno è vero
print(not is_adult)              # True: inverte il valore

Con True e False le regole sono quelle che ti aspetti:

and richiede che entrambi i lati siano veri. or ne richiede almeno uno. not prende un solo valore e lo inverte.

Nel codice reale i lati sono di solito dei confronti, e il risultato alimenta un if o un while:

age = 34
country = "CA"

if age >= 18 and country in ("US", "CA"):
    print("eligible")

if age < 13 or age > 65:
    print("discounted ticket")
else:
    print("standard ticket")

Output:

eligible
standard ticket

Questo basta per la maggior parte delle condizioni. Il resto della pagina spiega cosa fanno gli operatori con valori che non sono True o False, e le regole che decidono quale lato di un'espressione viene eseguito.

Valori truthy e falsy

and, or e not accettano qualsiasi valore, non solo i booleani. Python decide se un valore conta come vero in base alla sua truthiness. Questi valori sono falsy:

• False e None
• lo zero di qualsiasi tipo numerico: 0, 0.0
• contenitori e stringhe vuoti: "", [], (), {}, set(), range(0)

Tutto il resto è truthy, compresi "0", "False", [0] e -1. Puoi vedere come Python classifica un valore con bool():

for value in [0, 1, -1, "", "0", [], [0], None, 0.0]:
    print(repr(value), bool(value))

Output:

0 False
1 True
-1 True
'' False
'0' True
[] False
[0] True
None False
0.0 False

La stringa "0" è truthy perché è una stringa non vuota. È un tranello per chi legge numeri dall'input e li verifica prima di convertirli. La pagina su numeri e booleani spiega il rapporto tra bool e int.

and e or restituiscono un operando

Ecco dove Python si distingue dalla maggior parte dei linguaggi. and e or non producono un nuovo True o False. Restituiscono uno dei due valori che gli hai dato:

• x or y restituisce x se x è truthy, altrimenti restituisce y.
• x and y restituisce x se x è falsy, altrimenti restituisce y.

print(0 or 5)            # 5
print(3 or 5)            # 3
print("" or "guest")     # guest
print([] or None)        # None

print(0 and 5)           # 0
print(3 and 5)           # 5
print("a" and "b")       # b
print(None and 1 / 0)    # None, e nessun ZeroDivisionError

Quando entrambi gli operandi sono booleani, "restituire un operando" e "restituire un booleano" sono la stessa cosa: per questo la differenza passa inosservata finché non mescoli altri tipi.

not è l'eccezione: restituisce sempre True o False.

print(not 0)        # True
print(not "hi")     # False
print(not [])       # True

Se ti serve un vero booleano da un'espressione and/or, per esempio per salvarlo o restituirlo da una funzione che promette un bool, avvolgila in bool():

name = "Ada"
email = ""

print(name and email)         # stampa una riga vuota: il valore è ""
print(bool(name and email))   # False

Valutazione in cortocircuito

Python valuta and e or da sinistra a destra e si ferma non appena conosce la risposta:

• and si ferma al primo valore falsy, perché niente di ciò che viene dopo può rendere vera l'intera espressione.
• or si ferma al primo valore truthy, perché niente di ciò che viene dopo può rendere falsa l'intera espressione.

Il lato saltato non viene proprio eseguito. Puoi vederlo succedere con funzioni che stampano qualcosa quando vengono chiamate:

def check(label, result):
    print(f"  checking {label}")
    return result

print("and:")
print(check("A", False) and check("B", True))

print("or:")
print(check("A", True) or check("B", False))

Output:

and:
  checking A
False
or:
  checking A
True

B non viene mai controllato in nessuno dei due casi. È il cortocircuito a rendere sicure le condizioni di guardia. La seconda metà di ciascuna condizione qui sotto andrebbe in crash da sola, ma viene eseguita solo dopo che la prima metà ha escluso il caso problematico:

user = None
items = []

if user is not None and user.startswith("admin"):
    print("admin")
else:
    print("not an admin")

if items and items[0] > 10:
    print("first item is large")
else:
    print("no large first item")

Metti per primo il test più economico o quello protettivo. Invertendo l'ordine, user.startswith("admin") and user is not None solleva AttributeError quando user è None.

Schemi basati su or e and

Siccome or restituisce il suo primo operando truthy, ti dà un valore predefinito in una riga:

def greet(name):
    name = name or "guest"
    print(f"Hello, {name}!")

greet("Ada")
greet("")
greet(None)

Output:

Hello, Ada!
Hello, guest!
Hello, guest!

Il problema è che or sostituisce ogni valore falsy, non solo None. Se 0, "" o [] sono input legittimi, or li butterà via:

volume = 0
print(volume or 50)                           # 50: lo 0 è stato sostituito

print(volume if volume is not None else 50)   # 0: viene sostituito solo None

Usa x if x is not None else default quando zero o vuoto sono valori validi. La pagina su if/else spiega questa espressione condizionale.

and ha uno schema corrispondente: "usa questo valore solo se il primo è impostato". È meno comune e spesso più chiaro scritto come if, quindi usalo con parsimonia:

user = {"name": "Ada"}
print(user and user["name"])   # Ada

user = None
print(user and user["name"])   # None

Precedenza: prima not, poi and, poi or

Quando un'espressione mescola i tre operatori, Python applica prima not, poi and, poi or. I confronti come ==, < e in vengono applicati prima di tutti loro.

a, b, c = True, False, False

print(a or b and c)      # True: si legge come a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: si legge come (not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: si legge come not (1 == 2)

a or b and c e (a or b) and c danno risposte diverse con gli stessi valori, quindi una condizione mista dovrebbe avere le parentesi anche quando l'ordine predefinito è quello giusto. Non costano nulla e tolgono ogni dubbio a chi leggerà il codice dopo di te.

and/or contro &/|

& e | somigliano ad and e or e a volte danno la stessa risposta, ma sono operatori diversi.

• and / or verificano la truthiness, vanno in cortocircuito e restituiscono uno degli operandi.
• & / | sono operatori bit a bit. Sugli interi combinano i bit dei due numeri. Sui set significano intersezione e unione. Su True e False restituiscono un booleano. Non vanno mai in cortocircuito: entrambi i lati vengono sempre valutati.

print(6 and 3)   # 3: 6 è truthy, quindi and restituisce il secondo operando
print(6 & 3)     # 2: 110 & 011 = 010 in binario

print(6 or 3)    # 6
print(6 | 3)     # 7: 110 | 011 = 111

print({1, 2, 3} & {2, 3, 4})   # {2, 3}
print(True & False)             # False

Gli operatori bit a bit hanno anche una precedenza più alta dei confronti, e questo trasforma una condizione scritta con & in tutt'altra cosa:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: si legge come x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, ma le parentesi sono obbligatorie

1 & y è 1 & 5, cioè 1, quindi la riga centrale diventa la catena 5 > 1 > 1, e 1 > 1 è falso. Nel normale codice Python, usa and, or e not per le condizioni.

L'unico caso in cui &, | e ~ sono corretti per le condizioni è NumPy e pandas. Un array contiene molti valori, quindi non ha un unico valore di verità, e and solleva ValueError: The truth value of an array ... is ambiguous. Le librerie ridefiniscono & e | per lavorare elemento per elemento: ecco perché i filtri di pandas hanno la forma df[(df.age > 18) & (df.country == "CA")], con le parentesi attorno a ogni confronto per il motivo di precedenza visto sopra.

any() e all(): and e or su una lista

Per combinare un'intera sequenza di condizioni, usa le funzioni integrate all() (un and su tutti gli elementi) e any() (un or su tutti gli elementi). Entrambe vanno in cortocircuito allo stesso modo:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: tutti i voti sono sufficienti
print(any(s >= 90 for s in scores))   # True: almeno un voto eccellente
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: niente ha fallito
print(any([]))   # False: niente ha superato il test

A differenza di and e or, any() e all() restituiscono sempre un booleano.

Errori comuni

Confrontare una variabile con più valori usando or. Questa condizione è sempre vera:

color = "green"

if color == "red" or "blue":
    print("matched (wrong!)")

if color == "red" or color == "blue":
    print("matched")
else:
    print("no match")

if color in ("red", "blue"):
    print("matched")
else:
    print("no match")

Python legge la prima condizione come (color == "red") or "blue". Il confronto è False, quindi or restituisce "blue", una stringa non vuota, che è truthy. Ripeti il confronto su entrambi i lati o, meglio ancora, verifica l'appartenenza con in.

Scrivere && o ||. Sono entrambi un SyntaxError. Usa and e or.

Aspettarsi un booleano da and/or. x = a or b salva a o b stesso. Spesso è proprio ciò che vuoi, ma se una funzione deve restituire True o False, converti con bool().

Affidarsi alla precedenza nelle condizioni miste. a or b and c è legale e ben definito, ma aggiungi le parentesi così nessuno deve ricordarsi la regola.