Como anexar um array 2D em Python

Anexar valores a um array 2D em Python é uma operação comum em manipulação de dados, computação numérica e aplicações de ciência de dados. Esteja você trabalhando com listas nativas do Python ou usando NumPy para eficiência, existem vários métodos para anexar linhas, colunas ou valores individuais a um array 2D. Este guia explora diferentes técnicas, suas vantagens e casos de uso.

Usar listas aninhadas (listas do Python)

As listas integradas do Python podem representar arrays 2D como listas de listas. A maneira mais simples de anexar valores é usar o método append().

Anexar uma nova linha

array = [[1, 2, 3], [4, 5, 6]]
array.append([7, 8, 9])
print(array)

Saída:

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

Este método adiciona uma linha inteiramente nova à lista existente. O método append() é útil quando você deseja expandir uma lista 2D dinamicamente, adicionando mais dados ao longo do tempo. No entanto, observe que todas as linhas podem precisar ter o mesmo comprimento para o processamento de dados estruturados.

Anexar um valor a uma linha existente

array[0].append(10)
print(array)

Saída:

[[1, 2, 3, 10],
 [4, 5, 6],
 [7, 8, 9]]

Este método modifica uma linha específica anexando um novo elemento. Diferentemente de adicionar uma nova linha, esta operação afeta apenas a linha especificada, o que pode levar a uma estrutura de colunas irregular se não for gerenciada adequadamente.

Usar compreensão de lista

As compreensões de lista fornecem uma maneira elegante de anexar valores em todas as linhas de uma lista 2D.

array = [[1, 2], [3, 4]]
array = [row + [5] for row in array]
print(array)

Saída:

[[1, 2, 5],
 [3, 4, 5]]

Este método adiciona eficientemente uma nova coluna a cada linha. Ao iterar sobre cada linha e anexar um valor, a compreensão de lista garante que a nova coluna seja adicionada uniformemente em todas as linhas.

Usar arrays NumPy

O NumPy fornece métodos poderosos para manipular e anexar valores a arrays 2D de forma eficiente. No entanto, ao lidar com grandes conjuntos de dados com muitos valores vazios, usar uma matriz esparsa pode reduzir significativamente o consumo de memória. Saiba mais sobre [matrizes esparsas em Python]({{relref “/HowTo/Python/sparse matrix in python.en.md”}}) e como elas otimizam o armazenamento.

Usar numpy.append()

import numpy as np

array = np.array([[1, 2], [3, 4]])
array = np.append(array, [[5, 6]], axis=0)
print(array)

Saída:

[[1 2]
 [3 4]
 [5 6]]

Este método anexa uma nova linha a um array NumPy. A função numpy.append() é útil ao lidar com grandes conjuntos de dados, pois garante um gerenciamento eficiente de memória em comparação com as listas nativas do Python.

Para anexar uma nova coluna:

array = np.append(array, [[7], [8], [9]], axis=1)
print(array)

Saída:

[[1 2 7]
 [3 4 8]
 [5 6 9]]

Depois de anexar valores, você possivelmente precisará salvar o array modificado em um arquivo para uso posterior. Você pode consultar nosso guia sobre [escrever arrays em um arquivo de texto]({{relref “/HowTo/Python/write array to a textfile.en.md”}}) para obter detalhes sobre como armazenar arrays NumPy de forma eficiente.

Se você encontrar erros de indexação ao modificar arrays NumPy, consulte nosso guia sobre como corrigir erros de ‘Too Many Indices for Array’ para solucionar erros comuns.

Usar numpy.hstack() e numpy.vstack()

As funções hstack() e vstack() do NumPy foram projetadas para anexar colunas e linhas de forma eficiente.

Usar hstack() para anexar uma coluna

import numpy as np

array = np.array([[1, 2], [3, 4]])
new_column = np.array([[5], [6]])
result = np.hstack((array, new_column))
print(result)

Saída:

[[1 2 5]
 [3 4 6]]

Usar vstack() para anexar uma linha

new_row = np.array([[5, 6]])
result = np.vstack((array, new_row))
print(result)

Saída:

[[1 2]
 [3 4]
 [5 6]]

Esses métodos são eficientes e recomendados ao trabalhar com grandes conjuntos de dados. Diferentemente de numpy.append(), que pode exigir a reestruturação de todo o array, hstack() e vstack() são otimizados para extensões por coluna e por linha, respectivamente.

Se você estiver trabalhando com dados numéricos estruturados, também pode precisar transpor matrizes para remodelar os dados de forma eficiente. Confira nosso artigo sobre transpor matrizes em Python.

Usar o operador +=

array = [[1, 2], [3, 4]]
array += [[5, 6]]
print(array)

Saída:

[[1, 2],
 [3, 4],
 [5, 6]]

Este método é uma forma abreviada de append(), mas modifica a lista no local. Usar += garante que novas linhas sejam adicionadas diretamente sem criar uma nova referência, tornando-o uma abordagem eficiente para lidar com listas 2D pequenas.

Usar extend() para anexar várias linhas

array = [[1, 2], [3, 4]]
array.extend([[5, 6], [7, 8]])
print(array)

Saída:

[[1, 2],
 [3, 4],
 [5, 6],
 [7, 8]]

Isso é útil ao adicionar várias linhas de uma só vez. O método extend() é particularmente útil ao mesclar dados de diferentes fontes em uma única lista 2D.

Se você precisar armazenar a lista atualizada como um arquivo CSV, pode consultar nosso guia sobre escrever listas em um arquivo CSV em Python.

Usar insert() para adicionar uma linha em um índice específico

array = [[1, 2], [3, 4]]
array.insert(1, [5, 6])
print(array)

Saída:

[[1, 2],
 [5, 6],
 [3, 4]]

O método insert() permite o posicionamento preciso de linhas dentro do array. Isso é útil ao trabalhar com conjuntos de dados ordenados, nos quais novas entradas precisam ser inseridas em posições específicas sem perturbar a estrutura geral.

Usar laços aninhados para o preenchimento dinâmico de arrays 2D

array = []
for i in range(3):
    row = []
    for j in range(2):
        row.append(i * j)
    array.append(row)
print(array)

Saída:

[[0, 0],
 [0, 1],
 [0, 2]]

Este método é útil para gerar dinamicamente arrays 2D estruturados. Usar laços aninhados oferece controle total sobre como os dados são preenchidos, tornando-o ideal para gerar matrizes e estruturas baseadas em grade de forma programática.

Conclusão

O Python fornece várias maneiras de anexar valores a um array 2D. Se você estiver trabalhando com listas padrão, append(), extend() e as compreensões de lista são escolhas eficazes. Para operações numéricas de alto desempenho, append(), hstack() e vstack() do NumPy fornecem soluções otimizadas. O método certo depende de você estar lidando com listas pequenas ou dados numéricos em grande escala.

Comparação de métodos