Question Numpy - ajoute une ligne au tableau


Comment ajoute-t-on des lignes à un tableau numpy?

J'ai un tableau A:

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

Je souhaite ajouter des lignes à ce tableau à partir d'un autre tableau X si le premier élément de chaque ligne de X répond à une condition spécifique.

Les tableaux Numpy n'ont pas de méthode "append" comme celle des listes, à ce qu'il semble.

Si A et X étaient des listes, je le ferais simplement:

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

y a t-il numpythonique façon de faire l'équivalent?

Merci, S ;-)


97
2017-10-07 12:09


origine


Réponses:


Quel est X? S'il s'agit d'un tableau 2D, comment pouvez-vous comparer sa ligne à un nombre: i < 3?

EDIT après le commentaire de OP:

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

ajouter à A toutes les lignes de X où le premier élément < 3:

A = vstack((A, X[X[:,0] < 3]))

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

81
2017-10-07 12:14



bien tu peux faire ça:

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

118
2017-10-07 12:15



Comme cette question a été posée 7 ans auparavant, dans la dernière version que j'utilise est numpy version 1.13, et python3, je fais la même chose en ajoutant une ligne à une matrice, n'oubliez pas de mettre un double crochet au second argument, sinon, cela augmentera l'erreur de dimension. même usage dans np.r_

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

Juste pour quelqu'un d'intéressé, si vous souhaitez ajouter une colonne,

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


11
2017-12-16 11:16



Vous pouvez aussi faire ceci:

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

7
2017-12-14 17:00



Si vous pouvez faire la construction en une seule opération, alors une solution similaire à la réponse vstack-with-fantancy-indexing est une approche fine. Mais si votre condition est plus compliquée ou si vos lignes entrent à la volée, vous souhaiterez peut-être développer la matrice. En fait, la manière numpythonique de faire quelque chose comme ça - développer dynamiquement un tableau - consiste à développer dynamiquement une liste:

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

Les listes sont hautement optimisées pour ce type de modèle d'accès. vous ne disposez pas d'une indexation multidimensionnelle pratique sous forme de liste, mais tant que vous l'ajoutez, il est difficile de faire mieux qu'une liste de tableaux de lignes.


2
2018-06-25 15:48



Vous pouvez utiliser numpy.append() pour ajouter une ligne au tableau numpty et la remodeler ultérieurement à une matrice.

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)

1
2017-07-11 18:09



J'utilise 'np.vstack' qui est plus rapide, 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])

1
2018-02-12 01:26



Si aucun calcul n'est nécessaire après chaque ligne, il est beaucoup plus rapide d'ajouter des lignes dans python, puis de les convertir en numpy. Voici des tests de synchronisation utilisant python 3.6 vs. numpy 1.14, en ajoutant 100 lignes, une par une:

import numpy as py
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

Donc, la solution simple à la question initiale, il y a sept ans, est d'utiliser vstack () pour ajouter une nouvelle ligne après la conversion de la ligne en tableau numpy. Mais une solution plus réaliste devrait considérer les mauvaises performances de vstack dans ces circonstances. Si vous n'avez pas besoin d'exécuter une analyse de données sur le tableau après chaque ajout, il est préférable de mettre les nouvelles lignes en mémoire tampon dans une liste de lignes python (une liste de listes, en réalité) et de les ajouter au groupe numpy. utiliser vstack () avant d’effectuer une analyse de données.


0
2018-03-03 16:40