Liste 3 - Metodi

Scarica zip esercizi

Naviga file online

Le liste sono oggetti di tipo list e possiedono dei metodi che permettono di operare su di essi:

Metodo

Ritorna

Descrizione

list.append(obj)

None

Aggiunge un nuovo elemento alla fine della lista

list.extend(list)

None

Aggiunge diversi nuovi elementi alla fine della lista

list.insert(int,obj)

None

Aggiunge un nuovo elemento a qualche posizione data

list.pop()

obj

Rimuove e ritorna l’elemento all’ultima posizione

list.pop(int)

obj

Dato un indice, rimuove e ritorna l’elemento a quella posizione

list.reverse()

None

Inverte l’ordine degli elementi

list.sort

None

Ordina gli elementi

string_sep.join(seq)

string

produce una stringa concatenando tutti gli elementi in seq separati da string_sep

ATTENZIONE: I METODI DELLE LISTE *MODIFICANO* LA LISTA SU CUI VENGONO CHIAMATI !

Quando chiami un metodo di una lista (l’oggetto a sinistra del punto .), MODIFICHI la lista stessa (diversamente dai metodi sulle stringhe che generano sempre una nuova stringa senza cambiare l’originale)

ATTENZIONE: I METODI DELLE LISTE *NON* RITORNANO NULLA!

Quasi sempre ritornano l’oggetto None (diversamente da quelli delle stringhe che ritornano sempre una nuova stringa)

Metodi di ricerca

Le liste mettono a disposizione diversi metodi per effettuare ricerche e trasformazioni al loro interno, ma attenzione: il potere è nulla senza il controllo! Spesso ti troverai con l’esigenza di usarli, e potrebbero anche funzionare con qualche piccolo esempio, ma molto spesso nascondono tranelli che poi si rimpiangono amaramente. Quindi quando scrivi codice con uno di questi metodi, poniti sempre le domande che evidenzieremo!

Metodo

Ritorna

Descrizione

`str1.split(str2) <#Metodo-split—da-stringhe-a-liste> `__

list

Produce una lista con tutte le parole in str1 separate da str2

list.count(obj)

int

Conta le occorrenze di un elemento

list.index(obj)

int

Trova la prima occorrenza di un elemento e ne ritorna la posizione

list.remove(obj)

None

Rimuove la prima occorrenza di un elemento

Che fare

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

lists
    lists1.ipynb
    lists1-sol.ipynb
    lists2.ipynb
    lists2-sol.ipynb
    lists3.ipynb
    lists3-sol.ipynb
    lists4.ipynb
    lists4-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 lists3.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

Metodo append

Possiamo MODIFICARE una lista aggiungendo un elemento alla volta usando il metodo append.

Supponiamo di partire da una lista vuota:

[2]:
la = []

Se vogliamo aggiungere come elemento il numero 57, possiamo scrivere così:

[3]:
la.append(57)

Notiamo che la lista che abbiamo creato inizialmente risulta MODIFICATA:

[4]:
la
[4]:
[57]

ATTENZIONE: la.append(57) non ha restituito NULLA !!!!

Guarda bene l’output della cella con l’istruzione la.append(57), noterai che non c’è proprio niente. Questo perchè lo scopo di append è MODIFICARE la lista su cui viene chiamato, NON generare nuove liste.

Aggiungiamo un’altro numero alla fine della lista:

[5]:
la.append(96)
[6]:
la
[6]:
[57, 96]
[7]:
la.append(74)
[8]:
la
[8]:
[57, 96, 74]

Riguardiamoci cosa è successo in Python Tutor:

[9]:
# 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
[10]:
la = []
la.append(57)
la.append(96)
la.append(74)

jupman.pytut()
[10]:

Nota come ad espandersi sia sempre la stessa zona di memoria gialla associata alla variabile la.

Abbiamo detto che il metodo append non ritorna nulla, cerchiamo di specificare meglio. Nella tabella dei metodi, è presente una colonna chiamata Ritorna. Se vai a vedere, per quasi tutti i metodi incluso append è indicato che viene ritornato None.

None è l’oggetto più noioso di Python, perchè letteralmente significa niente. Cosa si può fare con niente? Ben poco, così poco che Jupyter quando si ritrova come risultato un oggetto None non lo stampa nemmeno. Proviamo a inserire direttamente None in una cella, vedrai che non verrà riportato nell’output della cella:

[11]:
None

Un modo per forzare la stampa è usare il comando print:

[12]:
print(None)
None

ESERCIZIO: Qual’è il tipo dell’oggetto None? Scoprilo usando la funzione type

Mostra soluzione
[13]:
# scrivi qui


Proviamo a ripetere cosa succede con append. Se chiami il metodo append su una lista, append MODIFICA silenziosamente la lista, e RITORNA come risultato di essere stato chiamato l’oggetto None. Dato che Jupyter ritiene questo oggetto non interessante, non lo stampa nemmeno come risultato.

Cerchiamo di esplicitare meglio questo misterioso None. Se è vero che append lo produce come risultato di essere chiamato, vuol dire che possiamo associare questo risultato a qualche variabile. Proviamo ad associarlo alla variabile x:

[14]:
la = []
x = la.append(78)

Ora, se tutto è andato come abbiamo scritto, append dovrebbe aver modificato la lista:

[15]:
la
[15]:
[78]

e alla variabile x dovrebbe essere associato None. Quindi, se chiediamo a Jupyter di mostrare il valore associato ad x e se quel valore è None, non dovremmo vedere nulla:

[16]:
x

notiamo che non c’è nessun output nella cella, pare che siamo davvero in presenza di None. Forziamo la stampa con il comando print:

[17]:
print(x)
None

Eccolo ! Probabilmente sarai un po’ confuso da tutto ciò, quindi proviamo a rivedere bene che succede in Python Tutor:

[18]:
la = []
x = la.append(78)
print("la è", la)
print("x è ", x)

jupman.pytut()
la è [78]
x è  None
[18]:

Qual’è il succo di tutto questo discorso?

RIUSARE IL RISULTATO DI CHIAMATE AI METODI DELLE LISTE E’ QUASI SEMPRE UN ERRORE !!!!

Dato che chiamare i metodi delle lista ci ritorna None, che è un oggetto ‘inutile’, tentare di riusarlo produrrà quasi sicuramente un errore

ESERCIZIO: Costruisci una lista aggiungendo un elemento alla volta con il metodo append. Aggiungi gli elementi 77, "prova", [60,93] con tre chiamate ad append, ed infine stampa la lista.

Dopo il tuo codice, dovresti vedere [77, 'prova', [60, 93]]

Mostra soluzione
[19]:
la = []

# scrivi qui


DOMANDA: Il codice seguente:

la = []
la.append(85,70,94)
  1. produce un errore (quale?)

  2. modifica la lista (come?)

Mostra risposta

DOMANDA: Il codice seguente

la = []
la.append(87).append(96)
  1. produce un errore

  2. aggiunge a la i numeri 87 e 96

Mostra risposta

DOMANDA: torniamo brevemente alle stringhe. Guarda il codice seguente (se non ti ricordi cosa fanno i metodi delle stringhe guarda qua):

sa = '    trento    '
sb = sa.strip().capitalize()
print(sb)
  1. produce un errore (quale?)

  2. cambia sa (come?)

  3. stampa qualcosa (cosa?)

Mostra risposta

DOMANDA: Guarda questo codice. Stamperà qualcosa alla fine? O produrrà un errore?

la = []
lb = []
la.append(lb)

lb.append(98)
lb.append(77)

print(la)
Mostra risposta

Esercizio - accrescere una lista 1

Data la lista la di dimensione fissa 7, scrivi del codice per crescere la lista vuota lb così che contenga solo gli elementi di la a indici pari (0, 2, 4, …).

  • Il tuo codice dovrebbe funzionare per qualunque lista la di dimensione fissa 7

#   0 1 2 3 4 5 6
la=[8,4,3,5,7,3,5]
lb=[]

Dopo il tuo codice, dovresti ottenere:

>>> print(lb)
[8,3,7,5]
Mostra soluzione
[20]:

#   0 1 2 3 4 5 6
la=[8,4,3,5,7,3,5]
lb=[]

# scrivi qui


[8, 3, 7, 5]

Metodo extend

Prima con append abbiamo visto come accrescere una lista un elemento alla volta.

E se volessimo aggiungere in un colpo solo parecchi elementi, magari presi da un’altra lista? Come potremmo fare?

Dovremmo usare il metodo extend, che MODIFICA la lista su cui è chiamato aggiungendo tutti gli elementi trovati nella sequenza presa in input.

[21]:
la = [78,60,59]
[22]:
lb = [68,97,67,98]
[23]:
la.extend(lb)
[24]:
la
[24]:
[78, 60, 59, 68, 97, 67, 98]
[25]:
lb
[25]:
[68, 97, 67, 98]

Nell’esempio qua sopra, extend è chiamato sulla variabile la, e come parametro gli abbiamo passato lb

ATTENZIONE: la è MODIFICATA, invece la sequenza che gli abbiamo passato tra le parentesi tonde no (lb nell’esempio)!

DOMANDA: l’esecuzione del metodo extend ritorna qualcosa? Cosa vedi nell’output della cella la.extend(lb) ?

Mostra risposta

Verifichiamo meglio cosa è successo con Python Tutor:

[26]:
la = [78,60,59]
lb = [68,97,67,98]
la.extend(lb)

jupman.pytut()
[26]:

DOMANDA: Guarda questo codice. Quali saranno i valori associati alle variabili la ,lb e x dopo la sua esecuzione?

la = [34,79,54]
lb = [86,45]
x = la.extend(lb)

print('la è ', la)
print('lb è ', lb)
print('x è ', x)
Mostra risposta

Estendere con sequenze

Abbiamo detto che tra le parentesi tonde extend può prendere una sequenza generica, non solo liste. Questo vuol dire che possiamo anche passargli una stringa. Per esempio:

[27]:
la = [78,65,87]

s = "ciao"

la.extend(s)
[28]:
la
[28]:
[78, 65, 87, 'c', 'i', 'a', 'o']

Dato che stringa è una sequenza di caratteri, extend ha preso ciascuno di questi elementi e li ha aggiunti a la

DOMANDA: il valore associato alla variabile s è stato modificato?

Mostra risposta

DOMANDA: Il codice seguente:

la = [78,65]
la.extend(68,85,87)
  1. produce un errore (quale?)

  2. modifica la (come?)

Mostra risposta

DOMANDA: Se questo codice viene eseguito, che succede?

sa = "ciao"
sb = "mondo"
sa.extend(sb)
  1. sa viene modificata (come?)

  2. otteniamo un errore (quale?)

Mostra risposta

DOMANDA: Se questo codice viene eseguito, che succede?

la = [1,2,3]
lb = [4,5]
lc = [6,7,8]

la.extend(lb).extend(lc)
  1. la diventa [1,2,3,4,5,6,7,8]

  2. un errore (quale?)

  3. la diventa [1,2,3,4,5] e un errore(quale?)

Mostra risposta

Esercizio: accrescere una lista 2

Date due liste la ed lb e un elemento x, scrivi del codice che MODIFICA la in modo che la contenga alla fine l’elemento x seguito da tutti gli elementi di lb

  • NOTA 1: il tuo codice dovrebbe funzionare con qualunque la ed lb

  • NOTA 2: id è una funzione di Python che associa ad ogni regione di memoria un identificativo numerico univoco. Se provi a stampare id(la) prima di modificare la e id(la) dopo, dovresti ottenere esattamente lo stesso id. Se ne ottieni uno diverso, significa che hai generato una lista interamente nuova. In ogni caso, verifica che funzioni in Python Tutor.

la = [5,9,2,4]
lb = [7,1,3]
x = 8

Dovresti ottenere:

>>> print(la)
[5,9,2,4,8,7,1,3]
>>> print(lb)
[7,1,3]
>>> print(x)
8
Mostra soluzione
[29]:

la = [5,9,2,4]
lb = [7,1,3]
x = 8

# scrivi qui


Esercizio - zslice

Scrivi del codice che date due liste la (di almeno 3 elementi) e lb, MODIFICA lb in modo che vi siano aggiunti i primi 3 elementi di la seguiti dagli ultimi 3 elementi di la

  • il tuo codice deve funzionare con qualsiasi lista

  • usa extend e le slice

la = ['a','b','c','d','e','f','g','h','i','l','m','n','o']
lb = ['z']

Dovresti ottenere:

>>> print(la)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'l', 'm', 'n', 'o']
>>> print(lb)
['z', 'a', 'b', 'c', 'm', 'n', 'o']
Mostra soluzione
[30]:
la = ['a','b','c','d','e','f','g','h','i','l','m','n','o']
lb = ['z']

# scrivi qui


Esercizio - vedunazeblag

Scrivi del codice che data una lista di tre stringhe parole e una lista vuota la, riempie la con tutti i primi 3 caratteri di ogni stringa in parole.

  • il tuo codice deve funzionare con qualsiasi lista di 3 stringhe

  • usa le slice

Esempio - data:

parole = ["vedo", "una", "zebra", "laggiù"]
la = []

il tuo codice deve mostrare

>>> print(t)
['v', 'e', 'd', 'u', 'n', 'a', 'z', 'e', 'b', 'l', 'a', 'g']
Mostra soluzione
[31]:
parole = ["vedo", "una", "zebra", "laggiù"]

la = []

# scrivi qui


['v', 'e', 'd', 'u', 'n', 'a', 'z', 'e', 'b', 'l', 'a', 'g']

Metodo insert

insert MODIFICA la lista inserendo un elemento ad uno specifico indice - tutti gli elementi a partire da quell’indice vengono spostati in avanti di una posizione

[32]:
     #0 1 2 3
la = [6,7,8,9]
[33]:
la.insert(2,55)  # inserisce il numero 55 all'indice 2
[34]:
la
[34]:
[6, 7, 55, 8, 9]
[35]:
la.insert(0,77)  # inserisce il numero 77 all'indice 0
[36]:
la
[36]:
[77, 6, 7, 55, 8, 9]

Possiamo inserire dopo la fine:

[37]:
la.insert(6,88)  # inserisce il numero 88 all'indice 6
[38]:
la
[38]:
[77, 6, 7, 55, 8, 9, 88]

Nota che se sforiamo con l’indice, l’elemento viene comunque messo alla fine e non vengono create celle vuote:

[39]:
la.insert(1000,99)  # in questo caso inserisce il numero 99 all'indice 7

DOMANDA: Data una lista qualsiasi x, questo codice cosa produce? Possiamo riscriverlo in un’altra maniera?

x.insert(len(x),66)
  1. produce una nuova lista (quale?)

  2. modifica x (come?)

  3. un errore

Mostra risposta

DOMANDA: Il seguente codice, cosa produce?

la = [3,4,5,6]
la.insert(0,[1,2])
print(la)
  1. stampa [1,2,3,4,5,6]

  2. un errore (quale?)

  3. qualcos’altro (cosa?)

Mostra risposta

DOMANDA: Il seguente codice cosa produce?

la = [4,5,6]
la.insert(0,1,2,3)
print(la)
  1. stampa [1,2,3,4,5,6]

  2. un errore (quale?)

  3. qualcos’altro (cosa?)

Mostra risposta

DOMANDA: Il seguente codice cosa produce?

la = [4,5,6]
lb = la.insert(0,3)
lc = lb.insert(0,2)
ld = lc.insert(0,1)
print(ld)
  1. stampa [1,2,3,4,5,6]

  2. un errore (quale?)

  3. qualcos’altro (cosa?)

Mostra risposta

Esercizio - insertando

Data la lista:

la = [7,6,8,5,6]

scrivi del codice che la MODIFICA usando solo chiamate a insert. Dopo il tuo codice, la deve apparire così:

>>> print(la)
[7, 77, 99, 6, 8, 88, 5, 6, 55]
Mostra soluzione
[40]:

la = [7,6,8,5,6]

# scrivi qui


ATTENZIONE: chiamare insert è molto più lento di append !!

Una chiamata ad insert riscrive tutte le celle successive a quella dell’inserimento, mentre invece append aggiunge una cella e basta. Dato che il computer è veloce, molto spesso non ci si accorge della differenza, ma quando possibile, e specialemente se devi scrivere programmi che operano su grandi quantità di dati, prova a scrivere il codice usando append invece di insert.

Esercizio - insappend

Questo codice prende come input una lista vuota la e una lista di numeri lb. Cerca di capire cosa fa, e riscrivilo usando degli append.

[41]:
la = []
lb = [7,6,9,8]
la.insert(0,lb[0]*2)
la.insert(0,lb[1]*2)
la.insert(0,lb[2]*2)
la.insert(0,lb[3]*2)
print(la)
[16, 18, 12, 14]
Mostra soluzione
[42]:
la = []
lb = [7,6,9,8]

# scrivi qui


Metodo pop

Il metodo pop se chiamato senza argomenti rimuove l’ultimo elemento (MODIFICANDO la lista) e lo ritorna:

[43]:
cesta = ['melone','fragola', 'anguria']
[44]:
cesta.pop()
[44]:
'anguria'
[45]:
cesta
[45]:
['melone', 'fragola']
[46]:
cesta.pop()
[46]:
'fragola'
[47]:
cesta
[47]:
['melone']

Visto che l’ultimo elemento è ritornato dalla pop, possiamo assegnarlo ad una variabile:

[48]:
frutto = cesta.pop()

Nota che non vediamo più nessun risultato stampato perchè l’elemento ritornato è stato assegnato alla variabile frutto:

[49]:
frutto
[49]:
'melone'

Constatiamo anche che cesta è stata MODIFICATA:

[50]:
cesta
[50]:
[]

Chiamare ulteriormente pop su una lista vuota genera un’errore:

cesta.pop()
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-67-086f38c9fbc0> in <module>()
----> 1 cesta.pop()

IndexError: pop from empty list
[ ]:

Opzionalmente, per rimuovere un elemento ad una specifica posizione possiamo passare a pop un indice da 0 INCLUSO alla lunghezza della lista ESCLUSA:

[51]:
#           0           1             2        3
attrezzi = ['martello', 'cacciavite', 'pinza', 'martello']
[52]:
attrezzi.pop(2)
[52]:
'pinza'
[53]:
attrezzi
[53]:
['martello', 'cacciavite', 'martello']

DOMANDA: Guarda i frammenti di codice seguenti, e per ciascuno cerca di indovinare che risultato produce (o se risulta in un errore).

  1. la = ['a']
    print(la.pop())
    print(la.pop())
    
  2. la = [4,3,2,1]
    print(la.pop(4))
    print(la)
    
  3. la = [1,2,3,4]
    print(la.pop(3))
    print(la)
    
  4. la = [1,2,3,4]
    print(la.pop(-1))
    print(la)
    
  5. s = 'grezzo'
    print(s.pop())
    print(s)
    
  6. la = ['molto', 'grezzo']
    print(la.pop())
    print(la)
    
  7. la = ['a', ['a']]
    print(la.pop())
    print(la)
    

Esercizio - popcorn

Data una lista corn di esattamente 4 caratteri, scrivi del codice che trasferisce in ordine inverso tutti i caratteri da corn ad un’altra lista scatola che inizialmente è vuota.

  • NON usare metodi come reverse o funzioni come reversed

  • Il tuo codice deve funzionare con qualsiasi lista corn di 4 elementi

Esempio - date:

corn = ['t','o','r','o']
scatola = []

dopo il tuo codice, deve risultare:

>>> print(corn)
[]
>>> print(scatola)
['o','r','o','t']
Mostra soluzione
[54]:
corn = ['t','o','r','o']
scatola = []

# scrivi qui


['o', 'r', 'o', 't']

Esercizio - zonzo

Data una lista la contenente dei caratteri, e una lista lb contente esattamente due posizioni ordinate in modo crescente , scrivi del codice che elimina da la i caratteri alle posizioni specificate in lb.

  • ATTENZIONE: chiamando la pop la prima volta MODIFICHERAI la, quindi l’indice del secondo elemento da eliminare andrà opportunamente aggiustato !

  • NON creare nuove liste, quindi niente righe che iniziano con la =

  • Il tuo codice deve funzionare per qualsiasi la, e qualsiasi lb da due elementi

Esempio - dati:

#      0   1   2   3   4
la = ['z','o','n','z','o']
lb = [2,4]

alla posizione 2 in la troviamo la n e alla 4 la o, quindi dopo il tuo codice dovrà risultare:

>>> print(la)
['z', 'o', 'z']
Mostra soluzione
[55]:
#      0   1   2   3   4
la = ['z','o','n','z','o']
lb = [2,4]

# scrivi qui


[55]:
'o'

Metodo reverse

Il metodo reverse MODIFICA la lista su cui è chiamato invertendo l’ordine degli elementi.

Vediamo un esempio:

[56]:
la = [7,6,8,4]
[57]:
la.reverse()
[58]:
la
[58]:
[4, 8, 6, 7]

ATTENZIONE: reverse NON RITORNA NULLA!

Per essere precisi, ritorna None

[59]:
lb = [7,6,8,4]
[60]:
x = lb.reverse()
[61]:
print(x)
None
[62]:
print(lb)
[4, 8, 6, 7]

DOMANDA: Il codice seguente che effetto produce?

s = "transatlantico"
s.reverse()
print(s)
  1. un errore (quale?)

  2. stampa la stringa rovesciata

Mostra risposta

DOMANDA: Se x è una lista qualsiasi, che effetto produce il codice seguente?

x.reverse().reverse()
  1. cambia la lista (come?)

  2. non cambia la lista

  3. genera un errore (quale?)

Mostra risposta

Esercizio - come va?

Scrivi del codice che date due liste la e lb, MODIFICA la aggiungendogli tutti gli elementi di lb e rovesciando poi l’intera lista.

  • il tuo codice deve funzionare per qualunque la e lb

  • NON modificare lb

Esempio - dati:

la = ['c','o','m','e']
lb = ['v','a','?']

Dopo il tuo codice, deve stampare:

>>> print('la=',la)
la= ['?', 'a', 'v', 'e', 'm', 'o', 'c']
>>> print('lb=',lb)
lb= ['v', 'a', '?']
Mostra soluzione
[63]:
la = ['c','o','m','e']
lb = ['v','a','?']

# scrivi qui


Esercizio - cose preziose

Date due liste la e lb, scrivi del codice che STAMPA una lista con gli elementi di la e lb in ordine invertito

  • NON modificare la e NON modificare lb

  • il tuo codice deve funzionare per qualsiasi lista la e lb

Esempio - dati

la = ['c', 'o', 's', 'e']
lb = ['p', 'r', 'e', 'z', 'i', 'o', 's', 'e']

dopo il tuo codice deve stampare

['e', 's', 'o', 'i', 'z', 'e', 'r', 'p', 'e', 's', 'o', 'c']
Mostra soluzione
[64]:
la = ['c', 'o', 's', 'e']
lb = ['p', 'r', 'e', 'z', 'i', 'o', 's', 'e']

# scrivi qui


['e', 's', 'o', 'i', 'z', 'e', 'r', 'p', 'e', 's', 'o', 'c']

Esercizio - potenze

Il codice seguente usa degli insert che come già detto non sono molto efficienti. Cerca di capire cosa fa, e riscrivilo usando solo append e reverse

  • il tuo codice deve funzionare per qualsiasi valore di x

[65]:
x = 2
la = [x]
la.insert(0,la[0]*2)
la.insert(0,la[0]*2)
la.insert(0,la[0]*2)
la.insert(0,la[0]*2)
print(la)
[32, 16, 8, 4, 2]
Mostra soluzione
[66]:
x = 2
la = [x]

# scrivi qui


Metodo sort

Se una lista contiene elementi omogenei, è possibile ordinarla rapidamente con il metodo sort, che MODIFICA la lista su cui viene chiamato:

[67]:
la = [8,6,7,9]
[68]:
la.sort()  # NOTA: sort non ritorna nulla !!!
[69]:
la
[69]:
[6, 7, 8, 9]

Anche le stringhe sono ordinabili:

[70]:
lb = ['Boccaccio', 'Alighieri', 'Manzoni', 'Leopardi']
[71]:
lb.sort()
[72]:
lb
[72]:
['Alighieri', 'Boccaccio', 'Leopardi', 'Manzoni']

Una lista con elementi non comparabili tra loro non è ordinabile, e Python si lamenterà:

[73]:
lc = [3,4,'cavoli',7,'patate']
>>> lc.sort()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-288-0cabfae30939> in <module>
----> 1 lc.sort()

TypeError: '<' not supported between instances of 'str' and 'int'

Esercizio - numlist

Data la lista la = [10, 60, 72, 118, 11, 71, 56, 89, 120, 175]

  1. trova il min, max e valore mediano (SUGGERIMENTO: ordinala ed estrai i giusti valori)

  2. crea una lista solo con gli elementi a indici pari (per es [10, 72, 11, ..], nota che “..” indica che lista non è completa !) e ricalcola i valori di min, max e mediana

  3. rifai lo stesso con gli elementi ad indici dispari (per es [60, 118,..])

Dovresti ottenere:

la: [10, 60, 72, 118, 11, 71, 56, 89, 120, 175]
pari: [10, 72, 11, 56, 120]
dispari: [60, 118, 71, 89, 175]

ordinati:   [10, 11, 56, 60, 71, 72, 89, 118, 120, 175]
ordinati pari:   [10, 11, 56, 72, 120]
ordinati dispari:   [60, 71, 89, 118, 175]

la: Min:  10  Max. 175  Median:  72
pari: Min:  10  Max. 120  Median:  56
dispari: Min:  60  Max. 175  Median:  89
Mostra soluzione
[74]:


la = [10, 60, 72, 118, 11, 71, 56, 89, 120, 175]

# scrivi qui


Metodo join - da liste a stringhe

Data una stringa che funge da separatore, e una sequenza come per esempio una lista la contenente solo stringhe, è possibile concatenarle in una sola stringa (nuova) con il metodo join:

[75]:
la = ['Quando', 'fuori', 'piove']

'SEPARATORE'.join(la)
[75]:
'QuandoSEPARATOREfuoriSEPARATOREpiove'

Come separatore possiamo mettere qualunque carattere, come uno spazio:

[76]:
' '.join(la)
[76]:
'Quando fuori piove'

Nota che la lista originale non viene modificata:

[77]:
la
[77]:
['Quando', 'fuori', 'piove']

DOMANDA: Questo codice cosa produce?

''.join(['a','b','c']).upper()
  1. un errore (quale?)

  2. una stringa (quale?)

  3. una lista (quale?)

Mostra risposta

DOMANDA: Questa codice cosa produce?

'A'.join('porto')
  1. una stringa (quale?)

  2. un errore (quale?)

  3. una lista (quale?)

Mostra risposta

DOMANDA: Questo codice cosa produce?

'\''.join('mmmm')
  1. un errore (quale?)

  2. una stringa (quale?)

Mostra risposta

DOMANDA: Data una stringa qualsiasi s e una lista di stringhe qualsiasi la di almeno due elementi, il seguente codice darà sempre lo stesso risultato - quale ? (pensaci, e se non sai rispondere prova a mettere dei valori a caso di s e la)

len(s) <= len(s.join(la))
  1. un errore (quale?)

  2. una stringa (quale?)

  3. altro (cosa?)

Mostra risposta

Esercizio - barzoletta

Data la stringa:

sa = 'barzoletta'

scrivi del codice che crea una NUOVA stringa sb cambiando la stringa originale in modo che risulti:

>>> print(sb)
'barzelletta'
  • USA il metodo insert e riassegnazione di celle

  • NOTA: non puoi usarle su una stringa, perchè è IMMUTABILE - dovrai quindi prima convertire la stringa in una lista

Mostra soluzione
[78]:


sa = 'barzoletta'

# scrivi qui


Esercizio - dub dab dib dob

Scrivi del codice che data una lista di stringhe la, associa alla variabile s una stringa con le stringhe concatenate separate da virgole e uno spazio

Esempio:

Data

la = ['dub', 'dab','dib', 'dob']

dopo il tuo codice, dovresti ottenere questi risultati:

>>> print(s)
dub, dab, dib, dob
>>> len(s)
18
Mostra soluzione
[79]:
la = ['dub', 'dab','dib', 'dob']

# scrivi qui


Esercizio - ghirigori

Data una lista di stringhe la e una lista di tre separatori seps, scrivi del codice che stampa gli elementi di la separati dal primo separatore, seguiti dal secondo separatore, seguiti dagli elementi di la separati dal terzo separatore.

  • il tuo codice deve funzionare con qualunque lista la e seps

Esempio: dati

la = ['ghi','ri','go','ri']
seps = [',','_','+']

Dopo il tuo codice, deve stampare:

ghi,ri,go,ri_ghi+ri+go+ri
Mostra soluzione
[80]:
la = ['ghi','ri','go','ri']
seps = [',','_','+']

# scrivi qui


Esercizio - welldone

Data la lista

la = ["walnut", "eggplant", "lemon", "lime", "date", "onion", "nectarine", "endive" ]:
  1. Crea un’altra lista (chiamala nuova) contenente il primo carattere di ogni elemento di la

  2. Aggiungi uno spazio a nuova all aposizione 4 e attacca un punto esclamativo ('!') alla fine

  3. Stampa la lista

  4. Stampa il contenuto della lista unendo tutti gli elementi con uno spazio vuoto (per es usa il metodo join: "".join(nuova))

Dovresti ottenere:

['w', 'e', 'l', 'l', ' ', 'd', 'o', 'n', 'e', '!']

 well done!
Mostra soluzione
[81]:
la = ["walnut", "eggplant", "lemon", "lime", "date", "onion", "nectarine", "endive" ]

# scrivi qui


['w', 'e', 'l', 'l', ' ', 'd', 'o', 'n', 'e', '!']

 well done!

Metodo split - da stringhe a liste

Il metodo split delle stringhe fa l’opposto di join: viene chiamato su una stringa e come parametro viene passato un separatore, che può essere un singolo carattere o una sottostringa. Il risultato è una lista di stringhe senza il separatore.

[82]:
"E' giunto il momento di dividere il tesoro".split("il")
[82]:
["E' giunto ", ' momento di dividere ', ' tesoro']

Chiamando split senza argomenti come separatori vengono usati in genere i blank (spazio, a capo \n, tab \t , etc)

[83]:
s = "E' giunto il\nmomento di    dividere\til tesoro"
print(s)
E' giunto il
momento di    dividere  il tesoro
[84]:
s.split()
[84]:
["E'", 'giunto', 'il', 'momento', 'di', 'dividere', 'il', 'tesoro']

E’ anche possibile limitare il numero di elementi da dividere specificando l’argomento maxsplit:

[85]:
s.split(maxsplit=2)
[85]:
["E'", 'giunto', 'il\nmomento di    dividere\til tesoro']

ATTENZIONE: Che succede se la lista non contiene il separatore? Ricordati di considerare anche questo caso!

[86]:
"Parlo e straparlo senza mai fare una pausa".split(',')
[86]:
['Parlo e straparlo senza mai fare una pausa']

DOMANDA: Guarda questo codice. Stamperà qualcosa alla fine? O produrrà un errore?

  1. "porta\tgirevole".split()
    
  2. "porre particolare\t\nattenzione".split()
    
  3. "non ti\tscordar\ndi\tme".split('\t')
    
  4. "non ti scordar\ndi\tme".split(' ')
    
  5. "Il Guardiano dell'Abisso ci osservava minaccioso".split('abisso')[1]
    
  6. "".split('abisso')[0]
    
  7. "abisso_OOOO_abisso".split('abisso')[0]
    

Esercizio - trash dance

Ti hanno ingaggiato per ballare nell’ultimo video della nota band Spazzatura Melodica. Non puoi perdere questa occasione e ti lanci a leggere la partitura, ma la trovi piena di errori (gli Spazzatura non hanno certo bisogno di saper scrivere spartiti per andare in tv). Ci sono strani simboli e l’ultima battuta è troppo lunga (dopo la sesta battuta) e va messa una riga alla volta. Scrivi del codice che sistema la partitura in una lista dance

Esempio - data:

musica = "Zam Dam\tZa Bum Bum\tZam\tBam To Tum\tRa Ta Pam\tBar Ra\tRammaGumma  Unza\n\t\nTACAUACA \n BOOMBOOM!"

dopo il tuo codice deve risultare:

>>> print(dance)
['Zam Dam',
 'Za Bum Bum',
 'Zam',
 'Bam To Tum',
 'Ra Ta Pam',
 'Bar Ra',
 'RammaGumma',
 'Unza',
 'TACAUACA',
 'BOOMBOOM!']
Mostra soluzione
[87]:


musica = "Zam Dam\tZa Bum Bum\tZam\tBam To Tum\tRa Ta Pam\tBar Ra\tRammaGumma  Unza\n\t\nTACAUACA \n BOOMBOOM!"

# scrivi qui


Esercizio - spazzatura In tour

Gli Spazzatura Melodica tornano a colpire nel nuovo tour dove presentano le hit dell’estate. La casa discografica fornisce però le vendite con numeri in formato anglosassone, e per comunicarle ai media italiani è necessaria prima una conversione.

Scrivi del codice che date le hits e una posizione nella classifica (da 1 a 4) mostra il numero di copie vendute

  • NOTA: le virgole devono essere sostituite con punti

Esempio - dati:

hits = """6,230,650 - Ti amo come i pomodori ammuffiti nel frigorifero
2,000,123 - Il dolore di vivere pieni di soldi
100,000 - Le groupies non sono mai abbastanza
837 - Ti ricordi i cassonetti l'estate..."""

posizione = 1   # i pomodori
#posizione = 4  # i cassonetti

Dopo il tuo codice, deve risultare:

La numero 1 in classifica "Ti amo come i pomodori ammuffiti nel frigorifero" ha venduto 6.230.650 copie
Mostra soluzione
[88]:

hits = """6,230,650 - Ti amo come i pomodori ammuffiti nel frigorifero
2,000,123 - Il dolore di vivere pieni di soldi
100,000 - Le groupies non sono mai abbastanza
837 - Ti ricordi i cassonetti l'estate..."""

posizione = 1   # i pomodori
#posizione = 4  # i cassonetti

# scrivi qui


Esercizio - moltelinee

Dato la seguente stringa di testo:

"""Questa è una stringa
di testo su
diverse linee che non dice niente. """
  1. stampala

  2. stampa quante linee, parole e caratteri contiene

  3. metti in ordine alfabetico le parole e stampale le prime e ultime in ordine lessicografico

Dovresti ottenere:

Questa è una stringa
di testo su
diverse linee che non dice niente.

Linee: 3 parole: 13 charatteri: 67

['Q', 'u', 'e', 's', 't', 'a', ' ', 'è', ' ', 'u', 'n', 'a', ' ', 's', 't', 'r', 'i', 'n', 'g', 'a', '\n', 'd', 'i', ' ', 't', 'e', 's', 't', 'o', ' ', 's', 'u', '\n', 'd', 'i', 'v', 'e', 'r', 's', 'e', ' ', 'l', 'i', 'n', 'e', 'e', ' ', 'c', 'h', 'e', ' ', 'n', 'o', 'n', ' ', 'd', 'i', 'c', 'e', ' ', 'n', 'i', 'e', 'n', 't', 'e', '.']
67

Prima parola:  Questa
Ultima parola: è
['Questa', 'che', 'di', 'dice', 'diverse', 'linee', 'niente.', 'non', 'stringa', 'su', 'testo', 'una', 'è']
Mostra soluzione
[89]:


s = """Questa è una stringa
di testo su
diverse linee che non dice niente."""


# scrivi qui


Metodo count

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

[90]:
la = ['c', 'o', 'r', 'r', 'o', 'b', 'o', 'r', 'a', 'r', 'e']
[91]:
la.count('c')
[91]:
1
[92]:
la.count('o')
[92]:
3
[93]:
la.count('r')
[93]:
4

Non abusare count

ATTENZIONE: count viene spesso usato in modo errato / inefficiente

Chiediti sempre:

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

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

  3. count compie una ricerca in tutta la lista, 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. ['A','aa','a','aaAah',"a", "aaaa"[1], " a "].count("a")
    
  2. ["il", "castigo", "degli", "stolti"].count('Stolti') == 1
    
  3. lista = ['oasi','dattero','oasi','cocco','dattero','cocco']
    print(lista.count('dattero') == 1)
    
  4. lista = ['oasi','dattero','oasi','cocco','dattero','cocco']
    print(lista[4] == 'dattero')
    
  5. ['2',2,"2",2,float("2"),2.0, 4/2,"1+1",int('3')-float('1')].count(2)
    
  6. [].count([])
    
  7. [[],[],[]].count([])
    

Esercizio - vita di campagna

Data una lista campagna, scrivi del codice che stampa True se la prima metà contiene un numero di elementi el1 uguale al numero di elementi el2 nella seconda metà.

Mostra soluzione
[94]:

el1,el2 = 'badili', 'zappe'    # True
#el1,el2 = 'badili', 'badili'  # False
#el1,el2 = 'cariole', 'aratri' # True
#el1,el2 = 'badili', 'cariole' # False

campagna = ['aratri','cariole', 'badili',  'cariole', 'badili','zappe', 'cariole',
            'zappe', 'aratri',  'cariole', 'aratri',  'badili','aratri','zappe']

# scrivi qui


Metodo index

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

[95]:
#      0   1   2   3   4
la = ['p','a','e','s','e']
[96]:
la.index('p')
[96]:
0
[97]:
la.index('a')
[97]:
1
[98]:
la.index('e')  # troviamo la PRIMA occorrenza
[98]:
2

Se l’elemento che cerchiamo non è presente, otterremo un errore:

>>> la.index('z')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-303-32d9c064ebe0> in <module>
----> 1 la.index('z')

ValueError: 'z' is not in list

Opzionalmente, puoi specificare un indice da dove iniziare a cercare (incluso):

[99]:
# 0   1   2   3   4   5   6   7   8   9   10
['a','c','c','a','p','a','r','r','a','r','e'].index('a',6)
[99]:
8

E anche dove finire (escluso):

# 0   1   2   3   4   5   6   7   8   9   10
['a','c','c','a','p','a','r','r','a','r','e'].index('a',6,8)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-7f344c26b62e> in <module>
      1 # 0   1   2   3   4   5   6   7   8   9   10
----> 2 ['a','c','c','a','p','a','r','r','a','r','e'].index('a',6,8)

ValueError: 'a' is not in list

Non abusare index

ATTENZIONE: index viene spesso usato in modo errato / inefficiente

Chiediti sempre:

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

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

  3. index compie una ricerca in tutta la lista, 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 lista[3] == elemento. Usando index potrebbe trovare caratteri duplicati che stanno prima o dopo di quello che vogliamo verificare!

DOMANDA: Guarda i frammenti di codice seguenti, e per ciascuno cerca di indovinare che risultato produce (o se risulta in un errore).

  1. ['arco','barca','conca','duna'].index('conca') == ['arco','barca','conca','duna'].index('conca',1)
    
  2. ['azzurro','blu','celeste','puffo'][-1:].index('celeste')
    
  3. strada = ['asfalto','bitume','cemento','ghiaia']
    print('malta' in strada or strada.index('malta'))
    
  4. strada = ['asfalto','bitume','cemento','ghiaia']
    print('malta' in strada and strada.index('malta'))
    
  5. strada = ['asfalto','bitume','malta','ghiaia']
    print('malta' in strada and strada.index('malta'))
    
  6. la = [0,5,10]
    la.reverse()
    print(la.index(5) > la.index(10))
    

Esercizio - Spatoč

In passato hai avuto conosciuto il pittore slavo Spatoč quando era ancora povero in canna. Ti ha regalato 2 o 3 quadri (non ricordi) dal dubbio valore artistico che hai nascosto in soffitta, ma dalla TV apprendi che Spatoč è diventato un artista di fama internazionale. Corri quindi in soffitta a recuperare i quadri, persi tra le mille cianfrusaglie. Ogni quadro è contenuto in uno [ ] scatolone, ma non sai in quale scaffale. Scrivi del codice che stampa dove sono.

  • gli scaffali sono numerati da 1. Se il terzo quadro non è trovato, stampa 0.

  • NON usare cicli nè if

  • SUGGERIMENTO: stampare i primi due (che ci sono sempre) è facile, mentre per l’ultimo riguardati Booleani - ordine di valutazione

Esempio 1 - data:

[100]:
         #  1  2     3            4      5
soffitta = [3,"\\", ["quadro"], "---", ['quadro'],
         #  6      7          8             9           10
            5.23, ['viti'], ['pattini'], ["quadro"], ['lampada']]

il tuo codice deve stampare:

scaffale primo quadro:  3
scaffale secondo quadro: 5
scaffale terzo quadro: 9

Esempio 2 - data:

[101]:
            # 1          2     3            4            5           6          7
soffitta = [["quadro"],  "--", ['pattini'], ['quadro'], ["statua"], ['viti'], ['stivali']]

il tuo codice deve stampare:

scaffale primo quadro: 1
scaffale secondo quadro: 4
scaffale terzo quadro: 0
Mostra soluzione
[102]:

        #   1  2     3            4      5          6      7          8             9           10
soffitta = [3,"\\", ["quadro"], "---", ['quadro'], 5.23, ['viti'], ['pattini'], ["quadro"], ['lampada']]
#  3,5,9
            #   1          2     3            4            5           6          7
#soffitta = [["quadro"],  "--", ['pattini'], ['quadro'], ["statua"], ['viti'], ['stivali']]
#  1,4,0


# scrivi qui


Metodo remove

remove prende come parametro un oggetto, cerca la PRIMA cella che contiene quell’oggetto e la elimina:

[103]:
#     0 1 2 3 4 5
la = [6,7,9,5,9,8]   # il 9 è alla cella con indice 2 e 4
[104]:
la.remove(9)   # cerca la prima cella contenente il numero 9
[105]:
la
[105]:
[6, 7, 5, 9, 8]

Come si può vedere, la cella che era all’indice 2 e che conteneva la PRIMA occorrenza di 9 è stata eliminata. La cella contenente la SECONDA occorrenza di 9 invece è ancora lì.

Se si cerca di rimuovere un oggetto non presente, si riceve un errore:

la.remove(666)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-121-5d04a71f9d33> in <module>
----> 1 la.remove(666)

ValueError: list.remove(x): x not in list

Non abusare remove

ATTENZIONE: remove viene spesso usato in modo errato / inefficiente

Chiediti sempre:

  1. la lista potrebbe contenere duplicati? Ricordati che verrà rimosso solo il primo!

  2. la lista potrebbe non contenere l’oggetto cercato? Ricordati di gestire anche questo caso!

  3. remove compie una ricerca in tutta la lista, che può essere inefficiente: è proprio necessaria, o sappiamo già la posizione i dove è presente l’elemento da rimuovere? In tal caso conviene usare .pop(i)

DOMANDA: Guarda i frammenti di codice seguenti, e per ciascuno cerca di indovinare che risultato produce (o se risulta in un errore).

  1. la = ['a','b','c','b']
    la.remove('b')
    print(la)
    
  2. la = ['a','b','c','b']
    x = la.remove('b')
    print(x)
    print(la)
    
  3. la = ['a','d','c','d']
    la.remove('b')
    print(la)
    
  4. la = ['a','bb','c','bbb']
    la.remove('b')
    print(la)
    
  5. la = ['a','b','c','b']
    la.remove('B')
    print(la)
    
  6. la = ['a',9,'99',9,'c',str(9),'999']
    la.remove("9")
    print(la)
    
  7. la = ['nun', 'me', 'fregà']
    la.remove('nun').remove('me').remove('fregà')
    print(la)
    
  8. la = ['nun', 'me', 'fregà']
    la.remove('nun')
    la.remove('me')
    la.remove('fregà')
    print(la)
    
  9. la = [4,5,7,10]
    11 in la or la.remove(11)
    print(la)
    
  10. la = [4,5,7,10]
    11 in la and la.remove(11)
    print(la)
    
  11. la = [4,5,7,10]
    5 in la and la.remove(5)
    print(la)
    
  12. la = [9, [9], [[9]], [[[9]]] ]
    la.remove([9])
    print(la)
    
  13. la = [9, [9], [[9]], [[[9]]] ]
    la.remove([[9]])
    print(la)
    

Esercizio - nob

Scrivi del codice che rimuove dalla lista la tutti i numeri contenuti nella lista di 3 elementi lb

  • il tuo codice deve funzionare con qualsiasi lista la e lb di 3 elementi

  • puoi assumere che la contenga esattamente DUE occorrenze di tutti gli elementi di lb (più eventuali altri numeri)

Esempio - dati:

lb = [8,7,4]
la = [7,8,11,8,7,4,5,4]

dopo il tuo codice deve risultare

>>> print(la)
[11, 5]
Mostra soluzione
[106]:
lb = [8,7,4]
la = [7,8,11,8,7,4,5,4]

# scrivi qui


Prosegui

Trovi ulteriori esercizi nel foglio Liste 4

[ ]: