Liste 1 - Introduzione

Scarica zip esercizi

Naviga file online

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.

Riferimenti

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 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. Gli esercizi sono graduati per difficoltà, da una stellina ✪ a quattro ✪✪✪✪

Scorciatoie da tastiera:

  • Per eseguire il codice Python dentro una cella di Jupyter, premi Control+Invio

  • Per eseguire il codice Python dentro una cella di Jupyter E selezionare la cella seguente, premi Shift+Invio

  • Per eseguire il codice Python dentro una cella di Jupyter E creare una nuova cella subito dopo, premi Alt+Invio

  • Se per caso il Notebook sembra inchiodato, prova a selezionare Kernel -> Restart

Creare 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: prova a scrivere la lista qua sopra SENZA mettere una virgola dopo il 5, che errore appare?

[14]:
# scrivi qui


Una lista può anche contenere altre liste:

[15]:
tabella = [  ['a','b','c'],  ['d','e','f']  ]

Tipicamente, quando abbiamo strutture come questa, conviene disporle su più righe (non è obbligatorio ma conviene per chiarezza):

[16]:
tabella = [                 # inizio listona esterna
            ['a','b','c'],    # lista interna 1
            ['d','e','f']     # lista interna 2
          ]                 # fine listona esterna
[17]:
tabella
[17]:
[['a', 'b', 'c'], ['d', 'e', 'f']]

Vediamo come viene mostrata in Python Tutor:

[18]:
tabella = [
            ['a','b','c'],
            ['d','e','f']
          ]

jupman.pytut()
[18]:

Come detto in precedenza, in una lista possiamo mettere gli elementi che vogliamo, quindi possiamo mischiare liste di dimensioni diverse, stringhe, numeri, etc:

[19]:
ditutto = [
               ['ciao',3,'mondo'],
               'una stringa',
               [9,5,6,7,3,4],
               8,
         ]
[20]:
print(ditutto)
[['ciao', 3, 'mondo'], 'una stringa', [9, 5, 6, 7, 3, 4], 8]

Vediamo anche come appare in Python Tutor:

[21]:
ditutto = [
               ['ciao',3,'mondo'],
               'una stringa',
               [9,5,6,7,3,4],
               8,
         ]

jupman.pytut()
[21]:

Lista vuota

Ci sono due modi per creare una lista vuota.

  1. con parentesi quadre:

[22]:
lista_vuota = []
[23]:
lista_vuota
[23]:
[]
  1. Oppure con list():

[24]:
altra_lista_vuota = list()
[25]:
altra_lista_vuota
[25]:
[]

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:

[26]:
a = []
b = []

jupman.pytut()
[26]:

Nota che sono apparse due frecce che puntano a regioni di memoria differenti. Lo stesso sarebbe accaduto inizializzando le liste con degli elementi:

[27]:
la = [8,6,7]
lb = [9,5,6,4]

jupman.pytut()
[27]:

E avremmo avuto due liste in regioni di memoria diverse anche mettendo elementi identici dentro le liste:

[28]:
la = [8,6,7]
lb = [8,6,7]

jupman.pytut()
[28]:

Le cose si complicano quando cominciamo ad usare operazioni di assegnazione:

[29]:
la = [8,6,7]
[30]:
lb = [9,5,6,4]
[31]:
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:

[32]:
la = [8,6,7]
lb = [9,5,6,4]
lb = la

jupman.pytut()
[32]:

ESERCIZIO: 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 ed lc

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]
Mostra soluzione
[33]:
la = [9,6,1]
lb = [2,3,4,3,5]
lc = None

# scrivi qui


DOMANDA: 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]:
Mostra risposta

Esercizio - creare liste 1

Date due variabili

la = [4,3]
lb = [9,6,7]

Scrivi del codice che stampi la lista [[4, 3], [[9, 6, 7], [4, 3], [9, 6, 7]], [4, 3]]

  • NON scrivere numeri, usa solo liste di variabili

Mostra soluzione
[36]:
la = [4,3]
lb = [9,6,7]

# scrivi qui


[[4, 3], [[9, 6, 7], [4, 3], [9, 6, 7]], [4, 3]]

Esercizio - creare liste 2

Inserire dei valori nelle liste la, lb tali per cui

print([[la,la],[lb,la]])

stampi

[[[8, 4], [8, 4]], [[4, 8, 4], [8, 4]]]
  • inserire solo dei NUMERI

  • Osservare in Python Tutor come vengono raffigurate le frecce

[37]:
la = []  # inserisci dei numeri
lb = []  # inserisci dei numeri

print([[la,la],[lb,la]])
[[[], []], [[], []]]
Mostra soluzione
[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]]
  • inseriri solo NUMERI oppure NUOVE LISTE DI NUMERI

  • Osservare 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])
[[[], [], [[], []]], []]
Mostra soluzione
[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 o lc

  • 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])
[[[], [], []], []]
Mostra soluzione
[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']]
Mostra soluzione
[46]:
s = 'GuLp'

# scrivi qui


[['g', 'u', 'l', 'p'], ['G', 'U', 'L', 'P']]

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

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

Esercizio - garaga

Date

sa = "ga"
sb = "ra"
la = ['ga']
lb = list(la)
  • Assegnare 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]:
Mostra soluzione
[48]:

[['g', 'a', 'r', 'a'], ['ga'], ['ga'], ['r', 'a', 'g', 'a']]
[48]:

Continua

Prosegui con il foglio Liste 2 - Operatori

[ ]: