Numpy - adicionar linha à matriz

Como se adiciona linhas a uma matriz numpy?

Eu tenho uma matriz A:

A = array([[0, 1, 2], [0, 2, 0]])

Desejo adicionar linhas a esta matriz de outra matriz X se o primeiro elemento de cada linha em X atender a uma condição específica.

As matrizes numpy não têm um método 'anexar' como o das listas, ou assim parece.

Se A e X fossem listas, eu simplesmente faria:

for i in X:
    if i[0] < 3:
        A.append(i)

Existe uma maneira numpythonic de fazer o equivalente?

Obrigado, S ;-)

O que é X? Se for um array 2D, como você pode comparar sua linha com um número i < 3:?

EDITAR após o comentário do OP:

A = array([[0, 1, 2], [0, 2, 0]])
X = array([[0, 1, 2], [1, 2, 0], [2, 1, 2], [3, 2, 0]])

adicione a Atodas as linhas de Xonde o primeiro elemento < 3:

import numpy as np
A = np.vstack((A, X[X[:,0] < 3]))

# returns: 
array([[0, 1, 2],
       [0, 2, 0],
       [0, 1, 2],
       [1, 2, 0],
       [2, 1, 2]])

bem, você pode fazer isso:

  newrow = [1,2,3]
  A = numpy.vstack([A, newrow])

Como essa pergunta foi feita 7 anos antes, na versão mais recente que eu estou usando é a versão numpy 1.13, e python3, estou fazendo a mesma coisa ao adicionar uma linha a uma matriz, lembre-se de colocar um colchete duplo no segundo argumento, caso contrário, aumentará o erro de dimensão.

Aqui eu estou adicionando na matriz A

1 2 3
4 5 6

com uma linha

7 8 9

mesmo uso em np.r_

A= [[1, 2, 3], [4, 5, 6]]
np.append(A, [[7, 8, 9]], axis=0)

    >> array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
#or 
np.r_[A,[[7,8,9]]]

Apenas para alguém interessado, se você quiser adicionar uma coluna,

array = np.c_[A,np.zeros(#A's row size)]

seguindo o que fizemos antes na matriz A, adicionando uma coluna a ela

np.c_[A, [2,8]]

>> array([[1, 2, 3, 2],
          [4, 5, 6, 8]])

Você também pode fazer isso:

newrow = [1,2,3]
A = numpy.concatenate((A,newrow))

Se nenhum cálculo for necessário após cada linha, é muito mais rápido adicionar linhas no python e converter para numpy. Aqui estão os testes de temporização usando python 3.6 vs. numpy 1.14, adicionando 100 linhas, uma de cada vez:

import numpy as np 
from time import perf_counter, sleep

def time_it():
    # Compare performance of two methods for adding rows to numpy array
    py_array = [[0, 1, 2], [0, 2, 0]]
    py_row = [4, 5, 6]
    numpy_array = np.array(py_array)
    numpy_row = np.array([4,5,6])
    n_loops = 100

    start_clock = perf_counter()
    for count in range(0, n_loops):
       numpy_array = np.vstack([numpy_array, numpy_row]) # 5.8 micros
    duration = perf_counter() - start_clock
    print('numpy 1.14 takes {:.3f} micros per row'.format(duration * 1e6 / n_loops))

    start_clock = perf_counter()
    for count in range(0, n_loops):
        py_array.append(py_row) # .15 micros
    numpy_array = np.array(py_array) # 43.9 micros       
    duration = perf_counter() - start_clock
    print('python 3.6 takes {:.3f} micros per row'.format(duration * 1e6 / n_loops))
    sleep(15)

#time_it() prints:

numpy 1.14 takes 5.971 micros per row
python 3.6 takes 0.694 micros per row

Portanto, a solução simples para a pergunta original, de sete anos atrás, é usar vstack () para adicionar uma nova linha após converter a linha em uma matriz numpy. Mas uma solução mais realista deve considerar o fraco desempenho do vstack nessas circunstâncias. Se você não precisar executar a análise de dados na matriz após cada adição, é melhor armazenar em buffer as novas linhas em uma lista de linhas python (uma lista de listas, na verdade) e adicioná-las como um grupo à matriz numpy usando vstack () antes de fazer qualquer análise de dados.

import numpy as np
array_ = np.array([[1,2,3]])
add_row = np.array([[4,5,6]])

array_ = np.concatenate((array_, add_row), axis=0)

Se você pode fazer a construção em uma única operação, algo como a resposta de indexação vstack-fancy-fancy é uma abordagem adequada. Mas se sua condição for mais complicada ou suas linhas surgirem rapidamente, convém aumentar a matriz. De fato, a maneira numptitônica de fazer algo assim - aumentar dinamicamente uma matriz - é aumentar dinamicamente uma lista:

A = np.array([[1,2,3],[4,5,6]])
Alist = [r for r in A]
for i in range(100):
    newrow = np.arange(3)+i
    if i%5:
        Alist.append(newrow)
A = np.array(Alist)
del Alist

As listas são altamente otimizadas para esse tipo de padrão de acesso; você não tem uma indexação multidimensional numpy conveniente enquanto estiver em forma de lista, mas enquanto estiver anexando, é difícil fazer melhor do que uma lista de matrizes de linha.

Eu uso 'np.vstack', que é mais rápido, EX:

import numpy as np

input_array=np.array([1,2,3])
new_row= np.array([4,5,6])

new_array=np.vstack([input_array, new_row])

Você pode usar numpy.append()para anexar uma linha à matriz numpty e remodelar para uma matriz posteriormente.

import numpy as np
a = np.array([1,2])
a = np.append(a, [3,4])
print a
# [1,2,3,4]
# in your example
A = [1,2]
for row in X:
    A = np.append(A, row)