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

str in str

bool

Controlla se la stringa è presente in un’altra stringa

indice

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

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

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

[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

Comparare caratteri

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

[61]:
'a' < 'g'
[61]:
True

un altro:

[62]:
'm' > 'c'
[62]:
True

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

[63]:
'a' < 'Z'
[63]:
False

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

[64]:
'a' > '♥'
[64]:
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:

[65]:
ord('a')
[65]:
97
[66]:
ord('b')
[66]:
98
[67]:
ord('z')
[67]:
122

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

[68]:
chr(97)
[68]:
'a'

I caratteri maiuscoli hanno posizioni differenti:

[69]:
ord('A')
[69]:
65
[70]:
ord('Z')
[70]:
90

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

Mostra soluzione
[71]:
# scrivi qui


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

[72]:
'a' < 'b'
[72]:
True
[73]:
'g' >= 'm'
[73]:
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
[74]:
car = 'G'   # True
#car = 'g'  # False

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

# scrivi qui


A: 65  Z: 90
G: 71
[74]:
True

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:

[75]:
ord('a')   # ascii
[75]:
97
[76]:
ord('♥')   # unicode
[76]:
9829
[77]:
'a' > '♥'
[77]:
False
[78]:
ord('a') > ord('♥')
[78]:
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:

[79]:
'mario' > 'luigi'
[79]:
True
[80]:
'mario' > 'wario'
[80]:
False
[81]:
'Mario' > 'Wario'
[81]:
False
[82]:
'Wario' < 'mario'    # il maiuscolo è *prima* del minuscolo in ASCII
[82]:
True

Comparare lunghezze diverse

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

[83]:
'troll' < 'trolley'
[83]:
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:

[84]:
'trolley' < 'trolls'
[84]:
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
[85]:
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


gm è contenuto in cp

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 le 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
[86]:
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


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

Operatore di replicazione

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

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

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

[88]:
beviamo = "birra"
[89]:
print(beviamo * 4)
birrabirrabirrabirra
[90]:
beviamo
[90]:
'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
[91]:

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

[ ]: