Numeri e booleani in Python: int, float, bool e aritmetica

Due tipi di numeri, un solo tipo di verità

I tipi numerici che userai ogni giorno sono int e float, più bool per i valori vero/falso. Bastano per quasi tutta l'aritmetica e la logica di cui ha bisogno un normale programma Python.

count = 42
ratio = 0.25
is_ready = True

print(type(count), type(ratio), type(is_ready))

In Python i booleani sono un sottotipo degli interi: True è letteralmente 1 e False è letteralmente 0, e questo apre la strada a qualche trucco utile più avanti.

Aritmetica con gli interi

Gli interi in Python non vanno mai in overflow. Sembra un dettaglio finché non scrivi la tua prima funzione fattoriale e ti accorgi che la maggior parte degli altri linguaggi a quel punto sarebbe già passata in silenzio a un numero negativo.

print(2 ** 100)
print(1000 * 1000 * 1000 * 1000)

Entrambi producono risposte esatte, per quanto grandi. L'unico limite è la memoria.

Gli operatori aritmetici sono quelli che ti aspetti, più un paio:

print(10 + 3)   # 13   addizione
print(10 - 3)   # 7    sottrazione
print(10 * 3)   # 30   moltiplicazione
print(10 / 3)   # 3.3333... divisione vera (restituisce 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

Tre cose da memorizzare da questo elenco:

• / restituisce sempre un float in Python 3, anche quando entrambi i lati sono interi. 10 / 2 ti dà 5.0, non 5. Se vuoi un intero, usa //.
• // arrotonda verso meno infinito, quindi -7 // 2 fa -4, non -3. Insolito, ma coerente.
• % restituisce il resto, ed è comodo per chiedersi "questo numero è pari?" (n % 2 == 0) e per ricominciare da capo dentro un intervallo fisso.

I float e la loro famosa trappola

I float sono imperfetti per costruzione. Vengono memorizzati in binario, che non può rappresentare esattamente la maggior parte delle frazioni decimali. L'esempio da manuale:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

La prima riga stampa 0.30000000000000004. La seconda stampa False. Ogni linguaggio che segue lo standard IEEE 754 (Python, JavaScript, Java, C) si comporta così. Non è un bug di Python.

In pratica questo significa due cose:

1. Non confrontare i float con ==. Se ti basta "abbastanza vicino", usa math.isclose(a, b) o controlla se abs(a - b) < some_tolerance.
2. Per i soldi, usa decimal.Decimal. Il modulo decimal della libreria standard offre un'aritmetica decimale esatta, senza sorprese come 0.1 + 0.2. È più lento dei float, ed è per questo che non è il comportamento predefinito, ma è la scelta giusta per le valute.

from decimal import Decimal

total = Decimal("0.1") + Decimal("0.2")
print(total)

Convertire tra tipi numerici

Python non converte di nascosto un intero in stringa o una stringa in numero. Lo chiedi tu in modo esplicito:

age_text = "30"
age = int(age_text)
print(age + 5)

price = float("19.99")
print(price)

count = 7
label = "Count: " + str(count)
print(label)

Le conversioni non valide sollevano ValueError:

>>> int("hello")
ValueError: invalid literal for int() with base 10: 'hello'

Il messaggio di errore è diretto e facile da gestire. Pulisci l'input o intercetta l'eccezione.

I booleani, un po' più a fondo

True e False sono i due valori booleani, scritti esattamente così, con l'iniziale maiuscola. La maggior parte dei confronti ne produce uno:

print(5 > 3)
print("abc" == "abc")
print([1] != [1])

Gli operatori booleani sono and, or e not, scritti come parole inglesi invece che con simboli:

can_drive = True
has_car = False

print(can_drive and has_car)   # False: servono entrambi
print(can_drive or has_car)    # True: ne basta uno
print(not can_drive)           # False

Una sottigliezza utile da conoscere: and e or non restituiscono per forza True o False, ma il valore che ha deciso l'espressione. 0 or "fallback" restituisce "fallback"; 5 and 10 restituisce 10. Questo ti permette di scrivere valori predefiniti brevi come name = user_input or "anonymous", ma è bene saperlo anche nel caso in cui un controllo booleano ti restituisca un tipo inaspettato.

Truthy e falsy

Python tratta molti valori come "quasi veri" o "quasi falsi" quando li usi in un contesto booleano come if o while. I valori falsy sono:

• False
• 0, 0.0
• None
• I contenitori vuoti: "", [], {}, set(), ()

Tutto il resto è truthy. Questo ti permette di scrivere controlli dall'aspetto più naturale:

name = ""

if name:
    print(f"Hello, {name}")
else:
    print("No name provided")

Leggi if name: come "se name contiene qualcosa". Molto più pulito di if name != "":. Fai solo attenzione con i numeri: if count: tratterà 0 come "salta", che di solito, ma non sempre, è quello che vuoi. Se zero è un valore legittimo, usa invece if count is not None:.

Aritmetica con i booleani

Visto che i booleani sono interi, puoi farci dei calcoli:

checks = [True, False, True, True, False]
print(sum(checks))   # 3: conta quanti sono True

È un trucco che torna utile abbastanza spesso da tenerlo a mente. Se vuoi contare quanti elementi di una lista superano un test, somma un generatore che restituisce booleani:

scores = [52, 78, 91, 45, 88, 63]
above_60 = sum(score >= 60 for score in scores)
print(above_60)

In pratica

• Gli interi non vanno mai in overflow. Usali liberamente.
• / restituisce un float; usa // quando vuoi la divisione intera.
• Non confrontare i float con ==; confrontali con una tolleranza, oppure usa Decimal per i soldi.
• La truthiness rende le condizioni più leggibili, purché ti ricordi che 0 e le stringhe vuote sono falsy.

Prossimo argomento: input e print, i due strumenti che trasformano i tuoi script da programmi muti in conversazioni.