Liste

La lista è una collezione ordinata di oggetti di qualsiasi tipo, come i tipi base, una collezione di qualsiasi tipo, oppure oggetti o funzioni, come vedremo più avanti.

list1 = [1,2,3]
list2 = [2, "two", [1,2,3]]

Gli elementi sono ordinati, e possono essere di tipo differente. E’ possibile sapere la lunghezza della lista con len:

print(len(list2)) # stampa 3

Per accedere ad un elemento si usa l’indice, cioè la posizione in cui compare nella lista:

print(list1[2]) # stampa 3
list1[0] = 4 # si memorizza in posizione 0 il valore 4

Gli indici partono sempre da 0. E’ possibile anche usare indici negativi, in questo caso si conta dall’ultimo elemento della lista:

list3 = ['a', 'b', 'c', 'd']
print(list3[-2]) # stampa 'c'

E’ possibile visualizzare una sottolista, operazione che viene chiamata slice, usando una coppia di indici, l’indice iniziale e quello finale: se si usa un come finale un valore positivo, si estrae fino al valore precedente. Se si usa un valore negativo, si estrae fino all’indice indicato. Se si omette l’indice iniziale si usa 0, se si omette quello finale, si usa len(nomedellalista):

print(list3[1:3]) # ['b', 'c']
print(list3[1:-1] # ['b', 'c']
print(:2) # ['a', 'b']
print(2:) # ['c', 'd']

Modifica

E’ possibile aggiungere elementi con le funzioni insert (in testa), append (in coda) e per cancellare le funzioni del e remove:

list4 = [1,2,3]
list4.insert(0, 5) # [5,1,2,3] il primo argomento è la posizione, il secondo il valore
list4.append(4) # [0,1,2,3,4] in coda
del(list4[2]) # [0,1,3,4] 
remove(4) # [0,1,3] ATTENZIONE, DA ERRORE SE NON TROVA NULLA

Le liste sono modificabili anche aggiungendo elementi usando coppie di indici:

list5 = [1,2,3,4]
list5[len(list4):] = [5,6,7] # [1,2,3,4,5,6,7] aggiunta in coda
list5[:0] = [-1, 0] # [-1,0, 1,2,3,4,5,6,7] aggiunta in testa

Con lo stesso sistema si possono togliere elementi:

list6 = [10,20,30,40]
list6[2:] = [] # [10,20]  

Operazioni comuni

Python offre una serie di funzioni utili sulle liste:

• reverse: inverte l’ordine della lista
• sort: ordina la lista
• in e count: in verifica se un elemento è nella lista, count indica quante volte compare
• +: concatena due liste
• *: permette di creare una lista di valori ripetuti
• min, max, sum: ottiene minimo, massimo e somma
• index: restituisce l’indice del primo elemento che corrisponde (oppure da errore)

Vediamo degli esempi:

list7 = [5,7,2,4,1]
list7.reverse() # [1,4,2,7,5]
list7.sort() # [1,2,4,5,7]
4 in list7 # True
list7.count(3) # 0, non compare mai
list7 + [6,3] # [1,2,4,5,7,6,3]
list8 = [3] * 3 # [3,3,3]
min(list7) # 1
max(list7) # 7
sum(list7) # 28
lista7.index(4) # 3 

Vediamo un esempio di programma con le liste.

Ciclo for con le liste

Il ciclo for può essere utilizzato per eseguire una operazione con tutti gli elementi di una lista.

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

for frutto in frutta: 
    print(frutto) 

Se serve sapere anche l’indice, si può usare enumerate

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

for indice, valore in enumerate(frutta):       
    print(f"Posizione {indice} valore: {valore}") 

Esempio

Per capire quanto sono utili tutti questi strumenti, scriviamo un semplice programma per gestire spese.

spese = []
fine = False

while not fine:
  print('''\nMenu
  1: inserisci spesa
  2: elimina spesa
  3: mostra totale spese
  0: esci''')
  scelta = int(input("Inserisci scelta: "))
  if scelta == 0:
    fine = True
  elif scelta == 1:
    spesa = float(input("Inserisci spesa: "))
    spese.append(spesa)
  elif scelta == 2:
    indice = int(input("Inserisci indice: "))
    del(spese[indice])
  elif scelta == 3:    
    print("\n\nINDICE\tSPESA")
    for indice, spesa in enumerate(spese):
      print(f"{indice}\t{spesa}")
    print(f"\nTotale: {sum(spese)}")

Liste annidate

Le liste possono essere anche annidate, cioè ogni elemento è una lista:

matrix = [[1,2],[3,4],[5,6]]

Per accedere ai singoli elementi:

print(matrix[2][1])
matrix[2][0] = 8

Possiamo stampare anche la tabella in modo incollato:

for row in matrix:
    print(*row) 

#
1 2
3 4
8 6

L’operatore * (unpacking) dice di considerare la riga come un array, e quindi lo stampa incolonnato.

E’ possibile avere quante dimensioni si vogliono, utili per risolvere problemi di algebra computazionale.

List comprehension

Le list comprehension sono un meccanismo, in pieno stile pitonico, per creare liste con un algoritmo di generazione. La loro forma più semplice è la seguente:

my_list = [expression for element in iterable]

Che vuol dire: “per ogni element di iterable (una lista, un range, ecc.) inserisci nella lista il risultato dell’espressione). Ad esempio:

values = [x*2 for x in range(1,5)] # [2,4,6,8,10]

Quindi siccome for x in range(1,5) emette 1,2,3,4,5 ed espressione calcola x*2, avremo 2,4,6,8,10.

E’ possibile usare filtri durante la generazione:

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
odds = [
  x for x in numbers 
  if x % 2 != 0] # [1,3,5,7
]

Possiamo poi utilizzare un operatore if nell’espressione di generazione. Non va confuso col filtro.

values = [1,2,3,4,5]
type = [
  "pari" if x % 2 == 0 else "dispari" 
  for x in values
]
# ["dispari", "pari", "dispari", "pari", "dispari"]

L’espressione "pari" if x % 2 == 0 else "dispari" dice “inserisci la stringa ‘pari’ se x è divisibile per 2 altrimenti inserisci la stringa ‘dispari’. Si tratta dell’operatore ternario (derivato dal C).

Naturalmente è possibile combinare insieme tutte queste caratteristiche. Qui uno specchietto riassuntivo di tutte le list comprehension.

Conclusioni

Le liste sono una delle più importanti strutture dati di Python, e consistono in collezioni di oggetti ordinati.

Esse sono accessibili tranne indice, e modificabili sia inserendo elementi in testa o in coda, sia eliminando singoli elementi, sia agendo su intere porzioni. Python poi mette a disposizione un insieme di funzioni specificamente pensate per le liste.

Le liste possono contenere altre liste annidate, creando quindi matrici, anche di 3 o più dimensioni.

Infine abbiamo visto che è possibile generare liste mediante list comprehension, costrutti di una riga che consentono di creare liste data una espressione.