10. Usare le espressioni condizionali (espressioni if-else)

Nel Capitolo 8, abbiamo imparato come prendere decisioni nei nostri programmi usando le istruzioni if. Queste istruzioni ci permettono di eseguire blocchi di codice diversi in base alle condizioni. Tuttavia, a volte dobbiamo scegliere tra due valori piuttosto che tra due blocchi di codice. Python fornisce una sintassi speciale per questa situazione comune: le espressioni condizionali (conditional expressions).

Le espressioni condizionali (chiamate anche espressioni ternarie (ternary expressions) o operatore ternario (ternary operator) in altri linguaggi) ci consentono di scrivere codice decisionale compatto quando dobbiamo semplicemente selezionare un valore o un altro in base a una condizione. Sono particolarmente utili per le assegnazioni e quando si costruiscono espressioni più grandi.

10.1) Cosa sono le espressioni condizionali

Un’espressione condizionale è una singola espressione che valuta uno dei due valori in base a una condizione. A differenza di un’istruzione if, che controlla quale blocco di codice viene eseguito, un’espressione condizionale produce un valore che può essere usato immediatamente.

Vediamo uno scenario comune. Supponiamo di scrivere un programma per categorizzare gli studenti in base all’età:

# Istruzione if (come già visto)
age = 16
if age >= 18:
    category = "adult"
else:
    category = "minor"
print(f"Category: {category}")  # Output: Category: minor

Questo funziona perfettamente, ma nota che in realtà stiamo solo scegliendo tra due valori stringa. La struttura è un po’ verbosa per una decisione così semplice. Ecco la stessa logica usando un’espressione condizionale:

# Usare un'espressione condizionale
age = 16
category = "adult" if age >= 18 else "minor"
print(f"Category: {category}")  # Output: Category: minor

Entrambe le versioni producono risultati identici, ma l’espressione condizionale è più compatta. Assegna direttamente uno dei due valori a category in base alla condizione.

Comprendere la differenza fondamentale

La distinzione chiave è che le espressioni condizionali sono espressioni, non istruzioni:

• Un’espressione (expression) è qualcosa che viene valutato come un valore. Puoi usarla ovunque sia atteso un valore: nelle assegnazioni, come argomenti di funzione, dentro altre espressioni, ecc.
• Un’istruzione (statement) è un’istruzione completa che esegue un’azione ma non produce un valore.

# Questa è un'espressione: produce un valore
result = 10 if True else 20
 
# Questa è un'istruzione: esegue azioni ma non è di per sé un valore
if True:
    result = 10
else:
    result = 20

Poiché le espressioni condizionali producono valori, sono più flessibili in certe situazioni. Tuttavia, questo non significa che siano sempre migliori: esploreremo più avanti in questo capitolo quando usare ciascun approccio.

10.2) Sintassi dell’espressione condizionale if–else

La sintassi di un’espressione condizionale segue questo schema:

value_if_true if condition else value_if_false

Scomponiamo ciascun componente:

1. value_if_true: L’espressione che viene valutata e restituita se la condizione è True
2. if: La parola chiave che introduce la condizione
3. condition: Un’espressione booleana che determina quale valore viene restituito
4. else: La parola chiave che introduce il valore alternativo
5. value_if_false: L’espressione che viene valutata e restituita se la condizione è False

Nota che l’ordine potrebbe sembrare insolito se conosci altri linguaggi di programmazione. In Python, il valore “vero” viene prima, poi la condizione, poi il valore “falso”. Questo ordinamento si legge un po’ come un inglese naturale: “Dammi X se la condizione è vera, altrimenti dammi Y”.

Vediamo diversi esempi con tipi diversi di valori:

# Esempio 1: scegliere tra numeri
temperature = 25
comfort_level = "warm" if temperature > 20 else "cool"
print(comfort_level)  # Output: warm
 
# Esempio 2: scegliere tra calcoli
score = 85
bonus = 10 if score >= 90 else 5
print(f"Bonus points: {bonus}")  # Output: Bonus points: 5
 
