Numpy – rij toevoegen aan array

Hoe voeg je rijen toe aan een numpy array?

Ik heb een array A:

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

Ik wil rijen aan deze array toevoegen uit een andere array X als het eerste element van elke rij in X aan een specifieke voorwaarde voldoet.

Numpy-arrays hebben geen methode ‘toevoegen’ zoals die van lijsten, althans zo lijkt het.

Als A en X lijsten waren, zou ik alleen het volgende doen:

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

Is er een numpythonicmanier om het equivalent te doen?

Bedankt,
S 😉

Antwoord 1, autoriteit 100%

Wat is X? Als het een 2D-array is, hoe kun je dan zijn rij vergelijken met een getal: i < 3?

BEWERKEN na de opmerking van OP:

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

voeg aan Aalle rijen toe van Xwaarbij het eerste element < 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]])

Antwoord 2, autoriteit 97%

wel, je kunt dit doen:

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

Antwoord 3, autoriteit 28%

Aangezien deze vraag 7 jaar eerder is geweest, in de nieuwste versie die ik gebruik is numpy versie 1.13, en python3, ik doe hetzelfde met het toevoegen van een rij aan een matrix, vergeet niet om een dubbel te plaatsen haakjenaar het tweede argument, anders wordt de dimensiefout verhoogd.

Hier voeg ik matrix A toe

1 2 3
4 5 6

met een rij

7 8 9

hetzelfde gebruik in 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]]]

Voor de interesse van iemand, als je een kolom wilt toevoegen,

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

volgens wat we eerder deden op matrix A, er een kolom aan toevoegen

np.c_[A, [2,8]]
>> array([[1, 2, 3, 2],
          [4, 5, 6, 8]])

Antwoord 4, autoriteit 12%

Als er na elke rij geen berekeningen nodig zijn, is het veel sneller om rijen in python toe te voegen en vervolgens om te zetten naar numpy. Hier zijn timingtests met python 3.6 versus numpy 1.14, waarbij 100 rijen één voor één worden toegevoegd:

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

Dus de eenvoudige oplossing voor de oorspronkelijke vraag, van zeven jaar geleden, is om vstack() te gebruiken om een nieuwe rij toe te voegen nadat de rij is geconverteerd naar een numpy-array. Maar een meer realistische oplossing zou rekening moeten houden met de slechte prestaties van vstack onder die omstandigheden. Als u na elke toevoeging geen gegevensanalyse op de array hoeft uit te voeren, is het beter om de nieuwe rijen te bufferen in een Python-lijst met rijen (eigenlijk een lijst met lijsten) en ze als een groep toe te voegen aan de numpy-array vstack() gebruiken voordat u een gegevensanalyse uitvoert.

Antwoord 5, autoriteit 7%

U kunt dit ook doen:

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

Antwoord 6, autoriteit 4%

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)

Antwoord 7, autoriteit 3%

Ik gebruik ‘np.vstack’ wat sneller is, 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])

Antwoord 8, autoriteit 2%

Als je de constructie in één handeling kunt doen, dan is zoiets als het vstack-with-fancy-indexing-antwoord een prima benadering. Maar als uw toestand gecompliceerder is of uw rijen snel binnenkomen, wilt u misschien de array laten groeien. In feite is de numpythonische manier om zoiets te doen – een array dynamisch laten groeien – door een lijst dynamisch te laten groeien:

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

Lijsten zijn sterk geoptimaliseerd voor dit soort toegangspatronen; je hebt geen handige numpy multidimensionale indexering in lijstvorm, maar zolang je aan het toevoegen bent, is het moeilijk om het beter te doen dan een lijst met rijmatrices.

Antwoord 9

Je kunt numpy.append()gebruiken om een rij toe te voegen aan een numpty-array en later om te vormen tot een matrix.

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)

Antwoord 10

Ik gebruik numpy.insert(arr, i, the_object_to_be_added, axis)om object_to_be_addedin te voegen in de ie rij(axis=0)of kolom(axis=1)

import numpy as np
a = np.array([[1, 2, 3], [5, 4, 6]])
# array([[1, 2, 3],
#        [5, 4, 6]])
np.insert(a, 1, [55, 66], axis=1)
# array([[ 1, 55,  2,  3],
#        [ 5, 66,  4,  6]])
np.insert(a, 2, [50, 60, 70], axis=0)
# array([[ 1,  2,  3],
#        [ 5,  4,  6],
#        [50, 60, 70]])

te oude discussie, maar ik hoop dat het iemand helpt.