La suppression des valeurs nan à partir d'un tableau

Je veux trouver comment l'enlever nan valeurs de mon tableau. Mon tableau ressemble à quelque chose comme ceci:

x = [1400, 1500, 1600, nan, nan, nan ,1700] #Not in this exact configuration

Comment puis-je supprimer le nan valeurs de x?

Pour être clair, par "supprimer NaNs" tu veux dire filtrer seulement le sous-ensemble de valeurs non null. Pas de "remplir les NaNs avec une certaine valeur (zéro, constant, moyenne, médiane, etc.)"

InformationsquelleAutor Dax Feliz | 2012-07-23

285

Si vous utilisez numpy pour vos tableaux, vous pouvez également utiliser
```
x = x[numpy.logical_not(numpy.isnan(x))]
```
De manière équivalente
```
x = x[~numpy.isnan(x)]
```
[Merci à chbrown pour l'ajout d'abréviation]

Explication

L'intérieur de la fonction, numpy.isnan retourne un booléen/ensemble logique qui a de la valeur True partout que x n'est pas un nombre. Comme nous voulons que le contraire, nous utilisons la logique de ne pas l'opérateur, ~ pour obtenir un tableau avec Trues partout que x est un nombre valide.

Enfin nous utilisons cette logique de tableau d'index dans le tableau d'origine x, de récupérer uniquement la non-valeurs NaN.
- Ou x = x[numpy.isfinite(x)]
- Ou x = x[~numpy.isnan(x)], ce qui est équivalent à mutzmatron d'origine de la réponse, mais plus court. Dans le cas où vous voulez garder votre infinis autour de, savoir que numpy.isfinite(numpy.inf) == False, bien sûr, mais ~numpy.isnan(numpy.inf) == True.
- Je suis d'accord avec @chbrown, NaN et l'Infini ne sont pas les mêmes dans numpy. @chbrown - merci pour le raccourci pour logical_not, mais méfiez-vous qu'il est beaucoup plus lent - stackoverflow.com/questions/15998188/..., stackoverflow.com/questions/13600988/...
- Hmm, @mutzmatron -- j'imagine qu'ils ont fait la même chose sous le capot, et j'obtiens des résultats très similaires avec timeit (comme l'a fait @unutbu à qui le premier lien): python -m timeit -s "import numpy; bools = numpy.random.uniform(size=10000) >= 0.5" "numpy.logical_not(bools)" vs python -m timeit -s "import numpy; bools = numpy.random.uniform(size=10000) >= 0.5" "~bools" (numpy.__version__ == '1.8.0')
- vous avez raison, tout gain de performances avec numpy semble avoir eu lieu sur le deuxième affiches de la machine - j'ai testé numpy.invert et numpy.logical_not et a obtenu le même résultat pour les deux comme pour ~, sur numpy v1.7.1. Vous ne savez pas si l'architecture affecte la comparaison de la performance - suis en train de tester sur mon chromebook (armv7l).
- Pour les personnes qui cherchent à résoudre ce avec un ndarray et de maintenir les dimensions, utiliser les numpy où: np.where(np.isfinite(x), x, 0)
- TypeError: entiers scalaires tableaux peuvent être convertis à un scalaire index
- cela se produit parce que votre entrée, x n'est pas un tableau numpy. Si vous souhaitez utiliser la logique d'indexation, il doit être un tableau - par exemple x = np.array(x)
- vous avez raison, merci.
InformationsquelleAutor jmetz
41
```
filter(lambda v: v==v, x)
```
fonctionne à la fois pour les listes et les tableau numpy
puisque v!=v uniquement pour NaN
- Un hack mais une particulièrement utile dans le cas où vous êtes filtrage de nans à partir d'un tableau d'objets avec un mélange de types, comme les cordes et les nans.
- Très propre solution.
- Cela peut sembler intelligent, mais si obscurcit la logique et de la théorie d'autres objets (comme des classes) peut aussi avoir cette propriété
InformationsquelleAutor udibr
32

Essayez ceci:
```
import math
print [value for value in x if not math.isnan(value)]
```
Pour en savoir plus, lire sur Interprétations De La Liste.
- Si vous êtes à l'aide de numpy fois de ma réponse et que par @lazy1 sont presque un ordre de grandeur plus rapide que la compréhension de liste - lazy1 la solution est légèrement plus rapide (si, techniquement, ne sera pas de retour tout l'infini de valeurs).
- N'oubliez pas les parenthèses 🙂 print ([value for value in x if not math.isnan(value)])
- Si vous êtes à l'aide de numpy comme le sommet de réponse, alors vous pouvez utiliser cette liste de compréhension de la réponse avec la np paquet: Alors, retourne votre liste sans les nans: [value for value in x if not np.isnan(value)]
InformationsquelleAutor liori
15

Pour moi la réponse par @jmetz ne fonctionne pas, cependant, l'utilisation des pandas isnull() n'.
```
x = x[~pd.isnull(x)]
```
- Cette réponse œuvres pour cordes, fwiw
InformationsquelleAutor Daniel Kislyuk
6

Faire ci-dessus :
```
x = x[~numpy.isnan(x)]
```
ou
```
x = x[numpy.logical_not(numpy.isnan(x))]
```
J'ai trouvé que la réinitialisation de la même variable (x) ne pas enlever les réelles valeurs nan et a dû utiliser une variable différente. Définissant une variable différente supprimé les nans.
par exemple,
```
y = x[~numpy.isnan(x)]
```
- C'est étrange, selon la doc boolean tableau d'indexation (ce qui est), est sous fonctions avancées d'indexation qui, apparemment, "retourne toujours une copie des données", de sorte que vous devrait être écrit x avec la nouvelle valeur (c'est à dire sans les NaNs...). Pouvez-vous donner plus d'info pour lesquelles cela pourrait se produire?
InformationsquelleAutor melissaOu
2

Comme indiqué par d'autres
```
x[~numpy.isnan(x)]
```
œuvres. Mais il va jeter erreur si la numpy dtype n'est pas un type de données natif, par exemple si elle est l'objet. Dans ce cas, vous pouvez utiliser les pandas.
```
x[~pandas.isnan(x)]
```
InformationsquelleAutor koliyat9811

Si vous utilisez numpy

# first get the indices where the values are finite
ii = np.isfinite(x)

# second get the values
x = x[ii]

InformationsquelleAutor aloha

La accepté de répondre à change de forme pour la 2d tableaux.
Je vous présente une solution ici, en utilisant les Pandas dropna() fonctionnalité.
Il fonctionne pour les codes 1D et 2D tableaux. Dans le 2D cas, vous pouvez choisir météo à chute de la ligne ou de la colonne contenant np.nan.

import pandas as pd
import numpy as np

def dropna(arr, *args, **kwarg):
    assert isinstance(arr, np.ndarray)
    dropped=pd.DataFrame(arr).dropna(*args, **kwarg).values
    if arr.ndim==1:
        dropped=dropped.flatten()
    return dropped

x = np.array([1400, 1500, 1600, np.nan, np.nan, np.nan ,1700])
y = np.array([[1400, 1500, 1600], [np.nan, 0, np.nan] ,[1700,1800,np.nan]] )


print('='*20+' 1D Case: ' +'='*20+'\nInput:\n',x,sep='')
print('\ndropna:\n',dropna(x),sep='')

print('\n\n'+'='*20+' 2D Case: ' +'='*20+'\nInput:\n',y,sep='')
print('\ndropna (rows):\n',dropna(y),sep='')
print('\ndropna (columns):\n',dropna(y,axis=1),sep='')

print('\n\n'+'='*20+' x[np.logical_not(np.isnan(x))] for 2D: ' +'='*20+'\nInput:\n',y,sep='')
print('\ndropna:\n',x[np.logical_not(np.isnan(x))],sep='')

Résultat:

==================== 1D Case: ====================
Input:
[1400. 1500. 1600.   nan   nan   nan 1700.]

dropna:
[1400. 1500. 1600. 1700.]


==================== 2D Case: ====================
Input:
[[1400. 1500. 1600.]
 [  nan    0.   nan]
 [1700. 1800.   nan]]

dropna (rows):
[[1400. 1500. 1600.]]

dropna (columns):
[[1500.]
 [   0.]
 [1800.]]


==================== x[np.logical_not(np.isnan(x))] for 2D: ====================
Input:
[[1400. 1500. 1600.]
 [  nan    0.   nan]
 [1700. 1800.   nan]]

dropna:
[1400. 1500. 1600. 1700.]

InformationsquelleAutor Markus Dutschke

0

C'est mon approche du filtre ndarray "X" pour NaNs et infs,

J'ai créer une carte de lignes sans NaN et tout inf comme suit:
```
idx = np.where((np.isnan(X)==False) & (np.isinf(X)==False))
```
idx est un n-uplet. C'est la deuxième colonne (idx[1]) contient les indices de la matrice, où aucun NaN ni inf où le trouver à travers la ligne.

Alors:
```
filtered_X = X[idx[1]]
```
filtered_X contient X sans NaN ni inf.

InformationsquelleAutor aerijman
-2

La manière la plus simple est:
```
numpy.nan_to_num(x)
```
Documentation: https://docs.scipy.org/doc/numpy/reference/generated/numpy.nan_to_num.html
- Bienvenue DONC! La solution que vous proposez n'est pas la réponse au problème: votre solution de substituts NaNs avec un grand nombre, alors que l'OP a demandé de retirer entièrement les éléments.
InformationsquelleAutor Bruno Rodrigues de Oliveira

Vous devez vous connecter pour publier un commentaire.