Stringhe 2 - operatori

Scarica zip esercizi

Naviga file online

Python offre diversi operatori per lavorare con le stringhe:

Operatore	Sintassi	Risultato	Significato
lunghezza	len(str)	int	Ritorna la lunghezza della stringa
`indice <#Leggere-caratteri >`__	str[int]	str	Legge il carattere all’indice specificato
concatenazione	str1 + str2	str	Concatena due stringhe
inclusione	str1 in str2	bool	Controlla se la stringa è presente in un’altra stringa
slice	str[int:int ]	str	Estrae una sotto-stringa
uguaglianza	==,!=	bool	Controlla se due stringhe sono uguali o differenti
comparazioni	<, <=, >, >=	bool	Controlla se due stringhe sono uguali o differenti
comparazioni	<, <=, >, >=	bool	Controlla se due stringhe sono uguali o differenti
ord	ord(str)	int	Ritorna l’ordine di un carattere
chr	chr(str)	str	Dato un ordine, ritorna il carattere corrispondente
replicazione	str * int	str	Replica la stringa

Che fare

• scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere:

strings
    strings1.ipynb
    strings1-sol.ipynb
    strings2.ipynb
    strings2-sol.ipynb
    strings3.ipynb
    strings3-sol.ipynb
    strings4.ipynb
    strings4-sol.ipynb
    strings5-chal.ipynb
    jupman.py

ATTENZIONE: Per essere visualizzato correttamente, il file del notebook DEVE essere nella cartella szippata.

• apri il Jupyter Notebook da quella cartella. Due cose dovrebbero aprirsi, prima una console e poi un browser. Il browser dovrebbe mostrare una lista di file: naviga la lista e apri il notebook strings2.ipynb

• Prosegui leggendo il file degli esercizi, ogni tanto al suo interno troverai delle scritte ESERCIZIO, che ti chiederanno di scrivere dei comandi Python nelle celle successive.

Scorciatoie da tastiera:

• Per eseguire il codice Python dentro una cella di Jupyter, premi Control+Invio

• Per eseguire il codice Python dentro una cella di Jupyter E selezionare la cella seguente, premi Shift+Invio

• Per eseguire il codice Python dentro una cella di Jupyter E creare una nuova cella subito dopo, premi Alt+Invio

• Se per caso il Notebook sembra inchiodato, prova a selezionare Kernel -> Restart

Leggere caratteri

Una stringa è una sequenza di caratteri, e spesso potremmo voler accedere ad un singolo carattere specificando la posizione del carattere che interessa

E’ importante ricordarsi che le posizioni dei caratteri nelle stringhe iniziano da 0. Per leggere un carattere ad una certa posizione, bisogna scrivere la stringa seguita da parentesi quadre con all’interno la posizione. Esempi:

'ciao'[0]

'c'

'ciao'[1]

'i'

#0123
'ciao'[2]

'a'

#0123
'ciao'[3]

'o'

Se cerchiamo di andare oltre all’ultimo carattere, otterremo un errore:

#0123
'ciao'[4]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-106-b8f1f689f0c7> in <module>
      1 #0123
----> 2 'ciao'[4]

IndexError: string index out of range

Prima abbiamo usato una stringa specificandola letteralmente, ma possiamo anche usare variabili:

    #01234
x = 'panca'

x[0]

'p'

x[2]

'n'

Come viene rappresentato il carattere letto? Se hai notato, è circondato da apici come se fosse una stringa. Controlliamo:

type(x[0])

str

Infatti è proprio una stringa. Questo potrebbe forse sorprendere alcuni, anche da un punto di vista filosico: le stringhe in Python sono a loro volta composte da… stringhe! In altri linguaggi di programmazione per i singoli caratteri si possono trovare tipi appositi, ma Python usa stringhe per gestire meglio anche alfabeti con simboli complicati come quello giapponese.

DOMANDA: Supponiamo che x sia una stringa qualsiasi. Se proviamo ad eseguire questo codice:

x[0]

otterremo:

1. sempre un carattere

2. sempre un errore

3. a volte un carattere, a volte un errore a seconda della stringa

Mostra risposta

RISPOSTA: la 3: potremmo ottenere un errore con la stringa vuota (prova)

DOMANDA: Supponiamo che x sia una stringa qualsiasi. Se proviamo ad eseguire questo codice:

x[len(x)]

otterremo:

1. sempre un carattere

2. sempre un errore

3. a volte un carattere, a volte un errore a seconda della stringa

