Remplacer les NaN dans le tableau NumPy avec la valeur non-NaN la plus proche

J'ai un tableau NumPy a comme suit:

>>> str(a)
'[        nan         nan         nan  1.44955726  1.44628034  1.44409573\n  1.4408188   1.43657094  1.43171624  1.42649744  1.42200684  1.42117704\n  1.42040255  1.41922908         nan         nan         nan         nan\n         nan         nan]'

Je veux remplacer chaque NaN le plus proche de la non-valeur NaN, de sorte que tous les NaN au début, se mettre à 1.449... et l'ensemble de la NaN est à la fin préparez-vous à 1.419....

Je peux voir comment le faire pour des cas spécifiques, comme ça, mais j'ai besoin d'être en mesure de le faire en général, pour toute longueur de tableau, avec toute la longueur de NaN est au début et à la fin du tableau (il n'y aura pas NaN est au milieu de ces chiffres). Des idées?

Je peux trouver le NaN est assez facilement avec np.isnan()mais je ne peux pas travailler sur la façon d'obtenir la valeur la plus proche à chaque NaN.

source d'informationauteur robintw | 2012-03-02

  1. 19

    Je veux remplacer chaque NaN le plus proche de la non-valeur NaN... il n'y aura pas NaN dans le milieu de l'numéros de

    La suite va le faire:

    ind = np.where(~np.isnan(a))[0]
first, last = ind[0], ind[-1]
a[:first] = a[first]
a[last + 1:] = a[last]

    C'est un droit numpy solution nécessitant pas de Python boucles, pas de récursivité, pas d'interprétations de la liste, etc.

  2. 34

    Une solution alternative (cela va interpoler linéairement pour les tableaux NaNs dans le milieu, en tant que bien):

    import numpy as np

# Generate data...
data = np.random.random(10)
data[:2] = np.nan
data[-1] = np.nan
data[4:6] = np.nan

print data

# Fill in NaN's...
mask = np.isnan(data)
data[mask] = np.interp(np.flatnonzero(mask), np.flatnonzero(~mask), data[~mask])

print data

    Cela donne:

    [        nan         nan  0.31619306  0.25818765         nan         nan
  0.27410025  0.23347532  0.02418698         nan]

[ 0.31619306  0.31619306  0.31619306  0.25818765  0.26349185  0.26879605
  0.27410025  0.23347532  0.02418698  0.02418698]
  3. 4

    NaNs ont la propriété intéressante de comparer différents d'eux-mêmes, donc nous permettre de trouver rapidement l'index de la non-nan éléments:

    idx = np.nonzero(a==a)[0]

    il est maintenant facile de remplacer les nans avec la valeur souhaitée:

    for i in range(0, idx[0]):
    a[i]=a[idx[0]]
for i in range(idx[-1]+1, a.size)
    a[i]=a[idx[-1]]

    Enfin, nous pouvons mettre cela dans une fonction:

    import numpy as np

def FixNaNs(arr):
    if len(arr.shape)>1:
        raise Exception("Only 1D arrays are supported.")
    idxs=np.nonzero(arr==arr)[0]

    if len(idxs)==0:
        return None

    ret=arr

    for i in range(0, idxs[0]):
        ret[i]=ret[idxs[0]]

    for i in range(idxs[-1]+1, ret.size):
        ret[i]=ret[idxs[-1]]

    return ret

    modifier

    Ouch, à venir à partir de C++ j'oublie toujours de liste des plages... @aix la solution est la façon la plus élégante et plus efficace que mon C++ish boucles, utiliser à la place de la mienne.

  4. 1

    Une solution récursive!

    def replace_leading_NaN(a, offset=0):
    if a[offset].isNaN():
        new_value = replace_leading_NaN(a, offset + 1)
        a[offset] = new_value
        return new_value
    else:
        return a[offset]

def replace_trailing_NaN(a, offset=-1):
    if a[offset].isNaN():
        new_value = replace_trailing_NaN(a, offset - 1)
        a[offset] = new_value
        return new_value
    else:
        return a[offset]
  5. 1

    Je suis tombé sur le problème et a dû trouver une solution personnalisée pour dispersées NaNs. La fonction ci-dessous remplace toute NaN par le premier numéro de l'occurrence vers la droite, si aucune n'existe, qu'il remplace par le premier numéro de l'apparition de la gauche. Autre manipulation qui peut être fait pour la remplacer par la moyenne de la limite d'occurrences.

    import numpy as np

Data = np.array([np.nan,1.3,np.nan,1.4,np.nan,np.nan])

nansIndx = np.where(np.isnan(Data))[0]
isanIndx = np.where(~np.isnan(Data))[0]
for nan in nansIndx:
    replacementCandidates = np.where(isanIndx>nan)[0]
    if replacementCandidates.size != 0:
        replacement = Data[isanIndx[replacementCandidates[0]]]
    else:
        replacement = Data[isanIndx[np.where(isanIndx<nan)[0][-1]]]
    Data[nan] = replacement

    Résultat est:

    >>> Data
array([ 1.3,  1.3,  1.4,  1.4,  1.4,  1.4])
  6. 0

    J'ai eu quelque chose comme cela

    i = [i for i in range(len(a)) if not np.isnan(a[i])]
a = [a[i[0]] if x < i[0] else (a[i[-1]] if x > i[-1] else a[x]) for x in range(len(a))]

    C'est un peu maladroit, mais étant donné qu'il est divisé en deux lignes avec imbriqué inline si dans l'un d'entre eux.