Como usar o método 'flatten()' para achatamento de listas em Python.

Como Aplanar uma Lista de Listas em Python

Às vezes, quando você está trabalhando com dados, pode ter os dados como uma lista de listas aninhadas. Uma operação comum é aplanar esses dados em uma lista unidimensional em Python. Aplanar uma lista envolve converter uma lista multidimensional, como uma matriz, em uma lista unidimensional.

Para ilustrar melhor o que significa aplanar uma lista, digamos que você tenha a seguinte matriz de valores numéricos:

matrix = [
    [9, 3, 8, 3],
    [4, 5, 2, 8],
    [6, 4, 3, 1],
    [1, 0, 4, 5],
]

A variável matrix contém uma lista em Python que contém quatro listas aninhadas. Cada lista aninhada representa uma linha na matriz. As linhas armazenam quatro elementos ou números cada. Agora digamos que você queira transformar essa matriz na seguinte lista:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

Como você consegue aplainar sua matriz e obter uma lista unidimensional como a acima? Neste tutorial, você aprenderá como fazer isso em Python.

Como Aplanar uma Lista de Listas com um Loop for

Como você pode aplainar uma lista de listas em Python? Em geral, para aplainar uma lista de listas, você pode seguir as seguintes etapas, explicitamente ou implicitamente:

1. Criar uma nova lista vazia para armazenar os dados aplainados.
2. Iterar sobre cada lista aninhada ou sublista na lista original.
3. Adicionar cada item da sublista atual à lista de dados aplainados.
4. Retornar a lista resultante com os dados aplainados.

Para continuar com o exemplo da matrix, aqui está como você traduziria essas etapas para código Python usando um loop for e o método .extend():

def aplanar_extend(matrix):
    lista_aplainada = []
    for linha in matrix:
        lista_aplainada.extend(linha)
    return lista_aplainada

Dentro de aplanar_extend(), você primeiro cria uma nova lista vazia chamada lista_aplainada. Você usará essa lista para armazenar os dados aplainados quando os extrair de matrix. Em seguida, você inicia um loop para iterar sobre as listas internas ou aninhadas de matrix. Neste exemplo, você usa o nome linha para representar a lista aninhada atual.

Agora execute o seguinte código para verificar se sua função faz o trabalho:

lista_aplainada = aplanar_extend(matrix)
print(lista_aplainada)

A saída será:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

Parabéns! Agora você sabe como aplanar uma lista de listas usando um loop for e o método .extend().

Continue lendo para aprender outras maneiras de aplainar listas em Python.

Usando uma Compreensão para Aplanar uma Lista de Listas

Outra maneira concisa de aplainar uma lista de listas em Python é usando uma compreensão de lista. Uma compreensão de lista oferece uma maneira elegante e eficiente de criar uma nova lista a partir de uma sequência existente, aplicando uma expressão a cada elemento dessa sequência.

No caso de aplainar uma lista de listas, você pode usar uma única linha de código para criar uma nova lista que contém todos os elementos das sublistas. Aqui está como você faria isso:

lista_aplainada = [item for sublist in matrix for item in sublist]

Aqui, a expressão [item for sublist in matrix for item in sublist] é a parte da compreensão de lista que cria uma nova lista plana. O for sublist in matrix indica que você deseja iterar sobre cada sublista em matrix. Em seguida, o segundo for item in sublist itera sobre cada item dentro de uma sublista. O item é adicionado à nova lista.

Aqui está o código completo:

def aplanar_compreensao(matrix):
    lista_aplainada = [item for sublist in matrix for item in sublist]
    return lista_aplainada

lista_aplainada = aplanar_compreensao(matrix)
print(lista_aplainada)

A saída será a mesma que antes:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

Usando uma compreensão de lista, você pode aplanar uma lista de listas de forma mais concisa e expressiva.

Continue lendo para descobrir outras ferramentas da biblioteca padrão e built-in do Python que você pode usar para aplainar listas.

Aplainando uma Lista Usando Ferramentas da Biblioteca Padrão e Built-In

Além do loop for e das compreensões de lista, o Python possui outras ferramentas da biblioteca padrão e built-in que você pode usar para aplainar listas de maneira eficiente.

Encadeando Iteráveis com itertools.chain()

Um desses recursos é o módulo itertools, que fornece uma coleção de funções que operam em iteráveis para criar iteráveis mais complexos. O itertools.chain() é uma dessas funções que permite encadear iteráveis, combinando-os em uma sequência única.

Para utilizar essa função, primeiro importe o módulo itertools:

import itertools

Agora, você pode usar o itertools.chain() para aplainar uma lista de listas. Aqui está como isso é feito:

lista_aplainada = list(itertools.chain(*matrix))

Neste exemplo, o *matrix é chamado de “operador de descompactação”. Ele descompacta os elementos de matrix e fornece cada lista aninhada como um argumento separado para itertools.chain(). Em seguida, list() é usado para converter o objeto iterável retornado por itertools.chain() de volta em uma lista.

Aqui está o código completo:

import itertools

def aplanar_encadeando(matrix):
    lista_aplainada = list(itertools.chain(*matrix))
    return lista_aplainada

lista_aplainada = aplanar_encadeando(matrix)
print(lista_aplainada)

A saída será a mesma de antes:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

Usando o itertools.chain(), você pode aplanar uma lista de listas de forma concisa e eficiente.

Concatenando Listas com functools.reduce()

Outra forma de aplanar uma lista de listas em Python é usando a função reduce() do módulo functools. A função reduce() aplica uma função a pares de itens da sequência dada até reduzi-la a um único valor.

No caso de aplanar uma lista de listas, você pode usar reduce() em conjunto com a função operator.add() para concatenar as sublistas em uma lista achatada:

import functools
import operator

def aplanar_reduzindo(matrix):
    lista_aplainada = functools.reduce(operator.add, matrix)
    return lista_aplainada

lista_aplainada = aplanar_reduzindo(matrix)
print(lista_aplainada)

Neste exemplo, functools.reduce(operator.add, matrix) aplica a função operator.add() (que é a função de adição) em pares de itens em matrix, concatenando-os em uma lista achatada.

O resultado será o mesmo da saída anterior:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

A função reduce() juntamente com a função operator.add() oferece outra maneira eficiente de aplanar uma lista de listas em Python.

Usando sum() para Concatenar Listas

Além de reduce() e chain(), você também pode usar a função sum() para aplainar uma lista de listas em Python. A função sum() é usada para calcular a soma dos elementos em uma sequência, mas você também pode usá-la para concatenar listas.

Aqui está como utilizar o sum() para aplainar uma lista de listas:

lista_aplainada = sum(matrix, [])

Ao passar um segundo argumento vazio [] para sum(), você define um valor inicial para a soma e, neste caso, uma lista vazia. A função sum() então concatena as sublistas em uma lista achatada.

Aqui está o código completo:

def aplanar_somando(matrix):
    lista_aplainada = sum(matrix, [])
    return lista_aplainada

lista_aplainada = aplanar_somando(matrix)
print(lista_aplainada)

A saída será a mesma de antes:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

A função sum() oferece uma maneira simples e concisa de aplainar uma lista de listas em Python.

Considerando o Desempenho ao Aplanar suas Listas

Ao aplanar listas em Python, é importante considerar o desempenho, especialmente quando você está lidando com grandes conjuntos de dados. Algumas das abordagens mencionadas anteriormente podem ser mais eficientes do que outras, dependendo do tamanho das suas listas.

Em geral, o loop for e a compreensão de lista são as abordagens mais rápidas e eficientes. No entanto, em certos casos, usar a função itertools.chain(), functools.reduce() ou sum() pode ser mais adequado, principalmente quando se lida com listas muito grandes.

Ao decidir qual abordagem usar, leve em consideração também a legibilidade do código e a familiaridade com as ferramentas disponíveis. Escolha aquela que melhor atenda às suas necessidades específicas e se ajuste ao contexto do seu código.

Aplainando Listas Python para Ciência de Dados com NumPy

Se você está trabalhando com ciência de dados em Python, pode se beneficiar do uso da biblioteca NumPy para aplainar listas. NumPy é uma biblioteca popular para manipulação de dados numéricos em Python.

Aqui está como você pode aplainar listas Python com NumPy:

import numpy as np

def aplanar_numpy(matrix):
    array_aplainado = np.array(matrix).flatten()
    lista_aplainada = array_aplainado.tolist()
    return lista_aplainada

lista_aplainada = aplanar_numpy(matrix)
print(lista_aplainada)

Primeiro, você precisa importar a biblioteca NumPy usando import numpy as np. Em seguida, utilize np.array() para criar um array NumPy a partir da sua matriz. Em seguida, chame o método .flatten() para aplainar o array NumPy. Finalmente, use o método .tolist() para converter o array aplainado de volta em uma lista Python.

A saída será a mesma da saída anterior:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

Usando NumPy, você pode aplainar listas Python de maneira eficiente e realizar manipulações numéricas adicionais.

Conclusão

Aplanhar uma lista de listas em Python é uma tarefa comum ao trabalhar com dados. Neste artigo, você aprendeu várias maneiras de aplainar listas de forma eficiente:

• Usando um loop for e o método .extend() para adicionar itens a uma nova lista.
• Usando uma compreensão de lista para criar uma nova lista mais concisa.
• Usando ferramentas da biblioteca padrão e built-in do Python, como itertools.chain(), functools.reduce() e sum().
• Considerando o desempenho ao escolher a melhor abordagem para a sua situação específica.
• Utilizando a biblioteca NumPy para aplainar listas em trabalhos de ciência de dados.

Agora você está equipado com várias opções para aplainar suas listas em Python. Escolha a abordagem que melhor se adapte ao seu caso de uso e melhore a eficiência do seu código.