Liste 1 - Introduzione
Scarica zip esercizi
Una lista in Python è una sequenza di elementi eterogenei mutabile, in cui possiamo mettere gli oggetti che vogliamo. L’ordine in cui li mettiamo viene preservato.
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
lists5-chal.ipynb
jupman.py
ATTENZIONE: Per essere visualizzato correttamente, il file del notebook DEVE essere nella cartella szippata.
apri il Jupyter Notebook da quella cartella. Due cose dovrebbero aprirsi, prima una console e poi un browser. Il browser dovrebbe mostrare una lista di file: naviga la lista e apri il notebook
lists1.ipynb
Prosegui leggendo il file degli esercizi, ogni tanto al suo interno troverai delle scritte ESERCIZIO, che ti chiederanno di scrivere dei comandi Python nelle celle successive.
Scorciatoie da tastiera:
Per eseguire il codice Python dentro una cella di Jupyter, premi
Control+Invio
Per eseguire il codice Python dentro una cella di Jupyter E selezionare la cella seguente, premi
Shift+Invio
Per eseguire il codice Python dentro una cella di Jupyter E creare una nuova cella subito dopo, premi
Alt+Invio
Se per caso il Notebook sembra inchiodato, prova a selezionare
Kernel -> Restart
Creare liste
Possiamo creare una lista specificando tra parentesi quadre gli elementi che contiene, e separandoli da una virgola.
Per esempio, in questa lista inseriamo i numeri 7
, 4
e 9
:
[2]:
[7,4,9]
[2]:
[7, 4, 9]
Come tutti gli oggetti in Python, possiamo associarli ad una variabile, in questo caso ce ne inventiamo una chiamata lista
:
[3]:
lista = [7,4,9]
[4]:
lista
[4]:
[7, 4, 9]
Vediamo meglio che succede in memoria, e compariamo la rappresentazione delle stringhe con quella delle liste:
[5]:
# 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
[6]:
stringa = "prova"
lista = [7,4,9]
jupman.pytut()
[6]:
Notiamo subito una differenza rilevante. La stringa è rimasta nella regione azzurra dove appaiono le associazioni tra variabili e valori, invece dalla variabile lista
parte una freccia che punta ad una nuova regione gialla di memoria, che si crea non appena l’esecuzione raggiunge la riga che definisce la lista.
In seguito approfondiremo meglio le conseguenze di ciò.
In una lista gli stessi elementi possono apparire più volte
[7]:
numeri = [1,2,3,1,3]
[8]:
numeri
[8]:
[1, 2, 3, 1, 3]
In una lista possiamo mettere qualunque elemento, per es. le stringhe:
[9]:
frutti = ["mela", "pera", "pesca", "fragola", "ciliegia"]
[10]:
frutti
[10]:
['mela', 'pera', 'pesca', 'fragola', 'ciliegia']
Possiamo anche mischiare i tipi di oggetti contenuti in una lista, per esempio possiamo avere interi e stringhe:
[11]:
misto = ["tavolo", 4 ,"sedia", 8, 5, 1, "sedia"]
In Python Tutor apparirà così:
[12]:
misto = ["tavolo", 5 , 4, "sedia", 8, "sedia"]
jupman.pytut()
[12]:
Per comodità possiamo anche scrivere la lista su più righe (gli spazi in questo caso non contano, ricordati solo di terminare le righe con delle virgole ,
)
[13]:
misto = ["tavolo",
5 ,
4,
"sedia",
8,
"sedia"]
Esercizio - proviamo l’errore
Prova a scrivere la lista qua sopra SENZA mettere una virgola dopo il 5, che errore appare?
[14]:
# scrivi qui
Lista vuota
Ci sono due modi per creare una lista vuota.
con parentesi quadre:
[15]:
lista_vuota = []
[16]:
lista_vuota
[16]:
[]
Oppure con
list()
:
[17]:
altra_lista_vuota = list()
[18]:
altra_lista_vuota
[18]:
[]
ATTENZIONE: Quando crei una lista vuota (indipendentemente dalla notazione usata), in memoria viene allocata una NUOVA regione di memoria per accogliere la lista
Vediamo meglio cosa vuol dire con Python Tutor:
[19]:
a = []
b = []
jupman.pytut()
[19]:
Nota che sono apparse due frecce che puntano a regioni di memoria differenti. Lo stesso sarebbe accaduto inizializzando le liste con degli elementi:
[20]:
la = [8,6,7]
lb = [9,5,6,4]
jupman.pytut()
[20]:
E avremmo avuto due liste in regioni di memoria diverse anche mettendo elementi identici dentro le liste:
[21]:
la = [8,6,7]
lb = [8,6,7]
jupman.pytut()
[21]:
Le cose si complicano quando cominciamo ad usare operazioni di assegnazione:
[22]:
la = [8,6,7]
[23]:
lb = [9,5,6,4]
[24]:
lb = la
Scrivendo lb = la
, abbiamo detto a Python di ‘dimenticare’ l’assegnazione precedente di lb
a [9,5,6,4]
, e di associare invece lb
alla stesso valore già associato ad la
, cioè [8,6,7]
. Quindi, nella memoria vedremo una freccia che parte da lb
ed arriva a [8,6,7]
, e la regione di memoria dove stava la lista [9,5,6,4]
verrà rimossa (non è più associata ad alcuna variabile). Guardiamo che succede con Python Tutor:
[25]:
la = [8,6,7]
lb = [9,5,6,4]
lb = la
jupman.pytut()
[25]:
Esercizio - scambi di liste
Prova a scambiare le liste associate alle variabili la
ed lb
usando solo assegnazioni e senza creare nuove liste. Se vuoi, puoi sovrascrivere una terza variabile lc
. Verifica che succede con Python Tutor.
il tuo codice deve poter funzionare con qualunque valore di
la
,lb
edlc
Esempio - dati:
la = [9,6,1]
lb = [2,3,4,3,5]
lc = None
Dopo il tuo codice, deve risultare:
>>> print(la)
[2,3,4,3,5]
>>> print(lb)
[9,6,1]
[26]:
la = [9,6,1]
lb = [2,3,4,3,5]
lc = None
# scrivi qui
Tabelle
Una lista può anche contenere altre liste:
[27]:
tabella = [ ['a','b','c'], ['d','e','f'] ]
Tipicamente, quando abbiamo strutture come questa, conviene disporle su più righe (non è obbligatorio ma conviene per chiarezza):
[28]:
tabella = [ # inizio listona esterna
['a','b','c'], # lista interna 1
['d','e','f'] # lista interna 2
] # fine listona esterna
[29]:
tabella
[29]:
[['a', 'b', 'c'], ['d', 'e', 'f']]
Vediamo come viene mostrata in Python Tutor:
[30]:
tabella = [
['a','b','c'],
['d','e','f']
]
jupman.pytut()
[30]:
Come detto in precedenza, in una lista possiamo mettere gli elementi che vogliamo, quindi possiamo mischiare liste di dimensioni diverse, stringhe, numeri, etc:
[31]:
di_tutto = [
['ciao',3,'mondo'],
'una stringa',
[9,5,6,7,3,4],
8,
]
[32]:
print(di_tutto)
[['ciao', 3, 'mondo'], 'una stringa', [9, 5, 6, 7, 3, 4], 8]
Vediamo anche come appare in Python Tutor:
[33]:
di_tutto = [
['ciao',3,'mondo'],
'una stringa',
[9,5,6,7,3,4],
8,
]
jupman.pytut()
[33]:
Domanda - creazione di liste
Guarda questi due pezzi di codice. Per ciascun caso, prova a pensare come possono essere rappresentati in memoria e verifica poi con Python Tutor.
che differenza ci potrà essere?
quante celle di memoria verranno allocate in totale ?
quante frecce vedrai ?
# primo caso
lb = [
[8,6,7],
[8,6,7],
[8,6,7],
[8,6,7],
]
# secondo caso
la = [8,6,7]
lb = [
la,
la,
la,
la
]
[34]:
# primo caso
lb = [
[8,6,7],
[8,6,7],
[8,6,7],
[8,6,7],
]
jupman.pytut()
[34]:
[35]:
# secondo caso
la = [8,6,7]
lb = [
la,
la,
la,
la
]
jupman.pytut()
[35]:
Esercizio - domino
Nel tuo quartiere stanno organizzando un super torneo di domino, visto che il primo premio consiste in una tessera per ottenere 10 crostate dalla mitica Nonna Severina decidi di impegnarti seriamente.
Inizi a pensare a come allenarti e decidi di iniziare a accodare le tessere in maniera corretta.
tessera1 = [1,3]
tessera3 = [1,5]
tessera2 = [3,9]
tessera5 = [9,7]
tessera4 = [8,2]
Date queste tessere genera una lista che conterrà a sua volta due liste: nella prima inserisci una possibile sequenza di tessere collegate; nella seconda lista invece metti le tessere rimaste escluse dalla sequenza di prima.
Esempio:
[ [ [1, 3], [3, 9], [9, 7] ], [ [1, 5], [8, 2] ] ]
NON scrivere numeri
USA solo liste di variabili
[36]:
tessera1 = [1,3]
tessera2 = [3,2]
tessera3 = [1,5]
tessera4 = [2,4]
tessera5 = [3,3]
tessera6 = [5,4]
tessera7 = [1,2]
# scrivi qui
Esercizio - creare liste 2
Inserisci dei valori nelle liste la
, lb
tali per cui
print([[la,la],[lb,la]])
stampi
[[[8, 4], [8, 4]], [[4, 8, 4], [8, 4]]]
inserisci solo dei NUMERI
Osserva in Python Tutor come vengono raffigurate le frecce
[37]:
la = [] # inserisci dei numeri
lb = [] # inserisci dei numeri
print([[la,la],[lb,la]])
[[[], []], [[], []]]
[38]:
Esercizio - creare liste 3
Inserire dei valori come elementi delle liste la
, lb
e lc
tali per cui
print([[lb,lb,[lc,la]],lc])
stampi
[[[8, [7, 7]], [8, [7, 7]], [[8, 7], [8, 5]]], [8, 7]]
inseririsci solo NUMERI oppure NUOVE LISTE DI NUMERI
Osserva in Python Tutor come vengono raffigurate le frecce
[39]:
la = [] # inserisci elementi (numeri o liste di numeri)
lb = [] # inserisci elementi (numeri o liste di numeri)
lc = [] # inserisci elementi (numeri o liste di numeri)
print([[lb,lb,[lc,la]],lc])
[[[], [], [[], []]], []]
[40]:
Esercizio - creare liste 4
Inserire dei valori nelle liste la
, lb
tali per cui
print([[la,lc,la], lb])
stampi
[[[3, 2], [[3, 2], [8, [3, 2]]], [3, 2]], [8, [3, 2]]]
inserire solo NUMERI oppure VARIABILI
la
,lb
olc
Osservare in Python tutor come vengono raffigurate le frecce
[41]:
la = [] # inserisci numeri o variabili la, lb, lc
lb = [] # inserisci numeri o variabili la, lb, lc
lc = [] # inserisci numeri o variabili la, lb, lc
print([[la,lc,la], lb])
[[[], [], []], []]
[42]:
Convertire sequenze in liste
list
può anche servire per convertire una qualsiasi sequenza in una NUOVA lista. Un tipo di sequenza che già abbiamo visto sono le stringhe, quindi proviamo a vedere cosa succede se usiamo list
come fosse una funzione e gli passiamo come parametro una stringa:
[43]:
list("treno")
[43]:
['t', 'r', 'e', 'n', 'o']
Abbiamo ottenuto una lista in cui ogni elemento è costituito da un carattere della stringa originale.
Se invece chiamiamo list
su un’altra lista cosa succede?
[44]:
list( [7,9,5,6] )
[44]:
[7, 9, 5, 6]
Apparentemente, niente di particolare, otteniamo una lista con gli stessi elementi di partenza. Ma è proprio la stessa lista? Guardiamo meglio con Python Tutor:
[45]:
la = [7,9,5,6]
lb = list( la )
jupman.pytut()
[45]:
Notiamo che è stata creata una NUOVA regione di memoria con gli stessi elementi di la
.
Esercizio - gulp
Data una stringa con caratteri misti minuscoli e maiuscoli, scrivere del codice che crea una lista contente come primo elemento una lista coi caratteri della stringa tutti minuscoli e come secondo elemento una lista contenente tutti i caratteri maiuscoli
il tuo codice deve funzionare con qualunque stringa
se non ricordi i metodi delle stringhe, guarda qui
Esempio - dato
s = 'GuLp'
il tuo codice dovrà stampare
[['g', 'u', 'l', 'p'], ['G', 'U', 'L', 'P']]
[46]:
s = 'GuLp'
# scrivi qui
Domanda - maratona
Questo codice:
produce un errore o assegna qualcosa ad
x
?Dopo la sua esecuzione, quante liste rimangono in memoria?
Possiamo accorciarlo?
s = "maratona"
x = list(list(list(list(s))))
Domanda - catena
Questo codice:
produce un errore o assegna qualcosa ad
x
?Dopo la sua esecuzione, quante liste rimangono in memoria?
s = "catena"
a = list(s)
b = list(a)
c = b
x = list(c)
Esercizio - garaga
Date:
sa = "ga"
sb = "ra"
la = ['ga']
lb = list(la)
assegna ad lc
una lista costruita in modo che una volta stampata produca:
>>> print(lc)
[['g', 'a', 'r', 'a'], ['ga'], ['ga'], ['r', 'a', 'g', 'a']]
In Python Tutor, TUTTE le frecce dovranno puntare ad una regione di memoria diversa
[47]:
sa = "ga"
sb = "ra"
la = ['ga']
lb = list(la)
# inserire del codice nella lista
lc = []
print(lc)
jupman.pytut()
[]
[47]:
[48]:
[['g', 'a', 'r', 'a'], ['ga'], ['ga'], ['r', 'a', 'g', 'a']]
[48]:
Continua
Prosegui con il foglio Liste 2 - Operatori