Liste in Python: creare, indicizzare, aggiungere, ordinare e scorrere

Le liste sono sequenze ordinate e modificabili

La lista è il tipo di collezione più usato in Python. Se devi tenere un insieme ordinato di valori che potrebbe cambiare (aggiungere, rimuovere, ordinare, aggiornare), una lista è quasi sempre la scelta giusta.

Ne crei una con le parentesi quadre:

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "two", 3.0, True]
empty = []

print(fruits)
print(numbers)
print(mixed)
print(empty)

Le liste possono contenere qualsiasi cosa, perfino altre liste. In pratica, la maggior parte delle liste finisce per contenere un solo tipo di cosa (una lista di utenti, una lista di numeri), perché è la soluzione più semplice da gestire mentalmente.

Indicizzazione

Ogni elemento ha una posizione, a partire da 0. Vi accedi con le parentesi quadre:

fruits = ["apple", "banana", "cherry"]

print(fruits[0])    # 'apple'
print(fruits[1])    # 'banana'
print(fruits[-1])   # 'cherry': gli indici negativi contano dalla fine
print(fruits[-2])   # 'banana'

Chiedere un indice che non esiste solleva IndexError. Se rischi di uscire dall'intervallo, controlla prima la lunghezza oppure metti l'accesso dentro un try.

Slicing

Lo slicing ti restituisce un intervallo di elementi. La sintassi è list[start:stop:step], la stessa delle stringhe:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]
print(nums[:3])       # [0, 1, 2]: dall'inizio
print(nums[7:])       # [7, 8, 9]: fino alla fine
print(nums[::2])      # [0, 2, 4, 6, 8]: un elemento sì e uno no
print(nums[::-1])     # copia invertita

Due cose da fissare bene:

• Lo slicing restituisce sempre una nuova lista. Modificare la slice non tocca l'originale.
• L'indice di stop è escluso: nums[2:5] ti dà gli indici 2, 3 e 4, non il 5.

Come usare append, extend e insert

I tre metodi per "aggiungere a una lista" fanno cose diverse, e confonderli è una fonte comune di bug:

items = ["a", "b", "c"]

items.append("d")       # aggiunge UN elemento in fondo
items.insert(0, "z")    # inserisce UN elemento a un indice preciso
items.extend(["e", "f"])  # aggiunge OGNI elemento di un altro iterabile

print(items)

• append(x) aggiunge x come singolo elemento, anche se x è una lista. items.append([1, 2]) aggiunge la lista stessa come un'unica voce.
• extend(iterable) aggiunge ogni elemento preso dall'iterabile. items.extend([1, 2]) aggiunge due voci.
• insert(i, x) inserisce a un indice preciso, spostando di una posizione in avanti tutto ciò che si trova in i o dopo.

+= con una lista a destra funziona come extend:

items = ["a", "b"]
items += ["c", "d"]
print(items)

E per rimuovere:

items = ["a", "b", "c", "b", "d"]

items.remove("b")       # rimuove la prima occorrenza di "b"
print(items)

last = items.pop()      # rimuove e restituisce l'ultimo elemento
print(last, items)

second = items.pop(0)   # rimuove e restituisce l'elemento all'indice 0
print(second, items)

Se provi a fare remove() di qualcosa che non è nella lista, Python solleva ValueError. Se ti serve "rimuovi se presente", controlla prima con in oppure usa un try.

Puoi anche eliminare per indice con del:

items = [10, 20, 30, 40, 50]
del items[1]
print(items)

Lunghezza, appartenenza, conteggio

nums = [4, 8, 15, 16, 23, 42, 16]

print(len(nums))         # 7
print(16 in nums)        # True
print(nums.count(16))    # 2
print(nums.index(23))    # 4: indice del primo 23

in è il modo leggibile per verificare se una lista contiene un valore. Se farai questa domanda molte volte su una lista grande, usa invece un set: l'appartenenza in un set è O(1), in una lista è O(n).

Ordinamento

Due modi, e la scelta conta:

nums = [5, 2, 9, 1, 7]

# Sul posto: modifica la lista, restituisce None.
nums.sort()
print(nums)    # [1, 2, 5, 7, 9]

# Restituisce una nuova lista ordinata, lascia intatto l'originale.
original = [5, 2, 9, 1, 7]
sorted_nums = sorted(original)
print(sorted_nums, original)

Entrambi accettano reverse=True per l'ordine decrescente:

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)    # [9, 7, 5, 2, 1]

E una funzione key per un ordinamento personalizzato:

words = ["banana", "apple", "kiwi", "strawberry"]
words.sort(key=len)
print(words)    # ['kiwi', 'apple', 'banana', 'strawberry']

key viene applicata a ogni elemento, e il risultato è ciò che viene confrontato. Casi comuni: ordinare per lunghezza, per un attributo specifico o per la versione in minuscolo di una stringa.

Invertire

Tre varianti, a seconda di ciò che ti serve:

items = [1, 2, 3, 4]

# Sul posto: modifica la lista, restituisce None.
items.reverse()
print(items)

# Slicing: restituisce una nuova lista invertita.
original = [1, 2, 3, 4]
copy = original[::-1]
print(copy, original)

# reversed(): restituisce un iteratore pigro.
for n in reversed([1, 2, 3, 4]):
    print(n)

Usa la versione sul posto quando l'originale non ti serve. Usa lo slicing quando vuoi una nuova copia. Usa reversed() quando devi solo scorrere al contrario senza creare una nuova lista.

La trappola del riferimento condiviso

Le liste sono mutabili e le variabili sono riferimenti. Questo significa che due variabili possono puntare alla stessa lista:

a = [1, 2, 3]
b = a
b.append(4)

print(a)    # [1, 2, 3, 4]: anche a è cambiata!

b = a non ha copiato la lista: ha reso b un secondo nome per la stessa lista. Se vuoi una copia, chiedila esplicitamente:

a = [1, 2, 3]
b = a.copy()   # oppure list(a), oppure a[:]
b.append(4)

print(a, b)    # [1, 2, 3]  [1, 2, 3, 4]

Prima o poi ci casca chiunque programmi in Python. Ricorda: = tra due liste non copia.

Scorrere e costruire

Conosci già lo schema di base dalla pagina sul ciclo for:

scores = [45, 72, 33, 90, 58, 61]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

È leggibile e andrà sempre bene. Quando ti senti a tuo agio, la list comprehension equivalente fa la stessa cosa in una riga:

scores = [45, 72, 33, 90, 58, 61]
passing = [s for s in scores if s >= 60]
print(passing)

Vedremo le comprehension nel dettaglio fra due pagine.

Promemoria veloce

I metodi da conoscere, a colpo d'occhio:

• append(x): aggiunge in fondo
• extend(iter): aggiunge ogni elemento di un iterabile
• insert(i, x): inserisce all'indice i
• pop() / pop(i): rimuove e restituisce
• remove(x): rimuove la prima occorrenza di x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x): posizione del primo x
• count(x): quante volte compare x
• copy(): copia superficiale

Prossimo argomento

Le liste sono il cavallo da tiro. Ora vedremo le tuple, le loro cugine immutabili, e quando conviene scegliere una tupla.