Como adicionar elementos a uma lista em Python

Listas são es­tru­tu­ras de dados fun­da­men­tais na Ciência da Com­pu­ta­ção, já que muitos al­go­rit­mos dependem da mo­di­fi­ca­ção dessas listas. Descubra como adicionar elementos a uma lista em Python.

Como adicionar elementos a uma lista em Python

Di­fe­ren­te­mente de tuplas e strings, listas em Python são mutáveis, ou seja, elas possuem es­tru­tu­ras de dados que podem ser mo­di­fi­ca­das. Podemos adicionar elementos a uma lista em Python, removê-los e alterar a ordem deles. Di­fe­ren­tes abor­da­gens realizam essas ações, cada uma com suas próprias vantagens e des­van­ta­gens.

Aqui estão quatro abor­da­gens que você pode usar para adicionar elementos a uma lista em Python:

1. Adicionar elementos a uma lista usando métodos list em Python.
2. Adicionar elementos a uma lista con­ca­te­nando listas em Python.
3. Adicionar elementos a uma lista usando notação de fatia em Python.
4. Adicionar elementos a uma lista usando a com­pre­en­são de listas em Python.

Métodos list para adicionar elementos a uma lista em Python

Em Python, a classe list é a base de todas as operações en­vol­vendo listas. Ela define um conjunto de métodos para os objetos de uma lista. Entre os conjuntos de métodos estão os três listados abaixo, adequados para adicionar elementos a uma lista:

Im­por­tante notar que a mo­di­fi­ca­ção realizada pelos três métodos acima men­ci­o­na­dos é feita lo­cal­mente. Isso significa que o objeto da lista em si é mo­di­fi­cado, não criando e re­tor­nando uma nova lista. Como resultado, todos os três métodos retornam None em vez de uma lista mo­di­fi­cada.

# Lista de números primos
primes = [2, 3, 5, 7]
# Anexar número primo adicional e salvar o resultado retornado
should_be_none = primes.append(11)
# Mostrar que o primo foi adicionado
assert primes == [2, 3, 5, 7, 11]
# Mostrar que `None` foi retornado
assert should_be_none is None

Adicionar único elemento ao final de uma lista com append()

Você pode usar Pythonappend() para adicionar um único elemento ao final de uma lista existente. Vamos ilustrar isso usando um exemplo:

# Lista contendo um único número primo
primes = [2]
# Adicionar um elemento ao final da lista
primes.append(3)
# Mostrar que o elemento foi adicionado
assert primes == [2, 3]

Tenha cuidado ao usar append(), pois esse método só adiciona um único elemento. Se o elemento a ser adi­ci­o­nado for uma lista, por exemplo, o resultado exibido será uma lista aninhada:

# Lista com dois números primos
primes = [2, 3]
# Tentativa de adicionar vários números de uma vez
primes.append([5, 7])
# Lista aninhada acidentalmente criada
assert primes == [2, 3, [5, 7]]

Nossa tentativa de criar a lista [2, 3, 5, 7] falhou. Para adicionar vários elementos a uma lista em Python, é melhor usar o método extend().

Adicionar elementos ao final de uma lista com extend()

Pythonextend() funciona de maneira parecida com Pythonappend(), exceto pelo fato de que vários elementos podem ser adi­ci­o­na­dos a uma lista existente. Vamos ver um exemplo:

# Lista contendo um único número primo
primes = [2]
# Estender lista por dois elementos
primes.extend([3, 5])
# Mostrar que ambos os elementos foram adicionados
assert primes == [2, 3, 5]

Cuidado ao fazer uso de extend(), pois ele espera um iterável como argumento e adiciona cada um de seus elementos se­pa­ra­da­mente à lista, o que pode resultar em um com­por­ta­mento ines­pe­rado:

# Lista de amigos
friends = ['Mary', 'Jim']
# Tentar estender por um amigo adicional
friends.extend('Jack')
# String é separada em letras individuais
assert friends == ['Mary', 'Jim', 'J', 'a', 'c', 'k']

Para adicionar um único elemento a uma lista Python, use append() ou coloque o elemento dentro de uma lista com colchetes. Assim, a chamada para extend() fun­ci­o­nará:

# Lista de amigos
friends = ['Mary', 'Jim']
# Estender por um amigo adicional dentro de uma lista
friends.extend(['Jack'])
# Mostrar que funcionou
assert friends == ['Mary', 'Jim', 'Jack']

Adicionar único elemento antes do index com insert()

Até agora, mostramos como adicionar um ou mais elementos ao final de uma lista em Python. No entanto, você sabe o que fazer se quiser inserir um elemento em uma posição ar­bi­trá­ria? Neste caso, você pode usar Python insert(), que recebe um índice numérico além do elemento a ser inserido:

# Lista de amigos
friends = ['Mary', 'Jim', 'Jack']
# Inserir amigo adicional `“Molly”` antes do index`2`
friends.insert(2, 'Molly')
# Mostrar que “Molly” foi adicionado
assert friends == ['Mary', 'Jim', 'Molly', 'Jack']

Tome cuidado ao adicionar vários elementos com insert(), pois você pode acabar criando, inad­ver­ti­da­mente, uma lista aninhada:

# Lista de amigos
friends = ['Mary', 'Jim']
# Tentar inserir vários amigos de uma vez
friends.insert(1, ['Molly', 'Lucy'])
# Lista aninhada acidentalmente criada
assert friends == ['Mary', ['Molly', 'Lucy'], 'Jim']

Para inserir vários elementos em uma lista, usamos um loop for. Podemos também usar a função reversed() para manter a ordem dos elementos inseridos:

# Lista de amigos
friends = ['Mary', 'Jim']
# `reversed()` mantém a ordem dos elementos inseridos
for friend in reversed(['Molly', 'Lucy']):
    friends.insert(1, friend)
# Mostrar que funcionou
assert friends == ['Mary', 'Molly', 'Lucy', 'Jim']

Con­ca­te­nar para adicionar elementos a uma lista em Python

Outra maneira de adicionar elementos a uma lista Python é re­a­li­zando a con­ca­te­na­ção de listas com o operador +. Essa abordagem é se­me­lhante ao uso de extend(), mas em vez de modificar a lista no local, a con­ca­te­na­ção cria uma nova lista com os elementos adi­ci­o­na­dos.

Vamos criar duas listas e adicionar a segunda à primeira. Como a operação retorna uma nova lista, atri­buí­mos o valor retornado a ela:

# Lista de rapazes
guys = ['Jim', 'Jack']
# Lista de garotas
gals = ['Molly', 'Mary']
# Concatenar ambas as listas
folks = guys + gals
# Mostrar que funcionou
assert folks == ['Jim', 'Jack', 'Molly', 'Mary']

Nos bas­ti­do­res, o operador de con­ca­te­na­ção chama o método __add__(). Isso quer dizer que as ex­pres­sões guys + gals e guys.__add__(gals) são equi­va­len­tes:

# Mostrar que ambas as expressões retornam o mesmo resultado
assert guys + gals == guys.__add__(gals)

Se você estiver fa­mi­li­a­ri­zado com ope­ra­do­res em Python, talvez já tenha percebido que a con­ca­te­na­ção de listas também suporta atri­bui­ção aumentada. O operador += é usado para adicionar elementos a uma lista “no local”:

# Lista de compras
groceries = ['Milk', 'Bread', 'Eggs']
# Adicionar manteiga
groceries += ['Butter']
# Mostrar que funcionou
assert groceries == ['Milk', 'Bread', 'Eggs', 'Butter']

O operador += chama o método __iadd__(). Por sua vez, “i” significa “in-place” (no local). Assim como o método extend(), o objeto no qual o método é chamado é mo­di­fi­cado di­re­ta­mente. Portanto, as seguintes linhas são equi­va­len­tes em termos de resultado:

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

Atente-se ao usar ope­ra­do­res de con­ca­te­na­ção para adicionar um único elemento a uma lista. Um elemento único deve ser colocado em uma lista; caso contrário, um iterável pode ser de­sem­pa­co­tado:

# Lista de cidades
cities = ['London', 'Paris']
# Tentativa de adicionar cidade; provavelmente não era o que você pretendia
cities += 'Rome'
# String é desempacotada em letras individuais
assert cities == ['London', 'Paris', 'R', 'o', 'm', 'e']

Se você usar uma lista de um único elemento, alcançará o efeito desejado de adicionar outra cidade à lista:

# Lista de cidades
cities = ['London', 'Paris']
# Criar uma lista de um único elemento
cities += ['Rome']
# Agora toda a string é adicionada
assert cities == ['London', 'Paris', 'Rome']

Notação de fatia para adicionar elementos a uma lista em Python

Fatiar em Python significa se­le­ci­o­nar uma sub­sequên­cia de elementos de uma lista. A sintaxe de fatias é se­me­lhante à sintaxe da conhecida função range():

# A função `slice()` constrói um novo objeto `slice`
slice(start, stop, step=1)

Além dessa, há ainda uma notação sim­pli­fi­cada para criar objetos slice usando o operador de índice []:

# Selecionar itens da lista
lst[start:stop:step]

Um objeto slice pode ser usado, em vez de um índice numérico, para se­le­ci­o­nar vários elementos de uma sequência:

people = ['Jim', 'John', 'Mary', 'Jack']
# Selecionar elementos entre o índice `1` (inclusivo) e `3` (exclusivo)
assert people[1:3] == ['John', 'Mary']
# Selecionar a cada outro elemento
assert people[::2] == ['Jim', 'Mary']

Em com­bi­na­ção com atri­bui­ções, fatias podem ser usadas como al­ter­na­tiva a métodos list, como append(), extend() e insert():

Para que você entenda como isso funciona, podemos examinar o processo de atri­bui­ção de um valor a um elemento da lista, usando um índice numérico. Isso nos permitirá so­bres­cre­ver um único elemento dentro da lista:

# Lista de compras
groceries = ['Milk', 'Bread', 'Eggs']
# Sobrescrever elemento no índice `1`
groceries[1] = 'Fruit'
# Mostrar que funcionou
assert groceries == ['Milk', 'Fruit', 'Eggs']

Para in­se­rir­mos um elemento usando a atri­bui­ção de índice, podemos utilizar uma fatia que inclua os valores start e stop desejados. É im­por­tante notar que, para a atri­bui­ção de fatia funcionar cor­re­ta­mente, deve haver uma lista do lado direito do sinal de igual:

# Lista de compras
groceries = ['Milk', 'Bread', 'Eggs']
# Inserir elemento antes do índice `1`
groceries[1:1] = ['Fruit']
# Mostrar que funcionou
assert groceries == ['Milk', 'Fruit', 'Bread', 'Eggs']

Se você usar esse truque, con­se­guirá inserir vários elementos de uma vez em uma lista Python, algo que o método insert() não pode fazer:

# Lista de compras
groceries = ['Milk', 'Bread', 'Eggs']
# Inserir elementos antes do índice `1`
groceries[1:1] = ['Fruit', 'Butter']
# Mostrar que funcionou
assert groceries == ['Milk', 'Fruit', 'Butter', 'Bread', 'Eggs']

Além disso, atri­bui­ções de fatia podem ser usadas para so­bres­cre­ver se­le­ti­va­mente elementos de uma lista. Em geral, fatias são um recurso muito flexível, que deve fazer parte do re­per­tó­rio de todo pro­gra­ma­dor de Python.

Adicionar elementos a uma lista em Python por com­pre­en­são de lista

Um cenário comum em Python é preencher uma nova lista com elementos. A abordagem padrão, também suportada por outras lin­gua­gens de pro­gra­ma­ção, funciona da seguinte forma:

1. Criar lista vazia
2. Criar elementos por meio de loop
3. Estender lista por elemento criado

Para entender melhor, observe a geração de uma lista contendo os primeiros dez números ao quadrado:

# Lista vazia a ser preenchida
squares = []
# Sucessivamente criar números 0..9
for n in range(10):
    # Calcular número ao quadrado
    squared = n * n
    # Anexar número ao quadrado à lista
    squares.append(squared)
# Mostrar que funcionou
assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

No entanto, a linguagem de pro­gra­ma­ção Python oferece uma abordagem mais eficiente, conhecida como com­pre­en­são de lista (list com­prehen­sion) para gerar uma lista sem a ne­ces­si­dade de um loop for ou de uma variável de lista vazia:

# Criar os primeiros dez números ao quadrado
squares = [n ** 2 for n in range(10)]
# Mostrar que funcionou
assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Por mais elegantes que sejam, com­pre­en­sões de lista são adequadas apenas para preencher uma nova lista. Para estender uma lista existente, você pode usar outros métodos apre­sen­ta­dos.