Mostra risposta

RISPOSTA: la 2: poichè l’indicizzazione inizia da 0, len ci da sempre un numero che è superiore di 1 al più grande indice usabile.

Esercizio - intercalare

Date due stringhe che hanno entrambe lunghezza 3, stampa una stringa che inercala caratteri da entrambe le stringhe. Il tuo codice deve poter funzionare con qualsiasi stringa di questa lunghezza

Esempio:

Dati

x="say"
y="hi!"

dovrebbe stampare

shaiy!

Mostra soluzione

# scrivi qui

x="say"
y="hi!"
print(x[0] + y[0] + x[1] + y[1] + x[2] + y[2])

shaiy!

# scrivi qui

shaiy!

Indici negativi

In Python possiamo anche usare indici negativi, che invece di partire dall’inizio partono dalla fine:

#4321
"ciao"[-1]

'o'

#4321
"ciao"[-2]

'a'

#4321
"ciao"[-3]

'i'

#4321
"ciao"[-4]

'c'

Se andiamo troppo in là, otteniamo un errore:

#4321
"ciao"[-5]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-126-668d8a13a324> in <module>
----> 1 "ciao"[-5]

IndexError: string index out of range

DOMANDA: Supponiamo che x sia una stringa NON vuota qualsiasi, con la seguente espressione cosa otterremmo ?

x[-len(x)]

1. sempre un carattere

2. sempre un errore

3. a volte un carattere, a volte un errore a seconda della stringa

Mostra risposta

RISPOSTA: La 1. (abbiamo supposto che la stringa non sia mai vuota)

DOMANDA: Supponendo che x sia una stringa qualsiasi (anche vuota), le espressioni

x[len(x)-1]

e

x[-len(x) - 1]

sono equivalenti ? Che cosa fanno ?

Mostra risposta

RISPOSTA: le espressioni non sono equivalenti: la prima restituisce l’ultimo carattere solo quando la stringa è non vuota, invece la seconda ritorna sempre un errore.

DOMANDA: Se x è una stringa non vuota, l’espressione seguente cosa produce? La possiamo semplificare in una più breve?

(x + x)[len(x)]

Mostra risposta

RISPOSTA: corrisponde a x[0]

DOMANDA: Se x è una stringa non vuota, cosa produce la seguente espressione? Un errore? Altro? La possiamo semplificare?

'ciao'[0][0]

Mostra risposta

RISPOSTA: Sappiamo che 'ciao'[0] produce un carattere, ma sappiamo anche che in Python i caratteri estratti dalle stringhe sono a loro volta stringhe di lunghezza 1. Quindi se dopo l’espressione "ciao"[0] che produce la stringa 'c' aggiungiamo un’altro [0] è come se stessimo scrivendo 'c'[0], che ritorna il carattere zeresimo trovato nella stringa 'c', cioè c stesso.

DOMANDA: Se x è una stringa non vuota, cosa produce la seguente espressione? Un errore? Altro? La possiamo semplificare?

(x[0])[0]

Mostra risposta

RISPOSTA: x[0] è un espressione che produce il primo carattere della stringa x. In Python, possiamo mettere le espressioni tra parentesi che vogliamo. Quindi in questo caso la parentesi non produce nessun effetto, e l’espressione è equivalente a x[0][0] che come abbiamo visto prima è uguale a scrivere x[0]

Sostituire caratteri

Abbiamo detto che in Python le stringhe sono immutabili, quindi se abbiamo una stringa

    #01234
x = 'ciao'

e vogliamo per esempio cambiare il carattere in posizione 2 (in questo caso, la a) perchè diventi una b, come facciamo ?

Potremmo essere tentati di scrivere così, ma Python ci punirebbe con un errore:

x[2] = 'b'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-113-e5847c6fa4bf> in <module>
----> 1 x[2] = 'b'

TypeError: 'str' object does not support item assignment

La soluzione corretta è assegnare a x una stringa completamente nuova, ottenuta prendendo pezzi della precedente:

x = x[0] + x[1] + 'b' + x[3]

x

'cibo'

Se il fatto che la x compaia a destra dell’uguale ti sconcerta, possiamo scomporre il codice così e funzionerebbe ugualmente

x = "ciao"
y = x
x = y[0] + y[1] + 'b' + y[3]

Provalo in Python Tutor:

x = "ciao"
y = x
x = y[0] + y[1] + 'b' + y[3]

jupman.pytut()

Python Tutor visualization

Slice

Potremmo voler leggere solo una sottosequenza che parte da una posizione e finisce in un’altra. Per esempio, supponiamo di avere la scritta

    #0123456789
x = 'mercantile'

e vogliamo estrarre la stringa 'canti', che parte dall’indice 3 incluso e arriva all’indice 8 escluso. Potremmo estrarre i singoli caratteri e concatenarli con il +, ma scriveremmo tantissimo codice. Un opzione migliore è usare le cosiddette slice: basta scrivere la stringa seguita da parentesi quadre contenti i due indici di inzio (incluso) e fine (escluso) separati dai due punti :

    #0123456789
x = 'mercantile'

x[3:8]   # notare i : in mezzo ai due indici di inizio e fine

'canti'

ATTENZIONE: Estrarre una sottostringa con le slice NON modifica la stringa originale !!

Vediamo un esempio:

    #0123456789
x = 'mercantile'

print('              x è', x)
print('La slice x[3:8] è', x[3:8])
print('              x è', x)       # nota che x continua a puntare alla vecchia stringa!

              x è mercantile
La slice x[3:8] è canti
              x è mercantile

DOMANDA: se x è una stringa qualsiasi di lunghezza almeno 5, cosa fa questo codice? Da errore? Funziona? Possiamo abbreviarlo?

x[3:4]

Mostra risposta

RISPOSTA: Se la stringa ha lunghezza almeno 5, potremmo avere una situazione del genere:

    #01234
x = 'abcde'

La slice x[3:4] estrarrà i caratteri da posizione 3 incluso fino alla posizione 4 esclusa, quindi di fatto estrarrà solo un carattere alla posizione 3. Il codice è quindi equivalente a x[3]

Esercizio - garalampog

Scrivi del codice per estrarre e stampare alam dalla stringa "garalampog". Prova a indovinare correttamente gli indici.

Mostra soluzione

x = "garalampog"

# scrivi qui

#      0123456789
print(x[3:7])

alam

x = "garalampog"

# scrivi qui

alam

Esercizio - ifEweEfav lkSD lkWe

Scrivi del codice per estrarre e stampare kS dalla stringa "ifE\te\nfav  lkD lkWe". Fai attenzione agli spazi e caratteri speciali (prima potresti voler stampare x). Prova a indovinare gli indici corretti.

Mostra soluzione

x = "ifE\te\nfav  lkD lkWe"

# scrivi qui

#     0123 45 67890123456789
#x = "ifE\te\nfav  lkD lkWe"

print(x[12:14])

kD

x = "ifE\te\nfav  lkD lkWe"

# scrivi qui

kD

Slice - limiti

Quando operiamo con le slice dobbiamo stare attenti ai limiti degli indici. Vediamo come si comportano:

#012345
"sedia"[0:3]  # da indice 0 *incluso* a 3 *escluso*

'sed'

#012345
"sedia"[0:4]  # da indice 0 *incluso* a 4 *escluso*

'sedi'

#012345
"sedia"[0:5]  # da indice 0 *incluso* a 5 *escluso*

'sedia'

#012345
"sedia"[0:6]   # se andiamo oltre la lunghezza della stringa Python non si arrabbia

'sedia'

DOMANDA: se x è una stringa qualsiasi (anche vuota), questa espressione cosa fa? Può dare errore? o ritorna qualcosa di utile?

x[0:len(x)]

Mostra risposta

RISPOSTA: Ritorna sempre una NUOVA copia dell’intera stringa, perchè parte da indice 0 incluso e finisce a indice len(x) escluso

Funziona anche con la stringa vuota, perchè ''[0:len('')] equivale a ''[0:0] cioè sottostringa da 0 incluso a 0 escluso, quindi non prendiamo nessun carattere e non sforiamo i limiti della stringa. In realtà, anche se sforassimo, Python non avrebbe problemi (prova a scrivere ''[0:100])

Slice - omissione limiti

Volendo, è possibile omettere l’indice di partenza, in tal caso Python supporrà sia 0:

#0123456789
"traghetto"[:3]

'tra'

E’ anche possibile omettere l’indice di fine, in tal caso Python estrarrà fino alla fine della stringa:

#0123456789
"traghetto"[3:]

'ghetto'

Omettendo entrambi gli indici si ottiene l’intera stringa:

"traghetto"[:]

'traghetto'

Esercizio - isteroister

Scrivere del codice che data una stringa x stampa la stringa composta da tutte le lettere di x eccetto la prima seguita da tutte le lettere di x eccetto l’ultima

• il tuo codice deve funzionare con qualunque stringa

Esempio:

Dato

x = "mistero"

deve stampare

isteromister

Dato

x = "corale"

deve stampare

oralecoral

Mostra soluzione

x = "mistero"
#x = "corale"

# scrivi qui

print(x[1:] + x[0:len(x)-1])

isteromister

x = "mistero"
#x = "corale"

# scrivi qui

Slice - limiti negativi

Volendo è anche possibile impostare limiti negativi, per quanto non sia sempre molto intuitivo.

#0123456
"foresta"[3:0]   # da indice 3 a indici positivi <= 3 non produce nulla

''

#0123456
"foresta"[3:1]   # da indice 3 a indici positivi <= 3 non produce nulla

''

#0123456
"foresta"[3:2]  # da indice 3 a indici positivi <= 3 non produce nulla

''

#0123456
"foresta"[3:3]  # da indice 3 a indici positivi <= 3 non produce nulla

''

Vediamo cosa succede con indici negativi:

#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-1]

'est'

#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-2]

'es'

#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-3]

'e'

#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-4]

''

#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-5]

''

Esercizio - javarnanda

Data una stringa x, scrivi del codice per estrarre e stampare i suoi ultimi 3 caratteri e unirli ai primi 3.

• Il tuo codice deve funzionare per qualsiasi stringa di lunghezza uguale o superiore a 3

Esempio 1 - dato:

x = "javarnanda"

dovrebbe stampare:

javnda

Esempio 2 - dato:

x = "bang"

dovrebbe stampare:

banang

Mostra soluzione

x = "javarnanda"
#x = "bang"

# scrivi qui

print(x[:3] + x[-3:])

javnda

x = "javarnanda"
#x = "bang"

# scrivi qui

javnda

Slice - modifica

Supponiamo di avere la stringa

    #0123456789
s = "il tavolo bianco è al centro della stanza"

e di voler cambiare l’assegnazione della variabile s in modo che diventi associata alla stringa

#0123456789
"il divano bianco è al centro della stanza"

Visto che le due stringhe sono simili, potremmo essere tentati di ridefinire solo la sequenza di caratteri corrispondente alla parola "tavolo", che va dall’indice 3 incluso all’indice 9 escluso:

s[3:9] = "divano"   # ATTENZIONE! SBAGLIATO!

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-57-0de7363c6882> in <module>
----> 1 s[3:9] = "divano"   # ATTENZIONE! SBAGLIATO!

TypeError: 'str' object does not support item assignment

Purtroppo, otterremo un errore, perchè come ripetuto più volte le stringhe sono IMMUTABILI, quindi non possiamo individuare una parte in una particolare stringa e provare a cambiare la stringa originale. Quello che invece possiamo fare è costruire una NUOVA stringa a partire da pezzi della stringa originale, concatenare i caratteri desiderati e associare il risultato alla variabile di cui vogliamo modificare l’assegnazione:

    #0123456789
s = "il tavolo bianco è al centro della stanza"
s = s[0:3] + "divano" + s[9:]
print(s)

il divano bianco è al centro della stanza

Quando Python trova la linea

s = s[0:3] + "divano" + s[9:]

PRIMA calcola il risultato della parte a destra dell’ =, e POI associa il risultato alla variabile che sta a sinistra. Nell’espressione a destra dell’ = vengono solo solo generate e concatenate NUOVE stringhe, che quindi una volta costruite possono essere assegnate alla variabile s.

Esercizio - la corsa

Scrivere del codice per cui data una stringa s

s = "la corsa all'oro è iniziata."

e delle variabili

cosa = "atomo"
verbo = "finita"

sostituisce la sottostringa in corrispondenza di "oro" con la stringa presente nella variabile cosa e sostituisce la sottostringa in corrispondenza di "iniziata" con la stringa presente nella variabile verbo.

Dopo l’esecuzione del tuo codice, la stringa associata ad s dovra essere

>>> print(s)
"la corsa all'atomo è finita."

• NON usare caratteri costanti nel tuo codice, quindi niente punto '.' !

Mostra soluzione

    #01234567890123456789012345678
s = "la corsa all'oro è iniziata."
cosa = "atomo"
verbo = "finita"

# scrivi qui

s = s[:13] + cosa + s[16:19] + verbo + s[27:]
print(s)

la corsa all'atomo è finita.

    #01234567890123456789012345678
s = "la corsa all'oro è iniziata."
cosa = "atomo"
verbo = "finita"

# scrivi qui

la corsa all'atomo è finita.

Operatore di inclusione

Per verificare se una stringa è contenuta in un’altra, possiamo usare l’operatore in.

Nota che il risultato di questa espressione è un booleano:

'tra' in 'Cantando per le strade'

True

'ca' in 'Cantando per le strade'  # l'operatore in   distingue tra maiuscole/minuscole

False

'Ca' in 'Cantando per le strade'

True

Non abusare in

ATTENZIONE: in viene spesso usato in modo errato / inefficiente

Chiediti sempre:

1. la stringa potrebbe non contenere la sottostringa cercata? Ricordati di gestire anche questo caso!

2. in compie una ricerca in tutta la stringa, che può essere inefficiente: è proprio necessaria, o sappiamo già l’intervallo in cui cercare?

3. se vogliamo sapere se un carattere è in una posizione nota a priori (es 3), in non ci serve, basta scrivere stringa[3] == carattere. Usando in potrebbe trovare caratteri duplicati che stanno prima o dopo di quello che vogliamo verificare!

Esercizio - contenute 1

Ti vengono date due stringhe x e y, e una terza z. Scrivi del codice che stampa True se x e y sono entrambe contenute in z.

Esempio 1 - date:

x = 'cad'
y = 'ra'
z = 'abracadabra'

dovrebbe stampare

True

Esempio 2 - date:

x = 'zam'
y = 'ra'
z = 'abracadabra'

dovrebbe stampare

False

Mostra soluzione

x,y,z = 'cad','ra','abracadabra'   # True
#x,y,z = 'zam','ra','abracadabra'  # False

# scrivi qui

print((x in z) and (y in z))

True

x,y,z = 'cad','ra','abracadabra'   # True
#x,y,z = 'zam','ra','abracadabra'  # False

# scrivi qui

Esercizio - contenute 2

Date tre stringhe x, y, z, scrivere del codice che stampa True se una stringa x è contenuta almeno in una delle stringhe y o z, altrimenti stampa False

• il tuo codice deve funzionare con qualunque insieme di stringhe

Esempio 1 - dati:

x = 'tti'
y = 'patti chiari amicizia lunga'
z = 'tutto chiaro?'

deve mostrare:

True

Esempio 2 - dati:

x = 'zio'
y = 'patti chiari amicizia lunga'
z = 'tutto chiaro?'

deve mostrare:

False

Esempio 3 - dati:

x = 'chiaro'
y = 'patti chiari amicizia lunga'
z = 'tutto chiaro?'

deve mostrare:

True

Mostra soluzione

x,y,z = 'tti', 'patti chiari amicizia lunga', 'tutto chiaro?'   # True
#x,y,z = 'zio','patti chiari amicizia lunga','tutto chiaro?'    # False
#x,y,z = 'chiaro','patti chiari amicizia lunga','tutto chiaro?' # True

# scrivi qui

print((x in y) or (x  in z))

True

x,y,z = 'tti', 'patti chiari amicizia lunga', 'tutto chiaro?'   # True
#x,y,z = 'zio','patti chiari amicizia lunga','tutto chiaro?'    # False
#x,y,z = 'chiaro','patti chiari amicizia lunga','tutto chiaro?' # True

# scrivi qui

Comparazioni

Python ci offre la possibilità di eseguire una comparazione lessicografica tra stringhe, come faremmo scrivendo nomi in una agenda di indirizzi. Sebbene ordinare nomi sia qualcosa di intuitivo che facciamo spesso, dobbiamo prestare attenzione ai casi speciali.

Per prima cosa, vediamo come determinare quando due stringhe sono uguali.

Operatori uguaglianza

Per verificare se due stringhe sono uguali, possiamo usare l’operatore == che come risultato produce un booleano True oppure False

ATTENZIONE: si scrive == con DUE uguali !!!

"gatto" == "gatto"

True

"gatto" == "cane"

False

L’operatore di uguaglianza distingue tra maiuscole e minuscole:

"gatto" == "GATTO"

False

Per vedere se due stringhe NON sono uguali, possiamo usare l’operatore !=, che come possiamo attenderci si comporta esattamente all’opposto di ==:

"gatto" != "gatto"

False

"gatto" != "cane"

True

"gatto" != "GATTO"

True

In alternativa, potremmo anche usare l’operatore not:

not "gatto" == "gatto"

False

not "gatto" == "cane"

True

not "gatto" == "GATTO"

True

DOMANDA: Il codice seguente cosa stampa?

x = "fiume" == "fiume"
print(x)

Mostra risposta

RISPOSTA: Quando Python incontra x = "fiume" == "fiume" vede che è un’assegnazione, che dovrebbe associare alla variabile x il risultato dell’espressione "fiume" == "fiume". Quindi PRIMA calcola l’espressione "fiume" == "fiume" che produce il booleano True, e POI associa il valore True alla variabile x. Quindi vedremo stampato True

DOMANDA: Per ciascuna delle espressioni seguenti, prova a indovinare se produce True o False

1. 'cappello' != 'Cappello'
   

2. 'cappello' == 'CAPPELLO'
   

3. 'pensieroso'[4:8] == 'forestiero'[6:]
   

4. 'CoStOsO'[4:] == 'oSo'
   

5. 'chiaro'[9:20] == 'scuro'[10:15]
   

6. 'ramarro'[-1] == 'giglio'[-1]
   

7. ('cappello' != 'giacca') == ('pantaloni' != 'cravatta')
   

8. ('stra' in 'stradivarius') == ('div' in 'divano')
   

9. len('nota') in '5436'
   

10. str(len('nota')) in '5436'
    

11. len('cartellone') in '5436'
    

12. str(len('cartellone')) in '5436'
    

Esercizio - rockettaro

Scrivi del codice che stampa True se una parola inizia con le stesse due lettere con cui finisce

• Il tuo codice deve funzionare per qualsiasi parola

Mostra soluzione

parola = 'rockettaro'  # True
#parola = 'massima'    # True
#parola = 'stima'      # False
#parola = 'baobab'     # False

# scrivi qui

print(parola[:2] == parola[-2:len(parola)])

True

parola = 'rockettaro'  # True
#parola = 'massima'    # True
#parola = 'stima'      # False
#parola = 'baobab'     # False

# scrivi qui

Comparare caratteri

I caratteri hanno un ordine che possiamo sfruttare. Vediamo un esempio:

'a' < 'g'

True

un altro:

'm' > 'c'

True

Sembrano comparazioni ragionevoli! Ma cosa dire di queste (nota la Z maiuscola)?

'a' < 'Z'

False

Forse questa non sembra così ovvia. E se proviamo ad essere creativi e compariamo con simboli come parentesi quadre o cuori Unicode ??

'a' > '♥'

False

Per determinare come gestire questi casi speciali, dobbiamo ricordare che la codifica ASCII assegna un numero di posizione ad ogni carattere, definendo di fatto un ordine tra tutti i suoi caratteri.

Se vogliamo sapere il numero corrispondente di un carattere, possiamo usare la funzione ord:

ord('a')

97

ord('b')

98

ord('z')

122

Se vogliamo andare nell’altro senso, dato un numero di posizione possiamo ottenere il carattere corrispondente con la funzione chr:

chr(97)

'a'

I caratteri maiuscoli hanno posizioni differenti:

ord('A')

65

ord('Z')

90

ESERCIZIO: Usando le funzioni sopra, prova a trovare quali caratteri sono tra la Z maiuscola e la a minuscola.

Mostra soluzione

# scrivi qui
print(chr(91),chr(92), chr(93),chr(94), chr(95),chr(96))

[ \ ] ^ _ `

# scrivi qui

L’ordine ci permette di eseguire comparazioni lessicografiche tra caratteri singoli:

'a' < 'b'

True

'g' >= 'm'

False

ESERCIZIO: Scrivi del codice che:

1. stampa i valori ord di 'A', 'Z' e un dato carattere car

2. stampa True se car è maiuscolo, e False altrimenti

• il tuo codice funzionerebbe anche con caratteri accentati capitalizzati come 'Á'?

• NOTA: gli insiemi di caratteri possibili sono parecchi, perciò la soluzione appropriata sarebbe usare il metodo isupper che vedremo nel prossimo tutorial.

Mostra soluzione

car = 'G'   # True
#car = 'g'  # False

#car = 'Á'  # True ?? Nota l'accento!

# scrivi qui
print('A:', ord('A'), ' Z:', ord('Z'))
print(car+':',ord(car))
ord(car) >= ord('A') and ord(car) <= ord('Z')  #  only checks simple English alphabet cases

A: 65  Z: 90
G: 71

True

car = 'G'   # True
#car = 'g'  # False

#car = 'Á'  # True ?? Nota l'accento!

# scrivi qui

Inoltre, dato che l’insieme dei caratteri Unicode include l’ASCII, l’ordine dei caratteri ASCII può essere usato per compararli in sicurezza con i caratteri unicode, perciò comparare i caratteri o i loro ord dovrebbe sempre essere equivalente:

ord('a')   # ascii

97

ord('♥')   # unicode

9829

'a' > '♥'

False

ord('a') > ord('♥')

False

Python offre anche comparazioni lessigrafiche su stringhe con più di un carattere. Per capire quale dovrebbe essere il risultato atteso, dobbiamo però distinguere diversi casi:

• stringhe di lunghezza uguale / differente

• stringhe con capitalizzazione uguale / diversa

Cominciamo con stringhe della stessa lunghezza:

'mario' > 'luigi'

True

'mario' > 'wario'

False

'Mario' > 'Wario'

False

'Wario' < 'mario'    # il maiuscolo è *prima* del minuscolo in ASCII

True

Comparare lunghezze diverse

Stringhe corte che sono incluse in altre più lunghe appaiono prima nell’ordinamento:

'troll' < 'trolley'

True

Se condividono solo un prefisso con una stringa più lunga, Python compara i caratteri dopo il prefisso comune, in questo caso rileva che e precede la s corrispondente:

'trolley' < 'trolls'

True

Esercizio - Intervalli di caratteri

Ti vengono fornite due coppie di stringhe i1 e i2 da due caratteri ciascuna.

Supponi che rappresentino intervalli di caratteri: il primo carattere di un intervallo ha sempre un numero d’ordine inferiore o uguale al secondo.

Ci sono cinque possibilità: il primo intervallo ‘è contenuto in’, oppure ‘contiene’, oppure ‘si sovrappone parzialmente a’, oppure ‘è prima’ o ‘è dopo’ il secondo intervallo. Scrivi del codice che dice quale relazione di contenimento abbiamo.

Esempio 1 - dati:

i1 = 'gm'
i2 = 'cp'

Il tuo programma dovrebbe stampare:

gm è contenuto in cp

Per vedere perchè, puoi guardare a questa piccola rappresentazione (non è necessario stamparla!):

  c   g     m  p
abcdefghijklmnopqrstuvwxyz

Esempio 2 - dati:

i1 = 'mr'
i2 = 'pt'

Il tuo programma dovrebbe stampare:

mr si sovrappone parzialmente a pt

perchè mr non è contenuto nè contiene ne completamente precede nè completamente segue pt (non è necessario stampare questo:)

            m  p r t
abcdefghijklmnopqrstuvwxyz

• se l’intervallo i1 coincide con i2, è considerato come contenente i2

• NON usare cicli nè if

• SUGGERIMENTO: per soddisfare i vincoli qui sopra, pensa all’ordine di valutazione dei booleani:

'g' >= 'c' and 'm' <= 'p' and 'è contenuto in'

produce come risultato la stringa 'è contenuto in'

Mostra soluzione

i1,i2 = 'gm','cp'   # gm è contenuto in cp
#i1,i2 = 'dh','dh'  # gm è contenuto in cp  #(caso speciale)
#i1,i2 = 'bw','dq'  # bw contiene dq
#i1,i2 = 'ac','bd'  # ac si sovrappone parzialmente a bd
#i1,i2 = 'mr','pt'  # mr si sovrappone parzialmente  pt
#i1,i2 = 'fm','su'  # fm è prima di su
#i1,i2 = 'xz','pq'  # xz è dopo pq

# scrivi qui
res = (i1[0] >= i2[0] and i1[1] <= i2[1] and 'è contenuto in')  \
      or (i1[0] < i2[0] and i1[1] >i2[1] and 'contiene')         \
      or (i1[0] >= i2[0] and i1[0] <= i2[1] and 'si sovrappone parzialmente a') \
      or (i1[1] >= i2[0] and i1[1] <= i2[1] and 'si sovrappone parzialmente a')  \
      or (i1[1] < i2[0] and 'è prima di')   \
      or (i1[0] > i2[1] and 'è dopo')

print(i1, res, i2)

gm è contenuto in cp

i1,i2 = 'gm','cp'   # gm è contenuto in cp
#i1,i2 = 'dh','dh'  # gm è contenuto in cp  #(caso speciale)
#i1,i2 = 'bw','dq'  # bw contiene dq
#i1,i2 = 'ac','bd'  # ac si sovrappone parzialmente a bd
#i1,i2 = 'mr','pt'  # mr si sovrappone parzialmente  pt
#i1,i2 = 'fm','su'  # fm è prima di su
#i1,i2 = 'xz','pq'  # xz è dopo pq

# scrivi qui

Esercizio - La Biblioteca di Encodicus

Nello studio dell’algoritmista Encodicus è presente uno scaffale diviso in 26 sezioni ordinate alfabeticamente, ove custodisce gelosamente i suoi preziosi testi alchemici. Ciascuna sezione può contenere al massimo 9 libri. Un giorno, Encodicus decide di acquistare un nuovo tomo da aggiungere alla sua collezione: scrivi del codice che data una stringa rappresentante lo scaffale con i conteggi dei libri e un nuovo libro, trovi la giusta posizione del libro e aggiorni scaffale di conseguenza

• assumi che nessuna sezione contenga 9 libri

• assumi che i nomi dei libri siano sempre in minuscolo

• NON usare cicli, if, o metodi delle stringhe

• NON scrivere manualmente stringhe con 26 caratteri, o peggio creare 26 variabili !!!

• USA ord per trovare la posizione della sezione

Esempio - dati:

scaffale = "|a 7|b 5|c 5|d 8|e 2|f 0|g 4|h 8|i 7|j 1|k 6|l 0|m 5|n 0|o 3|p 7|q 2|r 2|s 4|t 6|u 1|v 3|w 3|x 5|y 7|z 6|"
libro = "ciclare all'aperto"

dopo il tuo codice scaffale deve risultare aggiornato con |c 6|:

>>> print(scaffale)
|a 7|b 5|c 6|d 8|e 2|f 0|g 4|h 8|i 7|j 1|k 6|l 0|m 5|n 0|o 3|p 7|q 2|r 2|s 4|t 6|u 1|v 3|w 3|x 5|y 7|z 6|

Mostra soluzione

libro = "ciclare all'aperto"
#libro = "algoritmi occulti"
#libro = "teoria dello zippo"
#libro = "zoologia dello sviluppatore software"

scaffale = "|a 7|b 5|c 5|d 8|e 2|f 0|g 4|h 8|i 7|j 1|k 6|l 0|m 5|n 0|o 3|p 7|q 2|r 2|s 4|t 6|u 1|v 3|w 3|x 5|y 7|z 6|"

# scrivi qui

c = libro[0]

i = ord(c) - ord('a')
n = int(scaffale[(i*4)+3:((i)*4)+4])

scaffale = scaffale[:i*4] + '|' + c + ' ' + str(n+1)  + scaffale[(i+1)*4:]

print(scaffale)

|a 7|b 5|c 6|d 8|e 2|f 0|g 4|h 8|i 7|j 1|k 6|l 0|m 5|n 0|o 3|p 7|q 2|r 2|s 4|t 6|u 1|v 3|w 3|x 5|y 7|z 6|

libro = "ciclare all'aperto"
#libro = "algoritmi occulti"
#libro = "teoria dello zippo"
#libro = "zoologia dello sviluppatore software"

scaffale = "|a 7|b 5|c 5|d 8|e 2|f 0|g 4|h 8|i 7|j 1|k 6|l 0|m 5|n 0|o 3|p 7|q 2|r 2|s 4|t 6|u 1|v 3|w 3|x 5|y 7|z 6|"

# scrivi qui

Operatore di replicazione

Con l’operatore * puoi replicare una stringa n volte, per esempio:

'birra' * 4

'birrabirrabirrabirra'

Nota come venga creata una NUOVA stringa, l’originale non viene intaccata:

beviamo = "birra"

print(beviamo * 4)

birrabirrabirrabirra

beviamo

'birra'

Esercizio - za za za

Data una sillaba e una frase che termina con una carattere n come cifra, scrivi del codice che stampa una stringa con la sillaba ripetuta n volte, separate da spazi.

• Il tuo codice deve funzionare con qualsiasi stringa assegnata a sillaba e frase

Esempio - date:

frase = 'Il numero 7'
sillaba = 'za'

dopo il tuo codice, deve stampare:

za za za za za za za

Mostra soluzione

sillaba = 'za'
frase = 'Il numero 7'   # za za za za za za za
#frase = 'Dammi il 5'   # za za za za za


# scrivi qui

print((sillaba + ' ') * (int(frase[-1])))

za za za za za za za

sillaba = 'za'
frase = 'Il numero 7'   # za za za za za za za
#frase = 'Dammi il 5'   # za za za za za


# scrivi qui

Prosegui

Trovi ulteriori esercizi nel foglio Stringhe 3 - metodi base