Stringhe 2 - operatori
Scarica zip esercizi
Python offre diversi operatori per lavorare con le stringhe:
Operatore |
Sintassi |
Risultato |
Significato |
---|---|---|---|
lunghezza |
|
|
Ritorna la lunghezza della stringa |
str |
|
Legge il carattere all’indice specificato |
|
str1 |
|
Concatena due stringhe |
|
str1 |
|
Controlla se la stringa è presente in un’altra stringa |
|
str |
|
Estrae una sotto-stringa |
|
|
|
Controlla se due stringhe sono uguali o differenti |
|
|
|
Controlla se due stringhe sono uguali o differenti |
|
|
|
Controlla se due stringhe sono uguali o differenti |
|
ord |
ord(str) |
|
Ritorna l’ordine di un carattere |
chr |
chr(str) |
|
Dato un ordine, ritorna il carattere corrispondente |
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:
[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:
sempre un carattere
sempre un errore
a volte un carattere, a volte un errore a seconda della stringa
DOMANDA: Supponiamo che x
sia una stringa qualsiasi. Se proviamo ad eseguire questo codice:
x[len(x)]
otterremo:
sempre un carattere
sempre un errore
a volte un carattere, a volte un errore a seconda della stringa
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!
[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)]
sempre un carattere
sempre un errore
a volte un carattere, a volte un errore a seconda della stringa
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 rispostaDOMANDA: Se x
è una stringa non vuota, l’espressione seguente cosa produce? La possiamo semplificare in una più breve?
(x + x)[len(x)]
DOMANDA: Se x
è una stringa non vuota, cosa produce la seguente espressione? Un errore? Altro? La possiamo semplificare?
'ciao'[0][0]
DOMANDA: Se x
è una stringa non vuota, cosa produce la seguente espressione? Un errore? Altro? La possiamo semplificare?
(x[0])[0]
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]
Esercizio - garalampog
Scrivi del codice per estrarre e stampare alam
dalla stringa "garalampog"
. Prova a indovinare correttamente gli indici.
[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.
[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)]
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 = "corale"
deve stampare
oralecoral
[32]:
x = "mistero"
#x = "corale"
# scrivi qui
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 = "bang"
dovrebbe stampare:
banang
[42]:
x = "javarnanda"
#x = "bang"
# 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
'.'
!
[45]:
#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:
[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:
la stringa potrebbe non contenere la sottostringa cercata? Ricordati di gestire anche questo caso!
in
compie una ricerca in tutta la stringa, che può essere inefficiente: è proprio necessaria, o sappiamo già l’intervallo in cui cercare?se vogliamo sapere se un
carattere
è in una posizione nota a priori (es3
),in
non ci serve, basta scriverestringa[3] == carattere
. Usandoin
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
[49]:
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
[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
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)
DOMANDA: Per ciascuna delle espressioni seguenti, prova a indovinare se produce True
o False
'cappello' != 'Cappello'
'cappello' == 'CAPPELLO'
'pensieroso'[4:8] == 'forestiero'[6:]
'CoStOsO'[4:] == 'oSo'
'chiaro'[9:20] == 'scuro'[10:15]
'ramarro'[-1] == 'giglio'[-1]
('cappello' != 'giacca') == ('pantaloni' != 'cravatta')
('stra' in 'stradivarius') == ('div' in 'divano')
len('nota') in '5436'
str(len('nota')) in '5436'
len('cartellone') in '5436'
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
[60]:
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:
[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.
[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:
stampa i valori
ord
di'A'
,'Z'
e un dato caratterecar
stampa
True
secar
è maiuscolo, eFalse
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.
[74]:
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:
[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 coni2
, è considerato come contenentei2
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'
[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
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
libriassumi che i nomi dei libri siano sempre in minuscolo
NON usare cicli,
if
, o metodi delle stringheNON 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|
[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
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
efrase
Esempio - date:
frase = 'Il numero 7'
sillaba = 'za'
dopo il tuo codice, deve stampare:
za za za za za za za
[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
Prosegui
Trovi ulteriori esercizi nel foglio Stringhe 3 - metodi base
[ ]: