# Liste in Python (list): metodi, slice, ordinamento, append, tuple e set URL: https://skillaria.top/it/guides/python/liste-python La lista in Python (list) è una collezione ordinata e modificabile di valori tra parentesi quadre, per esempio [250, 1200, 99]: gli elementi si possono aggiungere con append, inserire, rimuovere, prelevare con le slice e ordinare. Il metodo sort ordina la lista sul posto e restituisce None, mentre la funzione sorted restituisce una nuova lista ordinata. 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`. | Metodo | Che cosa fa | | --- | --- | | `append(x)` | aggiunge x in fondo | | `extend(iter)` | aggiunge tutti gli elementi di una sequenza | | `insert(i, x)` | inserisce x prima dell'indice i | | `remove(x)` | rimuove la prima occorrenza di x (ValueError se manca) | | `pop(i=-1)` | rimuove e restituisce l'elemento con indice i | | `index(x)` | indice della prima occorrenza | | `count(x)` | quante volte compare x | | `sort()` | ordina sul posto | | `reverse()` | inverte sul posto | | `copy()` | copia superficiale | | `clear()` | svuota la lista | 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 | Compito | Collezione | | --- | --- | | Ordine e modifiche | `list` | | Record a campi fissi | `tuple` | | Ricerca per chiave | `dict` | | Unicità, verifica «c'è o non c'è» | `set` | | Impostazioni immutabili | `frozendict` (Python 3.15) | 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». ## FAQ **In che cosa una lista si differenzia da un array in Python?** In Python non esiste un array integrato nel senso di altri linguaggi: il suo ruolo è svolto dalla lista, che può contenere valori di tipi diversi. Per array numerici compatti esistono il modulo array e la libreria NumPy. **Come trovare l'indice di un elemento in una lista?** Il metodo a.index(x) restituisce l'indice della prima occorrenza e solleva ValueError se l'elemento non c'è. Per questo conviene verificare prima con x in a. **Come rimuovere i duplicati da una lista mantenendo l'ordine?** Usate list(dict.fromkeys(a)): il dizionario mantiene le chiavi uniche nell'ordine di inserimento. La variante list(set(a)) elimina i duplicati ma non conserva l'ordine. **Come unire una lista di stringhe in una sola stringa?** Con il metodo join: ", ".join(["a", "b", "c"]) restituisce "a, b, c". Tutti gli elementi devono essere stringhe; i numeri si convertono prima con map(str, a). **Si possono mettere nella stessa lista elementi di tipi diversi?** Sì, una lista può contenere contemporaneamente numeri, stringhe, altre liste e oggetti vari. Però ordinare una lista del genere senza il parametro key di solito non si può: il confronto tra un numero e una stringa genera un TypeError. --- Source: Skillaria.Top (https://skillaria.top)