Liste in Python

Python fornisce anche un tipo built-in chiamato lista, che viene solitamente usato per rappresentare una sequenza mutabile di oggetti, in genere omogenei.

Definire le liste

Le liste vengono definite elencando tra parentesi quadre ([]) una serie di oggetti separati da virgole (,). È possibile creare una lista vuota usando le parentesi quadre senza nessun elemento all'interno.

>>> nums = [0, 1, 2, 3] # nuova lista di 4 elementi
>>> nums
[0, 1, 2, 3]
>>> type(nums) # verifichiamo che il tipo sia "list"
<class 'list'>
>>> empty = [] # nuova lista vuota
>>> empty
[]
>>> one = ['Python'] # nuova lista con un elemento
>>> one
['Python']

Usare le liste

Così come le tuple e le stringhe, anche le liste sono un tipo di sequenza, e supportano quindi le operazioni comuni a tutte le sequenze, come indexing, slicing, contenimento, concatenazione, e ripetizione:

>>> letters = ['a', 'b', 'c', 'd', 'e']
>>> letters[0] # le liste supportano indexing
'a'
>>> letters[-1]
'e'
>>> letters[1:4] # slicing
['b', 'c', 'd']
>>> 'a' in letters # gli operatori di contenimento "in" e "not in"
True
>>> letters + ['f', 'g', 'h'] # concatenazione (ritorna una nuova lista)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> [1, 2, 3] * 3 # ripetizione (ritorna una nuova lista)
[1, 2, 3, 1, 2, 3, 1, 2, 3]

Le liste supportano anche funzioni e metodi comuni alle altre sequenze: len() per contare gli elementi, min() e max() per trovare l'elemento più piccolo/grande (a patto che i tipi degli elementi siano comparabili), .index() per trovare l'indice di un elemento, e .count() per contare quante volte un elemento è presente nella lista:

>>> letters = ['a', 'b', 'c', 'b', 'a']
>>> len(letters) # numero di elementi
5
>>> min(letters) # elemento più piccolo (alfabeticamente nel caso di stringhe)
'a'
>>> max(letters) # elemento più grande
'c'
>>> letters.index('c') # indice dell'elemento 'c'
2
>>> letters.count('c') # numero di occorrenze di 'c'
1
>>> letters.count('b') # numero di occorrenze di 'b'
2

A differenza di tuple e stringhe che sono immutabili, le liste possono essere mutate. È quindi possibile assegnare un nuovo valore agli elementi, rimuovere elementi usando la keyword del, o cambiare gli elementi usando uno dei metodi aggiuntivi delle liste:

• lista.append(elem): aggiunge elem alla fine della lista;
• lista.extend(seq): estende la lista aggiungendo alla fine gli elementi di seq;
• lista.insert(indice, elem): aggiunge elem alla lista in posizione indice;
• lista.pop(): rimuove e restituisce l'ultimo elemento della lista;
• lista.remove(elem): trova e rimuove elem dalla lista;
• lista.sort(): ordina gli elementi della lista dal più piccolo al più grande;
• lista.reverse(): inverte l'ordine degli elementi della lista;
• lista.copy(): crea e restituisce una copia della lista;
• lista.clear(): rimuove tutti gli elementi della lista;

Vediamo alcuni esempi:

>>> letters = ['a', 'b', 'c']
>>> letters.append('d') # aggiunge 'd' alla fine
>>> letters
['a', 'b', 'c', 'd']
>>> letters.extend(['e', 'f']) # aggiunge 'e' e 'f' alla fine
>>> letters
['a', 'b', 'c', 'd', 'e', 'f']
>>> letters.append(['e', 'f']) # aggiunge la lista come elemento alla fine
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', ['e', 'f']]
>>> letters.pop() # rimuove e ritorna l'ultimo elemento (la lista)
['e', 'f']
>>> letters.pop() # rimuove e ritorna l'ultimo elemento ('f')
'f'
>>> letters.pop(0) # rimuove e ritorna l'elemento in posizione 0 ('a')
'a'
>>> letters.remove('d') # rimuove l'elemento 'd'
>>> letters
['b', 'c', 'e']
>>> letters.reverse() # inverte l'ordine "sul posto" e non ritorna niente
>>> letters # gli elementi sono ora in ordine inverso
['e', 'c', 'b']
>>> letters[1] = 'x' # sostituisce l'elemento in posizione 1 ('c') con 'x'
>>> letters
['e', 'x', 'b']
>>> del letters[1] # rimuove l'elemento in posizione 1 ('x')
>>> letters
['e', 'b']
>>> letters.clear() # rimuove tutti gli elementi rimasti
>>> letters
[]

Alcuni di questi metodi accettano anche argomenti aggiuntivi che potrete vedere usando help(list.metodo) o consultando la documentazione ufficiale sulle liste.

Differenze tra tuple e liste

Anche se a prima vista le liste possono sembrare delle "tuple mutabili", in realtà vengono usate in situazioni diverse. Riassumiamo le differenze tra tuple e liste:

	tuple	liste
Mutabilità	immutabili	mutabili
Lunghezza	fissa	variabile
Accesso agli elementi avviene tramite	indexing	iterazione
Di solito contengono oggetti	eterogenei	omogenei
Simile in C al tipo di dati	struct	array

Dato che le tuple sono immutabili, la loro lunghezza è fissa, e in genere ogni elemento della tupla ha un ruolo preciso. Questi elementi, che possono essere di tipi diversi, in genere vengono letti tramite indexing (tupla[indice]).

Le liste, invece, sono mutabili, quindi la loro lunghezza è variabile (elementi possono essere aggiunti o rimossi). Questo significa che gli elementi singoli non hanno un ruolo preciso e vengono in genere letti mediante iterazione (ad esempio usando un for), e perciò devono anche essere dello stesso tipo.

Un altro modo per capire la differenza, è pensare a una tabella di un database, come ad esempio:

Nome	Cognome	Età
John	Smith	20
Jane	Johnson	30
Jack	Williams	28
Mary	Jones	25
Mark	Brown	23

Ogni riga della tabella può essere rappresentata con una tupla (es. ('John', 'Smith', 20)) di 3 elementi (lunghezza fissa) eterogenei (stringhe e interi) a cui possiamo accedere tramite indexing (es. t[1] per il cognome). Ogni colonna può essere rappresentata con una lista (es. ['John', 'Jane', 'Jack', ...]]) di lunghezza variabile (persone possono essere aggiunte o tolte) e elementi omogenei (la colonna del nome ha solo stringhe, quella dell'età solo numeri) che vengono accessi tramite iterazione (es. stampare la lista di cognomi usando un loop).

È inoltre possibile combinare i due tipi e rappresentare l'intera tabella come una lista di tuple:

[('John', 'Smith', 20),
('Jane', 'Johnson', 30),
('Jack', 'Williams', 28),
...]

Nella prossima lezione vedremo un altro tipo di dato built-in: i dizionari.