Liste in Python (list): metodi, slice, ordinamento, append, tuple e set

La lista in Python (list) è un insieme ordinato di valori qualsiasi racchiuso tra parentesi quadre, che si può modificare: si possono aggiungere elementi in fondo, inserirli al centro, rimuoverli, ordinarli. È la collezione più usata del linguaggio: le righe di un file, le spese del mese, le risposte di un'API — quasi tutto parte da una lista. Vediamo la list di Python per intero: creazione, metodi, slice, ordinamento, list comprehension, copia e, alla fine, tuple e set.

Che cos'è una lista in Python

La lista conserva gli elementi nell'ordine in cui li avete inseriti e vi si accede tramite l'indice, a partire da zero. In una stessa lista possono convivere valori di tipi diversi, anche se nella pratica di solito si memorizzano dati omogenei.

amounts = [250, 1200, 99]
print(amounts[0])     # 250 — primo elemento
print(amounts[-1])    # 99 — ultimo
amounts[1] = 1300     # la lista è modificabile
print(len(amounts))   # 3 — lunghezza della lista

La dimensione della lista si ottiene con la funzione len(). Se si accede a un indice inesistente si ottiene IndexError: list index out of range.

Creazione di una lista

empty = []                       # lista vuota
also_empty = list()              # la stessa cosa tramite la funzione list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

La funzione list() trasforma in lista qualsiasi oggetto iterabile: una stringa, un range, un set, le chiavi di un dizionario.

append e gli altri metodi delle liste

Il metodo append aggiunge un solo elemento in fondo alla lista — è il metodo più usato in Python. Modifica la lista sul posto e restituisce None.

amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # rimuove la prima occorrenza del valore 1200
last = amounts.pop()         # 20 — rimuove e restituisce l'ultimo

Errore frequente: a.append([10, 20]) aggiunge un solo elemento, cioè una lista annidata, e non due numeri. Per aggiungere più elementi serve extend.

Un elemento per indice o un intervallo intero si possono eliminare anche con l'operatore del: del a[0], del a[1:3]. Funzioni integrate utili con le liste: len, sum, min, max, sorted, reversed, enumerate, zip.

Slice in Python

La slice prende una parte della lista secondo lo schema a[start:stop:step]: da start incluso fino a stop escluso, con passo step. Ogni parte può essere omessa. La slice restituisce sempre una nuova lista.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — i primi due
print(a[-2:])     # [4, 5] — gli ultimi due
print(a[::2])     # [0, 2, 4] — uno ogni due
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — al contrario
print(a[:])       # copia di tutta la lista

A differenza dell'indice, una slice fuori dai limiti non genera errore: a[10:20] restituisce semplicemente []. A una slice si può anche assegnare un valore per sostituire un pezzo della lista: a[1:3] = ["x", "y", "z"].

Slice di una stringa

Le slice funzionano allo stesso modo per qualsiasi sequenza, comprese stringhe e tuple:

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

Una stringa non si può modificare con una slice: le stringhe sono immutabili, quindi la slice crea una nuova stringa.

Ordinamento di una lista: sort e sorted

È il punto in cui i principianti sbagliano più spesso. Il metodo sort riordina gli elementi nella lista stessa e restituisce None. La funzione sorted lascia intatta la lista originale e restituisce una nuova lista ordinata.

amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — nuova copia
print(amounts)             # [250, 1200, 99, 450] — l'originale è intatto

result = amounts.sort()    # ordina sul posto
print(result, amounts)     # None [99, 250, 450, 1200]

Da qui il classico errore «perché ho None»: a = a.sort() sovrascrive la lista con il valore None. Scrivete o a.sort() oppure a = sorted(a).

Chiave e ordine inverso

Entrambi accettano i parametri key e reverse. key è una funzione in base al cui risultato vengono confrontati gli elementi.

words = ["caffè", "Taxi", "abbonamento"]
print(sorted(words, key=len))               # ['Taxi', 'caffè', 'abbonamento']
print(sorted(words, key=str.lower))         # senza distinguere maiuscole e minuscole
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Cibo", 650), ("Cinema", 120), ("Taxi", 300)]
expenses.sort(key=lambda e: e[1])           # per importo

L'ordinamento in Python è stabile: gli elementi con la stessa chiave mantengono l'ordine originale. C'è anche una differenza di applicabilità: sorted accetta qualsiasi sequenza (stringa, dizionario, set), mentre sort esiste solo per le liste.

Invertire una lista

Tre modi con comportamenti diversi:

• a.reverse() — inverte sul posto, restituisce None;
• a[::-1] — una nuova lista invertita;
• reversed(a) — iteratore pigro, comodo nel ciclo: for x in reversed(a):.

Scorrere una lista

items = ["caffè", "metro", "cinema"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 caffè, 2 metro, 3 cinema

print("cinema" in items)    # True — verifica della presenza

Non rimuovete elementi dalla lista su cui state ciclando: alcuni verrebbero saltati. Costruite una nuova lista con una comprehension oppure scorrete una copia a[:].

List comprehension

La list comprehension costruisce una nuova lista in una sola riga: un'espressione, un ciclo e una condizione facoltativa.

squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" anna ", "luca"]]

Le comprehension sono di solito più veloci e leggibili di un ciclo con append. Ma se la logica non entra in una riga chiara, è meglio un ciclo esplicito.

Unione, somma e differenza di liste

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — nuova lista
a += b             # come a.extend(b)
print([*a, *b])    # unpacking in una nuova lista

Per le liste non esiste la sottrazione con l'operatore -. Per togliere da una lista gli elementi di un'altra si usa una comprehension: [x for x in a if x not in set(b)]. L'intersezione di liste si trova più comodamente con i set: set(a) & set(b) (in questo caso ordine e duplicati vanno persi).

Liste annidate e bidimensionali

Una lista di liste è un modo semplice per memorizzare una tabella o una matrice:

matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # corretto
bad = [[0] * 3] * 2                  # trappola: due riferimenti alla stessa lista
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]

Unpacking di una lista

first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — stampa della lista senza parentesi

Se il numero di variabili non corrisponde alla lunghezza della lista, si ottiene un ValueError — e qui aiuta l'asterisco.

Copia di una lista

b = a non copia la lista, ma applica una seconda etichetta allo stesso oggetto: le modifiche fatte tramite b si vedono in a. Una copia indipendente va creata esplicitamente: a.copy(), list(a) oppure a[:]. Per i dati annidati non basta: le liste interne resterebbero condivise, serve copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — la lista annidata è condivisa
c = copy.deepcopy(a)     # copia completamente indipendente

Tuple: lista immutabile

La tupla (tuple) somiglia a una lista, ma dopo la creazione non si può modificare. È un segnale chiaro per chi legge: si tratta di un singolo record con campi fissi, non di un insieme che cresce. Le tuple si scompattano facilmente, e proprio con le tuple le funzioni restituiscono più valori.

expense = (250, "Caffè")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment

Una tupla di valori immutabili è hashable e quindi può fare da chiave di un dizionario. La tupla con un solo elemento si scrive con la virgola: (5,).

Set: solo valori unici

Il set (set) conserva solo valori unici e non mantiene l'ordine. È il modo più rapido per eliminare i duplicati e per verificare se un elemento è presente, e sa anche calcolare intersezioni, unioni e differenze.

jan = {"Cibo", "Taxi", "Cinema"}
feb = {"Cibo", "Abbonamenti"}
print(jan & feb)    # {'Cibo'}
print(feb - jan)    # {'Abbonamenti'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — senza duplicati, ordine conservato
empty = set()       # {} — qui sarebbe un dict vuoto!

Quale collezione scegliere

La verifica x in list scorre gli elementi uno alla volta, mentre x in set è quasi istantanea. Se in un ciclo controllate molte volte la presenza in una lista grande, trasformatela in un set.

Conclusioni

La list di Python è una collezione ordinata e modificabile: append e extend aggiungono, pop e remove rimuovono, le slice a[start:stop:step] prelevano porzioni, sort ordina sul posto e restituisce None, mentre sorted restituisce una nuova lista. Le copie vanno fatte esplicitamente; per i record fissi si usa la tupla, per i valori unici il set. Liste, tuple, dizionari e set sono trattati in pratica nel corso «Python 3.15: dal principiante al professionista».