Metodi delle Liste

Le liste Python sono sequenze mutabili e ordinate. Poiché sono mutabili, il tipo lista include undici metodi integrati che consentono di aggiungere, rimuovere, cercare e riordinare elementi in-place — senza bisogno di importazioni. Questa pagina copre ogni metodo con esempi eseguibili, errori comuni e indicazioni su quando scegliere l'uno rispetto all'altro.

Capitoli correlati: Liste Python · Ordinare le Liste · List Comprehension · Copiare le Liste

Riferimento rapido

Aggiungere elementi

append()

append(x) aggiunge un singolo elemento x alla fine della lista. È un'operazione O(1) ammortizzata ed è il modo idiomatico per costruire una lista un elemento alla volta.

append() aggiunge sempre l'argomento come un solo elemento, anche se quell'argomento è a sua volta una lista:

fruits = ["banana", "orange"]
fruits.append(["apple", "mango"])
print(fruits)  # ['banana', 'orange', ['apple', 'mango']]
print(len(fruits))  # 3 — the nested list counts as one element

Per unire invece tutti gli elementi da un'altra lista, usa extend().

extend()

extend(iterable) aggiunge ogni elemento dell'iterabile dato alla fine della lista. L'iterabile può essere una lista, una tupla, un set, una stringa o qualsiasi altro iterabile.

extend() è equivalente a fruits += more_fruits. Usalo quando hai già una collezione di elementi da unire; usa append() per un singolo elemento.

insert()

insert(i, x) inserisce l'elemento x prima della posizione i. Tutti gli elementi esistenti all'indice i e successivi scorrono di una posizione verso destra.

• insert(0, x) aggiunge l'elemento all'inizio (ma è O(n) perché tutti gli elementi scorrono).
• Se i è maggiore o uguale alla lunghezza della lista, l'elemento viene aggiunto alla fine — nessun errore viene sollevato.

Rimuovere elementi

remove()

remove(x) scansiona la lista da sinistra a destra ed elimina il primo elemento uguale a x. Se x non viene trovato, solleva un ValueError.

Proteggere contro il ValueError:

fruits = ["banana", "orange"]
item = "mango"
if item in fruits:
    fruits.remove(item)
else:
    print(f"{item} not in list")
# mango not in list

pop()

pop(i) rimuove l'elemento all'indice i e lo restituisce. Il valore restituito è la differenza chiave rispetto a remove().

pop() chiamato senza argomento rimuove e restituisce l'ultimo elemento — un pattern comune per gli stack:

stack = ["a", "b", "c"]
last = stack.pop()
print(stack)  # ['a', 'b']
print(last)   # c

clear()

clear() rimuove ogni elemento dalla lista, lasciandola vuota. È equivalente a del lst[:] ma più leggibile.

fruits = ["banana", "apple", "orange"]
fruits.clear()
print(fruits)  # []

Usa clear() quando vuoi svuotare una lista a cui potrebbero fare riferimento anche altre variabili — fruits = [] reindirizzerebbe semplicemente il nome, mentre clear() svuota l'oggetto sottostante.

Cercare elementi

index()

index(x) restituisce l'indice intero della prima occorrenza di x. Accetta argomenti opzionali start e end per limitare la ricerca a una porzione.

Ricerca all'interno di un intervallo:

items = ["a", "b", "c", "b", "d"]
print(items.index("b"))       # 1  — first occurrence
print(items.index("b", 2))    # 3  — first occurrence at index >= 2

index() solleva ValueError se l'elemento è assente. Usa in per verificare prima quando l'assenza è possibile:

if "mango" in fruits:
    pos = fruits.index("mango")

count()

count(x) restituisce il numero di volte in cui x appare nella lista.

A differenza di index(), count() non solleva mai un errore per un valore mancante — restituisce 0.

Ordinare elementi

sort()

sort() ordina la lista in-place in ordine crescente per impostazione predefinita. Accetta due argomenti keyword opzionali:

• reverse=True — ordina in ordine decrescente.
• key=<callable> — una funzione applicata a ogni elemento prima del confronto.

Ordinare in ordine decrescente:

numbers = [3, 1, 4, 1, 5]
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 1, 1]

Ordinare stringhe senza distinzione tra maiuscole e minuscole con key:

words = ["banana", "Apple", "cherry", "date"]
words.sort(key=str.lower)
print(words)  # ['Apple', 'banana', 'cherry', 'date']

sort() modifica la lista e restituisce None. Se hai bisogno di una copia ordinata senza modificare l'originale, usa invece la funzione integrata sorted():

original = [3, 1, 4]
result = sorted(original)
print(original)  # [3, 1, 4]  — unchanged
print(result)    # [1, 3, 4]

Vedi Ordinare le Liste per una guida approfondita che include comparatori personalizzati e ordinamento di oggetti.

reverse()

reverse() inverte la lista in-place. Come sort(), restituisce None.

Per ottenere una copia invertita senza modificare l'originale, usa reversed() (restituisce un iteratore) o lo slicing:

fruits = ["banana", "apple", "orange"]
print(list(reversed(fruits)))  # ['orange', 'apple', 'banana']
print(fruits[::-1])            # ['orange', 'apple', 'banana']
print(fruits)                  # ['banana', 'apple', 'orange']  — unchanged

Copiare

copy()

copy() restituisce una copia superficiale della lista — un nuovo oggetto lista che contiene gli stessi riferimenti agli elementi.

original = ["banana", "apple", "orange"]
clone = original.copy()
clone.append("mango")

print(original)  # ['banana', 'apple', 'orange']  — unchanged
print(clone)     # ['banana', 'apple', 'orange', 'mango']

"Superficiale" significa che gli oggetti annidati (come una lista dentro una lista) non vengono duplicati — sia l'originale che la copia rifletteranno le modifiche a quegli oggetti annidati. Per un duplicato completamente indipendente, usa copy.deepcopy() dalla libreria standard. Vedi Copiare le Liste per una spiegazione dettagliata delle copie superficiali e profonde.

Errori comuni

Tutti i metodi che modificano la lista restituiscono None. Un errore comune è assegnare il risultato di sort(), reverse(), append(), ecc.:

# Wrong — result is None, not a sorted list
numbers = [3, 1, 2]
numbers = numbers.sort()
print(numbers)  # None

# Correct — sort() mutates in place
numbers = [3, 1, 2]
numbers.sort()
print(numbers)  # [1, 2, 3]

remove() e index() sollevano ValueError per elementi mancanti. Controlla sempre con in prima, o cattura l'eccezione, quando l'elemento potrebbe non essere presente.

append() vs extend() per le liste. Usare append(altra_lista) annida la lista come un singolo elemento; extend(altra_lista) unisce i suoi elementi.

Esercitazione