Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Python1. Valori, tipi, etichettep. 1

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.

Python
print(3 + 4)        # 7
print("3" + "4")    # 34

Lo 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.

Python
binario = 3
stazione = "Via Variabile"
prezzo = 2.2
aperta = True
guasto = None
binario = 3 stazione = "Via Variabile" prezzo = 2.2 aperta = True guasto = Nonebinariostazioneprezzoapertaguastoint3str"Via Variabile"float2.2boolTrueNoneTypeNone
Cinque etichette, cinque scatole

I cinque tipi di base

TipoCos'èSi scrivetype() dice
intUn numero intero3, 0, -12<class 'int'>
floatUn numero con i decimali, scritti dopo il punto2.2, 0.5, 3.0<class 'float'>
strUn testo, tra virgolette"Via Variabile", "3", ""<class 'str'>
boolVero o falso, con la maiuscolaTrue, False<class 'bool'>
NoneNessun valoreNone<class 'NoneType'>

Tre dettagli che sorprendono:

  • 3.0 è un float, anche se i decimali sono zero.
  • Una lettera sola è un str: "A". Il tipo «carattere» non esiste.
  • "3" è un str. Le virgolette vincono su tutto quello che c'è dentro.

Quando un valore non si comporta come pensi, chiedi a type() chi è:

Python
print(type(3))      # <class 'int'>
print(type("3"))    # <class 'str'>
print(type(3.0))    # <class 'float'>

Le operazioni sui numeri

Si scriveCosa faEsempioDà
+ - *Somma, sottrazione, moltiplicazione7 * 214
/La divisione. Dà sempre un float8 / 24.0
//La divisione intera: quante volte ci sta7 // 23
%Il resto della divisione intera7 % 21
**La potenza2 ** 101024

// 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:

Python
print(2 + 3 * 4)      # 14: prima la moltiplicazione
print((2 + 3) * 4)    # 20

Un int e un float insieme danno un float: 2 + 0.5 fa 2.5, 3 * 1.0 fa 3.0.

Il testo: + attacca, * ripete

Python
print("Via " + "Variabile")   # Via Variabile
print("ab" * 3)               # ababab
print("3" * 4)                # 3333
print("3" + 4)                # TypeError

Perché "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 str

Le 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 scriveCosa faEsempioDà
int(x)Un intero, da un testoint("42")42
int(x)Un intero, da un float: taglia i decimali, non arrotondaint(2.9)2
float(x)Un numero con i decimalifloat("2.20")2.2
str(x)Un testostr(42)"42"
bool(x)Vero o falsobool(0)False

I due errori che vedrai più spesso:

Python
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 scriveLa domandaEsempioDà
==È uguale?3 == 3True
!=È diverso?3 != 3False
< >È minore? È maggiore?2 > 5False
<= >=Minore o uguale? Maggiore o uguale?5 >= 5True

= 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.

Python
print(bool(0))        # False
print(bool(""))       # False
print(bool("no"))     # True
print(bool("0"))      # True

input() 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.

Python
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 str

Vale 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

Python
print(0.1 + 0.2)           # 0.30000000000000004
print(0.1 + 0.2 == 0.3)    # False

Il 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, e round(0.1 + 0.2, 2) dà 0.3. Senza il secondo numero round dà un int: round(2.7) fa 3.
  • Per i soldi, conta in centesimi interi: 2,20 euro sono 220. Gli int sono sempre esatti. Dal testo ai centesimi: round(float("2.20") * 100). Non int(), che taglia: int(float("0.29") * 100) fa 28.
  • Nei test, pytest.approx confronta 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.

Python
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)             # 5
DOPO LA RIGA 2                    DOPO LA RIGA 3

credito  ──┐                      riserva  ─────▶  int  5
           ├──▶  int  5
riserva  ──┘                      credito  ─────▶  int  3

credito - 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 = Mario cerca un'etichetta che si chiama Mario.

Negli esercizi: def e return

Gli esercizi di questo capitolo sono funzioni già cominciate: la riga con def c'è, tu scrivi il corpo.

Python
def doppio(numero: int) -> int:
    return numero * 2
  • numero: int dice che tipo arriva, -> int che tipo deve uscire. Python non li controlla: sono un promemoria, per te e per VS Code.
  • return consegna 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.

Python
def saluto():
    print("Benvenuti sulla Linea Menta")

risposta = saluto()
print(risposta)
Benvenuti sulla Linea Menta
None

print 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. E bool("no") è True.
  • I float non sono esatti: round per mostrarli, centesimi interi per i soldi.
  • = attacca un'etichetta al valore che sta a destra.