Tuple

Scarica zip esercizi

Naviga file online

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:

numeri = (6,7,5,7,7,9)

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:

tuplina = (4,)  # occhio alla virgola !!!

Verifichiamo che il tipo sia quello atteso:

type(tuplina)

tuple

Per vedere la differenza, scriviamo qua sotto (4) senza virgola e verifichiamo il tipo dell’oggetto ottenuto

farlocca = (4)

type(farlocca)

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:

vuota = ()

print(vuota)

()

type(vuota)

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:

a,b,c = 1, 2, 3

a

1

b

2

c

3

Se ci chiediamo cosa sia quel 1,2,3, possiamo provare a mettere a sinistra solo una variabile:

# ATTENZIONE: MEGLIO EVITARE !
x = 1,2,3

type(x)

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

1. z,w = 5,6
   print(type(z))
   print(type(w))
   

2. a,b = 5,6
   a,b = b,a
   print('a=',a)
   print('b=',b)
   

3. z = 5,
   print(type(z))
   

4. z = ,
   print(type(z))
   

Elementi eterogenei

In una tupla possiamo mettere elementi di tipo diverso, come numeri e stringhe:

roba = (4, "carta", 5, 2,"scatole", 7)

roba

(4, 'carta', 5, 2, 'scatole', 7)

type(roba)

tuple

Possiamo anche inserire anche altre tuple:

insalata = ( ("cavoli", 3), ("pomodori",9), ("verze",4) )

insalata

(('cavoli', 3), ('pomodori', 9), ('verze', 4))

type(insalata)

tuple

E anche liste:

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:

# 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

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

Python Tutor visualization

Creare tuple da sequenze

Puoi creare una tupla da una qualsiasi sequenza, per esempio da una lista:

tuple( [8,2,5] )

(8, 2, 5)

Oppure una stringa (che è una sequenza di caratteri):

tuple("abc")

('a', 'b', 'c')

Creare sequenze da tuple

Visto che la tupla è una sequenza, è anche possibile generare liste a partire da tuple:

list( (3,4,2,3)  )

[3, 4, 2, 3]

DOMANDA: Ha senso creare una tupla da un’altra tupla così? Possiamo riscrivere il codice in modo più conciso?

x = (4,2,5)
y = tuple(x)

Mostra risposta

RISPOSTA: visto che una tupla è IMMUTABILE, una volta che abbiamo creato in memoria l’oggetto (4,2,5) siamo sicuri che nessuno lo modificherà, quindi non occorre creare una nuova tupla e possiamo scrivere direttamente

x = (4,2,5)
y = x

DOMANDA: Guarda le seguenti espressioni, e per ciascuna cerca di indovinare quale risultato producono (o se danno errore):

1. (1.2,3.4)
   

2. (1;2;3;4)
   

3. (1,2;3,4)
   

4. (1,2,3,4)
   

5. (())
   

6. type(())
   

7. ((),)
   

8. tuple([('a'),('b'),('c')])
   

9. tuple(tuple(('z','u','m')))
   

10. str(('a','b','c'))
    

11. "".join(('a','b','c'))
    

Operatori

I seguenti operatori funzionano sulle tuple e si comportano esattamente come per le liste:

Operatore	Sintassi	Risultato	Significato
lunghezza	len(tuple)	int	Ritorna la lunghezza di una tupla
indice	tuple[int]	object	Legge un elemento all’indice specificato
slice	tuple[int:int]	tuple	Estrae una sotto-tupla - ritorna una NUOVA tupla
concatenazione	tuple + tuple	tuple	Concatena due tuple - ritorna una NUOVA tupla
appartenenza	object in tuple	bool	Controlla se un elemento è presente in una tupla
replicazione	tuple * int	tuple	Replica la tupla - ritorna una NUOVA tupla
uguaglianza	==,!=	bool	Controlla se due tuple sono uguali o differenti

len

La funzione len ritorna la lunghezza della tupla:

len( (4,2,3) )

3

len( (7,) )

1

len( () )

0

DOMANDA: Guarda le seguenti espressioni, e per ciascuna cerca di indovinare il risultato (o se produce un errore)

1. len(3,2,4)
   

2. len((3,2,4))
   

3. len(('a',))
   

4. len(('a,'))
   

5. len(((),(),()))
   

6. len(len((1,2,3,4)))
   

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

#        0  1  2  3
tupla = (10,11,12,13)

tupla[0]

10

tupla[1]

11

tupla[2]

12

tupla[3]

13

Anche per le tuple possiamo usare indici negativi:

tupla[-1]

13

DOMANDA: Guarda le espressioni seguenti e per ciascuna cerca di indovinare il risultato o se produce un errore:

1. (1,2,3)[0]
   

2. (1,2,3)[3]
   

3. (1,2,3)0
   

4. ('a,')[0]
   

5. ('a',)[0]
   

6. (1,2,3)[-0]
   

7. (1,2,3)[-1]
   

8. (1,2,3)[-3]
   

9. ()[0]
   

10. (())[0]
    

11. type((())[0])
    

Esercizio: animali

Data la stringa animali = "gatto siamese,cane,canarino,porcellino,coniglio,criceto"

1. convertila in una lista

2. 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))

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

Mostra soluzione

animali = "gatto siamese,cane,canarino,porcellino,coniglio,criceto"

# scrivi qui
lista = animali.split(',')

#print(animali)
print()

tuple_animali = ( (lista[0], len(lista[0])),
                  (lista[1], len(lista[1])),
                  (lista[2], len(lista[2])),
                  (lista[3], len(lista[3])),
                  (lista[4], len(lista[4])),
                  (lista[5], len(lista[5])))

print(tuple_animali)

(('gatto siamese', 13), ('cane', 4), ('canarino', 8), ('porcellino', 10), ('coniglio', 8), ('criceto', 7))

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:

tupla = (10,11,12,13,14,15,16,17,18,19)

tupla[2:6]  # da indice 2 INCLUSO a 6 ESCLUSO

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

tupla = (10,11,12,13,14,15,16,17)

tupla[0:8:5]

(10, 15)

tupla[0:8:2]

(10, 12, 14, 16)

tupla[1:8:1]

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

1. (7,6,8,9,5)(1:3)
   

2. (7,6,8,9,5)[1:3]
   

3. (10,11,12,13,14,15,16)[3:100]
   

4. (10,11,12,13,14,15,16)[-3:5]
   

5. (1,0,1,0,1,0)[::2]
   

6. (1,2,3)[::1]
   

7. (1,0,1,0,1,0)[1::2]
   

8. tuple("cartolina")[0::2]
   

9. (4,5,6,3,4,7)[0:::2]
   

Concatenazione

E’ possibile concatenare due tuple usando l’operatore +, che crea una NUOVA tupla

t = (1,2,3) + (4,5,6,7,8)

t

(1, 2, 3, 4, 5, 6, 7, 8)

type(t)

tuple

Verifichiamo che le tuple originali non vengano modificate:

x = (1,2,3)
y = (4,5,6,7,8)

t = x + y

t

(1, 2, 3, 4, 5, 6, 7, 8)

x

(1, 2, 3)

y

(4, 5, 6, 7, 8)

Guardiamo come vengono rappresentate in Python Tutor:

# 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

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)

Python Tutor visualization

DOMANDA: Guarda il codice seguente e per ciascuna espressione cerca di indovinare il risultato, o se produce un errore.

1. (2,3,4) + tuple([5,6,7])
   

2. "razzo"+('p','a','z','z','o')
   

3. ()+()
   

4. type(()+())
   

5. len(()+())
   

6. ()+[]
   

7. []+()
   

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:

'a' in ('c','a','s','c','o')

True

'z' in ('c','a','s','c','o')

False

not in

Per verificare se qualcosa non appartiene ad una tupla, possiamo usare due forme:

