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 = [77, 69, 95, 57]

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

[11]:
la[0]
[11]:
77
[12]:
la[1]
[12]:
69
[13]:
la[2]
[13]:
95
[14]:
la[3]
[14]:
57

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 = [77, 69, 95, 57]
[16]:
la[-1]
[16]:
57
[17]:
la[-2]
[17]:
95
[18]:
la[-3]
[18]:
69
[19]:
la[-4]
[19]:
77

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

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:

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

Possiamo scrivere così:

[21]:
la[2] = 5

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

Guardiamo meglio che succede in Python Tutor:

[23]:
# 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
[24]:
#     0  1  2  3
la = [7, 9, 6, 8]
la[2] = 5

jupman.pytut()
[24]:

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

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

[25]:
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 !

[26]:
lb = la
[27]:
print(la)  # la è sempre lo stesso
[7, 9, 6]
[28]:
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:

[29]:
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 !

[30]:
print(la)
[5, 9, 6]
[31]:
print(lb)
[5, 9, 6]

Guardiamo meglio che succede in Python Tutor:

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

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:

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

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
[34]:
la = [8,7,7]
lb = [9,6,7,5]
lc = lb
la = lb
#print('la è', la)
#print('lb è', lb)
#print('lc è', lc)
jupman.pytut()
[34]:

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

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:

[36]:
     #0  1  2  3  4  5  6  7  8  9
la = [43,35,82,75,93,12,43,28,54,65]
[37]:
la[3:7]
[37]:
[75, 93, 12, 43]

Abbiamo estratto una NUOVA lista [75, 93, 12, 43] a partire della lista la partendo dall’indice 3 INCLUSO fino all’indice 7 ESCLUSO. Possiamo vedere che la lista originale si è preservata:

[38]:
la
[38]:
[43, 35, 82, 75, 93, 12, 43, 28, 54, 65]

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

[39]:
#     0  1  2  3  4  5  6  7  8  9
la = [43,35,82,75,93,12,43,28,54,65]
lb = la[3:7]

jupman.pytut()
[39]:

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:

[40]:
#0  1  2  3  4
[58,97,76,87,99][0:3]  # da indice 0 *incluso* a 3 *escluso*
[40]:
[58, 97, 76]
[41]:
#0  1  2  3  4
[58,97,76,87,99][0:4]  # da indice 0 *incluso* a 4 *escluso*
[41]:
[58, 97, 76, 87]
[42]:
#0  1  2  3  4
[58,97,76,87,99][0:5]  # da indice 0 *incluso* a 5 *escluso*
[42]:
[58, 97, 76, 87, 99]
[43]:
#0  1  2  3  4
[58,97,76,87,99][0:6]   # se andiamo oltre la lunghezza della lista Python non si arrabbia
[43]:
[58, 97, 76, 87, 99]
[44]:
#0  1  2  3  4
[58,97,76,87,99][8:12]   # anche se partiamo da indici inesistenti Python non si arrabbia
[44]:
[]

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

Slice - omissione limiti

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

[45]:
#0  1  2  3  4  5  6  7  8  9
[98,67,85,77,65,99,67,55,79][:3]
[45]:
[98, 67, 85]

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

[46]:
#0  1  2  3  4  5  6  7  8  9
[98,67,85,77,65,99,67,55,79][3:]
[46]:
[77, 65, 99, 67, 55, 79]

Omettendo entrambi gli indici si ottiene l’intera lista:

[47]:
#0  1  2  3  4  5  6  7  8  9
[98,67,85,77,65,99,67,55,79][:]
[47]:
[98, 67, 85, 77, 65, 99, 67, 55, 79]

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
[48]:
la = [7,8,9]
lb = la[:]
lb[0] = 6
#print('la =',la)
#print('lb =',lb)

jupman.pytut()
[48]:

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

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

Slice - limiti negativi

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

[49]:
#0  1  2  3  4  5  6
[73,48,19,57,64,15,92][3:0]   # da indice 3 a indici positivi <= 3 non produce nulla
[49]:
[]
[50]:
#0  1  2  3  4  5  6
[73,48,19,57,64,15,92][3:1]   # da indice 3 a indici positivi <= 3 non produce nulla
[50]:
[]
[51]:
#0  1  2  3  4  5  6
[73,48,19,57,64,15,92][3:2]  # da indice 3 a indici positivi <= 3 non produce nulla
[51]:
[]
[52]:
#0  1  2  3  4  5  6
[73,48,19,57,64,15,92][3:3]  # da indice 3 a indici positivi <= 3 non produce nulla
[52]:
[]

Vediamo cosa succede con indici negativi:

[53]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][3:-1]
[53]:
[57, 64, 15]
[54]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][3:-2]
[54]:
[57, 64]
[55]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][3:-3]
[55]:
[57]
[56]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][3:-4]
[56]:
[]
[57]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][3:-5]
[57]:
[]

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:

[58]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][-7:3]
[58]:
[73, 48, 19]
[59]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][-6:3]
[59]:
[48, 19]
[60]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][-5:3]
[60]:
[19]
[61]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][-4:3]
[61]:
[]
[62]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][-3:3]
[62]:
[]
[63]:
# 0  1  2  3  4  5  6
#-7 -6 -5 -4 -3 -2 -1
[73,48,19,57,64,15,92][-2:3]
[63]:
[]

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]
    

Slice - modifica

Supponiamo di avere la lista

[64]:
     #0  1  2  3  4  5  6  7
la = [12,23,35,41,74,65,34,22]

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 [98,96,97]. Possiamo farlo con questa notazione speciale che ci consente di scrivere una slice alla sinistra dell’operatore =:

[65]:
la[3:6] = [98,96,97]
[66]:
la
[66]:
[12, 23, 35, 98, 96, 97, 34, 22]

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

[67]:
#     0  1  2  3  4  5  6  7
la = [12,23,35,41,74,65,34,22]
lb = la
lb[3:6] = [98,96,97]

jupman.pytut()
[67]:

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

Liste di stringhe

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

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

Proviamo ad estrarre una verdura scrivendo questa espressione:

[69]:
verdure[2]
[69]:
'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ì:

[70]:
'carote'[0]
[70]:
'c'

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

[71]:
verdure[2][0]
[71]:
'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']
Mostra soluzione
[72]:
sigle = ['tn','mi','to','ro']

# scrivi qui


Esercizio - giochi

Data una lista giochi di esattamente 3 stringhe, scrivere 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"]
Mostra soluzione
[73]:
giochi = ["Monopoli",
          "RISIKO",
          "Tombola"]


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

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

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

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

[76]:
coppie[3][0]
[76]:
96

e all’indice 1:

[77]:
coppie[3][1]
[77]:
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
[78]:
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 - nonunif

Data una lista nonunif di sottoliste di lunghezza arbitraria, e una riga ad indice i, scrivere del codice che MODIFICA le sottoliste di nonunif alla riga i e alla successiva in modo che l’ultimo elemento di entrambe le liste diventi 99.

  • il tuo codice deve funzionare con qualunque nonunif e qualunque i

Esempio 1 - date:

nonunif = [                   # 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

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

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

deve stampare:

[[67, 95],
 [60, 23, 23, 13, 99],
 [86, 99],
 [96, 90, 92],
 [88, 87]]
Mostra soluzione
[79]:
nonunif = [                   # 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

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

[80]:
9 in [6,8,9,7]
[80]:
True
[81]:
5 in [6,8,9,7]
[81]:
False
[82]:
"mela" in ["anguria","mela","banana"]
[82]:
True
[83]:
"carota" in ["anguria","banana","mela"]
[83]:
False

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:

[84]:
"carota" not in ["anguria","banana","mela"]
[84]:
True
[85]:
"anguria" not in ["anguria","banana","mela"]
[85]:
False

Forma 2:

[86]:
not "carota" in ["anguria","banana","mela"]
[86]:
True
[87]:
not "anguria" in ["anguria","banana","mela"]
[87]:
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
[88]:
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:

[89]:
la = [77,66,88]
lb = [99,55]

la + lb
[89]:
[77, 66, 88, 99, 55]

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

[90]:
print(la)
[77, 66, 88]
[91]:
print(lb)
[99, 55]

Vediamo meglio con Python Tutor:

[92]:
la = [77,66,88]
lb = [99,55]
lc = la + lb

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

jupman.pytut()
[77, 66, 88]
[99, 55]
[77, 66, 88, 99, 55]
[92]:

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, 37, 45]
Mostra soluzione
[93]:
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.

[94]:
min([4,5,3,7,8,6])
[94]:
3
[95]:
max([4,5,3,7,8,6])
[95]:
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:

[96]:
min(4,5,3,7,8,6)
[96]:
3
[97]:
max(4,5,3,7,8,6)
[97]:
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:

[98]:
min([4])
[98]:
4

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

[99]:
min("sportello")
[99]:
'e'
[100]:
max("sportello")
[100]:
't'

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

[101]:
min(['il','marinaio','cammina','per','le','vie','del','porto'])
[101]:
'cammina'
[102]:
max(['il','marinaio','cammina','per','le','vie','del','porto'])
[102]:
'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:

[103]:
sum([1,2,3])
[103]:
6
[104]:
sum([1.0, 2.0, 0.14])
[104]:
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
[105]:
bilancia = [4,3,7,1,5,8]
#bilancia = [4,3,3,1,9,8]

# scrivi qui


[105]:
True

Moltiplicazione per liste

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

[106]:
[7,6,8] * 2
[106]:
[7, 6, 8, 7, 6, 8]
[107]:
[7,6,8] * 3
[107]:
[7, 6, 8, 7, 6, 8, 7, 6, 8]

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

[108]:
la = [7,6,8]
[109]:
lb = [7,6,8] * 3
[110]:
la   # originale
[110]:
[7, 6, 8]
[111]:
lb   # risultato dell'espressione
[111]:
[7, 6, 8, 7, 6, 8, 7, 6, 8]

Possiamo moltiplicare una lista di stringhe:

[112]:
la = ["un", "mondo", "di", "parole"]
[113]:
lb = la * 2
[114]:
print(la)
['un', 'mondo', 'di', 'parole']
[115]:
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:

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

jupman.pytut()
[116]:

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

[117]:
la = [5,6]
lb = [7,8,9]
lc = [la,lb] * 2
[118]:
print(la)
[5, 6]
[119]:
print(lb)
[7, 8, 9]
[120]:
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:

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

jupman.pytut()
[121]:

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.

[122]:
[4,3,6] == [4,3,6]
[122]:
True
[123]:
[4,3,6] == [4,3]
[123]:
False
[124]:
[4,3,6] == [4,3,6, 'ciao']
[124]:
False
[125]:
[4,3,6] == [2,2,8]
[125]:
False

Possiamo verificare l’uguaglianza di liste con elementi eterogenei:

[126]:
['mele', 3, ['ciliegie', 2], 6] == ['mele', 3, ['ciliegie', 2], 6]
[126]:
True
[127]:
['banane', 3,['ciliegie', 2], 6] == ['mele', 3, ['ciliegie', 2], 6]
[127]:
False

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

[128]:
[2,2,8] != [2,2,8]
[128]:
False
[129]:
[4,6,0] != [2,2,8]
[129]:
True
[130]:
[4,6,0] != [4,6,0,2]
[130]:
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. [][:] == []
    
  4. [[]] == [] + []
    
  5. [[],[]] == [] + []
    
  6. [[[]]] == [[[]+[]]]
    
  7. [7,8][:] == [7,9-1]
    
  8. [7][0] == [[7]][0]
    
  9. [9] == [9][0]
    
  10. [max(7,9)] == [max([7]),max([9])]
    
  11. ['a','b','c'] == ['A','B','C']
    
  12. ['a','b'] != ['a','b','c']
    
  13. ["ciao"] != ["CIAO".lower()]
    
  14. [True in [True]] != [False]
    

Prosegui

Trovi ulteriori esercizi nel foglio Liste 3

[ ]: