Ag­giun­ge­re elementi a una lista Python

Le liste sono strutture di dati basilari in in­for­ma­ti­ca. Molti algoritmi si basano sulla modifica delle liste. Ti mostriamo come ag­giun­ge­re elementi a una lista in Python.

Come si ag­giun­go­no elementi a una lista Python?

A dif­fe­ren­za delle tuple e delle stringhe, le liste in Python sono strutture di dati “mutabili”, ossia mo­di­fi­ca­bi­li. È possibile ag­giun­ge­re elementi a una lista Python, ri­muo­ver­li e mo­di­fi­car­ne la sequenza. Per compiere queste ope­ra­zio­ni esistono vari metodi, ciascuno con i propri vantaggi e svantaggi.

Ti pre­sen­tia­mo quattro modi per ag­giun­ge­re elementi a una lista in Python:

1. Ag­giun­ge­re elementi a una lista in Python con il metodo list
2. Ag­giun­ge­re elementi a una lista in Python con la con­ca­te­na­zio­ne di liste
3. Ag­giun­ge­re elementi a una lista in Python con la notazione slice
4. Ag­giun­ge­re elementi a una lista in Python con la com­pren­sio­ne di lista

Ag­giun­ge­re elementi a una lista in Python con il metodo list

In Python la classe list è la base di tutte le ope­ra­zio­ni sulle liste. Questa classe definisce una serie di metodi per gli oggetti lista. Sono previsti tre metodi per ag­giun­ge­re elementi a una lista:

È im­por­tan­te com­pren­de­re che con i tre metodi indicati la modifica avviene “in-place”, che significa che l’oggetto lista viene mo­di­fi­ca­to anziché creare e re­sti­tui­re una nuova lista. Di con­se­guen­za, tutti i metodi re­sti­tui­sco­no None:

# 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

Ag­giun­ge­re un singolo elemento alla fine della lista con append()

Con il metodo append() in Python si può ag­giun­ge­re un singolo elemento alla fine di una lista esistente. Chiariamo il com­por­ta­men­to con un esempio:

# 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]

At­ten­zio­ne: il metodo append() aggiunge sempre solo un singolo elemento. Se l’elemento da ag­giun­ge­re è un’altra lista, si crea una lista annidata:

# 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 ag­giun­ge­re più elementi è meglio uti­liz­za­re il metodo extend().

Ag­giun­ge­re elementi alla fine della lista con extend()

Il metodo extend() in Python funziona ana­lo­ga­men­te ad append(), con la dif­fe­ren­za che a una lista esistente vengono aggiunti più elementi. Per capire ri­cor­ria­mo nuo­va­men­te a un esempio:

# 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]

At­ten­zio­ne: il metodo extend() si aspetta un iterabile come argomento e ne estrae gli elementi. Quando esegue la chiamata con una stringa, il com­por­ta­men­to è sor­pren­den­te:

# 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 ag­giun­ge­re 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():

# List of friends
friends = ['Mary', 'Jim']
# Extend by additional friend inside list
friends.extend(['Jack'])
# Show that it worked
assert friends == ['Mary', 'Jim', 'Jack']

Ag­giun­ge­re un singolo elemento prima dell’indice dato con insert()

Finora abbiamo mostrato come si ag­giun­go­no uno o più elementi alla fine di una lista Python. Cosa dobbiamo invece fare per ag­giun­ge­re un elemento in un’altra posizione? Proprio per questo caso è previsto il metodo insert() in Python, che oltre all’elemento da inserire riceve un indice numerico:

# 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 at­ten­zio­ne quando si ag­giun­go­no più elementi con insert(): poiché insert() inserisce proprio un elemento, si crea in­vo­lon­ta­ria­men­te una lista annidata:

# 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 ag­giun­ge­re più elementi cor­ret­ta­men­te all’interno di una lista uti­liz­zia­mo un ciclo for. In seguito ci serviamo della funzione reversed() per mantenere la sequenza degli elementi inseriti:

# 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']

Ag­giun­ge­re elementi a una lista in Python con la con­ca­te­na­zio­ne di liste

Oltre al metodo list, con la con­ca­te­na­zio­ne di liste esiste un’altra pos­si­bi­li­tà per ag­giun­ge­re elementi a una lista in Python: l’operatore +. La con­ca­te­na­zio­ne di liste cor­ri­spon­de all’incirca a extend(). Tuttavia, la con­ca­te­na­zio­ne genera una nuova lista anziché operare “in-place”.

Creiamo due liste e ag­giun­gia­mo la seconda alla prima. Siccome l’ope­ra­zio­ne re­sti­tui­sce una nuova lista, as­se­gnia­mo il valore re­sti­tui­to a una nuova lista:

# 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 con­ca­te­na­zio­ne chiama il metodo __add__(). Le espres­sio­ni guys + gals e guys.__add__(gals) sono dunque equi­va­len­ti:

# Show that both expressions return the same result
assert guys + gals == guys.__add__(gals)

Chi ha fa­mi­lia­ri­tà con gli operatori Python, pro­ba­bil­men­te lo ha già intuito: la con­ca­te­na­zio­ne di liste supporta anche l’as­se­gna­zio­ne aumentata. Per ag­giun­ge­re elementi a una lista “in-place” si usa l’operatore +=:

# 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”. Ana­lo­ga­men­te al metodo extend(), il de­sti­na­ta­rio del metodo viene mo­di­fi­ca­to di­ret­ta­men­te. Le righe seguenti sono dunque equi­va­len­ti:

• groceries = groceries + ['Butter']
• groceries += ['Butter']
• groceries.__iadd__(['Butter'])
• groceries.extend(['Butter'])

Occorre prestare at­ten­zio­ne quando si usano gli operatori di con­ca­te­na­zio­ne di liste per ag­giun­ge­re un singolo elemento a una lista. Anche un singolo elemento deve essere contenuto in una lista, al­tri­men­ti potrebbe essere estratto un iterabile:

# 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']

Uti­liz­zan­do una lista a un elemento si ottiene l’effetto ve­ro­si­mil­men­te de­si­de­ra­to, ag­giun­ge­re un’altra città alla lista:

# List of cities
cities = ['London', 'Paris']
# Create a single-element list
cities += ['Rome']
# Now the entire string is added
assert cities = ['London', 'Paris', 'Rome']

Ag­giun­ge­re elementi a una lista in Python con la notazione slice

Gli slice sono un mec­ca­ni­smo di Python per se­le­zio­na­re elementi con­se­cu­ti­vi di una lista. La sintassi degli slice cor­ri­spon­de alla nota funzione range():

# The `slice()` function constructs a new `slice` object
slice(start, stop, step=1)

Vi è inoltre una notazione ab­bre­via­ta per generare oggetti slice in ab­bi­na­men­to all’operatore di in­di­ciz­za­zio­ne []:

# Select items of list
lst[start:stop:step]

Un oggetto slice può essere usato al posto di un indice numerico per se­le­zio­na­re più elementi di una sequenza:

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 com­bi­na­zio­ne con le as­se­gna­zio­ni, gli slice sono uti­liz­za­bi­li in al­ter­na­ti­va ai metodi list append(), extend() e insert():

Per com­pren­de­re come funziona, ana­liz­zia­mo prima l’as­se­gna­zio­ne di un elemento di una lista tramite indice numerico, con cui viene so­vra­scrit­to un singolo elemento della lista:

# 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 ag­giun­ge­re un elemento tramite as­se­gna­zio­ne a un indice? Uti­liz­zia­mo uno slice, che contiene l’indice de­si­de­ra­to come valore di start e stop. Affinché l’as­se­gna­zio­ne slice funzioni, alla destra del segno di ugua­glian­za deve essere presente tas­sa­ti­va­men­te una lista:

# 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 truc­chet­to si possono ad­di­rit­tu­ra ag­giun­ge­re più elementi a una lista Python in una volta sola, cosa non possibile con il metodo insert():

# 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 as­se­gna­zio­ni slice per­met­to­no di so­vra­scri­ve­re elementi di una lista in modo selettivo. Nel complesso gli slice sono una funzione molto fles­si­bi­le, che dovrebbe essere presente nella cassetta degli attrezzi di tutti i pro­gram­ma­to­ri e le pro­gram­ma­tri­ci di Python.

Ag­giun­ge­re elementi a una lista in Python con la com­pren­sio­ne di lista

Per ag­giun­ge­re 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 pro­gram­ma­zio­ne, è il seguente:

1. Creare una lista vuota
2. Creare elementi con un ciclo
3. Ampliare la lista con l’elemento creato

Ana­liz­zia­mo ad esempio la creazione della lista dei primi dieci numeri quadrati:

# 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. Uti­liz­zia­mo una com­pren­sio­ne di lista per generare la lista senza ciclo for e variabile di lista vuota:

# 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 com­pren­sio­ni di lista sono adatte solo a riempire una nuova lista. Per ampliare una lista esistente si ricorre ai metodi già pre­sen­ta­ti.