not in - forma 1:

"carota" not in ("anguria","banana","mela")

True

"anguria" not in ("anguria","banana","mela")

False

not in - forma 2

not "carota" in ("anguria","banana","mela")

True

not "anguria" in ("anguria","banana","mela")

False

DOMANDA: Guarda le seguenti espressioni, e per ciascuna cerca di indovinare quale risultato producono (o se danno errore):

1. 3 in (1.0, 2.0,3.0)
   

2. 3.0 in (1,2,3)
   

3. 3 not in (3)
   

4. 3 not in (3,)
   

5. 6 not in ()
   

6. 0 in (0)[0]
   

7. [] in ()
   

8. () in []
   

9. not [] in ()
   

10. () in ()
    

11. () in (())
    

12. () in ((),)
    

13. 'ciao' in ('c','i','a','o')
    

Replicazione

Per replicare gli elementi di una tupla, è possibile usare l’operatore * che produce una NUOVA tupla:

(7,8,5) * 3

(7, 8, 5, 7, 8, 5, 7, 8, 5)

(7,8,5) * 1

(7, 8, 5)

(7,8,5) * 0

()

DOMANDA: Il seguente codice cosa stamperà?

x = (5,6,7)
y = x * 3
print('x=',x)
print('y=',y)

Mostra risposta

RISPOSTA: Stamperà

x = (5, 6, 7)
y = (5, 6, 7, 5, 6, 7, 5, 6, 7)

perchè la moltiplicazione genera una NUOVA tupla che viene associata a y. La tupla associata a x rimane invariata.

DOMANDA: Guarda il codice seguente e per ciascuna espressione cerca di indovinare il risultato, o se produce un errore.

1. (5,6,7)*(3.0)
   

2. (5,6,7)*(3,0)
   

3. (5,6,7)*(3)
   

4. (5,6,7)*3
   

5. (4,2,3)*int(3.0)
   

6. (1,2)*[3][0]
   

7. (1,2)*(3,4)[-1]
   

8. [(9,8)]*4
   

9. (1+2,3+4)*5
   

10. (1+2,)*4
    

11. (1+2)*4
    

12. (1,2,3)*0
    

13. (7)*0
    

14. (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')

Mostra soluzione

x = (2,4,3)
y = (('w','e','l','c'),('o',),('m','e'))

# scrivi qui
z = y[0]*x[0] + y[1]*x[1] + y[2]*x[2]

print(z)

('w', 'e', 'l', 'c', 'w', 'e', 'l', 'c', 'o', 'o', 'o', 'o', 'm', 'e', 'm', 'e', 'm', 'e')

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

#        0  1  2  3  4  5  6
tupla = (17,54,34,87,26,95,34)

tupla =  tupla[0:3] + (12,) + tupla[4:]

tupla

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

# 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’ultimo

• alla 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')

Mostra soluzione

x = ('a','b','c')

# scrivi qui
y = x[:-1] + ('d','e')

print('x=',x)
print('y=',y)

x= ('a', 'b', 'c')
y= ('a', 'b', 'd', 'e')

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

Mostra soluzione

t = ('C', 'a', 'R', 'i', 'S', 'm', 'A', 't', 'I', 'c', 'O')

# scrivi qui
t = t[::2] + t[1::2]
print(t)

('C', 'R', 'S', 'A', 'I', 'O', 'a', 'i', 'm', 't', 'c')

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)

Mostra soluzione

x = (3,4,2,5,5,5,2,3)

# scrivi qui
y = list(x)
y.sort()
x = tuple(y)
print(x)

(2, 2, 3, 3, 4, 5, 5, 5)

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
tuple.index(obj)	int	Trova la prima occorrenza di un elemento e ne ritorna la posizione
tuple.count(obj)	int	Conta le occorrenze di un elemento

Metodo index

Il metodo index ci permette di trovare l’indice della PRIMA occorrenza di un elemento.

tupla = ('b','a','r','a','t','t','a','r','e')

tupla.index('b')

0

tupla.index('a')

1

tupla.index('t')

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

# 0   1   2   3   4   5   6   7   8
('b','a','r','a','t','t','a','r','e').index('r',3)

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:

1. la tupla su cui operare potrebbe contenere duplicati? Ricordati che solo il primo verrà trovato!

2. la tupla potrebbe non contenere l’elemento cercato? Ricordati che in questo caso il programma lancerà un errore!

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

4. se vogliamo sapere se un elemento è in una posizione nota a priori (es 3), index non ci serve, basta scrivere tupla[3] == elemento. Usando index 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:

1. (3,4,2).index(4)
   

2. (3,4,---1).index(-1)
   

3. (2.2,.2,2,).index(2)
   

4. (3,4,2).index(len([3,8,2,9]))
   

5. (6,6,6).index(666)
   

6. (4,2,3).index(3).index(3)
   

7. tuple("GUG").index("g")
   

8. (tuple("ci") + ("a","o")).index('a')
   

9. (()).index(())
   

10. ((),).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

Mostra soluzione

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

t1 = tupla[:4]
t2 = tupla[4][:4]
t3 = tupla[4][4]
i1 = t1.index(parola)
i2 = t2.index(parola)
i3 = t3.index(parola)

print(t1,"contiene", parola, "alla posizione", i1)
print(t2,"contiene", parola, "alla posizione", i2)
print(t3,"contiene", parola, "alla posizione", i3)

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

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:

t = ('g', 'u', 'a', 'r', 'a', 'n', 't', 'i', 'g', 'i', 'a')

t.count('g')

2

t.count('a')

3

Se un elemento non è presente viene ritornato 0:

t.count('z')

0

Non abusare count

ATTENZIONE: count viene spesso usato in modo errato / inefficiente

Chiediti sempre:

1. la tupla potrebbe contenere duplicati? Ricordati che verranno tutti conteggiati!

2. la tupla potrebbe non contenere l’oggetto da contare? Ricordati di gestire anche questo caso!

3. 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).

1. ('p', 'o', 'r', 't', 'e', 'n', 't', 'o', 's', 'o').count('o')
   

2. ('p', 'o', 'r', 't', 'e', 'n', 't', 'o', 's', 'o').count( ('o') )
   

3. ('p', 'o', 'r', 't', 'e', 'n', 't', 'o', 's', 'o').count( ('o',) )
   

4. (1,0,0,0).count( 0 )
   

5. (1,0,0,0).count( (0) )
   

6. (1,0,0,0).count( (0,) )
   

7. (1,0,(0,),(0,)).count( (0,) )
   

8. (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.

1. Quanti elementi deve avere la lista?

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

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

Mostra soluzione

s = "mela|pera|mela|ciliegia|pera|mela|pera|pera|ciliegia|pera|fragola"

# scrivi qui

parole = s.split("|")
#print(parole)

tmele = ("mela", parole.count("mela"))
tpere = ("pera", parole.count("pera"))
tciliegie = ("ciliegia", parole.count("ciliegia"))
tfragole = ("fragola", parole.count("fragola"))
conteggi =[tmele, tpere, tciliegie, tfragole]

print(conteggi)
print()
print(tmele[0], " è presente ", tmele[1], " volte")
print(tpere[0], " è presente ", tpere[1], " volte")
print(tciliegie[0], " è presente ", tciliegie[1], " volte")
print(tfragole[0], " è presente ", tfragole[1], " volte")

[('mela', 3), ('pera', 5), ('ciliegia', 2), ('fragola', 1)]

mela  è presente  3  volte
pera  è presente  5  volte
ciliegia  è presente  2  volte
fragola  è presente  1  volte

s = "mela|pera|mela|ciliegia|pera|mela|pera|pera|ciliegia|pera|fragola"

# scrivi qui

Prosegui

Prosegui con le challenges