Comment créer un tableau / matrice vide dans NumPy?

Je ne peux pas comprendre comment utiliser un tableau ou une matrice de la manière que j'utiliserais normalement une liste. Je veux créer un tableau (ou matrice) vide, puis y ajouter une colonne (ou ligne) à la fois.

Pour le moment, la seule façon de le faire est comme:

mat = None
for col in columns:
    if mat is None:
        mat = col
    else:
        mat = hstack((mat, col))

Alors que si c'était une liste, je ferais quelque chose comme ça:

list = []
for item in data:
    list.append(item)

Existe-t-il un moyen d'utiliser ce type de notation pour les tableaux ou matrices NumPy ?

Vous avez le mauvais modèle mental pour utiliser NumPy efficacement. Les tableaux NumPy sont stockés dans des blocs de mémoire contigus. Si vous souhaitez ajouter des lignes ou des colonnes à un tableau existant, le tableau entier doit être copié dans un nouveau bloc de mémoire, créant des espaces pour les nouveaux éléments à stocker. Ceci est très inefficace s'il est répété pour construire un tableau.

Dans le cas de l'ajout de lignes, votre meilleur pari est de créer un tableau aussi grand que votre ensemble de données le sera finalement, puis d'y ajouter des données ligne par ligne:

>>> import numpy
>>> a = numpy.zeros(shape=(5,2))
>>> a
array([[ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.]])
>>> a[0] = [1,2]
>>> a[1] = [2,3]
>>> a
array([[ 1.,  2.],
   [ 2.,  3.],
   [ 0.,  0.],
   [ 0.,  0.],
   [ 0.,  0.]])

Un tableau NumPy est une structure de données très différente d'une liste et est conçu pour être utilisé de différentes manières. Votre utilisation de hstackest potentiellement très inefficace ... chaque fois que vous l'appelez, toutes les données du tableau existant sont copiées dans un nouveau. (La appendfonction aura le même problème.) Si vous souhaitez créer votre matrice une colonne à la fois, il est préférable de la conserver dans une liste jusqu'à ce qu'elle soit terminée, puis de la convertir en tableau.

par exemple

mylist = []
for item in data:
    mylist.append(item)
mat = numpy.array(mylist)

itempeut être une liste, un tableau ou tout autre itérable, tant que chacun itema le même nombre d'éléments.
Dans ce cas particulier ( dataest-il un certain nombre d'itérations pouvant contenir les colonnes de la matrice), vous pouvez simplement utiliser

mat = numpy.array(data)

(Notez également que l'utilisation en listtant que nom de variable n'est probablement pas une bonne pratique car elle masque le type intégré par ce nom, ce qui peut entraîner des bogues.)

ÉDITER:

Si, pour une raison quelconque, vous voulez vraiment créer un tableau vide, vous pouvez simplement l'utiliser numpy.array([]), mais cela est rarement utile!

Pour créer un tableau multidimensionnel vide dans NumPy (par exemple un tableau 2D m*npour stocker votre matrice), au cas où vous ne savez pas mcombien de lignes vous ajouterez et ne vous souciez pas du coût de calcul mentionné par Stephen Simmons (à savoir la reconstruction du tableau à chaque append), vous pouvez presser à 0 la dimension à laquelle vous voulez ajouter à: X = np.empty(shape=[0, n]).

De cette façon, vous pouvez utiliser par exemple (ici m = 5que nous supposons que nous ne savions pas lors de la création de la matrice vide, et n = 2):

import numpy as np

n = 2
X = np.empty(shape=[0, n])

for i in range(5):
    for j  in range(2):
        X = np.append(X, [[i, j]], axis=0)

print X

ce qui vous donnera:

[[ 0.  0.]
 [ 0.  1.]
 [ 1.  0.]
 [ 1.  1.]
 [ 2.  0.]
 [ 2.  1.]
 [ 3.  0.]
 [ 3.  1.]
 [ 4.  0.]
 [ 4.  1.]]

J'ai beaucoup réfléchi à cela parce que je devais utiliser un numpy.array comme un ensemble dans l'un de mes projets scolaires et je devais être initialisé vide ... Je n'ai trouvé aucune réponse pertinente ici sur Stack Overflow, alors j'ai commencé griffonner quelque chose.

# Initialize your variable as an empty list first
In [32]: x=[]
# and now cast it as a numpy ndarray
In [33]: x=np.array(x)

Le résultat sera:

In [34]: x
Out[34]: array([], dtype=float64)

Par conséquent, vous pouvez initialiser directement un tableau np comme suit:

In [36]: x= np.array([], dtype=np.float64)

J'espère que ça aide.

Vous pouvez utiliser la fonction d'ajout. Pour les lignes:

>>> from numpy import *
>>> a = array([10,20,30])
>>> append(a, [[1,2,3]], axis=0)
array([[10, 20, 30],      
       [1, 2, 3]])

Pour les colonnes:

>>> append(a, [[15],[15]], axis=1)
array([[10, 20, 30, 15],      
       [1, 2, 3, 15]])

EDIT
Bien sûr, comme mentionné dans d'autres réponses, à moins que vous ne fassiez un traitement (ex. Inversion) sur la matrice / le tableau CHAQUE fois que vous y ajoutez quelque chose, je créerais simplement une liste, y ajouterais puis la convertirais en un tableau.

Si vous ne connaissez absolument pas la taille finale du tableau, vous pouvez incrémenter la taille du tableau comme ceci:

my_arr = numpy.zeros((0,5))
for i in range(3):
    my_arr=numpy.concatenate( ( my_arr, numpy.ones((1,5)) ) )
print(my_arr)

[[ 1.  1.  1.  1.  1.]  [ 1.  1.  1.  1.  1.]  [ 1.  1.  1.  1.  1.]]

• Remarquez le 0dans la première ligne.
• numpy.appendest une autre option. Ça appelle numpy.concatenate.

Vous pouvez l'appliquer pour construire n'importe quel type de tableau, comme des zéros:

a = range(5)
a = [i*0 for i in a]
print a 
[0, 0, 0, 0, 0]

Voici quelques solutions pour faire ressembler numpys à des listes

np_arr = np.array([])
np_arr = np.append(np_arr , 2)
np_arr = np.append(np_arr , 24)
print(np_arr)

SORTIE: tableau ([2., 24.])

Selon l'utilisation que vous en faites, vous devrez peut-être spécifier le type de données (voir «dtype» ).

Par exemple, pour créer un tableau 2D de valeurs 8 bits (pouvant être utilisé comme image monochrome):

myarray = numpy.empty(shape=(H,W),dtype='u1')

Pour une image RVB, incluez le nombre de canaux de couleur dans la forme: shape=(H,W,3)

Vous pouvez également envisager d'initialiser zéro avec numpy.zerosau lieu d'utiliser numpy.empty. Voir la note ici .

Je pense que vous voulez gérer la plupart du travail avec des listes, puis utiliser le résultat comme matrice. C'est peut-être une façon;

ur_list = []
for col in columns:
    ur_list.append(list(col))

mat = np.matrix(ur_list)

Je pense que vous pouvez créer un tableau numpy vide comme:

>>> import numpy as np
>>> empty_array= np.zeros(0)
>>> empty_array
array([], dtype=float64)
>>> empty_array.shape
(0,)

Ce format est utile lorsque vous souhaitez ajouter un tableau numpy dans la boucle.

Pour créer un tableau NumPy vide sans définir sa forme, il y a moyen:

1.

arr = np.array([]) 

préféré. parce que vous savez que vous allez l'utiliser comme numpy.

2.

arr = []
# and use it as numpy. append to it or etc..

NumPy le convertit ensuite en type np.ndarray, sans supplément [] dimionsion.

Peut-être que ce que vous recherchez est quelque chose comme ceci:

x=np.array(0)

De cette façon, vous pouvez créer un tableau sans aucun élément. C'est similaire à:

x=[]

De cette façon, vous pourrez ajouter à l'avance de nouveaux éléments à votre tableau.