J'ai un tableau numpy comme suit:

x =
[[ 839.41    128.3      92.47     51.78         nan]
 [ 823.      126.43     91.31     51.63         nan]
 [ 819.      126.6      93.03     51.77         nan]
 [ 776.32    123.6      93.85     52.02         nan]
 [ 755.12    120.93     92.48     49.955        nan]
 [ 739.01    129.84     97.68     50.75         nan]
 [ 760.17    128.36     98.26     51.1          nan]
 [ 780.37    131.57     98.82     51.52         nan]
 [ 740.34    129.89     98.5      50.48         nan]
 [ 768.65    133.37    104.86     51.71         nan]
 [ 757.75    135.15    103.93     50.9297       nan]
 [ 760.58    135.02    105.15     51.91         nan]
 [ 750.03    134.15    104.28     50.84         nan]
 [ 795.99    133.56    109.02     53.92     57.12  ]
 [ 817.13    135.      108.04     52.92     57.84  ]
 [ 808.23    135.6     107.645    53.2      57.66  ]]

Quelle serait la meilleure façon possible de diviser le réseau où se termine le nan, c'est-à-dire

x =
[[ 839.41    128.3      92.47     51.78         nan]
 [ 823.      126.43     91.31     51.63         nan]
 [ 819.      126.6      93.03     51.77         nan]
 [ 776.32    123.6      93.85     52.02         nan]
 [ 755.12    120.93     92.48     49.955        nan]
 [ 739.01    129.84     97.68     50.75         nan]
 [ 760.17    128.36     98.26     51.1          nan]
 [ 780.37    131.57     98.82     51.52         nan]
 [ 740.34    129.89     98.5      50.48         nan]
 [ 768.65    133.37    104.86     51.71         nan]
 [ 757.75    135.15    103.93     50.9297       nan]
 [ 760.58    135.02    105.15     51.91         nan]
 [ 750.03    134.15    104.28     50.84         nan]]
[[ 795.99    133.56    109.02     53.92     57.12  ]
 [ 817.13    135.      108.04     52.92     57.84  ]]

Et si j'appelle x[0] cela se traduirait par le sous-tableau avec nans, et si j'appelais x[1] cela entraînerait le sous-tableau en dessous.

Remarque

Je voudrais que le tableau se divise à la fin de chaque série de nans, l'exemple que j'ai donné ci-dessus avait tout simplement nans aligné.

1
lee.edward01 23 mai 2018 à 19:24

4 réponses

Meilleure réponse

Si vous êtes sûr que nan se poursuit dans une colonne, vous pouvez trouver le dernier index de cette ligne respective comme suit:

In [16]: np.where(np.isnan(x).any(1))[0][-1] + 1
Out[16]: 13

Ensuite, vous pouvez diviser le tableau en utilisant np.split():

np.split(x, [np.where(np.isnan(x).any(1))[0][-1] + 1])

Si vous n'êtes pas sûr de cela, c'est-à-dire que les nan peuvent exister dans n'importe quel index. Vous pouvez effectuer une approche similaire sur la version défilée de votre tableau et trouver l'index en divisant le dernier nan à la deuxième longueur d'axe.

In [38]: (np.where(np.isnan(x.ravel()))[0][-1] + 1)//x.shape[1]
Out[38]: 13

Démo:

In [18]: np.split(x, [np.where(~np.isnan(x).any(1))[0][0]])
Out[18]: 
[array([[839.41  , 128.3   ,  92.47  ,  51.78  ,      nan],
        [823.    , 126.43  ,  91.31  ,  51.63  ,      nan],
        [819.    , 126.6   ,  93.03  ,  51.77  ,      nan],
        [776.32  , 123.6   ,  93.85  ,  52.02  ,      nan],
        [755.12  , 120.93  ,  92.48  ,  49.955 ,      nan],
        [739.01  , 129.84  ,  97.68  ,  50.75  ,      nan],
        [760.17  , 128.36  ,  98.26  ,  51.1   ,      nan],
        [780.37  , 131.57  ,  98.82  ,  51.52  ,      nan],
        [740.34  , 129.89  ,  98.5   ,  50.48  ,      nan],
        [768.65  , 133.37  , 104.86  ,  51.71  ,      nan],
        [757.75  , 135.15  , 103.93  ,  50.9297,      nan],
        [760.58  , 135.02  , 105.15  ,  51.91  ,      nan],
        [750.03  , 134.15  , 104.28  ,  50.84  ,      nan]]),
 array([[795.99 , 133.56 , 109.02 ,  53.92 ,  57.12 ],
        [817.13 , 135.   , 108.04 ,  52.92 ,  57.84 ],
        [808.23 , 135.6  , 107.645,  53.2  ,  57.66 ]])]
1
Kasramvd 23 mai 2018 à 16:39

Si je comprends bien le Q, plus de deux blocs sont possibles --- et aucune des réponses publiées jusqu'à présent ne semble résoudre ce problème.

Le code suivant se divise chaque fois qu'une colonne de nan se termine:

>>> A = np.random.randint(0, 10, (10, 4)).astype(float)
>>> for i in range(4):
...     A[slice(*np.sort(np.random.randint(2*i, 2*i + 6, (2,)))), np.random.randint(0, 4)] = np.nan
... 
>>> A
array([[ 3.,  9.,  1.,  7.],
       [ 1.,  8.,  3.,  0.],
       [nan,  1.,  7.,  9.],
       [nan,  1.,  9.,  0.],
       [nan,  3.,  8.,  6.],
       [ 3.,  2.,  6.,  0.],
       [ 3.,  7.,  9.,  6.],
       [ 7.,  6.,  7., nan],
       [ 3.,  0.,  9., nan],
       [nan,  2.,  2.,  2.]])
>>> 
>>> nans = np.isnan(A)
>>> idx  = np.where((nans[:-1] & ~nans[1:]).any(axis=1))[0] + 1
>>> 
>>> from pprint import pprint
>>> 
>>> pprint(np.split(A, idx, axis=0))
[array([[ 3.,  9.,  1.,  7.],
       [ 1.,  8.,  3.,  0.],
       [nan,  1.,  7.,  9.],
       [nan,  1.,  9.,  0.],
       [nan,  3.,  8.,  6.]]),
 array([[ 3.,  2.,  6.,  0.],
       [ 3.,  7.,  9.,  6.],
       [ 7.,  6.,  7., nan],
       [ 3.,  0.,  9., nan]]),
 array([[nan,  2.,  2.,  2.]])]
0
Paul Panzer 23 mai 2018 à 20:16

Vous pouvez utiliser:

wh = np.isnan(x).any(1).argmin()

Alors x[:wh] et x[wh:] sont ce que vous voulez.

2
llllllllll 23 mai 2018 à 16:31

Si tous les nan sont dans la dernière colonne, vous pouvez utiliser

x = [x[np.where(np.isnan(x[:, 4])), :][0], x[np.where(~np.isnan(x[:, 4])), :][0]]

J'ai gardé votre notation de réutilisation de la variable x.

0
Gianluca Micchi 23 mai 2018 à 16:33