7. Boolean e condizioni

Nei capitoli precedenti hai imparato a lavorare con numeri, stringhe e operazioni di base sui dati. Ora siamo pronti a esplorare come Python prende decisioni, una capacità fondamentale che permette ai programmi di reagire in modo diverso a seconda delle condizioni. Al cuore del processo decisionale in Python ci sono i valori Booleani e le condizioni.

Pensa alle decisioni di tutti i giorni: "Se piove, porto l'ombrello." "Se la temperatura è sopra i 30°C, accendo l'aria condizionata." Queste decisioni si basano su condizioni che sono vere o false. Python usa lo stesso principio: valuta condizioni per determinare se sono vere o false, e poi agisce di conseguenza.

In questo capitolo esploreremo i valori Booleani, impareremo a creare condizioni usando gli operatori di confronto, capiremo il concetto di "truthiness" di Python e scopriremo potenti tecniche per costruire espressioni logiche complesse. Alla fine del capitolo avrai padroneggiato i mattoni fondamentali necessari per le istruzioni if e per i cicli (loop) che imparerai nei prossimi capitoli.

7.1) Valori Booleani True e False

Python ha un tipo di dato speciale chiamato bool (abbreviazione di Boolean) che rappresenta valori di verità. Questo tipo ha esattamente due possibili valori: True e False. Nota che questi valori sono scritti con l'iniziale maiuscola: questo è importante in Python. Scrivere true o false (minuscolo) causerà un errore perché Python non li riconosce.

python

# boolean_basics.py
# Creazione di variabili Booleane
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

I valori Booleani sono fondamentali perché rappresentano il risultato di qualsiasi domanda sì/no che il tuo programma potrebbe porsi: Questo numero è maggiore di 10? Questa stringa contiene la lettera 'a'? L'utente è loggato? Ogni condizione in Python alla fine viene valutata come True oppure False.

7.1.1) Boolean in variabili ed espressioni

Puoi memorizzare valori Booleani in variabili proprio come fai con numeri o stringhe. Questo è utile quando vuoi tracciare lo stato di qualcosa nel tuo programma:

python

# boolean_variables.py
# Utilizzo di variabili Booleane per tracciare stati
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Le variabili Booleane possono essere riassegnate
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Le variabili Booleane spesso hanno prefissi come is_, has_ o can_ per chiarire il loro scopo. Questa convenzione di naming aiuta te e gli altri che leggono il codice a capire immediatamente che la variabile contiene un valore vero/falso.

7.2) Operatori di confronto e condizioni di base

Anche se puoi creare valori Booleani direttamente con True e False, la maggior parte dei valori Booleani nei tuoi programmi deriverà da confronti: verifiche di relazioni tra valori. Python fornisce diversi operatori di confronto che confrontano due valori e producono un risultato Booleano.

7.2.1) I sei operatori di confronto

Python ha sei principali operatori di confronto:

Operatore	Significato	Esempio	Risultato
`==`	Uguale a	`5 == 5`	`True`
`!=`	Diverso da	`5 != 3`	`True`
`<`	Minore di	`3 < 5`	`True`
`>`	Maggiore di	`5 > 3`	`True`
`<=`	Minore o uguale a	`5 <= 5`	`True`
`>=`	Maggiore o uguale a	`5 >= 3`	`True`

Vediamo questi operatori in azione:

python

# comparison_operators.py
# Confronto tra numeri
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# Confronti con valori uguali
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Confrontare numeri e stringhe

Gli operatori di confronto funzionano con molti tipi di valori, non solo con gli interi:

python

# comparing_types.py
# Confronto tra numeri in virgola mobile
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Confronto tra stringhe (ordine alfabetico/lessicografico)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# Il confronto tra stringhe è case-sensitive
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Confronto tra le lunghezze delle stringhe usando len()
print(len(name1) == len(name2))  # Output: False

Quando confronta stringhe, Python usa l'ordinamento lessicografico, che è essenzialmente l'ordine alfabetico basato sui valori dei caratteri Unicode. Le lettere maiuscole vengono prima delle minuscole in questo ordinamento, ed è per questo che "Python" e "python" non sono uguali.

7.2.3) Memorizzare i risultati dei confronti

Il risultato di qualsiasi confronto è un valore Booleano, il che significa che puoi memorizzarlo in una variabile:

python

# storing_comparisons.py
# Memorizzare i risultati dei confronti per usarli in seguito
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Impareremo presto i confronti concatenati
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# Uso dei confronti memorizzati in calcoli o altre espressioni
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Memorizzare i risultati dei confronti in variabili con nomi descrittivi rende il tuo codice più leggibile. Invece di scrivere ripetutamente age >= 18 in tutto il programma, puoi usare la variabile is_adult, che comunica chiaramente cosa stai verificando.

7.3) Boolean da confronti, espressioni e funzione bool()

Abbiamo visto che i confronti producono valori Booleani. Ma ci sono altri modi per ottenere valori Booleani in Python, inclusa l'uso della funzione bool() per convertire altri tipi in Booleani.

7.3.1) La funzione bool()

La funzione bool() converte qualsiasi valore nel suo equivalente Booleano. Questo è utile quando vuoi controllare esplicitamente se un valore verrebbe considerato vero o falso in un contesto Booleano:

python

# bool_function.py
# Conversione di numeri in Booleani
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# Conversione di stringhe in Booleani
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Conversione di None in Booleano
print(bool(None))    # Output: False

La funzione bool() segue regole specifiche per la conversione, che esploreremo in dettaglio nella prossima sezione sulla truthiness e falsiness. Per ora, nota che la maggior parte dei valori viene convertita in True, ma alcuni valori speciali come 0, 0.0, le stringhe vuote ("") e None vengono convertiti in False.

7.4) Truthiness e falsiness nelle condizioni

Una delle caratteristiche più potenti di Python è il concetto di truthiness e falsiness. In Python, ogni valore, non solo True e False, ha un'interpretazione Booleana intrinseca. Questo significa che puoi usare qualsiasi valore dove è atteso un Booleano, e Python lo tratterà come vero o falso.

7.4.1) Valori falsy: cosa viene considerato False

In Python, i seguenti valori sono considerati falsy (si comportano come False in contesti Booleani):

Il valore Booleano False stesso
Il valore speciale None
Lo zero numerico in qualsiasi forma: 0, 0.0, 0j (zero complesso)
Sequenze vuote: "" (stringa vuota), [] (lista vuota), () (tupla vuota)
Mapping vuoti: {} (dizionario vuoto)
Insiemi vuoti: set()

Verifichiamolo con la funzione bool():

python

# falsy_values.py
# Tutti questi valori sono falsy
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

7.4.2) Valori truthy: tutto il resto

Ogni altro valore in Python è considerato truthy (si comporta come True in contesti Booleani). Questo include:

Il valore Booleano True stesso
Qualsiasi numero diverso da zero (positivo o negativo)
Qualsiasi stringa, lista, tupla, dizionario o insieme non vuoto
La maggior parte degli oggetti che crei

python

# truthy_values.py
# Tutti questi valori sono truthy
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

Nota importante: La stringa "False" è truthy perché è una stringa non vuota. Anche la stringa "0" è truthy per lo stesso motivo. Solo il valore Booleano False e il valore numerico 0 sono falsy.

7.4.3) Perché la truthiness è importante

Capire la truthiness è importante perché è un concetto fondamentale in Python che incontrerai spesso. Nel Capitolo 8 imparerai le istruzioni if che prendono decisioni basate su condizioni. Queste istruzioni possono usare qualsiasi valore, non solo confronti Booleani espliciti, perché Python valuta automaticamente la truthiness dei valori.

La truthiness ti permette di scrivere codice conciso che controlla se le collezioni contengono elementi, se le stringhe hanno contenuto o se i valori opzionali sono presenti. Ecco un'anteprima di come la truthiness sarà utile (nel Capitolo 8 impareremo la sintassi completa dell'istruzione if):

python

# truthiness_preview.py
# Dimostrazione della truthiness con bool()
# (Nel Capitolo 8 useremo questi valori direttamente nelle istruzioni if)
 
# Controllare se una stringa ha contenuto
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# Controllare se una lista ha elementi
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# Controllare se un valore esiste (non è None)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

Capire la truthiness rende il tuo codice più "pythonic": segue le convenzioni e le idiomatiche di Python. Quando vedi programmatori esperti in Python controllare condizioni senza confronti espliciti, stanno sfruttando la truthiness per scrivere codice più pulito e leggibile.

7.5) Confronti concatenati e errori comuni con i Boolean

Python offre una potente funzionalità chiamata confronti concatenati (chained comparisons) che rende alcune condizioni più leggibili e più vicine alla notazione matematica. Tuttavia, questa funzionalità e altri aspetti della logica Booleana possono portare a errori comuni.

7.5.1) Confronti concatenati

In matematica potresti scrivere "10 < x < 20" per esprimere che x è compreso tra 10 e 20. Python ti permette di scriverlo esattamente nello stesso modo:

python

# chained_comparisons.py
# Verifica se un valore è in un intervallo
x = 15
 
# Il modo matematico (confronto concatenato)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Questo è equivalente a combinare due confronti
# (Impareremo 'and' nel Capitolo 9)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Test con un valore fuori dall'intervallo
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Test con valori al limite
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Inclusione degli estremi con <= e >=
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

