Liste 2 - operatori

Scarica zip esercizi

Naviga file online

Per manipolare le liste vi sono diversi operatori. I seguenti si comportano come quelli visti per le stringhe.

Operatore

Risultato

Significato

len(lst)

int

Ritorna la lunghezza di una lista

list[int]

obj

Legge/scrive un elemento all’indice specificato

list[int:int]

list

Estrae una sotto-lista - ritorna una NUOVA lista

obj in list

bool

Controlla se un elemento è presente in una lista

list + list

list

Concatena due liste - ritorna una NUOVA lista

max(lst)

int

Data una lista di numeri, ritorna il massimo

min(lst)

int

Data una lista di numeri, ritorna il minimo

sum(lst)

int

Data una lista di numeri, li somma tutti

list * int

list

Replica la lista - ritorna una NUOVA lista

==,!=

bool

Controlla se due liste sono uguali o differenti

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

Lunghezza di una lista

Una lista è una sequenza, e come per tutte le sequenze per ottenere la lunghezza si può usare la funzione len:

[2]:
a = [7,5,8]
[3]:
len(a)
[3]:
3
[4]:
b = [8,3,6,4,7]
[5]:
len(b)
[5]:
5

Se una lista contiene altre liste, contano come singoli elementi:

[6]:
mista = [
            [4,5,1],
            [8,6],
            [7,6,0,8],
        ]
[7]:
len(mista)
[7]:
3

ATTENZIONE: NON puoi usare ``len`` come se fosse un metodo

Per es questo NON funziona: [3,4,2].len()

ESERCIZIO: Prova a scrivere [3,4,2].len() qua sotto, che errore appare?

Mostra soluzione
[8]:
# scrivi qui


ESERCIZIO: Prova a scrivere [3,4,2].len SENZA le doppie tonde alla fine, che errore appare?

Mostra soluzione
[9]:
# scrivi qui


DOMANDA: Se x è una lista qualunque, scrivendo

len(len(x))

cosa otteniamo?

  1. la lunghezza della lista

  2. un errore

  3. qualcos’altro

Mostra risposta

DOMANDA: Guarda questa espressione, senza eseguirla. Cosa produce?

[len([]), len([len(['a','b'])])]
  1. un errore (quale?)

  2. un numero (quale?)

  3. una lista (quale?)

Prova a scrivere a mano il risultato, e poi confrontalo con quello ottenuto eseguendo il codice in una cella.

Mostra risposta

DOMANDA: Guarda questa espressione, senza eseguirla. Cosa produce?

len([[[],[]],[],[[[]]],[[],[]]])
  1. un errore (quale?)

  2. un numero (quale?)

  3. una lista (quale?)

Mostra risposta

DOMANDA: Cosa produce la seguente espressione?

[[((len('ababb')))],len(["argg",('b'),("c")]), len([len("bc")])]
Mostra risposta

Leggere un elemento

Come per le stringhe, possiamo accedere ad un elemento di una lista mettendo l’indice della posizione a cui vogliamo accedere tra parentesi quadre:

[10]:
    # 0   1   2   3
la = [70, 60, 90, 50]

Come per tutte le sequenze, le posizioni iniziano da ``0``:

[11]:
la[0]
[11]:
70
[12]:
la[1]
[12]:
60
[13]:
la[2]
[13]:
90
[14]:
la[3]
[14]:
50

Come per le stringhe, se sforiamo con l’indice otteniamo un errore:

la[4]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-134-09bfed834fa2> in <module>
----> 1 la[4]

IndexError: list index out of range

Di nuovo come per le stringhe possiamo ottenere l’ultimo elemento usando un indice negativo:

[15]:
    # 0   1   2   3
la = [70, 60, 90, 50]
[16]:
la[-1]
[16]:
50
[17]:
la[-2]
[17]:
90
[18]:
la[-3]
[18]:
60
[19]:
la[-4]
[19]:
70

Se esageriamo ed andiamo oltre la lunghezza della lista, otteniamo un errore:

la[-5]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-169-f77280923dce> in <module>
----> 1 la[-5]

IndexError: list index out of range

DOMANDA: se x è una lista qualunque, scrivendo

x[0]

cosa otteniamo?

  1. il primo elemento della lista

  2. sempre un errore

  3. a volte un elemento a volte un errore a seconda della lista

Mostra risposta

DOMANDA: se x è una lista qualunque, scrivendo

x[len(x)]

cosa otteniamo?

  1. un elemento della lista

  2. sempre un errore

  3. a volte un elemento a volte un errore a seconda della lista

Esercizio - L’apprendista di Gutenberg

Quale onore! Alla tua età assunta come apprendista del maestro Gutenberg! La tua mansione è quella di comporre le pagine con i blocchetti di caratteri in ferro in modo che gli altri collaboratori poi mandino il tutto alla pressa da stampa.

Hai a disposizione una lista in cui sono salvati i blocchetti originali. Riesci a stampare la scritta Gutenberg ?

  • NON scrivere caratteri o stringhe aggiuntive (es: niente 'g'o 'G'!)

  • ogni lettera PUO’ essere riutilizzata

Mostra soluzione
[20]:

lettere = ['b', 'e', 'g', 'n', 'r', 't', 'u']   # Gutenberg
#lettere = ['a', 'm', 's', 'p', 'o', 'a', 't']  # Stampamos

l = lettere      # Creiamo una nuova variabile più corta per comodità

# scrivi qui


Mostra risposta

Scrivere un elemento

Visto che le liste sono MUTABILI, dato un oggetto lista possiamo cambiare il contenuto di una qualunque cella al suo interno.

Supponiamo per esempio di voler cambiare la cella all’indice 2 della lista la, cambiandolo da 6 a 5:

[21]:
     #0  1  2  3
la = [7, 9, 6, 8]

Possiamo scrivere così:

[22]:
la[2] = 5

[23]:
la
[23]:
[7, 9, 5, 8]

Guardiamo meglio che succede 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]:
#     0  1  2  3
la = [7, 9, 6, 8]
la[2] = 5

