Stringhe 2 - operatori

Scarica zip esercizi

Naviga file online

Python offre diversi operatori per lavorare con le stringhe:

Operatore

Uso

Risultato

Significato

len

len(str)

int

Ritorna la lunghezza della stringa

concatenazione

str + str

str

Concatena due stringhe

`inclusione <#Operatore-in> `__

str in str

bool

Controlla se la stringa è presente in un’altra stringa

`indice <#Leggere-caratteri >`__

str[int]

str

Legge il carattere all’indice specificato

slice

str[int:int ]

str

Estrae una sotto-stringa

uguaglianza

==,!=

bool

Controlla se due stringhe sono uguali o differenti

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
    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 strings1.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. Gli esercizi sono graduati per difficoltà, da una stellina ✪ a quattro ✪✪✪✪

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:

[2]:

'ciao'[0]
[2]:
'c'
[3]:
'ciao'[1]
[3]:
'i'
[4]:
#0123
'ciao'[2]
[4]:
'a'
[5]:
#0123
'ciao'[3]
[5]:
'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:

[6]:
    #01234
x = 'panca'
[7]:
x[0]
[7]:
'p'
[8]:
x[2]
[8]:
'n'

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

[9]:
type(x[0])
[9]:
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

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

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
[10]:
# scrivi qui


shaiy!

Indici negativi

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

[11]:
#4321
"ciao"[-1]
[11]:
'o'
[12]:
#4321
"ciao"[-2]
[12]:
'a'
[13]:
#4321
"ciao"[-3]
[13]:
'i'
[14]:
#4321
"ciao"[-4]
[14]:
'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

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

x[len(x)-1]

e

x[-len(x)]

sono equivalenti ? Che cosa fanno ?

Mostra risposta

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

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

'ciao'[0][0]
Mostra risposta

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

(x[0])[0]
Mostra risposta

Sostituire caratteri

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

[15]:
    #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:

[16]:
x = x[0] + x[1] + 'b' + x[3]
[17]:
x
[17]:
'cibo'

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

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

Provalo in Python Tutor:

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

jupman.pytut()
[19]:

Slice

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

[20]:
    #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 :

[21]:
    #0123456789
x = 'mercantile'

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

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

Vediamo un esempio:

[22]:
    #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

Esercizio - garalampog

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

Mostra soluzione
[23]:
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
[24]:
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:

[25]:
#012345
"sedia"[0:3]  # da indice 0 *incluso* a 3 *escluso*
[25]:
'sed'
[26]:
#012345
"sedia"[0:4]  # da indice 0 *incluso* a 4 *escluso*
[26]:
'sedi'
[27]:
#012345
"sedia"[0:5]  # da indice 0 *incluso* a 5 *escluso*
[27]:
'sedia'
[28]:
#012345
"sedia"[0:6]   # se andiamo oltre la lunghezza della stringa Python non si arrabbia
[28]:
'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

Slice - omissione limiti

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

[29]:
#0123456789
"traghetto"[:3]
[29]:
'tra'

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

[30]:
#0123456789
"traghetto"[3:]
[30]:
'ghetto'

Omettendo entrambi gli indici si ottiene l’intera stringa:

[31]:
"traghetto"[:]
[31]:
'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 = "parlare"

deve stampare

arlareparlar

Mostra soluzione
[32]:
x = "mistero"

# scrivi qui


isteromister

Slice - limiti negativi

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

[33]:
#0123456
"foresta"[3:0]   # da indice 3 a indici positivi <= 3 non produce nulla
[33]:
''
[34]:
#0123456
"foresta"[3:1]   # da indice 3 a indici positivi <= 3 non produce nulla
[34]:
''
[35]:
#0123456
"foresta"[3:2]  # da indice 3 a indici positivi <= 3 non produce nulla
[35]:
''
[36]:
#0123456
"foresta"[3:3]  # da indice 3 a indici positivi <= 3 non produce nulla
[36]:
''

Vediamo cosa succede con indici negativi:

[37]:
#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-1]
[37]:
'est'
[38]:
#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-2]
[38]:
'es'
[39]:
#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-3]
[39]:
'e'
[40]:
#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-4]
[40]:
''
[41]:
#0123456   indici positivi
#7654321   indici negativi
"foresta"[3:-5]
[41]:
''

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 = "abcd"

dovrebbe stampare:

abcbcd
Mostra soluzione
[42]:
x = "javarnanda"
#x = "abcd"

# scrivi qui


javnda

Slice - modifica

Supponiamo di avere la stringa

[43]:
    #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:

[44]:
    #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
[45]:
    #01234567890123456789012345678
s = "la corsa all'oro è iniziata."
cosa = "atomo"
verbo = "finita"

# scrivi qui


la corsa all'atomo è finita.

Operatore in

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

Nota che il risultato di questa espressione è un booleano:

[46]:
'tra' in 'Cantando per le strade'
[46]:
True
[47]:
'ca' in 'Cantando per le strade'  # l'operatore in   distingue tra maiuscole/minuscole
[47]:
False
[48]:
'Ca' in 'Cantando per le strade'
[48]:
True

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
[49]:
x,y,z = 'cad','ra','abracadabra'   # True
#x,y,z = 'zam','ra','abracadabra'  # False

# scrivi qui


True

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
[50]:
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


True

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 !!!

[51]:
"gatto" == "gatto"
[51]:
True
[52]:
"gatto" == "cane"
[52]:
False

L’operatore di uguaglianza distingue tra maiuscole e minuscole:

[53]:
"gatto" == "GATTO"
[53]:
False

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

[54]:
"gatto" != "gatto"
[54]:
False
[55]:
"gatto" != "cane"
[55]:
True
[56]:
"gatto" != "GATTO"
[56]:
True

In alternativa, potremmo anche usare l’operatore not:

[57]:
not "gatto" == "gatto"
[57]:
False
[58]:
not "gatto" == "cane"
[58]:
True
[59]:
not "gatto" == "GATTO"
[59]:
True

DOMANDA: Il codice seguente cosa stampa?

x = "fiume" == "fiume"
print(x)
Mostra risposta

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
[60]:
parola = 'rockettaro'  # True
#parola = 'massima'    # True
#parola = 'stima'      # False
#parola = 'baobab'     # False

# scrivi qui


True

Operatore di replicazione

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

[61]:
'birra' * 4
[61]:
'birrabirrabirrabirra'

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

[62]:
beviamo = "birra"
[63]:
print(beviamo * 4)
birrabirrabirrabirra
[64]:
beviamo
[64]:
'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
[65]:

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


# scrivi qui


za za za za za za za

Prosegui

Trovi ulteriori esercizi nel foglio Stringhe 3 - metodi

[ ]: