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.

Riferimenti

Che fare

  • scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere:

tuples
    tuples.ipynb
    tuples-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 tuples.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

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

  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:

[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)
Mostra risposta

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

Risultato

Significato

len(tuple)

int

Ritorna la lunghezza di una tupla

tuple[int]

obj

Legge un elemento all’indice specificato

tuple[int:int]

tuple

Estrae una sotto-tupla - ritorna una NUOVA tupla

tuple + tuple

tuple

Concatena due tuple - ritorna una NUOVA tupla

obj in tuple

bool

Controlla se un elemento è presente in una tupla

tuple * int

tuple

Replica la tupla - ritorna una NUOVA tupla

==,!=

bool

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)

  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:

[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. (1,2,3)[0]
    
  2. (1,2,3)[3]
    
  3. (1,2,3)0
    
  4. ()[0]
    
  5. (())[0]
    
  6. type((())[0])
    
  7. ('a,')[0]
    
  8. ('a',)[0]
    
  9. (1,2,3)[-0]
    
  10. (1,2,3)[-1]
    
  11. (1,2,3)[-3]
    
[ ]:

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

  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

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

  1. ()+()
    
  2. type(()+())
    
  3. len(()+())
    
  4. ()+[]
    
  5. []+()
    
  6. (2,3,4) + tuple([5,6,7])
    
  7. "razzo"+('p','a','z','z','o')
    

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

  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')
    
[ ]:

Moltiplicazione

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)
Mostra risposta

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, e una tupla y contenente esattamente 3 tuple di caratteri, scrivere del codice che crea una tupla z contenente ogni tupla di y replicata per il corrispondente intero in x.

Esempio - dati

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

dopo il tuo codice dovrà stampare

>>> print(z)
('w', 'e', 'l', 'c', 'w', 'e', 'l', 'c', 'o', 'o', 'o', 'o', 'm', 'e', 'm', 'e', 'm', 'e')
Mostra soluzione
[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:

Mostra soluzione
[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’ultimo

  • alla fine gli elementi 'd' e 'e' .

  • Il tuo codice dovrebbe funzionare con qualunque tupla x

Esempio

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

dopo il tuo codice, dovresti veder stampato:

x = ('a', 'b', 'c')
y = ('a', 'b', 'd', 'e')
Mostra soluzione
[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')
Mostra soluzione
[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)
Mostra soluzione
[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

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.

[73]:
tupla = ('b','a','r','a','t','t','o')
[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

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

Metodo count

Si può ottenere il numero di occorrenze di un certo elemento in una lista usando il metodo count:

[77]:
t = ('g', 'u', 'a', 'r', 'a', 'n', 't', 'i', 'g', 'i', 'a')
[78]:
t.count('g')
[78]:
2
[79]:
t.count('a')
[79]:
3

Se un elemento non è presente viene ritornato 0:

[80]:
t.count('z')
[80]:
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.

  1. 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
[81]:
s = "mela|pera|mela|ciliegia|pera|mela|pera|pera|ciliegia|pera|fragola"

# scrivi qui


Esercizi con le funzioni

ATTENZIONE: Gli esercizi seguenti richiedono di conoscere:

Se sei alle prime armi con la programmazione, ti conviene saltarli e ripassare in seguito

appaia

✪✪ Scrivere una funzione appaia che data una tupla t, RITORNA una lista avente come elementi delle tuple da due elementi presi a due a due da t.

  • se la tupla t ha un numero dispari di elementi, l’ultima tupla nella lista da ritornare sarà costituita da un solo elemento

Esempio :

>>> appaia( ('c', 'a', 'p', 'i', 'r', 'e') )   # lunghezza pari
[('c', 'a'), ('p', 'i'), ('r', 'e')]
>>> appaia( ('t','a','p','p','e','t','o') )    # lunghezza dispari
[('t', 'a'), ('p', 'p'), ('e', 't'), ('o',)]
Mostra soluzione
[82]:
# scrivi qui


giunto

✪✪ Scrivi una funzione che date due tuple di caratteri ta e tb aventi ciascuna caratteri diversi (possono essere anche vuote), se la tupla ta termina con lo stesso carattere con cui tb inizia, RITORNA la concatenazione di ta e tb SENZA caratteri duplicati, altrimenti RITORNA una tupla vuota.

Esempio:

>>> giunto(('a','b','c'), ('c','d','e'))
('a', 'b', 'c', 'd', 'e')
>>> giunto(('a','b'), ('b','c','d'))
('a', 'b', 'c', 'd')
>>> giunto((),('e','f','g'))
()
>>> giunto(('a',),('e','f','g'))
()
>>>  f(('a','b','c'),())
()
>>> f(('a','b','c'),('d','e'))
()
Mostra soluzione
[83]:
# scrivi qui


Verifica comprensione

ATTENZIONE

Gli esercizi che segueno contengono dei test con gli assert. Per capire come svolgerli, leggi prima Gestione errori e testing

doppie

✪✪ Prende in input una lista con n numeri interi, e RITORNA una NUOVA lista che contiene n tuple ciascuna da due elementi. Ogni tupla contiene un numero preso dalla corrispondente posizione della lista di partenza, e il suo doppio.

Per esempio:

doppie([ 5, 3, 8])

deve dare la nuova lista

[(5,10), (3,6), (8,16)]
Mostra soluzione
[84]:
def doppie(lista):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
assert doppie([]) == []
assert doppie([3]) == [(3,6)]
assert doppie([2,7]) == [(2,4),(7,14)]
assert doppie([5,3,8]) == [(5,10), (3,6), (8,16)]

# verifica che la lista originale non venga cambiata
la = [6]
lb = doppie(la)
assert la == [6]
assert lb == [(6,12)]
# FINE TEST

nasty

✪✪✪ Date due tuple ta di caratteri e tb di numeri interi positivi, scrivere una funzione nasty che RITORNA una tupla avente stringhe da due caratteri: il primo carattere è preso da ta, e il secondo carattere è un numero preso dalla posizione corrispondente in tb. Le stringhe vengono ripetute per un numero di volte pari a quel numero.

>>> nasty(('u','r','g'), (4,2,3))
('u4', 'u4', 'u4', 'u4', 'r2', 'r2', 'g3', 'g3', 'g3')

>>> nasty(('g','a','s','p'), (2,4,1,3))
('g2', 'g2', 'a4', 'a4', 'a4', 'a4', 's1', 'p3', 'p3', 'p3')
Mostra soluzione
[85]:
# scrivi qui


[ ]: