Guida completa alle liste vuote in Python

Python, con le sue strutture dati versatili, si distingue come uno strumento potente per sviluppatori e data scientist. Tra queste strutture, le liste occupano un posto speciale grazie alla loro natura dinamica e alla facilità d’uso. Questo articolo approfondisce il concetto di liste vuote in Python, esplorandone la creazione, i casi d’uso comuni e le operazioni, con l’obiettivo di fornire spiegazioni chiare passo dopo passo ed esempi pratici.

Se cerchi maggiori informazioni sull’argomento, dai un’occhiata al nostro tutorial completo sulle liste in Python.

La risposta breve: come creare una lista vuota in Python

Per chi va di fretta, creare una lista vuota in Python è semplice come usare le parentesi quadre []. Questo metodo conciso non è solo facile da ricordare, ma è anche efficiente per inizializzare una lista su cui eseguire ulteriori operazioni. Ecco un esempio in cui creiamo una lista vuota chiamata my_list e aggiungiamo (approfondito più avanti) le parole «Python» e «Rocks».

# Create an empty list called my_list
my_list = []
# Append the words 'Python' and 'Rocks' to it
my_list.append('Python')
my_list.append('Rocks')

# my_list is now ['Python', 'Rocks']

Creare liste vuote in Python: due metodi da usare

Sebbene la breve sezione precedente abbia introdotto l’uso delle parentesi quadre [] come metodo rapido per inizializzare una lista vuota, vale la pena esplorare questa tecnica in maggior dettaglio per apprezzarne eleganza ed efficienza. Inoltre, Python offre anche un’alternativa più esplicita che si allinea a determinati stili di codice ed esigenze di chiarezza.

Metodo 1: Creare liste vuote usando []

L’uso delle parentesi quadre [] per creare una lista vuota è una testimonianza della filosofia di design di Python, che enfatizza semplicità e leggibilità. Rappresenta un punto di partenza pulito e intuitivo per le operazioni sulle liste. Ecco un promemoria su come inizializzare una lista vuota usando []:

# Initializing an empty list with square brackets
my_empty_list = []

Metodo 2: Usare la funzione integrata di Python list()

In alternativa, Python fornisce una funzione integrata list() che, se chiamata senza argomenti, restituisce una lista vuota. Questo metodo è altrettanto efficace, sebbene leggermente più verboso. Può risultare particolarmente utile quando si dà priorità alla leggibilità e all’esplicitazione del codice. Ecco un esempio pratico:

# Create an empty list using the list() function
my_empty_list = list()

Operazioni comuni sulle liste vuote

Capire come manipolare le liste vuote è fondamentale per programmare efficacemente in Python. Ecco alcune operazioni chiave che userai sicuramente lavorando con liste vuote.

Aggiungere elementi a una lista vuota con .append()

Una lista vuota non è molto utile se non puoi aggiungervi elementi. Per aggiungere un elemento alla fine di una lista, usa semplicemente il metodo .append(). Qui, per esempio, inizializziamo una lista vuota e aggiungiamo le parole «Python», «Rocks!» e «It’s easy to learn!» alla lista my_list.

# Initialize an empty list
my_list = []

# Append elements
my_list.append('Python')
my_list.append('Rocks!')
my_list.append('It’s easy to learn!')

# `my_list` is now ['Python', 'Rocks!', 'It’s easy to learn!']

Inserire un elemento in una posizione specifica con .insert()

Uno svantaggio di .append() è che aggiunge elementi solo alla fine di una lista — significa che non abbiamo controllo su dove inserire esattamente un nuovo elemento quando usiamo .append(). Il metodo .insert(), invece, ci permette di fare proprio questo. Riprendiamo l’esempio della sezione precedente e inseriamo «Truly» tra «Python» e «Rocks!». Nota che Python usa l’indicizzazione a base zero, il che significa che l’indice del primo elemento della lista è 0. Guarda l’esempio per maggiori dettagli:

# Initialize an empty list
my_list = []

# Append elements
my_list.append('Python')
my_list.append('Rocks!')
my_list.append('It’s easy to learn!')

# `my_list` is now ['Python', 'Rocks!', 'It’s easy to learn!']

# Showcase zero-based indexing in Python
my_list[0] # Returns 'Python'
my_list[1] # Returns 'Rocks'
my_list[2] # Returns 'It's easy to learn!'

# Use the .insert() method to insert ’Truly’ between ’Python’ and ’Rocks!’
my_list.insert(1, 'Truly')
# `my_list` is now ['Python', 'Truly', 'Rocks', 'It’s easy to learn!']

Aggiungere più elementi con .extend()

Mentre i metodi .append() e .insert() sono perfetti per aggiungere singoli elementi a una lista, .extend() ci consente di aggiungere più elementi in una volta. Questo può essere particolarmente utile quando vuoi unire due liste o aggiungere una collezione di elementi senza iterarli manualmente. Proseguendo dall’esempio precedente, aggiungiamo qualche parola descrittiva in più alla nostra my_list per rendere la frase più interessante:

# Reminder that `my_list` is ['Python', 'Truly', 'Rocks', 'It’s easy to learn!']

# Extend my_list with ['and', 'fun', 'to', 'use!']
my_list.extend(['and', 'fun', 'to', 'use!'])

# `my_list` is now ['Python', 'Truly', 'Rocks!', 'It’s easy to learn!', 'and', 'fun', 'to', 'use!']

In questo esempio, .extend() accetta un iterabile (come una lista, un set o una tupla) e ne aggiunge ciascun elemento alla fine di my_list, ampliando ulteriormente la nostra frase.

Concatenare liste usando +

Un altro modo per aggiungere elementi da una lista a un’altra è usare l’operatore +, che concatena due liste. Questo metodo è semplice e non modifica le liste originali, ma crea una nuova lista. Concatenamo una nuova lista alla nostra my_list esistente:

# Define a new list to concatenate
additional_words = ['Python is also', 'very versatile.']

# Concatenate lists using +
complete_sentence = my_list + additional_words

# `complete_sentence` now contains the elements of both lists
# `complete_sentence` is now ['Python', 'Truly', 'Rocks!', 'It’s easy to learn!', 'and', 'fun', 'to', 'use!', 'Python is also', 'very versatile.']

In questo esempio, .extend() accetta un iterabile (come una lista, un set o una tupla) e ne aggiunge ciascun elemento alla fine di my_list, ampliando ulteriormente la nostra frase.

Copiare liste con .copy()

Copiare una lista è essenziale quando vuoi conservare l’originale prima di modificarne una copia. Il metodo .copy() crea una copia superficiale della lista, il che significa che duplica la lista stessa ma non gli oggetti annidati in profondità. Facciamo una copia di my_list:

# Make a copy of `my_list`
my_list_copy = my_list.copy()

# Verify that `my_list_copy` is a separate object
assert my_list_copy is not my_list  # This will pass, confirming they are different objects

Usare .copy() garantisce che le modifiche apportate alla lista copiata non influiscano sulla lista originale.

Svuotare la lista con .clear()

A volte potresti aver bisogno di riportare una lista al suo stato vuoto, rimuovendone tutti gli elementi. Il metodo .clear() ti permette di farlo, modificando la lista in place. Svuotiamo my_list:

# Clear all elements from `my_list`
my_list.clear()

# `my_list` is now an empty list again
assert len(my_list) == 0  # This will pass, confirming the list is empty

Il metodo .clear() è particolarmente utile quando devi riutilizzare o azzerare la lista senza creare un nuovo oggetto lista.

Casi d’uso comuni per inizializzare liste vuote in Python

Le liste vuote fungono da elementi necessari in vari scenari di programmazione. Comprenderne le applicazioni può migliorare sensibilmente l’efficienza del codice e le capacità di problem solving.

Archiviare dati in modo dinamico in una lista vuota

In situazioni in cui la quantità o il tipo di dati è imprevedibile, le liste vuote emergono come contenitori flessibili per accumulare informazioni in modo dinamico. Considera un programma che legge input dell’utente fino al verificarsi di una condizione specifica. Qui non conosciamo il numero di input che potremmo ricevere e, usando il metodo .append(), possiamo aggiungere dinamicamente elementi alla lista user_response.

# Initialize an empty list to store user input
user_responses = []

# Collect user input in a loop
while True:
    response = input("Enter your response (or type 'exit' to finish): ")
    if response.lower() == 'exit':
        break
    user_responses.append(response)

# User responses are now stored in `user_responses`

Archiviare risultati in una lista vuota da un ciclo For

Quando lavori con i cicli, le liste vuote sono preziose per raccogliere i risultati generati a ogni iterazione. Ecco un esempio in cui memorizziamo i numeri pari mentre iteriamo nell’intervallo da 0 a 20.

# Initialize an empty list to store even numbers
even_numbers = []

# Loop through a range of numbers and store even ones
for number in range(21):  # Upper limit 21 to include 20 in the range
    if number % 2 == 0: # if remainder when divided by 2 =0, store it in empty list
        even_numbers.append(number)

# `even_numbers` now contains even numbers from 0 to 20

Archiviare output di funzioni in liste vuote

Quando progetti funzioni con valori di ritorno variabili, inizializzare e restituire una lista vuota può gestire elegantemente gli scenari senza risultati. Qui, ad esempio, iteriamo su una lista di parole e memorizziamo in una lista vuota quelle che iniziano con «A».

def find_strings_starting_with_a(strings):
    # Initialize an empty list to store strings that start with 'A'
    strings_starting_with_a = []
    
    # Iterate over the input list and append strings that start with 'A' to `strings_starting_with_a`
    for string in strings:
        if string.startswith('A'):
            strings_starting_with_a.append(string)
    
    return strings_starting_with_a

# Example usage
result = find_strings_starting_with_a(['Assert', 'Import', 'Function', 'Array', 'Arguments'])

# 'result' will contain ['Assert', 'Array', 'Arguments']

Conclusione

In sintesi, padroneggiare le liste vuote e le loro operazioni è fondamentale nella programmazione Python, perché permette una manipolazione dei dati versatile. Attraverso append, insert, extend, concatenazione, copia e clear, abbiamo visto come gestire efficacemente le liste in scenari pratici. Queste competenze di base sono la spina dorsale del coding in Python e ti consentono di affrontare problemi più complessi con facilità e creatività.

Puoi approfondire le liste in Python e molte altre funzioni utili nel nostro percorso di competenze Python Fundamentals: inizia oggi stesso!