# Esempio 3: scegliere tra valori booleani
has_permission = True
access = "granted" if has_permission else "denied"
print(f"Access: {access}")  # Output: Access: granted
 
# Esempio 4: la condizione può essere qualunque espressione booleana
username = "admin"
role = "administrator" if username == "admin" else "regular user"
print(f"Role: {role}")  # Output: Role: administrator

Note importanti sulla sintassi

La parte else è obbligatoria in un’espressione condizionale. A differenza di un’istruzione if dove else è opzionale, devi fornire entrambe le alternative:

# Questo è NON VALIDO: manca else
# result = "yes" if True  # SyntaxError
 
# Questo è VALIDO: entrambi i rami sono forniti
result = "yes" if True else "no"

Questo requisito ha senso perché un’espressione deve sempre produrre un valore. Se la condizione è False e non c’è una clausola else, quale valore dovrebbe produrre l’espressione? Python richiede che tu sia esplicito su entrambe le possibilità.

10.3) Come vengono valutate le espressioni condizionali

Capire come Python valuta le espressioni condizionali ti aiuta a scrivere codice corretto e a prevedere cosa faranno i tuoi programmi. La valutazione segue una sequenza specifica e prevedibile.

Il processo di valutazione

Python valuta un’espressione condizionale in questo ordine:

1. Valuta la condizione (l’espressione booleana dopo if)
2. In base al risultato:
   • Se la condizione è True, valuta e restituisce value_if_true
   • Se la condizione è False, valuta e restituisce value_if_false

In modo cruciale, Python valuta solo uno dei due valori dell’espressione, non entrambi. Questo si chiama valutazione a cortocircuito (short-circuit evaluation) ed è simile a come funzionano gli operatori and e or (che abbiamo imparato nel Capitolo 9).

# Viene valutato solo il ramo rilevante
x = 10
result = x * 2 if x > 5 else x / 2
# Poiché x > 5 è True, Python valuta x * 2 (ottenendo 20)
# e non valuta mai x / 2
print(result)  # Output: 20

Perché la valutazione a cortocircuito è importante

La valutazione a cortocircuito può prevenire errori e migliorare l’efficienza:

# Esempio 1: evitare una divisione per zero
denominator = 0
result = "undefined" if denominator == 0 else 100 / denominator
print(result)  # Output: undefined
# La divisione 100 / denominator non viene mai tentata perché
# la condizione è True, quindi evitiamo un ZeroDivisionError

# Esempio 2: evitare operazioni su None
data = None
length = 0 if data is None else len(data)
print(length)  # Output: 0
# len(data) non viene mai chiamata perché data è None,
# evitando un TypeError

Valori truthy/falsy nelle espressioni condizionali

Come per le istruzioni if (Capitolo 8), la condizione in un’espressione condizionale usa le regole di truthiness di Python. Qualunque valore può essere usato come condizione:

# La stringa vuota è falsy
name = ""
greeting = f"Hello, {name}" if name else "Hello, guest"
print(greeting)  # Output: Hello, guest
 
# Una stringa non vuota è truthy
name = "Alice"
greeting = f"Hello, {name}" if name else "Hello, guest"
print(greeting)  # Output: Hello, Alice
 
# Zero è falsy, diverso da zero è truthy
items = 0
message = "You have items" if items else "Your cart is empty"
print(message)  # Output: Your cart is empty
 
items = 3
message = "You have items" if items else "Your cart is empty"
print(message)  # Output: You have items

Valutazione annidata

I valori in un’espressione condizionale possono a loro volta essere espressioni, incluse altre espressioni condizionali. Python le valuta dall’interno verso l’esterno:

# Il value_if_true è esso stesso un calcolo
age = 25
price = age * 2 if age < 18 else age * 3
print(price)  # Output: 75
# Passi: age < 18 → False → valuta age * 3 → 75
 
# La condizione è un'espressione complessa
score = 85
grade = 90
status = "excellent" if score >= 80 and grade >= 85 else "good"
print(status)  # Output: excellent
# Passi: score >= 80 → True, grade >= 85 → True
#        True and True → True → restituisce "excellent"

10.4) Usare le espressioni condizionali nelle assegnazioni

Uno degli usi più comuni delle espressioni condizionali è nelle assegnazioni, quando vogliamo impostare una variabile su uno dei due valori in base a una condizione. Questo schema compare spesso nel codice reale.

Schemi di assegnazione semplici

Vediamo esempi pratici in cui le espressioni condizionali rendono le assegnazioni più pulite:

# Esempio 1: impostare uno sconto in base all'iscrizione
is_member = True
discount = 0.15 if is_member else 0.05
print(f"Discount: {discount * 100}%")  # Output: Discount: 15.0%
 
# Esempio 2: determinare il costo di spedizione
order_total = 45.00
shipping = 0 if order_total >= 50 else 5.99
print(f"Shipping: ${shipping:.2f}")  # Output: Shipping: $5.99
 
# Esempio 3: impostare un valore predefinito
user_input = ""  # Simulazione di input vuoto
page_size = int(user_input) if user_input else 10
print(f"Items per page: {page_size}")  # Output: Items per page: 10

Confronto con le istruzioni if

Vediamo le stesse assegnazioni scritte con istruzioni if per apprezzare la differenza:

# Usare un'istruzione if (più verbosa)
is_member = True
if is_member:
    discount = 0.15
else:
    discount = 0.05
 
# Usare un'espressione condizionale (più compatta)
is_member = True
discount = 0.15 if is_member else 0.05

Entrambi gli approcci funzionano correttamente, ma l’espressione condizionale è più concisa quando stai semplicemente scegliendo tra due valori. La versione con istruzione if richiede quattro righe e ripete due volte il nome della variabile discount, mentre l’espressione condizionale fa la stessa cosa in una sola riga.

Assegnazioni multiple con logica coerente

Quando devi effettuare diverse assegnazioni basate sulla stessa condizione, hai delle scelte:

# Approccio 1: più espressioni condizionali
is_premium = True
price = 99.99 if is_premium else 149.99
features = "all" if is_premium else "basic"
support = "priority" if is_premium else "standard"
 
# Approccio 2: una sola istruzione if per più assegnazioni
is_premium = True
if is_premium:
    price = 99.99
    features = "all"
    support = "priority"
else:
    price = 149.99
    features = "basic"
    support = "standard"

In questo caso, l’approccio con istruzione if (Approccio 2) è spesso più leggibile perché raggruppa insieme assegnazioni correlate e rende chiara la relazione tra di esse. L’approccio con espressione condizionale (Approccio 1) funziona ma ripete tre volte la condizione, cosa che può rendere più difficile la manutenzione se la condizione deve cambiare.

10.5) Usare le espressioni condizionali dentro espressioni più grandi

Poiché le espressioni condizionali producono valori, possono essere incorporate dentro espressioni più grandi. Questo permette codice potente e compatto, anche se richiede attenzione per mantenere la leggibilità.

Espressioni condizionali in aritmetica

Puoi usare le espressioni condizionali come operandi in operazioni aritmetiche:

# Addizione condizionale
base_score = 80
bonus_eligible = True
final_score = base_score + (10 if bonus_eligible else 0)
print(f"Final score: {final_score}")  # Output: Final score: 90

Espressioni condizionali nella formattazione delle stringhe

Le espressioni condizionali funzionano in modo naturale con le f-string e con altre operazioni sulle stringhe:

# Esempio 1: pluralizzazione nei messaggi
item_count = 1
message = f"You have {item_count} {'item' if item_count == 1 else 'items'}"
print(message)  # Output: You have 1 item
 
item_count = 3
message = f"You have {item_count} {'item' if item_count == 1 else 'items'}"
print(message)  # Output: You have 3 items
 
# Esempio 2: saluto condizionale in base all'ora
hour = 14
greeting = f"Good {'morning' if hour < 12 else 'afternoon'}, user!"
print(greeting)  # Output: Good afternoon, user!

Espressioni condizionali annidate

Puoi annidare espressioni condizionali per gestire più condizioni, anche se questo andrebbe fatto con parsimonia:

# Esempio 1: classificazione a tre livelli
score = 85
grade = "A" if score >= 90 else ("B" if score >= 80 else "C")
print(f"Grade: {grade}")  # Output: Grade: B
 
# Tracciamo questo passaggio per passaggio:
# score >= 90? No (85 < 90)
# Quindi valuta la parte else: ("B" if score >= 80 else "C")
# score >= 80? Sì (85 >= 80)
# Restituisce "B"
 
# Esempio 2: classificazione della temperatura
temp = 15
category = "hot" if temp > 25 else ("warm" if temp > 15 else "cold")
print(f"Category: {category}")  # Output: Category: cold
 
# Esempio 3: prezzo basato sull'età con più fasce
age = 65
price = 0 if age < 5 else (8 if age < 18 else (12 if age < 65 else 8))
print(f"Ticket price: ${price}")  # Output: Ticket price: $8

Nota importante sull’annidamento: anche se le espressioni condizionali annidate sono possibili, possono diventare rapidamente difficili da leggere. Il terzo esempio sopra è tecnicamente corretto ma difficile da capire. Discuteremo alternative migliori nella Sezione 10.7.

Espressioni condizionali nei confronti

Puoi usare le espressioni condizionali all’interno di operazioni di confronto:

# Esempio 1: confronto con un valore condizionale
base_value = 10
threshold = 15
is_large = True
result = base_value > (threshold if is_large else 5)
print(result)  # Output: False
# Valuta: base_value > 15 → 10 > 15 → False
 
# Esempio 2: controllo di uguaglianza condizionale
user_role = "admin"
required_role = "admin" if True else "user"
has_access = user_role == required_role
print(has_access)  # Output: True

10.6) Espressione condizionale vs istruzione if (espressione vs istruzione)

Capire quando usare un’espressione condizionale rispetto a un’istruzione if è fondamentale per scrivere codice chiaro e manutenibile. La distinzione dipende dalla differenza fondamentale tra espressioni e istruzioni in Python.

Espressioni vs istruzioni: la differenza fondamentale

Chiariamo questi termini con precisione:

• Un’espressione (expression) è una combinazione di valori, variabili, operatori e chiamate di funzione che Python valuta per produrre un valore. Esempi: 2 + 3, "hello".upper(), x if x > 0 else 0

• Un’istruzione (statement) è un’istruzione completa che esegue un’azione. Le istruzioni non producono valori: fanno cose. Esempi: if x > 0: print("positive"), x = 5, for i in range(10): print(i)

# Questa è un'espressione: produce un valore (7)
result = 3 + 4
 
# Questa è un'istruzione: esegue un'azione (stampa)
print("Hello")
 
# Un'espressione condizionale è un'espressione
value = "yes" if True else "no"  # Produce "yes"
 
# Un'istruzione if è un'istruzione
if True:
    value = "yes"
else:
    value = "no"
# Esegue l'assegnazione ma l'if in sé non produce un valore

Quando usare le espressioni condizionali

Le espressioni condizionali sono ideali quando:

1. Stai scegliendo tra due valori per un’assegnazione:

# Buon uso dell'espressione condizionale
age = 16
status = "adult" if age >= 18 else "minor"
 
# Meno conciso con l'istruzione if
age = 16
if age >= 18:
    status = "adult"
else:
    status = "minor"

2. Ti serve un valore inline dentro un’espressione più grande:

# Buon uso: valore necessario in una f-string
items = 1
print(f"You have {items} {'item' if items == 1 else 'items'}")
# Output: You have 1 item
 
# Scomodo con l'istruzione if: richiede un'assegnazione preliminare
items = 1
if items == 1:
    word = "item"
else:
    word = "items"
print(f"You have {items} {word}")

3. La logica è semplice e l’espressione rimane leggibile:

# Buon uso: logica semplice e chiara
discount = 0.15 if is_member else 0.05
max_value = a if a > b else b
sign = "positive" if x > 0 else "non-positive"

Quando usare le istruzioni if

Usa le istruzioni if quando:

1. Devi eseguire più istruzioni in ogni ramo:

# Usa l'istruzione if: più azioni per ramo
if score >= 90:
    grade = "A"
    message = "Excellent work!"
    bonus_points = 10
else:
    grade = "B"
    message = "Good job!"
    bonus_points = 5
 
# Le espressioni condizionali sarebbero scomode qui:
# grade = "A" if score >= 90 else "B"
# message = "Excellent work!" if score >= 90 else "Good job!"
# bonus_points = 10 if score >= 90 else 5
# (Ripete la condizione inutilmente)

2. Hai più di due rami (elif):

# Usa l'istruzione if: più rami
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"
 
# Le espressioni condizionali annidate diventano difficili da leggere:
# grade = "A" if score >= 90 else ("B" if score >= 80 else ("C" if score >= 70 else "F"))

3. Uno dei rami non dovrebbe fare nulla:

# Usa l'istruzione if: il ramo else non fa nulla
if error_occurred:
    print("An error occurred")
    log_error(error_message)
# Nessun else necessario
 
# L'espressione condizionale richiede entrambi i rami:
# result = handle_error() if error_occurred else None  # Scomodo

Confronto affiancato

Vediamo la stessa logica implementata in entrambi i modi:

# Scenario: impostare un costo di spedizione
 
# Versione 1: espressione condizionale (buona per una scelta semplice di valori)
order_total = 45.00
shipping = 0 if order_total >= 50 else 5.99
 
# Versione 2: istruzione if (più verbosa ma più chiara per alcuni)
order_total = 45.00
if order_total >= 50:
    shipping = 0
else:
    shipping = 5.99
 
# Entrambe producono lo stesso risultato
print(f"Shipping: ${shipping:.2f}")  # Output: Shipping: $5.99

Per questo caso semplice, l’espressione condizionale è più concisa ed è altrettanto chiara. Ma considera uno scenario più complesso:

# Scenario: elaborare un ordine con più passaggi
 
# Versione 1: istruzione if (appropriata per più azioni)
order_total = 45.00
if order_total >= 50:
    shipping = 0
    discount = 0.10
    message = "Free shipping applied!"
else:
    shipping = 5.99
    discount = 0
    message = "Add $5 more for free shipping"
 
# Versione 2: espressioni condizionali (scomode e ripetitive)
order_total = 45.00
shipping = 0 if order_total >= 50 else 5.99
discount = 0.10 if order_total >= 50 else 0
message = "Free shipping applied!" if order_total >= 50 else "Add $5 more for free shipping"

Qui la versione con istruzione if è più chiara perché raggruppa la logica correlata e non ripete la condizione.

10.7) Quando le espressioni condizionali migliorano la leggibilità (e quando no)

Le espressioni condizionali sono uno strumento potente, ma come qualsiasi strumento possono essere usate male. L’obiettivo è sempre scrivere codice non solo corretto, ma anche chiaro e manutenibile. Esploriamo alcune linee guida per usare efficacemente le espressioni condizionali.

Quando le espressioni condizionali migliorano la leggibilità

1. Scelte semplici e chiare tra due valori

Le espressioni condizionali eccellono quando la logica è diretta:

# Uso eccellente: chiarissimo
discount = 0.20 if is_member else 0.10
 
# Uso eccellente: significato evidente
status = "active" if user_logged_in else "inactive"
 
# Uso eccellente: scelta booleana semplice
can_vote = True if age >= 18 else False
# Anche se potrebbe essere ancora più semplice: can_vote = age >= 18

2. Selezione di valori inline nelle espressioni

Quando ti serve un valore inline e separarlo sarebbe scomodo:

# Uso eccellente: pluralizzazione naturale
print(f"Found {count} {'result' if count == 1 else 'results'}")
 
# Uso eccellente: aggiustamento inline del calcolo
total = base_price * (0.9 if is_sale else 1.0)
 
# Uso eccellente: formattazione condizionale
output = f"Status: {status.upper() if is_error else status.lower()}"

3. Impostare valori predefiniti

Le espressioni condizionali funzionano bene per fornire valori di fallback:

# Uso eccellente: pattern del valore predefinito
display_name = username if username else "Guest"
 
