Vai al contenuto
code-to-code

Apro l'indice…

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

Python8. Etichette e scatolep. 227

Etichette e scatole

Una variabile non contiene il valore, ci è attaccata

  • 12 minuti di lettura

Hai copiato una lista, hai cambiato la copia, ed è cambiato anche l'originale. Nessun errore, nessun traceback: solo un risultato sbagliato, che sembra arrivare dal nulla.

Non arriva dal nulla. Per vederlo serve il disegno delle etichette e delle scatole, che funziona per tutto Python: etichette a sinistra, scatole a destra.

Il disegno

Una variabile non è una scatola che contiene un valore. È un'etichetta attaccata a una scatola. Il valore sta nella scatola, e la scatola sa di che tipo è.

Python
corse = 12
stazione = "Largo Lista"
fermate = ["Porta Codice", "Via Variabile"]
corse = 12 stazione = "Largo Lista" fermate = ["Porta Codice", "Via Variabile"]corsestazionefermateint12str"Largo Lista"list"Porta Codice"0"Via Variabile"1
Tre etichette, tre scatole

Le etichette sono solo nomi. Le scatole sono i valori veri, con il loro tipo. La freccia va sempre da un'etichetta a una scatola. L'hai visto con i numeri nel capitolo Valori, tipi, etichette e con un dizionario in quello dei dizionari: qui lo usiamo per tutto, e soprattutto per le scatole che si possono cambiare dentro.

= attacca l'etichetta

Un ripasso dal capitolo 1. = si legge da destra: prima Python prepara la scatola a destra, poi ci attacca l'etichetta scritta a sinistra. Se quell'etichetta era già attaccata a un'altra scatola, si stacca e si sposta.

Python
treno = "M12"
treno = "M14"
dopo la riga 1

treno  ──────▶  str  "M12"


dopo la riga 2

treno  ──┐      str  "M12"      nessuna etichetta: Python la butta via
         │
         └───▶  str  "M14"

La scatola "M12" non è cambiata. È rimasta senza etichette, e Python l'ha buttata. Non hai cambiato una scatola: hai spostato un'etichetta.

Due etichette, una scatola

Se a destra dell'= c'è un'altra etichetta, Python non prepara niente di nuovo: attacca una seconda etichetta alla stessa scatola. Con i dizionari l'hai già visto in Due etichette, una scatola. Con le liste è identico.

Python
fermate = ["Porta Codice", "Via Variabile"]
percorso = fermate
percorso.append("Largo Lista")
print(fermate)       # ['Porta Codice', 'Via Variabile', 'Largo Lista']
fermate = ["Porta Codice", "Via Variabile", "Largo Lista"] percorso = fermatefermatepercorsolist"Porta Codice"0"Via Variabile"1"Largo Lista"2
Due etichette, una scatola

Due nomi per la stessa cosa: si chiama alias. La regola da ricordare: conta le scatole, non le etichette. Qui le etichette sono due, la scatola è una, e l'append l'ha fatto la scatola.

Mutabile e immutabile

Alcune scatole si possono cambiare dentro. Altre no.

TipoSi cambia dentro?Le mosse che cambiano la scatola
listSì: mutabileappend, remove, pop, sort, lista[0] = …
dictSì: mutabiled[chiave] = …, del d[chiave], pop
int, float, bool, NoneNo: immutabileNessuna
strNo: immutabileNessuna: upper, replace, strip danno una stringa nuova
tupleNo: immutabileNessuna

Con una scatola immutabile ogni «modifica» prepara una scatola nuova, e l'etichetta si sposta lì. Per questo con numeri e stringhe gli alias non fanno danni.

Python
corse = 12
oggi = corse
oggi += 1            # vuol dire oggi = oggi + 1
print(corse, oggi)   # 12 13
corse = 12 oggi = corsecorseoggiint12
Dopo oggi = corse
corse = 12 oggi = 13corseoggiint12int13
Dopo oggi += 1

Con una lista, invece, append cambia la scatola. E chi ha un'etichetta sulla stessa scatola se ne accorge.

Python
contatore = [12]
adesso = contatore
adesso.append(13)
print(contatore)     # [12, 13]
contatore = [12, 13] adesso = contatorecontatoreadessolist120131
Una scatola, cambiata dentro

Le stringhe sono come i numeri. upper non tocca la scatola: ne prepara una nuova.

Python
nome = "porta codice"
nome.upper()         # 'PORTA CODICE': una stringa nuova, che nessuno tiene
print(nome)          # porta codice
nome = nome.upper()  # così sì: l'etichetta nome si sposta sulla scatola nuova

is e ==

Sono due domande diverse.

  • == chiede: queste due scatole hanno lo stesso contenuto?
  • is chiede: queste due etichette sono attaccate alla stessa scatola?
Python
mattina = ["Porta Codice", "Piazza Query"]
sera = ["Porta Codice", "Piazza Query"]
notte = mattina

mattina == sera      # True: stesso contenuto
mattina is sera      # False: due scatole
mattina is notte     # True: una scatola, due etichette
mattina = ["Porta Codice", "Piazza Query"] sera = ["Porta Codice", "Piazza Query"] notte = mattinamattinaseranottelist"Porta Codice"0"Piazza Query"1list"Porta Codice"0"Piazza Query"1
Due scatole uguali, una terza etichetta

Quasi sempre ti serve ==. is serve in due casi: x is None, che usi dal capitolo delle condizioni, e quando vuoi proprio sapere se due etichette sono sulla stessa scatola, come in questo capitolo.

Copiare

Per avere una scatola nuova con lo stesso contenuto, la devi chiedere.

Per copiareSi scrive
Una listalist(fermate), fermate.copy(), fermate[:]: fanno la stessa cosa
Un dizionariodict(orari), orari.copy()
Python
fermate = ["Porta Codice", "Via Variabile"]
domenica = list(fermate)          # una scatola nuova, con lo stesso contenuto
domenica.remove("Via Variabile")
print(fermate)                    # ['Porta Codice', 'Via Variabile']: intatta
fermate = ["Porta Codice", "Via Variabile"] domenica = ["Porta Codice"]fermatedomenicalist"Porta Codice"0"Via Variabile"1list"Porta Codice"0
Dopo il remove sulla copia

fermate[:] è la fetta che va dall'inizio alla fine: una lista nuova con tutto dentro.

La copia a metà

Le copie della tabella sono superficiali: copiano la scatola esterna, non quelle dentro. Con una lista di numeri o di stringhe non te ne accorgi. Con una lista di liste sì.

Il M12 è fatto di due metà, e ogni metà è una lista di vagoni:

Python
m12 = [["motrice", "carrozza"], ["carrozza", "motrice"]]
m14 = list(m12)
m14[0].append("bici")
print(m12)           # [['motrice', 'carrozza', 'bici'], ['carrozza', 'motrice']]

Dentro una lista non ci sono altre liste: ci sono frecce verso altre scatole. list(m12) ha preparato una scatola esterna nuova e ci ha copiato le frecce. Le metà a cui puntano sono rimaste quelle:

m12 = [["motrice", "carrozza", "bici"], ["carrozza", "motrice"]] m14 = list(m12)m12m14list01list"motrice"0"carrozza"1"bici"2list"carrozza"0"motrice"1list01
Dopo m14[0].append("bici")

Conta le scatole: quattro. Due esterne, una per etichetta, e due metà in comune. m14 is m12 è False, ma m14[0] is m12[0] è True. La bici l'ha ricevuta la metà, e la metà è di tutti e due.

Per una copia completa, copi anche ogni lista di dentro:

Python
m14 = []
for meta in m12:
    m14.append(list(meta))       # una scatola nuova per ogni metà

Oppure lasci fare a Python, che copia tutto, a ogni livello:

Python
import copy

m14 = copy.deepcopy(m12)

deepcopy è comodo. Ma saperlo fare a mano ti fa capire cosa succede.

La lista entra nella funzione

Quando chiami una funzione, ogni parametro è un'etichetta nuova, attaccata alla scatola che passi. Non a una copia: alla stessa scatola.

Python
def aggiungi_bici(vagoni):
    vagoni.append("bici")

treno = ["motrice", "carrozza"]
aggiungi_bici(treno)
print(treno)         # ['motrice', 'carrozza', 'bici']

Mentre la funzione lavora, il disegno è questo. Le etichette stanno in due riquadri: quelle di fuori, e quelle della funzione.

ETICHETTE               SCATOLE

┌ fuori ─────────┐
│ treno  ────────┼──┐
└────────────────┘  │
                    ├──▶  list  [ "motrice", "carrozza", "bici" ]
┌ aggiungi_bici ─┐  │
│ vagoni ────────┼──┘
└────────────────┘

Il riquadro della funzione è un foglietto che vive solo finché la funzione lavora. Quando finisce, il foglietto si butta, con l'etichetta vagoni. La scatola resta, con la bici dentro.

Ma dentro la funzione = sposta solo l'etichetta della funzione:

Python
def svuota(vagoni):
    vagoni = []      # l'etichetta vagoni va su una scatola nuova; treno non se ne accorge

svuota(treno)
print(treno)         # ['motrice', 'carrozza', 'bici']

Una funzione che lavora su una lista ha due strade oneste:

  1. Cambia la scatola che riceve e non restituisce niente. Come append, come lista.sort(). Il nome lo dice: aggiungi_bici.
  2. Non tocca la scatola che riceve e restituisce una scatola nuova. Come sorted(lista). Se la scrivi tu, la prima riga fa la copia: nuova = list(lista).

Il guaio è a metà strada: una funzione che sembra restituire una lista nuova e intanto cambia quella che riceve.

Il default che ricorda (trappola avanzata)

Python
def segna(guasto, quaderno=[]):
    quaderno.append(guasto)
    return quaderno

primo = segna("freno")
secondo = segna("porta")
print(secondo)       # ['freno', 'porta']

Il secondo quaderno doveva essere nuovo, e invece contiene il freno del primo. La lista [] del default non nasce a ogni chiamata: nasce una volta sola, quando Python legge il def, e resta attaccata alla funzione. Ogni chiamata senza quaderno attacca l'etichetta quaderno a quella stessa scatola.

default_di_segna = ["freno", "porta"] primo = default_di_segna secondo = default_di_segnadefault_di_segnaprimosecondolist"freno"0"porta"1
Il default, dopo le due chiamate

La cura: None come default, e la scatola nuova dentro la funzione, dove nasce a ogni chiamata.

Python
def segna(guasto, quaderno=None):
    if quaderno is None:
        quaderno = []            # una scatola nuova, a ogni chiamata
    quaderno.append(guasto)
    return quaderno

Vale per ogni default mutabile, [] e {}. Con numeri, stringhe e None non c'è pericolo: sono immutabili.

Vederlo: Python Tutor

Non devi indovinare: Python Tutor fa il disegno per te.

  1. Vai su pythontutor.com, scegli Python, incolla il codice.
  2. Visualize Execution, poi Next: una riga alla volta. Prev per tornare indietro.
  3. A sinistra i Frames: le etichette, un riquadro per ogni funzione. A destra gli Objects: le scatole.
  4. Prima disegna tu, su un foglio. Poi guarda il suo disegno. Era uguale? Se no, correggi il tuo con un altro colore.

Python Tutor scrive i numeri e le stringhe dentro il riquadro, accanto all'etichetta, senza freccia. È solo una scorciatoia di disegno: sono scatole anche loro. Funziona con Python «puro»: niente pytest, niente FastAPI. Negli esercizi spiegati ogni esempio ha il suo link, con il codice già dentro.

Cosa viene dopo

Nel capitolo Classi e oggetti le scatole diventano oggetti costruiti da te: self è un'etichetta sulla scatola prima del punto, e riserva = m12 è di nuovo un treno solo, con due nomi. Il disegno resta questo.

Ricorda

  • Una variabile è un'etichetta su una scatola. Conta le scatole, non le etichette.
  • = attacca o sposta un'etichetta. Non copia mai.
  • Liste e dizionari si cambiano dentro; numeri, stringhe e tuple no.
  • == confronta il contenuto, is la scatola.
  • list(x), dict(x), .copy(), [:] copiano solo la scatola esterna.
  • Una funzione riceve un'etichetta sulla stessa scatola. E il default [] è una scatola sola: usa None.