J'ai une fonction qui renvoie un tableau numpy. Je boucle cette fonction avec différents fichiers de données mais je finirai avec chaque boucle donnant un tableau de taille différente (qui est la sortie souhaitée) mais je ne peux pas comprendre comment ajouter correctement ces tableaux. Des exemples de tableaux et la méthode que j'utilise pour les organiser après avoir récupéré les données du fichier sont affichés:

a1 = np.array([1,2,3]) 
a2 = np.vstack(a1)
# array([[1],
   [2],
   [3]])
b1 = np.array([4,5,6,7])
b2 = np.vstack(b2)
# array([[4],
   [5],
   [6],
   [7]])

J'ai simplement ces deux tableaux avec un ayant 3 éléments et un avec 4. Je veux les arranger verticalement pour ressembler à ceci pour qu'il soit exporté:

1  4 
2  5
3  6
   7

Je ne veux pas de zéros ou de Na pour combler les lacunes dans les données car cela ferait plus de travail.

Cela doit fonctionner pour les tableaux verticaux avec une largeur de colonne de 2 pour que les données de sortie soient organisées comme ceci:

1  2   5  6   10  11
2  3   6  7   11  12
3  4   7  8   12  13
       8  9 

Ainsi, la première boucle produirait ce tableau 3,2 vertical tandis que la deuxième itération de la boucle produirait le tableau 4,2 où je voudrais ajouter ou concaténer le tableau 4,2 au tableau 3,2 d'origine et ainsi de suite. Ces ensembles de tableaux auront toujours une largeur de 2 mais les longueurs changeront à partir de chaque ensemble de 2.

J'ai essayé d'utiliser les fonctions de base np.column_stack, np.concatenate et np.append mais elles n'ont pas fonctionné. Ceux-ci peuvent être des listes au lieu de tableaux numpy si cela fonctionne mieux ou même organiser les données en sortie dans une trame de données serait bien.

======= Mise à jour =======

Pour être plus précis et après avoir essayé certaines des solutions fournies, voici quelques détails sur mon problème. Ma fonction obtient les données d'un fichier de données (fonctionne très bien) qui renvoie 2 listes ou tableaux (qui jamais) de valeurs qui ont les mêmes dimensions (pas de problème ici non plus).

Maintenant, j'essaie de faire cela en faisant une boucle sur tous les fichiers d'un répertoire et je veux ajouter / concaténer ces deux listes (ou tableaux) pour chaque fichier ensemble, mais elles peuvent être de tailles différentes. Le problème survient lorsque j'essaie de les assembler verticalement pour produire des colonnes de données de sortie. J'ai aussi besoin de faire une opération mathématique simple sur les valeurs dans la boucle, donc je pense qu'elles pourraient avoir besoin d'être des tableaux numpy (ou quelque chose de similaire) et non une liste.

La boucle # 1 renvoie:

outdata1 = [0.0012, 0.0013, 0.00124, 0.00127] outdata2 = [0.0016, 0.0014, 0.00134, 0.0013]

La boucle # 2 renvoie:

outdata1 = [0.00155, 0.00174, 0.0018] outdata2 = [0.0019, 0.0020, 0.0021]

Etc...

Maintenant, je dois faire des calculs sur ces derniers et les recracher en données de colonnes organisées verticalement sans couper aucune donnée. Cela peut être fait en mettant Na dans l'espace ou avec une trame de données si cela fonctionne et je pourrais corriger ces espaces avant l'exportation. Je voudrais qu'il ressemble à ceci:

0.0012 0.0016 0.00155 0.0019 0.0013 0.0014 0.00174 0.0020 0.00124 0.00134 0.0018 0.0021 0.00127 0.0013

4
Killian Tallman 14 mars 2019 à 08:18

2 réponses

Meilleure réponse

Tout d'abord, vstack sur un tableau traite le tableau comme une liste sur la première dimension. Il transforme ensuite chaque «ligne / élément» en un tableau 2D et les concatène.

Tout cela fait la même chose:

In [94]: np.vstack(np.array([1,2,3]))                                           
Out[94]: 
array([[1],
       [2],
       [3]])
In [95]: np.vstack([[1],[2],[3]])                                               
Out[95]: 
array([[1],
       [2],
       [3]])
In [96]: np.concatenate(([[1]],[[2]],[[3]]), axis=0)                            
Out[96]: 
array([[1],
       [2],
       [3]])

Les tableaux ou listes correspondants peuvent être «column_stack» - les tableaux sont transformés en (n, 1) tableaux, puis joints sur la 2e dimension:

In [97]: np.column_stack(([1,2,3], [4,5,6]))                                    
Out[97]: 
array([[1, 4],
       [2, 5],
       [3, 6]])

Mais les tableaux en lambeaux ne fonctionnent pas.

Un tableau de listes / tableaux de tailles différentes a un type d'objet et est, à de nombreuses fins, comme une liste de listes:

In [98]: np.array(([1,2,3],[4,5,6,7]))                                          
Out[98]: array([list([1, 2, 3]), list([4, 5, 6, 7])], dtype=object)

Votre dernière structure pourrait être écrite comme une liste de listes irrégulière:

In [100]: [[1,2,5,6,10,11],[2,3,6,7,11,12],[3,4,7,8,12,13],[8,9]]               
Out[100]: [[1, 2, 5, 6, 10, 11], [2, 3, 6, 7, 11, 12], [3, 4, 7, 8, 12, 13], [8, 9]]
In [101]: np.array(_)                                                           
Out[101]: 
array([list([1, 2, 5, 6, 10, 11]), list([2, 3, 6, 7, 11, 12]),
       list([3, 4, 7, 8, 12, 13]), list([8, 9])], dtype=object)

Notez bien que cela n'aligne pas le [8,9] avec les autres. Vous avez besoin d'une sorte de remplissage / entretoise. La liste Python zip_longest prévoit que:

In [102]: from itertools import zip_longest                                     
In [103]: alist = [[1,2,3],[2,3,4],[5,6,7,8],[11,12,13]]                        
In [104]: list(zip_longest(*alist))                                             
Out[104]: [(1, 2, 5, 11), (2, 3, 6, 12), (3, 4, 7, 13), (None, None, 8, None)]

Avec ce remplissage, nous pouvons créer un tableau 2d (type d'objet à cause de None):

In [105]: np.array(_)                                                           
Out[105]: 
array([[1, 2, 5, 11],
       [2, 3, 6, 12],
       [3, 4, 7, 13],
       [None, None, 8, None]], dtype=object)

===

Je peux générer les chiffres dans votre dernier affichage avec une petite fonction:

In [232]: def foo(i,n): 
     ...:     return np.column_stack((np.arange(i,i+n), np.arange(i+1,i+1+n))) 
     ...:                                                                       
In [233]: foo(1,3)                                                              
Out[233]: 
array([[1, 2],
       [2, 3],
       [3, 4]])
In [234]: foo(5,4)                                                              
Out[234]: 
array([[5, 6],
       [6, 7],
       [7, 8],
       [8, 9]])
In [235]: foo(10,3)                                                             
Out[235]: 
array([[10, 11],
       [11, 12],
       [12, 13]])

Je peux mettre tous ces tableaux dans une liste:

In [236]: [Out[233], Out[234], Out[235]]                                        
Out[236]: 
[array([[1, 2],
        [2, 3],
        [3, 4]]), array([[5, 6],
        [6, 7],
        [7, 8],
        [8, 9]]), array([[10, 11],
        [11, 12],
        [12, 13]])]

Je peux transformer cette liste en un tableau de type d'objet:

In [237]: np.array([Out[233], Out[234], Out[235]])                              
Out[237]: 
array([array([[1, 2],
       [2, 3],
       [3, 4]]),
       array([[5, 6],
       [6, 7],
       [7, 8],
       [8, 9]]),
       array([[10, 11],
       [11, 12],
       [12, 13]])], dtype=object)

Je pourrais également afficher plusieurs rangées de ces tableaux avec:

In [238]: for i in range(3): 
     ...:     print(np.hstack([a[i,:] for a in Out[236]])) 
     ...:                                                                       
[ 1  2  5  6 10 11]
[ 2  3  6  7 11 12]
[ 3  4  7  8 12 13]

Mais pour afficher la 4ème ligne, qui n'existe que pour le tableau du milieu, je devrais ajouter plus de code pour tester si nous ne sommes pas à la fin, et si nous devons ajouter du rembourrage, etc. Je vous laisse cet exercice, si ça compte vraiment. :)

1
hpaulj 15 mars 2019 à 05:58

Puisque vous avez mentionné que les listes sont correctes, pourquoi ne pas utiliser une liste de ces "tableaux verticaux"?:

my_list = []
while (not_done_yet):
    two_col_array = your_func (some_param) # your_func returns (x,2) array
    my_list.append(two_col_array)

my_list serait désormais une liste de tableaux de forme (x,2), où x pourrait être différent pour différents tableaux de la liste.

0
fountainhead 14 mars 2019 à 12:39