# Uso eccellente: configurazione con valori predefiniti
page_size = user_preference if user_preference else 25
 
# Uso eccellente: divisione sicura
result = total / count if count > 0 else 0

Quando le espressioni condizionali peggiorano la leggibilità

1. Espressioni condizionali annidate

Annidare espressioni condizionali crea codice difficile da leggere:

# Scarsa leggibilità: espressioni condizionali annidate
grade = "A" if score >= 90 else ("B" if score >= 80 else ("C" if score >= 70 else "F"))
 
# Molto meglio: usa l'istruzione if-elif-else
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

La versione if-elif-else è immediatamente comprensibile. L’espressione condizionale annidata richiede un’analisi attenta per capire la logica.

2. Condizioni complesse

Quando la condizione stessa è complessa, le espressioni condizionali diventano difficili da leggere:

# Scarsa leggibilità: condizione complessa
result = "eligible" if age >= 18 and income > 30000 and credit_score > 650 and not has_bankruptcy else "not eligible"
 
# Meglio: usa un'istruzione if con struttura chiara
if age >= 18 and income > 30000 and credit_score > 650 and not has_bankruptcy:
    result = "eligible"
else:
    result = "not eligible"
 
# Ancora meglio: scomponi la condizione
meets_age_requirement = age >= 18
meets_income_requirement = income > 30000
meets_credit_requirement = credit_score > 650
has_clean_record = not has_bankruptcy
 
if meets_age_requirement and meets_income_requirement and meets_credit_requirement and has_clean_record:
    result = "eligible"
else:
    result = "not eligible"

3. Più espressioni condizionali in una sola riga

Combinare più espressioni condizionali in una singola riga:

# Scarsa leggibilità: troppo in una riga
price = base * (0.9 if is_member else 1.0) * (0.85 if is_sale else 1.0) + (0 if free_shipping else 5.99)
 
# Meglio: dividi in passaggi
member_multiplier = 0.9 if is_member else 1.0
sale_multiplier = 0.85 if is_sale else 1.0
shipping_cost = 0 if free_shipping else 5.99
price = base * member_multiplier * sale_multiplier + shipping_cost
 
# Oppure usa l'istruzione if se la logica è complessa
if is_member:
    price = base * 0.9
else:
    price = base
 
if is_sale:
    price = price * 0.85
 
if free_shipping:
    shipping_cost = 0
else:
    shipping_cost = 5.99
 
price = price + shipping_cost

La conclusione

Usa le espressioni condizionali quando rendono il tuo codice più chiaro e più conciso. Usa le istruzioni if quando ti servono:

• Più istruzioni per ramo
• Più di due rami (elif)
• Condizioni o logica complesse
• Effetti collaterali o azioni, anziché selezione di valori

Nel dubbio, preferisci la chiarezza alla furbizia. Il codice viene letto molto più spesso di quanto venga scritto, quindi ottimizza per il lettore.

Le espressioni condizionali sono un’aggiunta preziosa al tuo toolkit Python. Ti permettono di scrivere codice conciso ed elegante quando scegli tra due valori. Capendo quando migliorano la leggibilità e quando no, puoi prendere decisioni informate su quando usarle.

I principi chiave da ricordare:

1. Le espressioni condizionali producono valori e possono essere usate ovunque serva un valore
2. La sintassi è value_if_true if condition else value_if_false
3. Python valuta solo il ramo rilevante (valutazione a cortocircuito)
4. Sono ideali per scelte semplici di valori in assegnazioni ed espressioni
5. Usa le istruzioni if per più azioni, logica complessa o più di due rami
6. Dai priorità alla leggibilità: se un’espressione condizionale è difficile da capire, usa invece un’istruzione if

Man mano che continui a imparare Python, svilupperai un’intuizione su quando le espressioni condizionali migliorano il tuo codice. Esercitati a usarle prima in casi semplici e, gradualmente, riconoscerai gli schemi in cui danno il meglio. Nel prossimo capitolo esploreremo i cicli while, che ci permettono di ripetere azioni in base alle condizioni—costruendo sulle capacità decisionali che abbiamo sviluppato in questa parte del libro.