Le stringhe, esercizi spiegati
Cinque esempi, una riga alla volta
- 20 minuti di lettura
Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa succede a ogni riga.
- Cosa portiamo a casa: la cosa da ricordare.
Puoi provare ogni esempio nel terminale di Python (python3, poi incolla) o su Python Tutor, che disegna le etichette per te.
A · L'insegna che non cambia
Il nome della stazione di Ponte Ciclo arriva dalla centrale tutto minuscolo e con gli spazi ai lati. Proviamo a sistemarlo per l'insegna.
insegna = " ponte ciclo "
insegna.strip()
insegna.title()
print("[" + insegna + "]")
insegna = insegna.strip().title()
print("[" + insegna + "]")Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
[ ponte ciclo ]
[Ponte Ciclo]La prima stampa è uguale a come siamo partiti: le righe 3 e 4 hanno lavorato, ma nessuno ha preso il loro risultato.
In italiano.
- Attacco l'etichetta
insegnaal nome sporco. - Chiedo «come saresti senza spazi?» e «come saresti con le maiuscole?»… e butto via le due risposte.
- Stampo l'insegna tra quadre, così gli spazi ai lati si vedono.
- Questa volta prendo la risposta: l'etichetta
insegnasi attacca alla stringa nuova.
Passo per passo.
| Riga | Cosa crea | Chi la prende | insegna dopo la riga |
|---|---|---|---|
insegna.strip() | "ponte ciclo" | nessuno: va persa | " ponte ciclo " |
insegna.title() | " Ponte Ciclo " | nessuno: va persa | " ponte ciclo " |
insegna = insegna.strip().title() | "ponte ciclo", poi "Ponte Ciclo" | l'etichetta insegna | "Ponte Ciclo" |
Il disegno, dopo l'ultima riga:
" ponte ciclo " la stringa vecchia: è ancora com'era,
ma nessuna etichetta la guarda più
insegna ──────▶ "Ponte Ciclo" la stringa nuovaCosa portiamo a casa. Un metodo su una stringa è una domanda: «come saresti senza spazi?». La risposta è una stringa nuova. Se non la prendi con = (o, in una funzione, con return), sparisce.
B · Il codice del biglietto
Ogni biglietto della Linea Menta ha un codice di nove caratteri: la stazione di partenza (due lettere), l'ora (quattro cifre), il treno (tre caratteri). PQ0742M12 vuol dire: da Piazza Query, alle 07:42, sul treno M12.
biglietto = "PQ0742M12"
print(biglietto[0])
print(biglietto[-1])
print(biglietto[0:2])
print(biglietto[2:6])
print(biglietto[-3:])
print(len(biglietto))
print(biglietto[::-1])
print(biglietto[9])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
P
2
PQ
0742
M12
9
21M2470QP
IndexError: string index out of rangeLe caselle sono nove, numerate da 0 a 8: la casella 9 non esiste. L'ultima riga del traceback lo dice.
Il disegno.
0 1 2 3 4 5 6 7 8
┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
biglietto ─▶│ P │ Q │ 0 │ 7 │ 4 │ 2 │ M │ 1 │ 2 │
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
-9 -8 -7 -6 -5 -4 -3 -2 -1
└─────┘ └─────────────┘ └─────────┘
stazione ora treno
[0:2] [2:6] [6:]Passo per passo.
| Riga | Cosa chiede | Risposta |
|---|---|---|
biglietto[0] | la casella 0, la prima | P |
biglietto[-1] | l'ultima casella | 2 |
biglietto[0:2] | dal bordo 0 al bordo 2: le caselle 0 e 1 | PQ |
biglietto[2:6] | dal bordo 2 al bordo 6: le caselle 2, 3, 4, 5 | 0742 |
biglietto[-3:] | le ultime tre, fino alla fine | M12 |
len(biglietto) | quante caselle | 9 |
biglietto[::-1] | tutte, da destra a sinistra | 21M2470QP |
biglietto[9] | la casella 9, che non c'è | IndexError |
E per scrivere l'ora come si deve, si attaccano due fette con i due punti in mezzo:
print(biglietto[2:4] + ":" + biglietto[4:6]) # 07:42
print(biglietto[6:100]) # M12: la fetta esce dalla fila, nessun erroreCosa portiamo a casa. Con nove caselle l'ultima è la 8. Per «le ultime tre» non serve contare: [-3:]. Una casella che non c'è dà errore; una fetta troppo lunga no, prende quello che c'è.
C · La riga del deposito
Il deposito tiene un registro: per ogni treno una riga, con i pezzi separati da un punto e virgola. Il codice del treno, quanti vagoni ha, la stazione dove dorme.
riga = "M12;4;Porta Codice"
pezzi = riga.split(";")
print(pezzi)
print(pezzi[0])
print(int(pezzi[1]) + 1)
print(" - ".join(pezzi))
print("Porta Codice".split(" "))
print("Porta Codice".split())
print(pezzi[1] + 1)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
['M12', '4', 'Porta Codice']
M12
5
M12 - 4 - Porta Codice
['Porta', '', '', 'Codice']
['Porta', 'Codice']
TypeError: can only concatenate str (not "int") to strIn italiano.
- Taglio la riga dove trovo il punto e virgola: tre pezzi.
- Prendo il primo pezzo, il codice.
- Il secondo pezzo è
"4", testo: lo trasformo in numero conint(), poi aggiungo un vagone. - Rimetto insieme i pezzi con un'altra colla,
" - ". - Due modi di tagliare sugli spazi, con tre spazi di fila.
- Provo a sommare 1 al testo
"4": Python si ferma.
Passo per passo. Dopo la seconda riga, pezzi è una lista di tre stringhe:
| Indice | Pezzo | È… |
|---|---|---|
pezzi[0] | 'M12' | testo |
pezzi[1] | '4' | testo! Sembra un numero, ma ha le virgolette |
pezzi[2] | 'Porta Codice' | testo: lo spazio in mezzo resta, split(";") taglia solo sui punti e virgola |
Con split(" ") ogni singolo spazio è un taglio. Tra Porta e Codice ci sono tre spazi, quindi tre tagli: tra il primo e il secondo spazio non c'è niente, e lo stesso tra il secondo e il terzo. Sono i due pezzi vuoti ''. Con split(), senza niente tra le parentesi, un gruppo di spazi vale come un taglio solo.
Cosa portiamo a casa. Quello che esce da split è sempre testo. "4" + 1 è un errore, int("4") + 1 fa 5. E join si scrive al rovescio di come ti aspetti: prima la colla, poi i pezzi.
D · L'avviso
Sul tabellone di Largo Lista scorre l'avviso della mattina. Facciamogli qualche domanda.
avviso = "Treno M14 in ritardo. Treno M16 in orario."
print("M14" in avviso)
print("m14" in avviso)
print(avviso.count("Treno"))
print(avviso.find("M16"))
print(avviso.find("M99"))
print(avviso.startswith("Treno"))
print(avviso.endswith("orario"))
dove = avviso.find("M16")
print(avviso[dove:dove + 3])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
True
False
2
28
-1
True
False
M16Passo per passo.
| Domanda | Risposta | Perché |
|---|---|---|
"M14" in avviso | True | il pezzo M14 c'è, identico |
"m14" in avviso | False | m minuscola e M maiuscola sono caratteri diversi |
avviso.count("Treno") | 2 | Treno compare due volte |
avviso.find("M16") | 28 | la casella dove comincia M16: prima ci sono 28 caratteri, spazi e punto compresi |
avviso.find("M99") | -1 | non c'è: find non dà errore, dà -1 |
avviso.startswith("Treno") | True | le prime caselle sono Treno |
avviso.endswith("orario") | False | l'ultima casella è il punto: l'avviso finisce con orario. |
avviso[dove:dove + 3] | M16 | dalla casella 28, tre caselle |
Le ultime due righe sono lo schema che userai nella palestra: find ti dice dove comincia una cosa, la fetta la prende.
Le maiuscole contano anche per count: avviso.count("treno") dà 0. Se non ti interessano, abbassa tutto prima di cercare: avviso.lower().count("treno") dà 2.
Cosa portiamo a casa. in per sapere se c'è, find per sapere dove, count per sapere quante volte. E un punto in fondo basta a far dire False a endswith: i caratteri invisibili o piccoli contano come gli altri.
E · Lo scontrino
La biglietteria di Largo Lista stampa lo scontrino. Tre corse da 2,20 euro.
stazione = "Largo Lista"
prezzo = 2.2
corse = 3
print(prezzo * corse)
print(f"{corse} corse per {stazione}")
print(f"Totale: {prezzo * corse:.2f} euro")
print(f"[{stazione:>14}]")
print(f"[{stazione:<14}]")
print(f"{stazione!r}")
print("Totale: {prezzo:.2f} euro")Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
6.6000000000000005
3 corse per Largo Lista
Totale: 6.60 euro
[ Largo Lista]
[Largo Lista ]
'Largo Lista'
Totale: {prezzo:.2f} euroLa prima riga sorprende tutti, anche se l'avevi già vista nel capitolo 1: i numeri con la virgola, nel computer, sono quasi sempre un'approssimazione. 2.2 non è esattamente 2,2, e moltiplicando l'errore si vede. :.2f arrotonda quando scrive, e il problema sparisce dallo scontrino.
Passo per passo.
| Riga | Tra le graffe | Diventa |
|---|---|---|
| 2 | {corse} e {stazione} | 3 e Largo Lista, il numero già trasformato in testo |
| 3 | {prezzo * corse:.2f} | il calcolo, poi scritto con due decimali: 6.60 |
| 4 | {stazione:>14} | 11 lettere in 14 caselle, a destra: tre spazi davanti |
| 5 | {stazione:<14} | lo stesso, a sinistra: tre spazi dietro |
| 6 | {stazione!r} | il testo come lo scriveresti in Python, con le virgolette |
| 7 | niente: manca la f | le graffe restano lì, così come sono |
Cosa portiamo a casa. :.2f non cambia il numero: cambia come lo scrivi. Il punto dei decimali resta un punto; per la virgola all'italiana serve un replace(".", ",") sul testo, ed è quello che farai nella storia.
Pronto? Gli stessi attrezzi ti aspettano nella palestra: otto esercizi da scaricare, con i test.