I confronti concatenati funzionano valutando ciascuna coppia di elementi adiacenti. L'espressione 10 < x < 20 viene valutata come (10 < x) and (x < 20). Tutti i confronti devono essere veri perché l'intera catena risulti vera.

Puoi concatenare più di due confronti:

python

# multiple_chains.py
# Concatenare più confronti
a = 5
b = 10
c = 15
d = 20
 
# Verifica se i valori sono in ordine crescente
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Ecco una rappresentazione visiva di come funzionano i confronti concatenati:

7.5.2) Errore comune: assegnazione vs confronto

Uno degli errori più comuni che fanno i principianti è usare l'assegnazione (=) quando intendono il confronto (==):

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Questo è un assegnamento, non un confronto
# Assegna 20 a x, non confronta x con 20
# x = 20  # Questo cambierebbe x a 20
 
# Questo è un confronto
result = (x == 20)  # Questo controlla se x è uguale a 20
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# Nel Capitolo 8 imparerai che usare = nelle condizioni causa un errore
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# Il confronto corretto
# Nel Capitolo 8 scriverai: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

Python aiuta a prevenire questo errore nelle istruzioni if (che imparerai nel Capitolo 8) sollevando un SyntaxError se usi l'assegnamento invece del confronto. Tuttavia, in altri contesti, usare = quando intendevi == può creare bug sottili difficili da trovare.

7.5.3) Errore comune: confronti con numeri in virgola mobile

Quando confronti numeri in virgola mobile, devi essere consapevole dei problemi di precisione:

python

# floating_point_comparison.py
# L'aritmetica in virgola mobile può avere problemi di precisione
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# Un confronto diretto potrebbe non funzionare come previsto
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# Il valore reale è molto vicino ma non esattamente 0.3
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Per i confronti tra numeri in virgola mobile, usa una piccola tolleranza
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# Python 3.5+ fornisce math.isclose() per questo
# Impareremo come importare moduli nel Capitolo 23
# import math
# is_close = math.isclose(result, 0.3)

Questo problema nasce perché i computer memorizzano i numeri in virgola mobile in binario, e alcuni numeri decimali (come 0.1) non possono essere rappresentati esattamente in binario. Quando esegui operazioni aritmetiche con questi numeri, si accumulano piccoli errori di arrotondamento. Per la maggior parte degli scopi pratici, questi errori sono trascurabili, ma possono far fallire inaspettatamente confronti di uguaglianza diretti.

7.6) Boolean come interi (1 e 0) e perché evitare l'aritmetica

Ecco un fatto sorprendente: in Python, True e False sono in realtà casi speciali di interi. True è equivalente a 1 e False è equivalente a 0. Questo è un retaggio storico del design di Python, ma ha alcune implicazioni interessanti. Capire questa relazione ti aiuta a evitare confusione, ma dovresti raramente usarla direttamente nel tuo codice.

7.6.1) I Boolean sono interi

Puoi verificare che i Boolean sono interi controllando il loro tipo ed eseguendo operazioni intere:

python

# booleans_as_integers.py
# I Boolean sono un sottotipo di interi
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True è uguale a 1, False è uguale a 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Puoi usare i Boolean nell'aritmetica (ma non dovresti!)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# I Boolean possono essere usati come indici di lista
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

La funzione isinstance() controlla se un valore è un'istanza di un tipo. Quando controlliamo isinstance(True, int), Python restituisce True perché il tipo bool è una sottoclasse del tipo int.

7.6.2) Perché dovresti evitare l'aritmetica con i Boolean

Anche se Python ti permette di usare i Boolean nell'aritmetica, dovresti evitarlo. Usare i Boolean come numeri rende il tuo codice confuso e più difficile da capire. La relazione tra Boolean e interi è principalmente un dettaglio storico di cui dovresti essere consapevole, ma che dovresti raramente usare direttamente.

Ecco perché l'aritmetica con i Boolean è problematica:

python

# boolean_arithmetic_problems.py
# Esempio di codice confuso
count = 0
has_error = True
has_warning = False
 
# Questo funziona ma è confuso
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# Cosa significa? Non è chiaro!
# Approccio migliore: essere espliciti
# Impareremo l'espressione if-else nel Capitolo 10.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

L'unica eccezione comune a questa regola è quando si contano i valori True in una collezione:

python

# counting_trues.py
# Contare quante condizioni sono true
conditions = [True, False, True, True, False]
 
# Questo è accettabile perché l'intento è chiaro
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Questo funziona perché sum() somma i valori
# True è trattato come 1, False come 0
# Quindi sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

In questo caso, usare sum() su una lista di Boolean è un'idiomatica Python comune e ampiamente compresa. L'intento, cioè contare quante condizioni sono vere, è chiaro dal contesto.

7.6.3) Boolean nella conversione di tipi

Poiché i Boolean sono interi, convertirli esplicitamente in interi è ridondante:

