# Como adicionar elementos a uma lista em Python Listas são estruturas de dados fundamentais na Ciência da Computação, já que muitos **algoritmos dependem da modificação dessas listas**. Descubra como adicionar elementos a uma lista em Python. ## Como adicionar elementos a uma lista em Python Diferentemente de tuplas e strings, **listas em Python são mutáveis**, ou seja, elas possuem estruturas de dados que podem ser modificadas. Podemos adicionar elementos a uma [lista em Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/listas-em-python/ "Listas em Python"), removê-los e alterar a ordem deles. Diferentes abordagens realizam essas ações, cada uma com suas próprias vantagens e desvantagens. Aqui estão **quatro abordagens** 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 concatenando listas em Python. 3. Adicionar elementos a uma lista usando notação de fatia em Python. 4. Adicionar elementos a uma lista usando a compreensã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 envolvendo 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:
Método `list` Argumentos Explicação
`append()` `element` Adiciona um único elemento ao final da lista
`extend()` `[elements]` Adiciona vários elementos ao final da lista
`insert()` `index element` Adiciona um único elemento antes do index
Importante notar que a **modificação realizada pelos três métodos acima mencionados é feita localmente**. Isso significa que o objeto da lista em si é modificado, não criando e retornando uma nova lista. Como resultado, todos os três métodos retornam `None` em vez de uma lista modificada. ```Python # 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 [Python`append()`](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-append/) para adicionar um **único elemento ao final de uma lista existente**. Vamos ilustrar isso usando um exemplo: ```python # 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 adicionado for uma lista, por exemplo, o resultado exibido será uma lista aninhada: ```Python # 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()` [Python`extend()`](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-extend/) funciona de maneira parecida com Python`append()`, exceto pelo fato de que **vários elementos podem ser adicionados a uma lista existente**. Vamos ver um exemplo: ```python # 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 separadamente à lista**, o que pode resultar em um comportamento inesperado: ```python # 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()` funcionará: ```python # 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 arbitrária? Neste caso, você pode usar Python `insert()`, que recebe um índice numérico além do elemento a ser inserido: ```python # 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, inadvertidamente, **uma lista aninhada**: ```python # 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: ```python # 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'] ``` ## Concatenar para adicionar elementos a uma lista em Python Outra maneira de adicionar elementos a uma lista Python é realizando a **concatenação de listas** com o operador `+`. Essa abordagem é semelhante ao uso de `extend()`, mas em vez de modificar a lista no local, a concatenação cria uma nova lista com os elementos adicionados. Vamos criar duas listas e adicionar a segunda à primeira. Como a **operação retorna uma nova lista**, atribuímos o valor retornado a ela: ```Python # 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 bastidores, **o operador de concatenação chama o método `__add__()`**. Isso quer dizer que as expressões `guys + gals` e `guys.__add__(gals)` são equivalentes: ```python # Mostrar que ambas as expressões retornam o mesmo resultado assert guys + gals == guys.__add__(gals) ``` Se você estiver familiarizado com [operadores em Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operadores-python/ "Operadores em Python"), talvez já tenha percebido que **a concatenação de listas também suporta atribuição aumentada**. O operador `+=` é usado para adicionar elementos a uma lista “no local”: ```python # 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 é modificado diretamente**. Portanto, as seguintes linhas são equivalentes em termos de resultado: - `groceries = groceries + ['Butter']` - `groceries += ['Butter']` - `groceries.__iadd__(['Butter'])` - `groceries.extend(['Butter'])` Atente-se ao usar operadores de concatenaçã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 desempacotado: ```python # 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: ```python # 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 **selecionar uma subsequência de elementos de uma lista**. A sintaxe de fatias é semelhante à sintaxe da conhecida função `range()`: ```python # A função `slice()` constrói um novo objeto `slice` slice(start, stop, step=1) ``` Além dessa, há ainda uma **notação simplificada para criar objetos slice** usando o operador de índice `[]`: ```python # Selecionar itens da lista lst[start:stop:step] ``` Um **objeto slice pode ser usado, em vez de um índice numérico**, para selecionar vários elementos de uma sequência: ```python 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 **combinação com atribuições**, fatias podem ser usadas como alternativa a métodos `list`, como `append()`, `extend()` e `insert()`:
Método `list` Atribuição de fatia correspondente Explicação
`lst.append(element)` `lst[len(lst)+1:] = [element]` Adiciona um item ao final da lista
`lst.extend([elements])` `lst[len(lst)+1:] = [elements]` Adiciona vários elementos ao final da lista
`lst.insert(index, element)` `lst[index:index] = [element]` Adiciona um elemento antes do índice dado
Para que você entenda como isso funciona, podemos examinar o processo de **atribuição de um valor a um elemento da lista, usando um índice numérico**. Isso nos permitirá sobrescrever um único elemento dentro da lista: ```python # Lista de compras groceries = ['Milk', 'Bread', 'Eggs'] # Sobrescrever elemento no índice `1` groceries[1] = 'Fruit' # Mostrar que funcionou assert groceries == ['Milk', 'Fruit', 'Eggs'] ``` Para inserirmos um **elemento usando a atribuição de índice**, podemos utilizar uma fatia que inclua os valores `start` e `stop` desejados. É importante notar que, para a atribuição de fatia funcionar corretamente, deve haver uma lista do lado direito do sinal de igual: ```python # 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, conseguirá **inserir vários elementos de uma vez** em uma lista Python, algo que o método `insert()` não pode fazer: ```python # 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, **atribuições de fatia podem ser usadas para sobrescrever seletivamente elementos de uma lista**. Em geral, fatias são um recurso muito flexível, que deve fazer parte do repertório de todo programador de Python. ## Adicionar elementos a uma lista em Python por compreensão de lista Um cenário comum em Python é preencher uma **nova lista com elementos**. A abordagem padrão, também suportada por outras linguagens de programaçã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**: ```python # 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 programação Python oferece uma abordagem mais eficiente, conhecida como **compreensão de lista** (*list comprehension*) para gerar uma lista sem a necessidade de um loop `for` ou de uma variável de lista vazia: ```python # 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, compreensões de lista **são adequadas apenas para preencher uma nova lista**. Para estender uma lista existente, você pode usar outros métodos apresentados. Dica Para implantar sites e aplicativos pelo GitHub com toda facilidade, use o [Deploy Now](https://www.ionos.com/hosting/deploy-now "Deploy Now: Deploy Websites and Apps via GitHub — IONOS") da IONOS. This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/adicionar-elementos-lista-python/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/adicionar-elementos-lista-python/) for AI/LLM consumption.