Valori, tipi, etichette
Ogni valore ha un tipo, e il tipo decide cosa puoi farci
- 12 minuti di lettura
3 e "3" sembrano la stessa cosa. Per Python no: il primo è un numero, il secondo è un testo lungo un carattere. Con il numero puoi fare i conti, con il testo no.
print(3 + 4) # 7
print("3" + "4") # 34Lo stesso +, due risultati diversi. Non decide il +: decide il tipo dei valori. Questo capitolo è tutto qui: quali tipi ci sono, come si passa da uno all'altro, e cosa succede quando li mescoli.
Il disegno
Lo disegniamo come in Etichette e scatole: etichette a sinistra, scatole a destra. Il valore sta nella scatola, e sulla scatola c'è scritto il suo tipo. La variabile è solo l'etichetta attaccata alla scatola.
binario = 3
stazione = "Via Variabile"
prezzo = 2.2
aperta = True
guasto = NoneI cinque tipi di base
| Tipo | Cos'è | Si scrive | type() dice |
|---|---|---|---|
int | Un numero intero | 3, 0, -12 | <class 'int'> |
float | Un numero con i decimali, scritti dopo il punto | 2.2, 0.5, 3.0 | <class 'float'> |
str | Un testo, tra virgolette | "Via Variabile", "3", "" | <class 'str'> |
bool | Vero o falso, con la maiuscola | True, False | <class 'bool'> |
None | Nessun valore | None | <class 'NoneType'> |
Tre dettagli che sorprendono:
3.0è unfloat, anche se i decimali sono zero.- Una lettera sola è un
str:"A". Il tipo «carattere» non esiste. "3"è unstr. Le virgolette vincono su tutto quello che c'è dentro.
Quando un valore non si comporta come pensi, chiedi a type() chi è:
print(type(3)) # <class 'int'>
print(type("3")) # <class 'str'>
print(type(3.0)) # <class 'float'>Le operazioni sui numeri
| Si scrive | Cosa fa | Esempio | Dà |
|---|---|---|---|
+ - * | Somma, sottrazione, moltiplicazione | 7 * 2 | 14 |
/ | La divisione. Dà sempre un float | 8 / 2 | 4.0 |
// | La divisione intera: quante volte ci sta | 7 // 2 | 3 |
% | Il resto della divisione intera | 7 % 2 | 1 |
** | La potenza | 2 ** 10 | 1024 |
// e % lavorano in coppia. Un abbonamento di 30 giorni: 30 // 7 fa 4 settimane intere, 30 % 7 fa 2 giorni in più.
L'ordine è quello della matematica: prima **, poi *, /, // e %, per ultimi + e -. Le parentesi lo cambiano:
print(2 + 3 * 4) # 14: prima la moltiplicazione
print((2 + 3) * 4) # 20Un int e un float insieme danno un float: 2 + 0.5 fa 2.5, 3 * 1.0 fa 3.0.
Il testo: + attacca, * ripete
print("Via " + "Variabile") # Via Variabile
print("ab" * 3) # ababab
print("3" * 4) # 3333
print("3" + 4) # TypeErrorPerché "3" * 4 funziona e "3" + 4 no? Un testo per un numero ha un significato solo: ripeti il testo quattro volte. Un testo più un numero ne avrebbe due: 7 o "34"? Python non tira a indovinare, e si ferma:
TypeError: can only concatenate str (not "int") to strLe conversioni
Per passare da un tipo all'altro si usa il nome del tipo, come una funzione. Il valore di partenza non cambia: ne nasce uno nuovo.
| Si scrive | Cosa fa | Esempio | Dà |
|---|---|---|---|
int(x) | Un intero, da un testo | int("42") | 42 |
int(x) | Un intero, da un float: taglia i decimali, non arrotonda | int(2.9) | 2 |
float(x) | Un numero con i decimali | float("2.20") | 2.2 |
str(x) | Un testo | str(42) | "42" |
bool(x) | Vero o falso | bool(0) | False |
I due errori che vedrai più spesso:
int("2.5") # ValueError: invalid literal for int() with base 10: '2.5'
float("2,20") # ValueError: could not convert string to float: '2,20'int() vuole un testo con dentro un intero, senza punto. float() vuole il punto, non la virgola. Per arrivare da "2.5" a un intero: int(float("2.5")), che fa 2.
bool: vero o falso
True e False nascono quasi sempre da una domanda:
| Si scrive | La domanda | Esempio | Dà |
|---|---|---|---|
== | È uguale? | 3 == 3 | True |
!= | È diverso? | 3 != 3 | False |
< > | È minore? È maggiore? | 2 > 5 | False |
<= >= | Minore o uguale? Maggiore o uguale? | 5 >= 5 | True |
= e == non sono la stessa cosa: = attacca un'etichetta, == fa una domanda. E "3" == 3 è False: un testo non è mai uguale a un numero. Tra int e float invece conta il valore: 3 == 3.0 è True.
bool() trasforma qualsiasi valore in vero o falso. La regola: sono falsi lo zero (0 e 0.0), il testo vuoto "" e None. Tutto il resto è vero. Anche "no", "0" e "False": sono testi, e non sono vuoti.
print(bool(0)) # False
print(bool("")) # False
print(bool("no")) # True
print(bool("0")) # Trueinput() dà sempre testo
input() scrive una domanda nel terminale, aspetta che tu scriva qualcosa e prema Invio, e restituisce quello che hai scritto. Sempre come testo, anche se hai scritto un numero.
eta = input("Quanti anni hai? ") # scrivi 15, poi Invio
print(int(eta) + 1) # 16
print(eta + 1) # TypeError: can only concatenate str (not "int") to strVale per tutto quello che arriva da fuori: la tastiera, i file CSV, quello che scrivi nel terminale dopo il nome del programma. La regola: converti all'ingresso, una volta sola, e da lì in poi lavora con i numeri.
I float non sono esatti
print(0.1 + 0.2) # 0.30000000000000004
print(0.1 + 0.2 == 0.3) # FalseIl computer tiene i numeri in binario, e in binario 0.1 è come un terzo per noi: 0,3333… e non finisce mai. Resta un errore piccolissimo, che a volte si vede.
Cosa fai:
- Per mostrarli, arrotonda:
round(x, 2)tiene due decimali, eround(0.1 + 0.2, 2)dà0.3. Senza il secondo numerorounddà unint:round(2.7)fa3. - Per i soldi, conta in centesimi interi: 2,20 euro sono
220. Gliintsono sempre esatti. Dal testo ai centesimi:round(float("2.20") * 100). Nonint(), che taglia:int(float("0.29") * 100)fa28. - Nei test,
pytest.approxconfronta due float «quasi uguali». Lo trovi nel capitolo Scrivere un test.
= attacca un'etichetta
= non è l'uguale della matematica. Si legge da destra: prima Python calcola il valore, poi gli attacca l'etichetta.
credito = 5
riserva = credito # una seconda etichetta sulla stessa scatola
credito = credito - 2 # calcola 3, poi ci sposta l'etichetta credito
print(credito) # 3
print(riserva) # 5DOPO LA RIGA 2 DOPO LA RIGA 3
credito ──┐ riserva ─────▶ int 5
├──▶ int 5
riserva ──┘ credito ─────▶ int 3credito - 2 non cambia la scatola del 5: ne fa una nuova, con dentro 3, e ci sposta sopra l'etichetta credito. riserva resta dov'era. Con numeri e testi va sempre così: spostare un'etichetta non tocca le altre. Con liste e dizionari, che si possono cambiare dentro la scatola, la storia cambia: è il capitolo Etichette e scatole.
Due conseguenze:
credito + 10, da solo su una riga, calcola 15 e lo butta via: nessuna etichetta lo prende. Per tenerlo:credito = credito + 10.- Un'etichetta mai attaccata non esiste:
print(prezo)dàNameError: name 'prezo' is not defined. Di solito è un errore di battitura, oppure mancano le virgolette:nome = Mariocerca un'etichetta che si chiamaMario.
Negli esercizi: def e return
Gli esercizi di questo capitolo sono funzioni già cominciate: la riga con def c'è, tu scrivi il corpo.
def doppio(numero: int) -> int:
return numero * 2numero: intdice che tipo arriva,-> intche tipo deve uscire. Python non li controlla: sono un promemoria, per te e per VS Code.returnconsegna il risultato a chi ha chiamato la funzione, e quindi anche al test.
Le funzioni hanno un capitolo tutto loro: Le funzioni.
None: nessun valore
None vuol dire «qui non c'è niente». Lo usi quando un valore non c'è ancora: guasto = None. Per bool() è falso, e ha un tipo tutto suo, NoneType.
Il posto dove lo incontrerai di più: una funzione senza return restituisce None.
def saluto():
print("Benvenuti sulla Linea Menta")
risposta = saluto()
print(risposta)Benvenuti sulla Linea Menta
Noneprint mostra, ma non consegna niente. È il famoso assert None == … di pytest: la funzione ha ancora pass, o usa print al posto di return.
Ricorda
- Ogni valore ha un tipo:
int,float,str,bool,None.type()te lo dice. "3" + 4è un errore,"3" * 4è"3333". Prima converti:int(),float(),str()./dà sempre un float;//dice quante volte ci sta,%cosa resta.input()dà sempre testo. Ebool("no")èTrue.- I float non sono esatti:
roundper mostrarli, centesimi interi per i soldi. =attacca un'etichetta al valore che sta a destra.