Um guia completo sobre listas vazias em Python

Com suas estruturas de dados versáteis, Python se destaca como uma ferramenta poderosa para desenvolvedores e cientistas de dados. Entre essas estruturas, as listas têm um lugar especial por serem dinâmicas e fáceis de usar. Este artigo aprofunda o conceito de listas vazias em Python, explorando sua criação, casos de uso comuns e operações, com explicações claras, passo a passo, e exemplos práticos.

Se você quer se aprofundar no tema, confira nosso tutorial completo sobre listas em Python.

Resposta rápida: como criar uma lista vazia em Python

Para quem está com pressa, criar uma lista vazia em Python é tão simples quanto usar colchetes []. Esse método conciso é fácil de lembrar e eficiente para inicializar uma lista para operações futuras. Veja um exemplo de criação de uma lista vazia chamada my_list e de como adicionar (vamos detalhar mais adiante) as palavras ‘Python’ e ‘Rocks’ a ela.

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

Criando listas vazias em Python: dois métodos para usar

Embora a seção acima tenha apresentado o uso de colchetes [] como um jeito rápido de inicializar uma lista vazia, vale a pena explorar essa técnica em mais detalhes para apreciar sua elegância e eficiência. Além disso, Python também oferece uma alternativa mais explícita, que combina com certos estilos de código e requisitos de clareza.

Método 1: criando listas vazias com []

Usar colchetes [] para criar uma lista vazia é um reflexo da filosofia de design do Python, que prioriza simplicidade e legibilidade. É um ponto de partida limpo e intuitivo para trabalhar com listas. Veja como inicializar uma lista vazia usando []:

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

Método 2: usando a função nativa list() do Python

Como alternativa, Python oferece a função nativa list() que, quando chamada sem argumentos, retorna uma lista vazia. Esse método é igualmente eficaz, embora um pouco mais verboso. Ele pode ser especialmente útil quando a legibilidade e a explicitação do código são prioridade. Veja um exemplo em ação:

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

Operações comuns em listas vazias

Entender como manipular listas vazias é essencial para programar bem em Python. Aqui estão algumas operações importantes que você certamente vai usar ao trabalhar com listas vazias.

Adicionando elementos a uma lista vazia com .append()

Uma lista vazia não é muito útil se você não puder adicionar elementos a ela. Para incluir um elemento no final de uma lista, use o método .append(). No exemplo abaixo, inicializamos uma lista vazia e adicionamos as palavras ’Python’, ’Rocks!’ e ‘It’s easy to learn!’ à 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!']

Inserindo um elemento em uma posição específica com .insert()

Uma limitação de .append() é que ele só adiciona elementos ao final da lista — ou seja, não temos controle sobre onde exatamente inserir um novo elemento usando .append(). Já o método .insert() permite fazer exatamente isso. Vamos retomar o exemplo anterior e inserir ’Truly’ entre ’Python’ e ’Rocks!’. Lembre que Python usa indexação baseada em zero, o que significa que o índice do primeiro elemento é 0. Confira o exemplo:

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

Adicionando vários elementos com .extend()

Enquanto os métodos .append() e .insert() são perfeitos para incluir elementos individuais, .extend() permite adicionar vários elementos de uma vez. Isso é útil, por exemplo, ao juntar duas listas ou adicionar uma coleção de itens sem iterar um a um. Seguindo o exemplo anterior, vamos adicionar mais algumas palavras descritivas à nossa my_list para deixar a frase mais 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!']

Neste exemplo, .extend() recebe um iterável (como lista, conjunto ou tupla) e adiciona cada um de seus elementos ao final de my_list, expandindo nossa frase.

Concatenando listas com +

Outra forma de adicionar elementos de uma lista a outra é usando o operador +, que concatena duas listas. Esse método é direto e não modifica as listas originais; em vez disso, cria uma nova lista. Vamos concatenar uma nova lista à nossa my_list:

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

Neste exemplo, .extend() recebe um iterável (como lista, conjunto ou tupla) e adiciona cada um de seus elementos ao final de my_list, expandindo nossa frase.

Copiando listas com .copy()

Copiar uma lista é essencial quando você quer manter a lista original antes de modificar sua cópia. O método .copy() cria uma cópia rasa da lista, ou seja, duplica a própria lista, mas não os objetos aninhados. Vamos fazer uma cópia de 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

Usar .copy() garante que alterações feitas na cópia não afetem a lista original.

Limpando a lista com .clear()

Às vezes, você pode precisar redefinir uma lista para o estado vazio, removendo todos os elementos. O método .clear() faz exatamente isso, modificando a lista em memória. Vamos limpar a 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

O método .clear() é especialmente útil quando você quer reutilizar ou resetar a lista sem criar um novo objeto.

Casos de uso comuns para inicializar listas vazias em Python

Listas vazias são elementos importantes em vários cenários de programação. Entender suas aplicações pode aumentar bastante sua eficiência e capacidade de resolver problemas.

Armazenando dados dinamicamente em uma lista vazia

Em situações nas quais a quantidade ou o tipo de dados é imprevisível, listas vazias funcionam como contêineres flexíveis para acumular informações dinamicamente. Considere um programa que lê entradas do usuário até uma condição ser atendida. Aqui, não sabemos quantas respostas teremos; usando .append(), conseguimos adicionar elementos à lista user_response de forma dinâmica.

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

Armazenando resultados em uma lista vazia a partir de um loop for

Ao trabalhar com loops, listas vazias são valiosas para compilar resultados gerados a cada iteração. Veja um exemplo em que armazenamos os números pares ao percorrer o intervalo de 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

Armazenando saídas de funções em listas vazias

Ao projetar funções com valores de retorno variáveis, inicializar e retornar uma lista vazia pode lidar elegantemente com cenários sem resultados. Aqui, por exemplo, percorremos uma lista de palavras e armazenamos as que começam com ’A’ em uma lista vazia.

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

Conclusão

Em resumo, dominar listas vazias e suas operações é fundamental na programação em Python e permite manipular dados com versatilidade. Vimos como gerenciar listas de forma eficiente com as operações de adicionar, inserir, estender, concatenar, copiar e limpar em cenários práticos. Esses fundamentos sustentam a codificação em Python e ajudam você a encarar problemas mais complexos com facilidade e criatividade.

Você pode aprender mais sobre listas em Python e várias outras funções úteis na nossa trilha de aprendizado Python Fundamentals — comece hoje mesmo!