Vai al contenuto
code-to-code

Apro l'indice…

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

Python4. Liste e ciclip. 91

Liste e cicli

Una fila di scatole, un dito che le indica

  • 12 minuti di lettura

Una variabile tiene un valore. Ma la Linea Menta ha cinque fermate, e il treno M12 fa venti corse al giorno: non scriverai venti variabili. Ti serve una lista: tanti valori in fila, sotto un nome solo.

Python
fermate = ["Porta Codice", "Via Variabile", "Largo Lista", "Ponte Ciclo", "Piazza Query"]
ritardi = [0, 3, 12, 1]       # i minuti di ritardo di quattro treni
vuota = []                    # una lista senza niente dentro, per ora

E per fare la stessa cosa con ogni valore della fila, uno alla volta, ti serve un ciclo: il for.

Il disegno

Lo disegniamo come in Etichette e scatole: l'etichetta a sinistra, la scatola a destra. Una lista è una fila di scatole numerate. Il numero di una scatola si chiama indice, e si parte da 0. Si conta anche da destra, con i numeri negativi: -1 è l'ultima.

ritardi = [0, 3, 12, 1]ritardilist003112213
La lista dei ritardi

Gli indici sono 0, 1, 2, 3 da sinistra e -4, -3, -2, -1 da destra.

Il for è un dito che indica le scatole una alla volta, da sinistra a destra. A ogni giro, il nome che hai scritto dopo for (qui ritardo) vale quello che c'è nella scatola indicata. Quando le scatole finiscono, finisce il ciclo.

for ritardo in ritardi:

                ┌─────┬─────┬─────┬─────┐
                │  0  │  3  │ 12  │  1  │
                └─────┴─────┴─────┴─────┘
 giro 1            ▲                        ritardo = 0
 giro 2                  ▲                  ritardo = 3
 giro 3                        ▲            ritardo = 12
 giro 4                              ▲      ritardo = 1

Le mosse

Tutto quello che si fa con una lista sta in questa tabella. Ogni riga parte dalla stessa lista: ritardi = [0, 3, 12, 1].

MossaSi scriveCosa succedeAttenzione
Leggere una scatolaritardi[1]dà 3Una posizione che non c'è: IndexError
Leggere l'ultimaritardi[-1]dà 1Va bene con liste di qualunque lunghezza
Contare le scatolelen(ritardi)dà 4L'ultima posizione è len(ritardi) - 1, cioè 3
Prendere una fettaritardi[1:3]dà [3, 12]La fine è esclusa: la scatola 3 non c'è
Chiedere se c'è12 in ritardidà TrueCerca tra i valori, non tra le posizioni. Il contrario: 12 not in ritardi dà False
Cambiare una scatolaritardi[0] = 5diventa [5, 3, 12, 1]
Aggiungere in fondoritardi.append(7)diventa [0, 3, 12, 1, 7]Un valore per volta
Inserire in un postoritardi.insert(0, 2)diventa [2, 0, 3, 12, 1]Le altre scatole scorrono a destra
Togliere un valoreritardi.remove(12)diventa [0, 3, 1]Toglie il primo che trova. Se non c'è: ValueError
Togliere una posizioneritardi.pop()dà 1, e resta [0, 3, 12]pop(0) toglie la prima. Su una lista vuota: IndexError

Le fette funzionano come per le stringhe: ritardi[:2] sono i primi due, ritardi[2:] dal terzo in poi, ritardi[-2:] gli ultimi due. Una fetta è una lista nuova: quella di partenza non cambia.

Il for

Python
for ritardo in ritardi:
    print("ritardo:", ritardo)
print("fine")
ritardo: 0
ritardo: 3
ritardo: 12
ritardo: 1
fine

Tre cose da guardare:

  1. ritardo è un nome nuovo, lo inventi tu. Usa il singolare della lista: for fermata in fermate, for corsa in corse.
  2. Le righe rientrate sono il corpo del ciclo: si ripetono a ogni giro.
  3. La riga senza rientro parte una volta sola, dopo l'ultimo giro.

Contare i giri: range ed enumerate

range dà una fila di numeri interi, senza doverli scrivere. Come nelle fette, la fine è esclusa.

Python
for numero in range(3):         # 0, 1, 2
    print(numero)

for numero in range(1, 4):      # 1, 2, 3
    print(numero)

for i in range(len(ritardi)):   # 0, 1, 2, 3: proprio gli indici di ritardi
    print(i, ritardi[i])

Con gli indici puoi guardare anche la scatola accanto. Per esempio, di quanto cambia il ritardo da un treno al successivo:

Python
for i in range(1, len(ritardi)):            # da 1: la scatola 0 non ha una scatola prima
    print(ritardi[i] - ritardi[i - 1])      # 3, poi 9, poi -11

Se ti servono insieme la posizione e il valore, c'è enumerate, che ti dà le due cose in coppia. Con start=1 conta da 1, come si conta a voce:

Python
for numero, fermata in enumerate(fermate, start=1):
    print(numero, fermata)                  # 1 Porta Codice, 2 Via Variabile, …

while e break, in breve

Il while ripete finché una condizione è vera. Serve quando non sai in anticipo quanti giri farai.

Python
posti = 3
while posti > 0:
    print("sale un passeggero")
    posti = posti - 1
print("treno pieno")

Stampa tre volte sale un passeggero, poi treno pieno.

break esce dal ciclo subito, anche se restano scatole da guardare. Serve per fermarsi al primo che trovi:

Python
for ritardo in ritardi:
    if ritardo > 10:
        print("primo ritardo grave:", ritardo)   # 12
        break                                    # l'1 dopo non lo guarda nessuno

Quattro schemi che tornano sempre

Quasi ogni esercizio con le liste è uno di questi quattro, o due in fila. Lo scheletro ha sempre tre tempi: prima del for il punto di partenza, dentro l'aggiornamento a ogni giro, dopo il risultato.

L'accumulatore: sommare, contare.

Python
totale = 0                              # prima: da dove si parte
in_ritardo = 0
for ritardo in ritardi:
    totale = totale + ritardo           # dentro: a ogni giro
    if ritardo > 0:
        in_ritardo = in_ritardo + 1
print(totale, in_ritardo)               # dopo, senza rientro: 16 3

Il setaccio: tenere solo alcuni valori, in una lista nuova.

Python
gravi = []
for ritardo in ritardi:
    if ritardo >= 5:
        gravi.append(ritardo)
print(gravi)                            # [12]

Il massimo (o il minimo): il migliore visto finora.

Python
peggiore = ritardi[0]                   # si parte dal primo, non da un numero inventato
for ritardo in ritardi:
    if ritardo > peggiore:
        peggiore = ritardo
print(peggiore)                         # 12

La trasformazione: una lista nuova, lunga uguale, con ogni valore cambiato.

Python
in_secondi = []
for ritardo in ritardi:
    in_secondi.append(ritardo * 60)
print(in_secondi)                       # [0, 180, 720, 60]

Quando li sai scrivere a mano, Python ha le scorciatoie. Per l'accumulatore e il massimo:

Python
sum(ritardi)                            # 16
max(ritardi)                            # 12
min(ritardi)                            # 0

Per il setaccio e la trasformazione c'è la comprehension: le quattro righe (lista vuota, for, if, append) diventano una.

Python
gravi = [ritardo for ritardo in ritardi if ritardo >= 5]      # [12]
in_secondi = [ritardo * 60 for ritardo in ritardi]           # [0, 180, 720, 60]

Si legge così: «ritardo * 60, per ogni ritardo in ritardi». L'if in fondo è il setaccio, e si può non mettere. Se non sta in una riga che si legge bene, torna al for: la chiarezza viene prima.

sorted o .sort()?

Tutti e due mettono in ordine, ma in due modi diversi.

Python
ritardi = [0, 3, 12, 1]
in_ordine = sorted(ritardi)    # una lista NUOVA, in ordine
print(in_ordine)               # [0, 1, 3, 12]
print(ritardi)                 # [0, 3, 12, 1]: quella di prima non è cambiata

ritardi.sort()                 # mette in ordine PROPRIO ritardi, e non restituisce niente
print(ritardi)                 # [0, 1, 3, 12]

Per l'ordine dal più grande: sorted(ritardi, reverse=True), oppure ritardi.sort(reverse=True).

Non togliere scatole dalla lista che stai scorrendo

Python
corse = ["07:00", "soppressa", "soppressa", "07:45"]
for corsa in corse:
    if corsa == "soppressa":
        corse.remove(corsa)
print(corse)                   # ['07:00', 'soppressa', '07:45']

Una «soppressa» è rimasta. Quando togli una scatola, quelle dopo scivolano indietro di un posto; il dito invece va avanti, e ne salta una. Il disegno, giro per giro, è nell'esempio G degli esercizi spiegati.

La regola: mentre scorri una lista, non toglierle né aggiungerle scatole. Costruisci una lista nuova, con il setaccio:

Python
partono = [corsa for corsa in corse if corsa != "soppressa"]

Tuple e spacchettamento

Una tupla è una fila corta che non cambia, tra parentesi tonde. Serve per tenere insieme cose che vanno in coppia, come un treno e il suo ritardo.

Python
arrivo = ("M12", 4)
print(arrivo[0])               # M12: gli indici funzionano come nelle liste
treno, ritardo = arrivo        # spacchettare: un nome per ogni pezzo, nell'ordine
print(treno, ritardo)          # M12 4

Si spacchetta anche nel for, quando la lista è fatta di coppie:

Python
arrivi = [("M12", 4), ("M14", 0), ("M16", 9)]
for treno, ritardo in arrivi:
    print(treno, "ha", ritardo, "minuti di ritardo")    # M12 ha 4 minuti di ritardo, …
arrivi = [("M12", 4), ("M14", 0), ("M16", 9)]arrivilist012tuple"M12"041tuple"M14"001tuple"M16"091
Una lista di coppie

Una funzione che restituisce due cose, in realtà ne restituisce una: una tupla. return prima, ultima è lo stesso di return (prima, ultima).

Due liste lunghe uguali si scorrono insieme con zip, che le accoppia una posizione alla volta:

Python
orari = ["07:00", "07:04", "07:09"]
for fermata, ora in zip(fermate, orari):
    print(ora, fermata)        # 07:00 Porta Codice, 07:04 Via Variabile, 07:09 Largo Lista

Se una delle due è più corta, zip si ferma lì: fermate ha cinque scatole, ma i giri sono tre.

Dopo le liste

Una lista trova le cose per posizione: «qual è la terza fermata?». Quando ti servirà trovarle per nome («quanti vagoni ha M14?»), arriva il dizionario: è il capitolo I dizionari. I quattro schemi di questa pagina tornano lì quasi identici.

Ricorda

  • Si conta da 0: la prima è [0], l'ultima [-1].
  • Il for è un dito: una scatola per giro. Il nome lo scegli tu.
  • Prima del for il punto di partenza, dentro l'aggiornamento, dopo il risultato. Anche il return va dopo.
  • Accumulatore, setaccio, massimo, trasformazione. Poi sum, max, min e la comprehension.
  • sorted(x) dà una lista nuova; x.sort() cambia x e dà None.
  • Mentre scorri una lista non toglierle scatole: costruiscine una nuova.