python

# boolean_conversion.py
# Conversione di Boolean in interi (non necessaria)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# Ma convertire interi in Boolean è utile
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

Convertire un Boolean in un intero con int() è inutile perché i Boolean si comportano già come interi. Tuttavia, convertire interi (o altri tipi) in Boolean con bool() è utile quando vuoi controllare esplicitamente la truthiness.

7.6.4) La ragione storica

Il motivo per cui i Boolean sono interi in Python è storico. Le prime versioni di Python (prima della 2.3) non avevano un tipo Boolean separato. I programmatori usavano 1 per true e 0 per false. Quando è stato aggiunto il tipo bool, è stato reso una sottoclasse di int per mantenere la retrocompatibilità con il codice esistente.

Oggi dovresti pensare a True e False prima di tutto come valori Booleani. La loro relazione con 1 e 0 è un dettaglio di implementazione a cui raramente devi pensare, tranne quando lo incontri in modi inaspettati.

7.7) Uso di in e not in nelle condizioni

Gli operatori in e not in verificano l'appartenenza, cioè se un valore esiste all'interno di una collezione. Questi operatori sono estremamente utili per creare condizioni leggibili, soprattutto quando lavori con stringhe, liste e altre collezioni.

7.7.1) Verificare l'appartenenza nelle stringhe

L'operatore in controlla se una stringa appare all'interno di un'altra stringa:

python

# string_membership.py
# Verifica se una sottostringa esiste in una stringa
text = "Python programming is fun"
 
# Uso di 'in' per controllare le sottostringhe
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# Confronto case-sensitive
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# Uso di 'not in' per controllare l'assenza
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

L'operatore in esegue una ricerca case-sensitive. Se ti serve una ricerca case-insensitive, puoi convertire entrambe le stringhe nello stesso caso:

python

# case_insensitive_search.py
text = "Python Programming"
 
# Ricerca case-sensitive (non trova corrispondenza)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Ricerca case-insensitive (converti entrambe in minuscolo)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# La stringa originale non viene modificata
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Verificare l'appartenenza nelle liste

L'operatore in funziona anche con le liste (che impareremo in dettaglio nel Capitolo 14):

python

# list_membership.py
# Verifica se un valore esiste in una lista
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# Uso di 'not in'
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Funziona con stringhe in liste
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

7.7.3) Verificare l'appartenenza con gli intervalli (range)

Puoi usare in anche con oggetti range (che impareremo nel Capitolo 12):

python

# range_membership.py
# Verifica se un numero è in un intervallo
age = 25
 
# Uso di 'in' con range
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Tuttavia, gli operatori di confronto sono più efficienti per intervalli numerici
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' con range è utile per sequenze specifiche
valid_ages = range(18, 66)  # Fascia di età lavorativa
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) L'operatore not in

L'operatore not in è l'opposto di in: restituisce True se il valore NON si trova nella collezione:

python

# not_in_operator.py
# Uso di 'not in' per una logica più chiara
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# Usare 'not in' è più leggibile
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Verifica dei campi obbligatori mancanti
provided_fields = ["name", "email"]
 
# Trovare i campi mancanti
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True

Gli operatori in e not in rendono le tue condizioni più leggibili ed espressive. Invece di scrivere confronti complessi, puoi esprimere direttamente "questo valore è in questa collezione?", che corrisponde al modo in cui pensi al problema.

In questo capitolo hai imparato le basi dei valori Booleani e delle condizioni in Python. Ora capisci:

I valori Booleani True e False e il loro ruolo nel processo decisionale
Gli operatori di confronto (==, !=, <, >, <=, >=) per creare condizioni
La funzione bool() per convertire i valori in Booleani
Truthiness e falsiness, cioè come Python tratta tutti i valori come veri o falsi
I confronti concatenati per controlli di intervallo leggibili
Gli errori comuni da evitare quando lavori con i Boolean
La relazione tra Boolean e interi (e perché evitare l'aritmetica con i Boolean)
Il controllo di appartenenza con gli operatori in e not in

Questi concetti costituiscono le fondamenta per le strutture di controllo di flusso che imparerai nei prossimi capitoli. Nel Capitolo 8 userai espressioni Booleane nelle istruzioni if per far sì che i tuoi programmi reagiscano a condizioni diverse. Nel Capitolo 9 imparerai a combinare più condizioni usando operatori logici come and, or e not. E nei Capitoli 10 e 11 userai le condizioni per controllare cicli (loop) che ripetono azioni.

Capire i Boolean e le condizioni è essenziale per scrivere programmi che possono prendere decisioni, validare input e rispondere in modo appropriato a situazioni diverse. Esercitati a lavorare con questi concetti e scoprirai che prendere decisioni in Python diventa naturale e intuitivo.