# Aggiungere elementi a una lista Python Le liste sono strutture di dati basilari in informatica. Molti **algoritmi si basano sulla modifica delle liste**. Ti mostriamo come aggiungere elementi a una lista in Python. ## Come si aggiungono elementi a una lista Python? A differenza delle tuple e delle stringhe, **le liste in Python sono strutture di dati “mutabili”, ossia modificabili**. È possibile aggiungere elementi a una [lista Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/liste-in-python/), rimuoverli e modificarne la sequenza. Per compiere queste operazioni esistono vari metodi, ciascuno con i propri vantaggi e svantaggi. Ti **presentiamo quattro modi** per aggiungere elementi a una lista in Python: 1. Aggiungere elementi a una lista in Python con il metodo `list` 2. Aggiungere elementi a una lista in Python con la concatenazione di liste 3. Aggiungere elementi a una lista in Python con la notazione slice 4. Aggiungere elementi a una lista in Python con la comprensione di lista ## Aggiungere elementi a una lista in Python con il metodo list In Python la **classe `list` è la base di tutte le operazioni sulle liste**. Questa classe definisce una serie di metodi per gli oggetti lista. Sono previsti tre metodi per aggiungere elementi a una lista:
Metodo `list` Argomenti Spiegazione
`append()` `element` Aggiungere un singolo elemento alla fine della lista
`extend()` `[elements]` Aggiungere più elementi alla fine della lista
`insert()` `index, element` Aggiungere un singolo elemento prima dell’indice dato
È importante comprendere che **con i tre metodi indicati la modifica avviene “in-place”**, che significa che l’oggetto lista viene modificato anziché creare e restituire una nuova lista. Di conseguenza, tutti i metodi restituiscono `None`: ```Python # List of prime numbers primes = [2, 3, 5, 7] # Append additional prime number, saving returned result should_be_none = primes.append(11) # Show that the prime was added assert primes == [2, 3, 5, 7, 11] # Show that `None` was returned assert should_be_none is None ``` ### Aggiungere un singolo elemento alla fine della lista con append() Con il [metodo `append()` in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-append/) si può **aggiungere un singolo elemento alla fine di una lista esistente**. Chiariamo il comportamento con un esempio: ```Python # List containing single prime number primes = [2] # Add an element to the end of the list primes.append(3) # Show that the element was added assert primes == [2, 3] ``` Attenzione: il metodo `append()` **aggiunge sempre solo un singolo elemento**. Se l’elemento da aggiungere è un’altra lista, si crea una lista annidata: ```Python # List with two prime numbers primes = [2, 3] # Try to appends multiple numbers at once primes.append([5, 7]) # Accidentally created a nested list assert primes == [2, 3, [5, 7]] ``` Il nostro tentativo di generare la lista `[2, 3, 5, 7]` è fallito. Per aggiungere più elementi è meglio utilizzare il metodo `extend()`. ### Aggiungere elementi alla fine della lista con extend() [Il metodo `extend()` in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-extend/) funziona analogamente ad `append()`, con la differenza che **a una lista esistente vengono aggiunti più elementi**. Per capire ricorriamo nuovamente a un esempio: ```Python # List containing single prime number primes = [2] # Extend list by two elements primes.extend([3, 5]) # Show that both element were added assert primes == [2, 3, 5] ``` Attenzione: il metodo `extend()` si aspetta un **iterabile come argomento e ne estrae gli elementi**. Quando esegue la chiamata con una stringa, il comportamento è sorprendente: ```Python # List of friends friends = ['Mary', 'Jim'] # Try to extend by additional friend friends.extend('Jack') # String is unpacked into individual letters assert friends == ['Mary', 'Jim', 'J', 'a', 'c', 'k'] ``` Per aggiungere un singolo elemento a una lista Python si utilizza `append()` oppure **si racchiude l’elemento tra parentesi quadre in una lista**. Quindi funziona anche la chiamata di `extend()`: ```Python # List of friends friends = ['Mary', 'Jim'] # Extend by additional friend inside list friends.extend(['Jack']) # Show that it worked assert friends == ['Mary', 'Jim', 'Jack'] ``` ### Aggiungere un singolo elemento prima dell’indice dato con insert() Finora abbiamo mostrato come si aggiungono uno o più elementi alla fine di una lista Python. Cosa dobbiamo invece fare per **aggiungere un elemento in un’altra posizione**? Proprio per questo caso è previsto il [metodo `insert()` in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-insert/), che oltre all’elemento da inserire riceve un indice numerico: ```Python # List of friends friends = ['Mary', 'Jim', 'Jack'] # Insert additional friend `"Molly"` before index `2` friends.insert(2, 'Molly') # Show that "Molly" was added assert friends == ['Mary', 'Jim', 'Molly', 'Jack'] ``` Occorre prestare attenzione quando si aggiungono più elementi con `insert()`: poiché `insert()` inserisce proprio un elemento, **si crea involontariamente una lista annidata**: ```Python # List of friends friends = ['Mary', 'Jim'] # Try to insert multiple friends at once friends.insert(1, ['Molly', 'Lucy']) # Accidentally created a nested list assert friends == ['Mary', ['Molly', 'Lucy'], 'Jim'] ``` Per **aggiungere più elementi correttamente all’interno di una lista** utilizziamo un ciclo `for`. In seguito ci serviamo della funzione `reversed()` per mantenere la sequenza degli elementi inseriti: ```Python # List of friends friends = ['Mary', 'Jim'] # Using `reversed()` keeps order of inserted elements for friend in reversed(['Molly', 'Lucy']): friends.insert(1, friend) # Show that it worked assert friends == ['Mary', 'Molly', 'Lucy', 'Jim'] ``` ## Aggiungere elementi a una lista in Python con la concatenazione di liste Oltre al metodo `list`, con la **concatenazione di liste esiste un’altra possibilità per aggiungere elementi a una lista in Python**: l’operatore `+`. La concatenazione di liste corrisponde all’incirca a `extend()`. Tuttavia, la concatenazione genera una nuova lista anziché operare “in-place”. Creiamo due liste e aggiungiamo la seconda alla prima. Siccome **l’operazione restituisce una nuova lista**, assegniamo il valore restituito a una nuova lista: ```Python # List of guys guys = ['Jim', 'Jack'] # List of gals gals = ['Molly', 'Mary'] # Concatenate both lists folks = guys + gals # Show that it worked assert folks == ['Jim', 'Jack', 'Molly', 'Mary'] ``` Dietro le quinte **l’operatore di concatenazione chiama il metodo `__add__()`**. Le espressioni `guys + gals` e `guys.__add__(gals)` sono dunque equivalenti: ```Python # Show that both expressions return the same result assert guys + gals == guys.__add__(gals) ``` Chi ha familiarità con gli [operatori Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-python/), probabilmente lo ha già intuito: la **concatenazione di liste supporta anche l’assegnazione aumentata**. Per aggiungere elementi a una lista “in-place” si usa l’operatore `+=`: ```Python # Shopping list groceries = ['Milk', 'Bread', 'Eggs'] # Add butter groceries += ['Butter'] # Show that it worked assert groceries == ['Milk', 'Bread', 'Eggs', 'Butter'] ``` L’operatore `+=` chiama il metodo `__iadd__()`, dove la “i” sta per “in-place”. Analogamente al metodo `extend()`, il **destinatario del metodo viene modificato direttamente**. Le righe seguenti sono dunque equivalenti: - `groceries = groceries + ['Butter']` - `groceries += ['Butter']` - `groceries.__iadd__(['Butter'])` - `groceries.extend(['Butter'])` Occorre prestare attenzione quando si usano gli operatori di concatenazione di liste per aggiungere un singolo elemento a una lista. Anche un **singolo elemento deve essere contenuto in una lista**, altrimenti potrebbe essere estratto un iterabile: ```Python # List of cities cities = ['London', 'Paris'] # Attempt to add city; likely not what you intended cities += 'Rome' # String is unpacked into individual letters assert cities = ['London', 'Paris', 'R', 'o', 'm', 'e'] ``` **Utilizzando una lista a un elemento si ottiene l’effetto verosimilmente desiderato**, aggiungere un’altra città alla lista: ```Python # List of cities cities = ['London', 'Paris'] # Create a single-element list cities += ['Rome'] # Now the entire string is added assert cities = ['London', 'Paris', 'Rome'] ``` ## Aggiungere elementi a una lista in Python con la notazione slice Gli slice sono un **meccanismo di Python per selezionare elementi consecutivi di una lista**. La sintassi degli slice corrisponde alla nota funzione `range()`: ```Python # The `slice()` function constructs a new `slice` object slice(start, stop, step=1) ``` Vi è inoltre una **notazione abbreviata per generare oggetti slice** in abbinamento all’operatore di indicizzazione `[]`: ```Python # Select items of list lst[start:stop:step] ``` Un **oggetto slice può essere usato al posto di un indice numerico** per selezionare più elementi di una sequenza: ```Python people = ['Jim', 'John', 'Mary', 'Jack'] # Select elements between index `1` (inclusive) and `3` (exclusive) assert people[1:3] == ['John', 'Mary'] # Select every other element assert people[::2] == ['Jim', 'Mary'] ``` In **combinazione con le assegnazioni**, gli slice sono utilizzabili in alternativa ai metodi `list` `append()`, `extend()` e `insert()`:
Metodo `list` Assegnazione slice corrispondente Spiegazione
`lst.append(element)` `lst[len(lst)+1:] = [element]` Aggiungere un elemento alla fine della lista
`lst.extend([elements])` `lst[len(lst)+1:] = [elements]` Aggiungere più elementi alla fine della lista
`lst.insert(index, element)` `lst[index:index] = [element]` Aggiungere un elemento prima dell’indice dato
Per comprendere come funziona, analizziamo prima **l’assegnazione di un elemento di una lista tramite indice numerico**, con cui viene sovrascritto un singolo elemento della lista: ```Python # List of groceries groceries = ['Milk', 'Bread', 'Eggs'] # Overwrite element at index `1` groceries[1] = 'Fruit' # Show that it worked assert groceries == ['Milk', 'Fruit', 'Eggs'] ``` Cosa dobbiamo invece fare per **aggiungere un elemento tramite assegnazione a un indice**? Utilizziamo uno slice, che contiene l’indice desiderato come valore di `start` e `stop`. Affinché l’assegnazione slice funzioni, alla destra del segno di uguaglianza deve essere presente tassativamente una lista: ```Python # List of groceries groceries = ['Milk', 'Bread', 'Eggs'] # Insert element before index `1` groceries[1:1] = ['Fruit'] # Show that it worked assert groceries == ['Milk', 'Fruit', 'Bread', 'Eggs'] ``` Con questo trucchetto si possono addirittura **aggiungere più elementi a una lista Python in una volta sola**, cosa non possibile con il metodo `insert()`: ```Python # List of groceries groceries = ['Milk', 'Bread', 'Eggs'] # Insert elements before index `1` groceries[1:1] = ['Fruit', 'Butter'] # Show that it worked assert groceries == ['Milk', 'Fruit', 'Butter', 'Bread', 'Eggs'] ``` Inoltre, le **assegnazioni slice permettono di sovrascrivere elementi di una lista in modo selettivo**. Nel complesso gli slice sono una funzione molto flessibile, che dovrebbe essere presente nella cassetta degli attrezzi di tutti i programmatori e le programmatrici di Python. ## Aggiungere elementi a una lista in Python con la comprensione di lista Per aggiungere elementi a una lista in Python spesso si **riempie una nuova lista di elementi**. L’approccio standard, che funziona sia in Python sia nella maggior parte dei linguaggi di programmazione, è il seguente: 1. Creare una lista vuota 2. Creare elementi con un ciclo 3. Ampliare la lista con l’elemento creato Analizziamo ad esempio la **creazione della lista dei primi dieci numeri quadrati**: ```Python # Empty list to be filled squares = [] # Successively create numbers 0..9 for n in range(10): # Compute squared number squared = n * n # Append squared number to list squares.append(squared) # Show that it worked assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ``` In Python si può tuttavia ricorrere a un sistema migliore. Utilizziamo una **comprensione di lista** per generare la lista senza ciclo `for` e variabile di lista vuota: ```Python # Create first ten square numbers squares = [n ** 2 for n in range(10)] # Show that it worked assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ``` Per quanto eleganti, le comprensioni di lista sono adatte **solo a riempire una nuova lista**. Per ampliare una lista esistente si ricorre ai metodi già presentati. Consiglio Con [Deploy Now](https://www.ionos.it/hosting/deploy-now "Deploy Now di IONOS") di IONOS puoi distribuire siti web e app tramite GitHub. This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/aggiungere-elementi-a-una-lista-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/aggiungere-elementi-a-una-lista-python/) for AI/LLM consumption.