jupman.pytut()
[25]:

Come vedi, in questo non vengono create regioni di memoria nuove, semplicemente si va a sovrascrivere una cella esistente.

Esercizio - Un parcheggio intasato

Sei l’amministratore del condominio “La Gioia Pitonica”. Ogni appartamento ha uno o due posti auto assegnati e ciascuno è numerato da 1 a 11.

La seguente è il parcheggio attuale, e come si può vedere ci sono tre buchi non assegnati, perchè gli appartamenti 3, 4 e 7 non hanno più un affittuario.

[26]:
parcheggi = ["Carlo", "App.3", "Ernesto", "App.4", "App.7", "Pam", "Giovanna", "Camilla", "Giorgia", "Jessica", "Jim"]

Per mantenere l’ordine decidi che è il caso di compattare le assegnazioni e di lasciare i posti vuoti tutti in fondo (può essere comodo per far parcheggiare i traslocatori!)

Scrivi del codice per MODIFICARE parcheggi in modo che risulti:

>>> print(parcheggi)
['Carlo', 'Jim', 'Ernesto', 'Pam', 'Giorgia', 'Pam', 'Giovanna', 'Camilla', 'Apt.3', 'Apt.4', 'Apt.7']
  • NON creare nuove liste

  • Assegna ogni elemento uno per volta

  • supponi parcheggi abbia lunghezza fissa e che i posti non assegnati siano sempre 3 e in posizione fissa

parking-jam

Mostra soluzione
[27]:

parcheggi = ["Carlo", "App.3", "Ernesto", "App.4", "App.7", "Pam", "Giovanna", "Camilla", "Giorgia", "Jessica", "Jim"]
#parcheggi = ["Cristian", "App.3", "Edgar", "App.4", "App.7", "Pamela", "Giusy", "Cristina", "Gaia", "Jessie", "John"]

# scrivi qui


Mutare liste condivise

ATTENZIONE: L’ARGOMENTO CHE SEGUE E’ CAUSA DEL 90% DEGLI ERRORI DI PROGRAMMAZIONE !!!

LEGGI BENE !!!

Cosa succede quando associamo a due variabili lo stesso identico oggetto mutabile, come per esempio una lista, e poi usando una delle due variabili mutiamo l’oggetto?

Guardiamo un esempio - per prima cosa, alla variabile la associamo la lista [7,9,6]:

[28]:
la = [7,9,6]

Adesso definiamo una nuova variabile lb, e associamogli come valore lo stesso valore già associato alla variabile la. Nota bene: qua NON stiamo creando nuove liste !

[29]:
lb = la
[30]:
print(la)  # la è sempre lo stesso
[7, 9, 6]
[31]:
print(lb)  # lb è la stessa lista associata a la
[7, 9, 6]

Proviamo a modificare una cella di lb, mettendo 5 nella cella all’indice 0:

[32]:
lb[0] = 5

Se proviamo a stampare le variabili la ed lb, Python andrà a guardare i valori associati a ciascuna variabile. Dato che il valore è la stessa identica lista (che risiede nella stessa identica regione di memoria ), in entrambi i casi vedrai la modifica appena fatta !

[33]:
print(la)
[5, 9, 6]
[34]:
print(lb)
[5, 9, 6]

Guardiamo meglio che succede in Python Tutor:

[35]:
la = [7,9,6]
lb = la
lb[0] = 5
print('la è', la)
print('lb è', lb)

jupman.pytut()
la è [5, 9, 6]
lb è [5, 9, 6]
[35]:

Guardiamo la differenza se invece creiamo esplicitamente una lista uguale a la.

In questo caso avremo due regioni di memoria distinte e la NON sarà modificato:

[36]:
la = [7,9,6]
lb = [7,9,6]
lb[0] = 5
print('la è', la)
print('lb è', lb)

jupman.pytut()
la è [7, 9, 6]
lb è [5, 9, 6]
[36]:

DOMANDA: Dopo l’esecuzione di questo codice, cosa verrà stampato? Quante liste ci saranno effettivamente in memoria?

Prova a disegnare SU CARTA quello che succede in memoria, e poi confronta con il risultato in Python Tutor!

la = [8,7,7]
lb = [9,6,7,5]
lc = lb
la = lb
print('la è', la)
print('lb è', lb)
print('lc è', lc)
Mostra risposta
[37]:
la = [8,7,7]
lb = [9,6,7,5]
lc = lb
la = lb
#print('la è', la)
#print('lb è', lb)
#print('lc è', lc)
jupman.pytut()
[37]:

DOMANDA: Guarda il codice seguente. Dopo la sua esecuzione, cosa produrrà la stampa di la, lb ed lc ?

Prova a disegnare SU CARTA quello che succede in memoria, e poi confronta con il risultato in Python Tutor!

la = [7,8,5]
lb = [6,7]
lc = lb
lb = la
lc[0] = 9
print('la è', la)
print('lb è', lb)
print('lc è', lc)
Mostra risposta
[38]:
la = [7,8,5]
lb = [6,7]
lc = lb
lb = la
lc[0] = 9
#print('la è', la)
#print('lb è', lb)
#print('lc è', lc)

jupman.pytut()
[38]:

Liste di stringhe

Abbiamo detto che in una lista possiamo mettere qualunque oggetto, per esempio delle stringhe:

[39]:
verdure = ['pomodori', 'verze', 'carote', 'cavoli']

Proviamo ad estrarre una verdura scrivendo questa espressione:

[40]:
verdure[2]
[40]:
'carote'

Ora, l’espressione precedente ci ha prodotto il risultato 'carote', che sappiamo essere una stringa. Questo ci suggerisce che possiamo usare l’espressione esattamente come se fosse una stringa.

Supponiamo che vogliamo ottenere il primo carattere della stringa 'carote', avendo direttamente la stringa scriveremmo così:

[41]:
'carote'[0]
[41]:
'c'

Ma se la stringa è racchiusa nella lista di prima, potremmo fare direttamente così:

[42]:
verdure[2][0]
[42]:
'c'

Esercizio - sigle

Data una lista con sigle di esattamente 4 capoluoghi in minuscolo, scrivere del codice che crea una NUOVA lista contente le stesse sigle in caratteri tutti maiuscoli.

  • il tuo codice deve funzionare con qualunque lista di 4 capoluoghi

  • suggerimento: se non ti ricordi il metodo giusto, guarda qua

Esempio 1 - dato:

sigle = ['tn','mi','to','ro']

il tuo codice deve stampare

['TN', 'MI', 'TO', 'RO']

Esempio 2 - dato:

sigle = ['pa','ge','ve', 'aq']

il tuo codice deve stampare:

['PA', 'GE', 'VE', 'AQ']

plate

Mostra soluzione
[43]:

sigle = ['tn','mi','to','ro']

# scrivi qui


Esercizio - giochi

Data una lista giochi di esattamente 3 stringhe, scrivi del codice che MODIFICA la lista in modo che contenga solo i primi caratteri di ciascuna stringa

  • Il tuo codice deve funzionare con qualunque lista di esattamente 3 stringhe

Esempio - data:

giochi = ["Monopoli", "RISIKO", "Tombola"]

Dopo l’esecuzione del tuo codice, deve risultare:

>>> print(giochi)
["M","R","T"]
  • NON creare liste nuove (quindi niente assegnazioni come giochi = …)

Mostra soluzione
[44]:

giochi = ["Monopoli", "RISIKO", "Tombola"]                     # ['M','R','T']
#giochi = ["Non t'arrabbiare", "Gioco dell'oca", "Scarabeo"]   # ['N','G','S']

# scrivi qui


Slice

Possiamo estrarre delle sequenze dalle liste usando le slice. Una slice si produce aggiungendo delle parentesi quadre alla destra della lista e mettendo nelle quadre l’indice di partenza (INCLUSO), seguito da due punti :, seguito dall’indice di fine (ESCLUSO). Funziona esattamente come per le stringhe: in quel caso la quadra produceva una nuova stringa, in questo si produce una NUOVA lista. Vediamo un esempio:

[45]:
     #0  1  2  3  4  5  6  7  8  9
la = [40,30,90,80,60,10,40,20,50,60]
[46]:
la[3:7]
[46]:
[80, 60, 10, 40]

Abbiamo estratto una NUOVA lista [80, 60, 10, 40] a partire della lista la partendo dall’indice 3 INCLUSO fino all’indice 7 ESCLUSO. Possiamo vedere che la lista originale si è preservata:

[47]:
la
[47]:
[40, 30, 90, 80, 60, 10, 40, 20, 50, 60]

Verifichiamo cosa succede con Python Tutor, assegnando la nuova lista ad una variabile lb:

[48]:
#     0  1  2  3  4  5  6  7  8  9
la = [40,30,90,80,60,10,40,20,50,60]
lb = la[3:7]

jupman.pytut()
[48]:

Noterai che compare una NUOVA regione di memoria, associata alla variabile lb.

Slice - limiti

Quando operiamo con le slice dobbiamo stare attenti ai limiti degli indici. Vediamo come si comportano:

[49]:
#0  1  2  3  4
[50,90,70,80,60][0:3]  # da indice 0 *incluso* a 3 *escluso*
[49]:
[50, 90, 70]
[50]:
#0  1  2  3  4
[50,90,70,80,60][0:4]  # da indice 0 *incluso* a 4 *escluso*
[50]:
[50, 90, 70, 80]
[51]:
#0  1  2  3  4
[50,90,70,80,60][0:5]  # da indice 0 *incluso* a 5 *escluso*
[51]:
[50, 90, 70, 80, 60]
[52]:
#0  1  2  3  4
[50,90,70,80,60][0:6]   # se andiamo oltre la lunghezza della lista Python non si arrabbia
[52]:
[50, 90, 70, 80, 60]
[53]:
#0  1  2  3  4
[50,90,70,80,60][8:12]   # anche se partiamo da indici inesistenti Python non si arrabbia
[53]:
[]

DOMANDA: Questa espressione

[][0:8]
  1. produce un risultato (quale?)

  2. produce un errore (quale?)

Mostra risposta

DOMANDA: Questa espressione

[][3:8]
  1. produce un risultato (quale?)

  2. produce un errore (quale?)

Mostra risposta

DOMANDA: se x è una lista qualsiasi (anche vuota), questa espressione cosa fa? Può dare errore? o ritorna qualcosa di utile?

x[0:len(x)]
Mostra risposta

Esercizio - La treccia mochena

Come ben sai nella valle dei Mocheni vi è una meravigliosa specialità di cucina pasticciera: si tratta della famosa treccia Mochena.

Ad un’occhiata frettolosa la treccia mochena potrebbe apparire come uno sfilatino, lungo tra i 30 e 60 cm al cui interno vengono messi un mix di ingredienti insieme alla mirabolante e segretissima crema.

Insieme ai tuoi amici Camilla e Giorgio hai acquistato una treccia farcita con granella di noci, mirtilli e ribes rossi.

Ma a te non piacciono le noci e a Giorgio non piacciono i mirtilli!

Scrivi del codice per mettere nelle variabili mio, giorgio e camilla delle liste ottenute da treccia, e STAMPA il risultato:

Mio: ['m', 'm', 'm', 'm', 'm', 'm']
Giorgio: ['n', 'n', 'n', 'n', 'n']
Camilla: ['r', 'r', 'r', 'r']
  • supponi la treccia abbia lunghezza e numero di ingredienti fissi

Mostra soluzione
[54]:


#           Noci                     Mirtilli                     Ribes
treccia = ['n', 'n', 'n', 'n', 'n', 'm', 'm', 'm', 'm', 'm', 'm', 'r', 'r', 'r', 'r', 'r']
#treccia = ['N', 'N', 'N', 'N', 'N', 'M', 'M', 'M', 'M', 'M', 'M', 'R', 'R', 'R', 'R', 'R']


