Tuple
Scarica zip esercizi
Una tupla in Python è una sequenza immutabile di elementi eterogenei che ammette duplicati, perciò possiamo mettere gli oggetti che vogliamo, anche di tipi diversi, e anche ripetuti.
Che fare
scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere:
tuples
tuples1.ipynb
tuples1-sol.ipynb
tuples2-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
tuples1.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
Creare tuple
Le tuple si creano con le parentesi tonde ()
e separando gli elementi da virgole ,
.
Qualche esempio:
[2]:
numeri = (6,7,5,7,7,9)
[3]:
print(numeri)
(6, 7, 5, 7, 7, 9)
Tuple di un solo elemento: Puoi creare una tupla di un solo elemento aggiungendo una virgola dopo l’elemento:
[4]:
tuplina = (4,) # occhio alla virgola !!!
Verifichiamo che il tipo sia quello atteso:
[5]:
type(tuplina)
[5]:
tuple
Per vedere la differenza, scriviamo qua sotto (4)
senza virgola e verifichiamo il tipo dell’oggetto ottenuto
[6]:
farlocca = (4)
[7]:
type(farlocca)
[7]:
int
Vediamo che farlocca
è un int
, perchè il 4
è stato valutato come un’espressione dentro delle tonde e il risultato è il contenuto delle tonde
Tupla vuota
Possiamo anche creare una tupla vuota:
[8]:
vuota = ()
[9]:
print(vuota)
()
[10]:
type(vuota)
[10]:
tuple
Tuple senza parentesi
Quando assegnamo dei valori a delle variabili, (e solo quando assegnamo valori a delle variabili) è possibile usare una notazione del genere, in cui a sinistra dell’ =
mettiamo nomi di variabili e a destra una sequenza di valori:
[11]:
a,b,c = 1, 2, 3
[12]:
a
[12]:
1
[13]:
b
[13]:
2
[14]:
c
[14]:
3
Se ci chiediamo cosa sia quel 1,2,3
, possiamo provare a mettere a sinistra solo una variabile:
[15]:
# ATTENZIONE: MEGLIO EVITARE !
x = 1,2,3
[16]:
type(x)
[16]:
tuple
Vediamo che Python ha considerato quel 1,2,3
come una tupla. Tipicamente, non scriverai mai assegnazioni con meno variabili che valori da metterci, ma se per caso ti capita, probabilmente ti troverai con qualche tupla indesiderata!
DOMANDA: Guarda i seguenti frammenti di codice, e per ciascuno cerca di indovinare quale risultato produce (o se danno errore):
z,w = 5,6 print(type(z)) print(type(w))
a,b = 5,6 a,b = b,a print('a=',a) print('b=',b)
z = 5, print(type(z))
z = , print(type(z))
Elementi eterogenei
In una tupla possiamo mettere elementi di tipo diverso, come numeri e stringhe:
[17]:
roba = (4, "carta", 5, 2,"scatole", 7)
[18]:
roba
[18]:
(4, 'carta', 5, 2, 'scatole', 7)
[19]:
type(roba)
[19]:
tuple
Possiamo anche inserire anche altre tuple:
[20]:
insalata = ( ("cavoli", 3), ("pomodori",9), ("verze",4) )
[21]:
insalata
[21]:
(('cavoli', 3), ('pomodori', 9), ('verze', 4))
[22]:
type(insalata)
[22]:
tuple
E anche liste:
[23]:
misto = ( ["quando", "fuori", "piove"], ["scrivo", "programmi"], [7,3,9] )
ATTENZIONE agli oggetti mutabili dentro le tuple!
Inserire oggetti mutabili come le liste dentro le tuple potrebbe causare problemi in alcune situazioni - per es. se poi vuoi usare la tupla come elemento di un insieme o chiave di un dizionario (lo vedremo meglio nei rispettivi tutorial)
Vediamo come gli esempi precedenti vengono rappresentati in Python Tutor:
[24]:
# AFFINCHE' PYTHON TUTOR FUNZIONI, RICORDATI DI ESEGUIRE QUESTA CELLA con Shift+Invio
# (basta eseguirla una volta sola, la trovi anche all'inizio di ogni foglio)
import jupman
[25]:
roba = (4, "carta", 5, 2,"scatole", 7)
insalata = ( ("cavoli", 3), ("pomodori",9), ("verze",4) )
misto = ( ["quando", "fuori", "piove"], ["scrivo", "programmi"], [7,3,9] )
jupman.pytut()
[25]:
Creare tuple da sequenze
Puoi creare una tupla da una qualsiasi sequenza, per esempio da una lista:
[26]:
tuple( [8,2,5] )
[26]:
(8, 2, 5)
Oppure una stringa (che è una sequenza di caratteri):
[27]:
tuple("abc")
[27]:
('a', 'b', 'c')
Creare sequenze da tuple
Visto che la tupla è una sequenza, è anche possibile generare liste a partire da tuple:
[28]:
list( (3,4,2,3) )
[28]:
[3, 4, 2, 3]
DOMANDA: Ha senso creare una tupla da un’altra tupla così? Possiamo riscrivere il codice in modo più conciso?
[29]:
x = (4,2,5)
y = tuple(x)
DOMANDA: Guarda le seguenti espressioni, e per ciascuna cerca di indovinare quale risultato producono (o se danno errore):
(1.2,3.4)
(1;2;3;4)
(1,2;3,4)
(1,2,3,4)
(())
type(())
((),)
tuple([('a'),('b'),('c')])
tuple(tuple(('z','u','m')))
str(('a','b','c'))
"".join(('a','b','c'))
Operatori
I seguenti operatori funzionano sulle tuple e si comportano esattamente come per le liste:
Operatore |
Sintassi |
Risultato |
Significato |
---|---|---|---|
|
|
Ritorna la lunghezza di una tupla |
|
tuple |
|
Legge un elemento all’indice specificato |
|
tuple |
|
Estrae una sotto-tupla - ritorna una NUOVA tupla |
|
tuple |
|
Concatena due tuple - ritorna una NUOVA tupla |
|
object |
|
Controlla se un elemento è presente in una tupla |
|
tuple |
|
Replica la tupla - ritorna una NUOVA tupla |
|
uguaglianza |
|
|
Controlla se due tuple sono uguali o differenti |
len
La funzione len
ritorna la lunghezza della tupla:
[30]:
len( (4,2,3) )
[30]:
3
[31]:
len( (7,) )
[31]:
1
[32]:
len( () )
[32]:
0
DOMANDA: Guarda le seguenti espressioni, e per ciascuna cerca di indovinare il risultato (o se produce un errore)
len(3,2,4)
len((3,2,4))
len(('a',))
len(('a,'))
len(((),(),()))
len(len((1,2,3,4)))
len([('d','a','c','d'),(('ab')),[('a','b','c')]])
[ ]:
Leggere un elemento
Come per stringhe e liste possiamo leggere un elemento ad una certa posizione con le quadre:
[33]:
# 0 1 2 3
tupla = (10,11,12,13)
[34]:
tupla[0]
[34]:
10
[35]:
tupla[1]
[35]:
11
[36]:
tupla[2]
[36]:
12
[37]:
tupla[3]
[37]:
13
Anche per le tuple possiamo usare indici negativi:
[38]:
tupla[-1]
[38]:
13
DOMANDA: Guarda le espressioni seguenti e per ciascuna cerca di indovinare il risultato o se produce un errore:
(1,2,3)[0]
(1,2,3)[3]
(1,2,3)0
('a,')[0]
('a',)[0]
(1,2,3)[-0]
(1,2,3)[-1]
(1,2,3)[-3]
()[0]
(())[0]
type((())[0])
[ ]:
Esercizio: animali
Data la stringa animali = "gatto siamese,cane,canarino,porcellino,coniglio,criceto"
convertila in una lista
crea una tupla di tuple dove ogni tupla ha due informazioni: il nome dell’animale e la lunghezza del nome, per esempio ((“cane”,3), ( “criceto”,7))
stampa la tupla
Dovresti ottenere:
gatto siamese,cane,canarino,porcellino,coniglio,criceto
(('gatto siamese', 13), ('cane', 4), ('canarino', 8), ('porcellino', 10), ('coniglio', 8), ('criceto', 7))
puoi assumere che
animali
contenga sempre esattamente 6 animali
[39]:
animali = "gatto siamese,cane,canarino,porcellino,coniglio,criceto"
# scrivi qui
Slice
Come per stringhe e liste possiamo ricavare sottosequenze da una tupla usando le slice, cioè scrivendo alla destra della tupla delle quadre con dentro un indice di partenza INCLUSO, due punti :
e un indice di fine ESCLUSO:
[40]:
tupla = (10,11,12,13,14,15,16,17,18,19)
[41]:
tupla[2:6] # da indice 2 INCLUSO a 6 ESCLUSO
[41]:
(12, 13, 14, 15)
Si può specificare di raccogliere elementi saltandone tra uno e l’altro aggiungendo il numero di elementi da saltare come un terzo numero tra le quadre, per esempio:
[42]:
tupla = (10,11,12,13,14,15,16,17)
[43]:
tupla[0:8:5]
[43]:
(10, 15)
[44]:
tupla[0:8:2]
[44]:
(10, 12, 14, 16)
[45]:
tupla[1:8:1]
[45]:
(11, 12, 13, 14, 15, 16, 17)
ATTENZIONE: ricordati che le slice producono una NUOVA tupla !
DOMANDA: Guarda il codice seguente e per ciascuna espressione prova a indovinare il risultato o se produce un errore:
(7,6,8,9,5)(1:3)
(7,6,8,9,5)[1:3]
(10,11,12,13,14,15,16)[3:100]
(10,11,12,13,14,15,16)[-3:5]
(1,0,1,0,1,0)[::2]
(1,2,3)[::1]
(1,0,1,0,1,0)[1::2]
tuple("cartolina")[0::2]
(4,5,6,3,4,7)[0:::2]
Concatenazione
E’ possibile concatenare due tuple usando l’operatore +
, che crea una NUOVA tupla
[46]:
t = (1,2,3) + (4,5,6,7,8)
[47]:
t
[47]:
(1, 2, 3, 4, 5, 6, 7, 8)
[48]:
type(t)
[48]:
tuple
Verifichiamo che le tuple originali non vengano modificate:
[49]:
x = (1,2,3)
y = (4,5,6,7,8)
[50]:
t = x + y
[51]:
t
[51]:
(1, 2, 3, 4, 5, 6, 7, 8)
[52]:
x
[52]:
(1, 2, 3)
[53]:
y
[53]:
(4, 5, 6, 7, 8)
Guardiamo come vengono rappresentate in Python Tutor:
[54]:
# AFFINCHE' PYTHON TUTOR FUNZIONI, RICORDATI DI ESEGUIRE QUESTA CELLA con Shift+Invio
# (basta eseguirla una volta sola, la trovi anche all'inizio di ogni foglio)
import jupman
[55]:
x = (1,2,3)
y = (4,5,6,7,8)
t = x + y
print(t)
print(x)
print(y)
jupman.pytut()
(1, 2, 3, 4, 5, 6, 7, 8)
(1, 2, 3)
(4, 5, 6, 7, 8)
[55]:
DOMANDA: Guarda il codice seguente e per ciascuna espressione cerca di indovinare il risultato, o se produce un errore.
(2,3,4) + tuple([5,6,7])
"razzo"+('p','a','z','z','o')
()+()
type(()+())
len(()+())
()+[]
[]+()
Appartenenza
Come per tutte le sequenze, se vogliamo verificare se un elemento è contenuto in una tupla possiamo usare l’operatore in
che ci ritorna un valore booleano:
[56]:
'a' in ('c','a','s','c','o')
[56]:
True
[57]:
'z' in ('c','a','s','c','o')
[57]:
False
not in
Per verificare se qualcosa non appartiene ad una tupla, possiamo usare due forme:
not in - forma 1:
[58]:
"carota" not in ("anguria","banana","mela")
[58]:
True
[59]:
"anguria" not in ("anguria","banana","mela")
[59]:
False
not in - forma 2
[60]:
not "carota" in ("anguria","banana","mela")
[60]:
True
[61]:
not "anguria" in ("anguria","banana","mela")
[61]:
False
DOMANDA: Guarda le seguenti espressioni, e per ciascuna cerca di indovinare quale risultato producono (o se danno errore):
3 in (1.0, 2.0,3.0)
3.0 in (1,2,3)
3 not in (3)
3 not in (3,)
6 not in ()
0 in (0)[0]
[] in ()
() in []
not [] in ()
() in ()
() in (())
() in ((),)
'ciao' in ('c','i','a','o')
Replicazione
Per replicare gli elementi di una tupla, è possibile usare l’operatore *
che produce una NUOVA tupla:
[62]:
(7,8,5) * 3
[62]:
(7, 8, 5, 7, 8, 5, 7, 8, 5)
[63]:
(7,8,5) * 1
[63]:
(7, 8, 5)
[64]:
(7,8,5) * 0
[64]:
()
DOMANDA: Il seguente codice cosa stamperà?
x = (5,6,7)
y = x * 3
print('x=',x)
print('y=',y)
DOMANDA: Guarda il codice seguente e per ciascuna espressione cerca di indovinare il risultato, o se produce un errore.
(5,6,7)*(3.0)
(5,6,7)*(3,0)
(5,6,7)*(3)
(5,6,7)*3
(4,2,3)*int(3.0)
(1,2)*[3][0]
(1,2)*(3,4)[-1]
[(9,8)]*4
(1+2,3+4)*5
(1+2,)*4
(1+2)*4
(1,2,3)*0
(7)*0
(7,)*0
Esercizio - welcome
Data una tupla x
contenente esattamente 3 interi, ed una tupla y
contenente esattamente 3 tuple di caratteri, scrivi del codice per creare una tupla z
contenente ogni tupla di y
replicata dal numero corrispondente in x
.
Esempio - dati:
x = (2,4,3)
y = (('w','e','l','c'),('o',),('m','e'))
dopo il tuo codice dovrebbe stampare:
>>> print(z)
('w', 'e', 'l', 'c', 'w', 'e', 'l', 'c', 'o', 'o', 'o', 'o', 'm', 'e', 'm', 'e', 'm', 'e')
[65]:
x = (2,4,3)
y = (('w','e','l','c'),('o',),('m','e'))
# scrivi qui
Scrivere un elemento
Le tuple sono immutabili, quindi provare per esempio a scrivere un assegnazione per mettere il numero 12
nella cella all’indice 3
provoca un errore:
# 0 1 2 3 4
tupla = (5,8,7,9,11)
tupla[3] = 666
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-118-83949b0c81e2> in <module>
1 tupla = (5,8,7,9)
----> 2 tupla[1] = 666
TypeError: 'tuple' object does not support item assignment
Quello che possiamo fare è creare una NUOVA tupla componendola da sequenze prese dall’originale
[66]:
# 0 1 2 3 4 5 6
tupla = (17,54,34,87,26,95,34)
[67]:
tupla = tupla[0:3] + (12,) + tupla[4:]
[68]:
tupla
[68]:
(17, 54, 34, 12, 26, 95, 34)
ATTENZIONE: append
, extend
, insert
, sort
NON FUNZIONANO CON LE TUPLE !
Tutti i metodi che hai usato per modificare le liste non funzioneranno con le tuple.
Esercizio - errando
Prova a scrivere qua sotto (1,2,3).append(4)
e guarda che errore appare:
[69]:
# scrivi qui
Esercizio: abde
Data una tupla x
, salva nella variabile y
un’altra tupla contenente:
all’inizio gli stessi elementi di
x
eccetto l’ultimoalla fine gli elementi
'd'
e'e'
.Il tuo codice dovrebbe funzionare con qualunque tupla
x
Esempio - data:
x = ('a','b','c')
dopo il tuo codice, dovresti veder stampato:
x = ('a', 'b', 'c')
y = ('a', 'b', 'd', 'e')
[70]:
x = ('a','b','c')
# scrivi qui
Esercizio - carismatico
Data una tupla t
avente caratteri intervallati maiuscolo / minuscolo, scrivere del codice che modifica l’assegnazione di t
in modo che t
sia uguale ad una tupla avente tutti i caratteri maiuscoli per primi e tutti i caratteri minuscoli per ultimi.
Esempio - data
t = ('C', 'a', 'R', 'i', 'S', 'm', 'A', 't', 'I', 'c', 'O')
dopo il tuo codice deve risultare
>>> print(t)
('C', 'R', 'S', 'A', 'I', 'O', 'a', 'i', 'm', 't', 'c')
[71]:
t = ('C', 'a', 'R', 'i', 'S', 'm', 'A', 't', 'I', 'c', 'O')
# scrivi qui
Esercizio - ordinare
Data una tupla x
di numeri disordinati, scrivere del codice che cambia l’assegnazione di x
in modo che abbia assegnata una tupla con i numeri ordinati.
il tuo codice deve funzionare per qualsiasi tupla
x
SUGGERIMENTO: Come già scritto, le tuple NON hanno il metodo
sort
(perchè le muterebbe), ma le liste ce l’hanno….
Esempio - dati:
x = (3,4,2,5,5,5,2,3)
dopo il tuo codice deve risultare
>>> print(x)
(2, 2, 3, 3, 4, 5, 5, 5)
[72]:
x = (3,4,2,5,5,5,2,3)
# scrivi qui
Metodi
Le tuple sono oggetti di tipo tuple
e possiedono dei metodi che permettono di operare su di esse:
Metodo |
Ritorna |
Descrizione |
---|---|---|
|
Trova la prima occorrenza di un elemento e ne ritorna la posizione |
|
|
Conta le occorrenze di un elemento |
Metodo index
Il metodo index
ci permette di trovare l’indice della PRIMA occorrenza di un elemento.
[73]:
tupla = ('b','a','r','a','t','t','a','r','e')
[74]:
tupla.index('b')
[74]:
0
[75]:
tupla.index('a')
[75]:
1
[76]:
tupla.index('t')
[76]:
4
Se l’elemento che cerchiamo non è presente, otterremo un errore:
>>> tupla.index('z')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-318-96cf33478b69> in <module>
----> 1 tupla.index('z')
ValueError: tuple.index(x): x not in tuple
Opzionalmente, puoi specificare un indice da dove iniziare a cercare (incluso):
[77]:
# 0 1 2 3 4 5 6 7 8
('b','a','r','a','t','t','a','r','e').index('r',3)
[77]:
7
E anche dove finire (escluso):
# 0 1 2 3 4 5 6 7 8
('b','a','r','a','t','t','a','r','e').index('r',3,7)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-12-e91a1f6569d7> in <module>
1 # 0 1 2 3 4 5 6 7 8
----> 2 ('b','a','r','a','t','t','a','r','e').index('r',3,7)
ValueError: tuple.index(x): x not in tuple
Non abusare index
ATTENZIONE: index
viene spesso usato in modo errato / inefficiente
Chiediti sempre:
la tupla su cui operare potrebbe contenere duplicati? Ricordati che solo il primo verrà trovato!
la tupla potrebbe non contenere l’elemento cercato? Ricordati che in questo caso il programma lancerà un errore!
index
compie una ricerca in tutta la tupla, che può essere inefficiente: è proprio necessaria, o sappiamo già l’intervallo in cui cercare?se vogliamo sapere se un
elemento
è in una posizione nota a priori (es3
),index
non ci serve, basta scriveretupla[3] == elemento
. Usandoindex
potrebbe trovare caratteri duplicati che stanno prima o dopo di quello che vogliamo verificare!
DOMANDA: Guarda il codice seguente e per ciascuna espressione prova a indovinare il risultato o se produce un errore:
(3,4,2).index(4)
(3,4,---1).index(-1)
(2.2,.2,2,).index(2)
(3,4,2).index(len([3,8,2,9]))
(6,6,6).index(666)
(4,2,3).index(3).index(3)
tuple("GUG").index("g")
(tuple("ci") + ("a","o")).index('a')
(()).index(())
((),).index(())
Esercizio - Le scatole cinesi
Scrivi del codice che cerca la parola "Cinesi"
in ciascuna di 3 tuple una dentro l’altra, indicando la posizione relativa alla tupla che contiene l’occorrenza.
le tuple iniziano sempre con 4 stringhe
Esempio - data:
tupla = ('Apri','Le','Scatole','Cinesi', ('Scatole','Cinesi','Le','Apri', ('Apri','Le','Cinesi','Scatole')))
dopo il tuo codice, deve stampare:
('Apri', 'Le', 'Scatole', 'Cinesi') contiene Cinesi alla posizione 3
('Scatole', 'Cinesi', 'Le', 'Apri') contiene Cinesi alla posizione 1
('Apri', 'Le', 'Cinesi', 'Scatole') contiene Cinesi alla posizione 2
[78]:
parola = 'Cinesi'
tupla = ('Apri','Le','Scatole','Cinesi', ('Scatole','Cinesi','Le','Apri', ('Apri','Le','Cinesi','Scatole')))
# 3 1 2
#parola = 'c'
#tupla = ('a','b','c','d',('e','c','g','h',('a','b','d','c')))
# 2 1 3
# scrivi qui
Metodo count
Si può ottenere il numero di occorrenze di un certo elemento in una lista usando il metodo count
:
[79]:
t = ('g', 'u', 'a', 'r', 'a', 'n', 't', 'i', 'g', 'i', 'a')
[80]:
t.count('g')
[80]:
2
[81]:
t.count('a')
[81]:
3
Se un elemento non è presente viene ritornato 0
:
[82]:
t.count('z')
[82]:
0
Non abusare count
ATTENZIONE: count
viene spesso usato in modo errato / inefficiente
Chiediti sempre:
la tupla potrebbe contenere duplicati? Ricordati che verranno tutti conteggiati!
la tupla potrebbe non contenere l’oggetto da contare? Ricordati di gestire anche questo caso!
count
compie una ricerca in tutta la tupla, che può essere inefficiente: è proprio necessaria, o sappiamo già l’intervallo in cui cercare?
DOMANDA: Guarda i frammenti di codice seguenti, e per ciascuno cerca di indovinare che risultato produce (o se risulta in un errore).
('p', 'o', 'r', 't', 'e', 'n', 't', 'o', 's', 'o').count('o')
('p', 'o', 'r', 't', 'e', 'n', 't', 'o', 's', 'o').count( ('o') )
('p', 'o', 'r', 't', 'e', 'n', 't', 'o', 's', 'o').count( ('o',) )
(1,0,0,0).count( 0 )
(1,0,0,0).count( (0) )
(1,0,0,0).count( (0,) )
(1,0,(0,),(0,)).count( (0,) )
(1,0,(0.0),((0,0),(0,0))).count( (0,0) )
Esercizio - frutti
Data la stringa s = "mela|pera|mela|ciliegia|pera|mela|pera|pera|ciliegia|pera|fragola"
Inserisci gli elementi separati da "|"
in una lista.
Quanti elementi deve avere la lista?
Sapendo che la lista creata al punto precedente ha solo quattro elementi distinti (es
"mela"
,"pera"
,"ciliegia"
, e"fragola"
), crea un’altra lista dove ogni elemento è una tupla contenente il nome del frutto e la sua moltiplicità (cioè il numero di volte che compare nella lista originale). Esempio:
conteggi = [("mela", 3), ("pera",5), ...]
Qua puoi scrivere codice che funziona data una specifica costante, quindi non hai bisogno di cicli.
Stampa il contenuto di ciascuna tupla in una linea separata (es: prima linea:
"mela"
è presente 3 volte)
Dovresti ottenere:
['mela', 'pera', 'mela', 'ciliegia', 'pera', 'mela', 'pera', 'pera', 'ciliegia', 'pera', 'fragola']
[('mela', 3), ('pera', 5), ('ciliegia', 2), ('fragola', 1)]
mela è presente 3 volte
pera è presente 5 volte
ciliegia è presente 2 volte
fragola è presente 1 volte
[83]:
s = "mela|pera|mela|ciliegia|pera|mela|pera|pera|ciliegia|pera|fragola"
# scrivi qui
Prosegui
Prosegui con le challenges