# scrivi qui


Slice - omissione limiti

Volendo, è possibile omettere l’indice di partenza, in tal caso Python supporrà sia 0:

[55]:
#0  1  2  3  4  5  6  7  8  9
[90,60,80,70,60,90,60,50,70][:3]
[55]:
[90, 60, 80]

E’ anche possibile omettere l’indice di fine, in tal caso Python estrarrà fino alla fine della lista:

[56]:
#0  1  2  3  4  5  6  7  8  9
[90,60,80,70,60,90,60,50,70][3:]
[56]:
[70, 60, 90, 60, 50, 70]

Omettendo entrambi gli indici si ottiene l’intera lista:

[57]:
#0  1  2  3  4  5  6  7  8  9
[90,60,80,70,60,90,60,50,70][:]
[57]:
[90, 60, 80, 70, 60, 90, 60, 50, 70]

DOMANDA: Cosa stamperà questo codice ? la sarà modificato oppure no?

la = [7,8,9]
lb = la[:]
lb[0] = 6
print('la =',la)
print('lb =',lb)
Mostra risposta
[58]:
la = [7,8,9]
lb = la[:]
lb[0] = 6
#print('la =',la)
#print('lb =',lb)

jupman.pytut()
[58]:

DOMANDA: Per ciascuna delle espressioni seguenti, prova a indovinare quale valore produce, o se da errore.

  1. [9,7,8,6][1:1]
    
  2. [9,7,8,6][1:2]
    
  3. [9,7,8,6][2:3][0]
    
  4. [][]
    
  5. [][:]
    
  6. [3][:]
    
  7. [:][]
    

Esercizio - La chitarra scordata

In soffitta hai trovato una vecchia chitarra che girava per casa quando eri una bambina. Adesso che ti sei laureata in ingegneria della gestione del suono provi a strimpellarla mentre un sensore misura la nota prodotta.

Il sensore è un microfono e ogni decimo di secondo registra la nota principale che ha rilevato.

Con questo test ti accorgi di un fenomeno molto bizzarro. Alcune delle corde della chitarra appena vengono suonate hanno un comportamento altalenante ma poi si sintonizzano su una nota precisa fino alla fine:

"do, re, mi, do, sol, do, do, do, do, do, do, do, ..."

Altre corde invece fanno l’opposto:

"sol, sol, sol, sol, sol, sol, sol, sol, sol, re, mi, fa, sol, do, do, sol, re, mi, mi, re, ..."

Scrivi del codice per tagliare l’output del sensore e ottenere così solo le sequenze di note continue e corrette. Alla fine deve STAMPARE:

['do', 'do', 'do', 'do', 'do', 'do', 'do']
['sol', 'sol', 'sol', 'sol', 'sol', 'sol']
['fa', 'fa', 'fa', 'fa', 'fa', 'fa', '...']
['re', 're', 're', 're', 're', 're', '...']
Mostra soluzione
[59]:

corda1 = ['do', 'do', 'do', 'do', 'do', 'do', 'do', 're', 'sol', 'fa', 'si', 'si', 'do', 'si', '...']
corda2 = ['sol', 'sol', 'sol', 'sol', 'sol', 'sol', 're', 're', 'la', 'la', 'si', 'fa', 'si', '...']
corda3 = ['do', 'la', 'fa', 'mi', 'la', 'do', 'si', 'fa', 'fa', 'fa', 'fa', 'fa', 'fa', 'fa', '...']
corda4 = ['si', 'si', 'mi', 'sol', 'la', 'la', 'mi', 're', 're', 're', 're', 're', 're', '...']

# scrivi qui


Slice - limiti negativi

Volendo è anche possibile impostare limiti negativi, per quanto non sia sempre molto intuitivo.

[60]:
#0  1  2  3  4  5  6
[70,40,10,50,60,10,90][3:0]   # da indice 3 a indici positivi <= 3 non produce nulla
[60]:
[]
[61]:
#0  1  2  3  4  5  6
[70,40,10,50,60,10,90][3:1]   # da indice 3 a indici positivi <= 3 non produce nulla
[61]:
[]
[62]:
#0  1  2  3  4  5  6
[70,40,10,50,60,10,90][3:2]  # da indice 3 a indici positivi <= 3 non produce nulla
[62]:
[]
[63]:
#0  1  2  3  4  5  6
[70,40,10,50,60,10,90][3:3]  # da indice 3 a indici positivi <= 3 non produce nulla
[63]:
[]

Vediamo cosa succede con indici negativi:

[64]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][3:-1]
[64]:
[50, 60, 10]
[65]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][3:-2]
[65]:
[50, 60]
[66]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][3:-3]
[66]:
[50]
[67]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][3:-4]
[67]:
[]
[68]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][3:-5]
[68]:
[]

E’ anche possibile partire da un indice negativo e arrivare ad uno positivo: finchè il primo indice marca una posizione antecedente a quella del secondo indice, viene restituito qualcosa:

[69]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][-7:3]
[69]:
[70, 40, 10]
[70]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][-6:3]
[70]:
[40, 10]
[71]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][-5:3]
[71]:
[10]
[72]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][-4:3]
[72]:
[]
[73]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][-3:3]
[73]:
[]
[74]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[70,40,10,50,60,10,90][-2:3]
[74]:
[]

DOMANDA: Per ciascuna delle espressioni seguenti, prova a indovinare quale valore produce, o se da errore.

  1. [9,7,8,6][0:-2]
    
  2. [0:-2][9,7,8,6]
    
  3. [5,7,9][1:-1]
    
  4. [][-13:-17]
    
  5. [9,7,8,6][-4:-1]
    
  6. [9,7,8,6][-5:-1]
    
  7. [9,7,8,6,10,32][-3:1]
    
  8. [9,7,8,6,10,32][-3:5]
    

Esercizio - lo scontrino

Per controllare le tue spese vuoi scrivere un software che tenga traccia di tutto ciò che compri. E cercare di ridurre le spese inutili.

Grazie ad una libreria ti basta scattare una foto con lo smartphone allo scontrino e il testo verrà letto in maniera automatica.

Sai che tutti gli scontrini seguono lo stesso schema: nome negozio, data, “articoli acquistati”, 1 riga per prodotto, totale, ringraziamenti.

Scrivi del codice per creare una NUOVA lista con solamente le righe degli articoli, per esempio:

['Pettine per pitoni               12,00€',
 'Accendisigari da immersione      23,00€',
 'Coriandoli piombo anti-vento      4,99€',
 'Scarpe trasparenti da casa       35,56€',
 'Insaporitore per insalata         1,12€']
Mostra soluzione
[75]:

scontrino = ["Negozio La Bislaccheria",
             "21 Luglio 2021 14:54",
             "Articoli acquistati",
             "Pettine per pitoni               12,00€",
             "Accendisigari da immersione      23,00€",
             "Coriandoli piombo anti-vento      4,99€",
             "Scarpe trasparenti da casa       35,56€",
             "Insaporitore per insalata         1,12€",
             "Totale 56,66€",
             "Grazie per aver fatto acquisti in questo negozio!"
            ]

# scontrino = ["Eleganz", "3 Gennaio 2020 12:5", "Articoli acquistati",
#              "Zeppe con acquario e pesci  342,00€",
#              "Abito Completo 'Elvis'      20.000,00€",
#              "Totale 20.000,342€","Grazie per aver fatto acquisti in questo negozio!"]


# scrivi qui


Slice - passo

E’ anche possibile specificare un terzo parametro detto ‘passo’ per indicare a python di quante celle spostarsi ad ogni lettura. Qui per esempio partiamo dall’indice 3 per arrivare all’indice 9 escluso, saltando di 2:

[76]:
# 0 1  2  3  4  5  6  7  8  9
[ 0,10,20,30,40,50,60,70,80,90][3:9:2]
[76]:
[30, 50, 70]

Tutta la sequenza, saltando di 3:

[77]:
# 0 1  2  3  4  5  6  7  8  9
[ 0,10,20,30,40,50,60,70,80,90][0:10:3]
[77]:
[0, 30, 60, 90]

Possiamo anche omettere i limiti per ottenere l’espressione equivalente:

[78]:
# 0 1  2  3  4  5  6  7  8  9
[ 0,10,20,30,40,50,60,70,80,90][::3]
[78]:
[0, 30, 60, 90]

Slice - modifica

Supponiamo di avere la lista

[79]:
     #0  1  2  3  4  5  6  7
la = [30,40,80,10,70,60,40,20]

e di voler cambiare le celle di la dall’indice 3 INCLUSO all’indice 6 ESCLUSO in modo che contengano i numeri presi dalla lista [91,92,93]. Possiamo farlo con questa notazione speciale che ci consente di scrivere una slice alla sinistra dell’operatore =:

[80]:
la[3:6] = [91,92,93]
[81]:
la
[81]:
[30, 40, 80, 91, 92, 93, 40, 20]

In questo esempio leggermente più complesso verifichiamo in Python Tutor che viene effettivamente modificata la regione di memoria originale:

[82]:
#     0  1  2  3  4  5  6  7
la = [30,40,80,10,70,60,40,20]
lb = la
lb[3:6] = [91,92,93]

jupman.pytut()
[82]:

DOMANDA: Guarda il seguente codice - cosa produce?

la = [9,6,5,8,2]
la[1:4] = [4,7,0]
print(la)
  1. modifica la (come?)

  2. un errore (quale?)

Mostra risposta

DOMANDA: Guarda il seguente codice. Cosa produce?

la = [7,6,8,4,2,4,2,3,1]
i = 3
lb = la[0:i]
la[i:2*i] = lb
print(la)
  1. modifica la (come?)

  2. un errore (quale?)

Mostra risposta

Esercizio - I banditi della ferrovia

ferrovia

Stati Uniti - 13 Maggio 1857

La colonizzazione dei territori del west è un duro lavoro ma qualcuno deve pur farlo. Le montagne sono zeppe di minerali rari e di animali pulciosi da trasformare in preziose pellicce per le nobildame d’Europa. Ma come sempre, dove ci sono grandi ricchezze, arrivano anche grandi banditi.

Sei il capostazione della stazione di Denver e devi gestire i treni. Ci sono tre direttrici principali, Colorado Springs, Fort Collins e New York:

  • da Colorado Springs arrivano sempre esattamente 1 vagone di carbone, 3 di minerali e 3 di persone alternati

  • da Fort Collins arrivano sempre esattamente 2 vagoni di carbone, 2 di persone e 2 di bestiame

Quando i treni arrivano a Denver, il loro contenuto viene trasferito nei vagoni vuoti del treno per New York così:

  • per impedire il compiersi di furti al treno, tutti i vagoni preziosi vanno posizionati vicino alla locomotiva

  • il bestiame va sempre messo dietro le persone, perchè per quanto l’igiene nel west sia carente è comunque più facile pretendere che gli umani si lavino piuttosto che il bestiame

Scrivi del codice che MODIFICA new_york copiando le stringhe da colorado e fort.

  • MINIMIZZA il numero di assegnazioni! (la soluzione migliore ha solamente due assegnazioni!)

Esempio - dati:

[83]:
colorado = ["locomotiva CS","carbone", "cowboy",    "oro","minatori",   "oro","cowboy","argento"]
fort     = ["locomotiva FC","carbone","carbone","signori",    "dame","mucche","cavalli"]
new_york = ["locomotiva NY","carbone",       "",       "",        "",      "",       "",      "", "","",""]

dopo il tuo codice deve risultare:

>>> print(new_york)
['locomotiva NY', 'carbone', 'oro', 'oro', 'argento', 'cowboy', 'minatori', 'cowboy', 'signori', 'dame', 'mucche', 'cavalli']
Mostra soluzione
[84]:

           # 0               1         2          3        4          5        6        7         8  9  10
colorado = ["locomotiva CS","carbone", "cowboy",    "oro","minatori",   "oro","cowboy","argento"]
fort     = ["locomotiva FC","carbone","carbone","signori",    "dame","mucche","cavalli"]
new_york = ["locomotiva NY","carbone",       "",       "",        "",      "",       "",      "", "","",""]

# scrivi qui


Liste di liste

NOTA: Parleremo molto più nel dettaglio delle liste di liste nel tutorial Matrici - liste di liste, questa è solo un’introduzione sommaria.

Le considerazioni viste per le liste di stringhe valgono anche per una lista di liste:

[85]:
coppie = [          # lista esterna
            [67,95],    # lista interna ad indice 0
            [60,59],    # lista interna ad indice 1
            [86,75],    # lista interna ad indice 2
            [96,90],    # lista interna ad indice 3
            [88,87],    # lista interna ad indice 4
         ]

Se vogliamo estrarre il numero 90, dobbiamo prima estrarre la sottolista all’indice 3:

[86]:
coppie[3]   # NOTA: il risultato di questa espressione è una lista
[86]:
[96, 90]

e quindi dalla sottolista estratta (che ha solo due elementi) possiamo recuperare il numero all’indice 0:

[87]:
coppie[3][0]
[87]:
96

e all’indice 1:

[88]:
coppie[3][1]
[88]:
90

Esercizio - coppie

  1. Scrivi il codice per recuperare e stampare il numero 86, il 67 e l’87

  2. Date una riga con indice i e una colonna j, stampare il numero alla riga i e colonna j moltiplicato per il numero alla riga successiva e stessa colonna

Dopo il tuo codice, dovresti veder stampato:

punto 1: 86 67 87

punto 2: 7830
Mostra soluzione
[89]:
coppie = [           # lista esterna
            [67,95],    # lista interna ad indice 0
            [60,59],    # lista interna ad indice 1
            [86,75],    # lista interna ad indice 2
            [96,90],    # lista interna ad indice 3
            [88,87],    # lista interna ad indice 4
         ]

i = 3
j = 1

# scrivi qui


Esercizio - Gloria ai Gladiatori!

I gladiatori lottano per la gloria della battaglia e per il divertimento dell’imperatore e del popolo!

Non tutti i gladiatori riescono a… beh… combattere lo stesso numero di battaglie.

Per ogni combattimento, ogni gladiatore riceve un compenso in sesterzi (in caso non sia sopravissuto, verrà offerto al suo patrono…)

Alla fine dei giochi, l’imperatore getta un premio in sesterzi al gladiatore favorito. L’imperatore ha però scarsa mira e le sue deboli braccia non gli consentono di tirare tutto in un colpo solo, quindi finisce sempre per tirare metà malloppo al gladiatore giusto e metà al gladiatore subito dopo.

  • NOTA: L’imperatore non può premiare l’ultimo della lista perchè è troppo lontano

Data un premio e una lista gladiatori di sottoliste di lunghezza arbitraria, e un gladiatore ad indice i, scrivi del codice che MODIFICA le sottoliste di gladiatori alla riga i e alla successiva in modo che l’ultimo elemento di entrambe le liste venga aumentato di metà premio.

  • il tuo codice deve funzionare con qualunque premio, gladiatori e qualunque i

Esempio - dati:

gladiatori

Dopo il tuo codice, scrivendo (usiamo pprint perchè così la stampa avverrà su più linee)

from pprint import pprint
pprint(gladiatori,width=30)

deve stampare:

[[67, 95],
 [60, 23, 23, 13, 79],
 [86, 95],
 [96, 90, 92],
 [88, 87]]
Mostra soluzione
[90]:

premio = 40                      # sesterzi

gladiatori = [                   # lista esterna
               [67,95],          # lista interna ad indice 0
               [60,23,23,13,59], # lista interna ad indice 1
               [86,75],          # lista interna ad indice 2
               [96,90,92],       # lista interna ad indice 3
               [88,87],          # lista interna ad indice 4
             ]

i = 1                            # gladiatore da premiare

# scrivi qui


Operatore in

Per verificare se un oggetto è contenuto in una lista, possiamo usare l’operatore in.

Nota che il risultato di questa espressione è un booleano:

[91]:
9 in [6,8,9,7]
[91]:
True
[92]:
5 in [6,8,9,7]
[92]:
False
[93]:
"mela" in ["anguria","mela","banana"]
[93]:
True
[94]:
"carota" in ["anguria","banana","mela"]
[94]:
False

Non abusare in

ATTENZIONE: in viene spesso usato in modo errato / inefficiente

Chiediti sempre:

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

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

  3. se vogliamo sapere se un elemento è in una posizione nota a priori (es 3), in non ci serve, basta scrivere lista[3] == elemento. Usando in potremmo trovare elementi duplicati che stanno prima o dopo di quello che vogliamo verificare!

DOMANDA: Questa espressione cosa restituisce? True o False?

True in [ 5 in [6,7,5],
          2 in [8,1]
        ]
Mostra risposta

not in

Possiamo scrivere la verifica di non appartenza in due forme:

Forma 1:

[95]:
"carota" not in ["anguria","banana","mela"]
[95]:
True
[96]:
"anguria" not in ["anguria","banana","mela"]
[96]:
False

Forma 2:

[97]:
not "carota" in ["anguria","banana","mela"]
[97]:
True
[98]:
not "anguria" in ["anguria","banana","mela"]
[98]:
False

DOMANDA: Data qualunque elmento x e lista y , la seguente espressione cosa restituisce?

x in y and not x in y
  1. False

  2. True

  3. False oppure True a seconda dei valori di x e y

  4. un errore

Mostra risposta

DOMANDA: Per ciascuna delle seguenti espressioni, provare a indovinare il risultato

  1. 3 in [3]
    
  2. [4,5] in [1,2,3,4,5]
    
  3. [4,5] in [[1,2,3],[4,5]]
    
  4. [4,5] in [[1,2,3,4],[5,6]]
    
  5. 'a' in ['prova'[-1]]
    
  6. 'ghe' in 'paghe'[1:4]
    
  7. [] in [[[]]]
    
  8. [] in [[]]
    
  9. [] in ["[]"]
    

DOMANDA: Per ciascuna delle seguenti espressioni, indipendentemente dal valore di x, dire se risulta sempre True :

  1. x in x
    
  2. x in [x]
    
  3. x not in []
    
  4. x in [[x]]
    
  5. x in [[x][0]]
    
  6. (x and y) in [x,y]
    
  7. x in [x,y] and y in [x,y]
    

Esercizio - ortaggi

Date le lista ortaggi di esattamente 5 stringhe e la lista di stringhe frutta, MODIFICARE la variabile ortaggi in modo che in ogni cella vi sia True se l’ortaggio è un frutto oppure False altrimenti.

  • il tuo codice deve funzionare con qualsiasi lista di 5 stringhe ortaggi e qualsiasi lista frutta

Esempio - dati:

ortaggi = ["carota",
           "cavolfiore",
           "mela",
           "melanzana",
           "anguria"]

frutta = ["anguria","banana","mela",]

dopo l’esecuzione del tuo codice deve stampare:

>>> print(ortaggi)
[False, False, True, False, True]
Mostra soluzione
[99]:
ortaggi = ["carota",
           "cavolfiore",
           "mela",
           "melanzana",
           "anguria"]

frutta = ["anguria","banana","mela",]

# scrivi qui


Concatenazione di liste con +

Date due liste la e lb, possiamo concatenarle con l’operatore + che produce una NUOVA lista:

[100]:
la = [70,60,80]
lb = [90,50]

la + lb
[100]:
[70, 60, 80, 90, 50]

Nota bene che l’operatore + produce una NUOVA lista, quindi la ed lb sono rimaste immutate:

[101]:
print(la)
[70, 60, 80]
[102]:
print(lb)
[90, 50]

Vediamo meglio con Python Tutor:

[103]:
la = [70,60,80]
lb = [90,50]
lc = la + lb

print(la)
print(lb)
print(lc)

jupman.pytut()
[70, 60, 80]
[90, 50]
[70, 60, 80, 90, 50]
[103]:

Esercizio - concatenazione

Scrivere del codice che date due liste la e lb, mette nella lista lc gli ultimi due elementi di la e i primi due elementi di lb

Esempio - date:

la = [18,26,30,45,55]
lb = [16,26,37,45]

dopo il tuo codice deve risultare:

>>> print(la)
[18, 26, 30, 45, 55]
>>> print(lb)
[16, 26, 37, 45]
>>> print(lc)
[45, 55, 16, 26]
Mostra soluzione
[104]:

la = [18,26,30,45,55]
lb = [16,26,37,45]

# scrivi qui


DOMANDA: Per ciascuna delle seguenti espressioni, provare a indovinare il risultato

  1. [6,7,8] + [9]
    
  2. [6,7,8] + []
    
  3. [] + [6,7,8]
    
  4. [] + []
    
  5. [] + [[]]
    
  6. [[]]+[]
    
  7. [[]]+[[]]
    
  8. ([6] + [8])[0]
    
  9. ([6] + [8])[1]
    
  10. ([6] + [8])[2:]
    
  11. len([4,2,5])+len([3,1,2])
    
  12. len([4,2,5] + [3,1,2])
    
  13. [5,4,3] + "3,1"
    
  14. [5,4,3] + "[3,1]"
    
  15. "[5,4,3]" + "[3,1]"
    
  16. ["4","1","7"] + ["3","1"]
    
  17. list('coca') + ['c','o','l','a']
    

min e max

Una lista è una sequenza di elementi, e come tale la possiamo passare alla funzione min o max per trovare rispettivamente il minimo o massimo elemento della lista.

[105]:
min([4,5,3,7,8,6])
[105]:
3
[106]:
max([4,5,3,7,8,6])
[106]:
8

ATTENZIONE: MAI CHIAMARE VARIABILI min O max

Facendolo, finiresti per sovrascrivere le funzioni e al momento di chiamarle otterresti errori molto strani !

Notare che è anche possibile passare direttamente a min e max gli elementi da comparare senza includerli in una lista:

[107]:
min(4,5,3,7,8,6)
[107]:
3
[108]:
max(4,5,3,7,8,6)
[108]:
8

Ma se ne passiamo uno solo, senza includerlo in una lista, otterremo un errore:

min(4)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-156-bb3db472b52e> in <module>
----> 1 min(4)

TypeError: 'int' object is not iterable

L’errore ci comunica che quando passiamo un solo argomento, Python si aspetta che sia una lista:

[109]:
min([4])
[109]:
4

A min e max possiamo anche passare stringhe, e ci verrà tornato il carattere alfabeticamente rispettivamente minore o maggiore :

[110]:
min("sportello")
[110]:
'e'
[111]:
max("sportello")
[111]:
't'

Se passiamo una lista di stringhe, otterremo la stringa minore o maggiore in ordine lessicografico (per intenderci, quello dell’elenco telefonico):

[112]:
min(['il','marinaio','cammina','per','le','vie','del','porto'])
[112]:
'cammina'
[113]:
max(['il','marinaio','cammina','per','le','vie','del','porto'])
[113]:
'vie'

DOMANDA: Per ciascuna delle seguenti espressioni, prova a indovinare il risultato (o se da un errore)

  1. max(7)
    
  2. max([7])
    
  3. max([5,4,6,2])
    
  4. max([min([7,3])])
    
  5. max([])
    
  6. max(2,9,3)
    
  7. max([3,2,5] + [9,2,3])
    
  8. max(max([3,2,5], max([9,2,3]))
    
  9. max(min(3,6), min(8,2))
    
  10. min(max(3,6), max(8,2))
    
  11. max(['a','b','d','c'])
    
  12. max(['barca', 'dado', 'aloa', 'cerchio'])
    
  13. min(['prova','','z','v'])
    
  14. max(['martello'[-1],'cacciavite'[-1],'brugola'[-1]])
    
  15. min(['martello'[-1],'cacciavite'[-1],'brugola'[-1]])
    

sum

Con sum possiamo sommare tutti gli elementi di una lista:

[114]:
sum([1,2,3])
[114]:
6
[115]:
sum([1.0, 2.0, 0.14])
[115]:
3.14

ATTENZIONE: MAI CHIAMARE VARIABILI sum

Facendolo, finiresti per sovrascrivere la funzione e al momento di chiamarle otterresti errori molto strani !

DOMANDA: Per ciascuna delle seguenti espressioni, prova a indovinare il risultato (o se da un errore)

  1. sum[3,1,2]
    
  2. sum(1,2,3)
    
  3. la = [1,2,3]
    sum(la) > max(la)
    
  4. la = [1,2,3]
    sum(la) > max(la)*len(la)
    
  5. la = [4,2,6,4,7]
    lb = [max(la), min(la), max(la)]
    print(max(lb) != max(la))
    

Esercizio - bilancia

Data una lista di n numeri bilancia con n pari, scrivere del codice che stampa True se la somma di tutti i primi n/2 numeri è uguale alla somma di tutti i successivi

  • il tuo codice deve funzionare per qualunque lista di numeri

Esempio 1 - dati:

bilancia = [4,3,7,1,5,8]

dopo il tuo codice, deve stampare

True

Esempio 2 - dati:

bilancia = [4,3,3,1,9,8]

dopo il tuo codice, deve stampare

False
Mostra soluzione
[116]:
bilancia = [4,3,7,1,5,8]
#bilancia = [4,3,3,1,9,8]

# scrivi qui


[116]:
True

Moltiplicazione per liste

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

[117]:
[7,6,8] * 2
[117]:
[7, 6, 8, 7, 6, 8]
[118]:
[7,6,8] * 3
[118]:
[7, 6, 8, 7, 6, 8, 7, 6, 8]

Notare che viene prodotta una NUOVA lista, e quella originale non viene modificata:

[119]:
la = [7,6,8]
[120]:
lb = [7,6,8] * 3
[121]:
la   # originale
[121]:
[7, 6, 8]
[122]:
lb   # risultato dell'espressione
[122]:
[7, 6, 8, 7, 6, 8, 7, 6, 8]

Possiamo moltiplicare una lista di stringhe:

[123]:
la = ["un", "mondo", "di", "parole"]
[124]:
lb = la * 2
[125]:
print(la)
['un', 'mondo', 'di', 'parole']
[126]:
print(lb)
['un', 'mondo', 'di', 'parole', 'un', 'mondo', 'di', 'parole']

Finchè moltiplichiamo liste che contengono elementi immutabili come numeri o stringhe, non si presentano particolari problemi:

[127]:
la = ["un", "mondo", "di", "parole"]
lb = la * 2

jupman.pytut()
[127]:

La questione diventa molto più complicata quando moltiplichiamo liste che contengono oggetti mutabili come altre liste. Vediamo un esempio:

[128]:
la = [5,6]
lb = [7,8,9]
lc = [la,lb] * 2
[129]:
print(la)
[5, 6]
[130]:
print(lb)
[7, 8, 9]
[131]:
print(lc)
[[5, 6], [7, 8, 9], [5, 6], [7, 8, 9]]

Stampando, vediamo che le liste la e lb si ripresentano all’interno di lc - ma esattamente, come? Le print possono ingannare sull’effettivo stato della memoria - per indagare meglio conviene usare Python Tutor:

[132]:
la = [5,6]
lb = [7,8,9]
lc = [la,lb] * 2

jupman.pytut()
[132]:

Arggh ! Vedrai apparire una giungla di frecce ! Questo perchè quando scriviamo [la, lb] creiamo una lista con due riferimenti alle liste [5,6] e [7,8,9], e l’operatore * mentre duplica copia i riferimenti.

Per il momento ci fermiamo qui, vedremo meglio le implicazioni in seguito nel tutorial matrici - liste di liste.

Uguaglianza

Possiamo verificare se due liste sono uguali con l’operatore di uguaglianza ==, che date due liste ritorna True se contengono elementi uguali oppure False altrimenti.

[133]:
[4,3,6] == [4,3,6]
[133]:
True
[134]:
[4,3,6] == [4,3]
[134]:
False
[135]:
[4,3,6] == [4,3,6, 'ciao']
[135]:
False
[136]:
[4,3,6] == [2,2,8]
[136]:
False

Possiamo verificare l’uguaglianza di liste con elementi eterogenei:

[137]:
['mele', 3, ['ciliegie', 2], 6] == ['mele', 3, ['ciliegie', 2], 6]
[137]:
True
[138]:
['banane', 3,['ciliegie', 2], 6] == ['mele', 3, ['ciliegie', 2], 6]
[138]:
False

Per verificare la disuguaglianza, possiamo usare l’operatore !=:

[139]:
[2,2,8] != [2,2,8]
[139]:
False
[140]:
[4,6,0] != [2,2,8]
[140]:
True
[141]:
[4,6,0] != [4,6,0,2]
[141]:
True

DOMANDA: Per ciascuna delle seguenti espressioni, indovinare se è True, False o produce un errore

  1. [2,3,1] != [2,3,1]
    
  2. [4,8,12] == [2*2,4*2,6*2]
    
  3. [7,8][:] == [7,9-1]
    
  4. [7][0] == [[7]][0]
    
  5. [9] == [9][0]
    
  6. [max(7,9)] == [max([7]),max([9])]
    
  7. ['a','b','c'] == ['A','B','C']
    
  8. ['a','b'] != ['a','b','c']
    
  9. ["ciao"] != ["CIAO".lower()]
    
  10. [True in [True]] != [False]
    
  11. [][:] == []
    
  12. [[]] == [] + []
    
  13. [[],[]] == [] + []
    
  14. [[[]]] == [[[]+[]]]
    

Prosegui

Trovi ulteriori esercizi nel foglio Liste 3

[ ]: