Première valeur non nulle par ligne à partir d'une liste de Pandas colonnes

Si j'ai un DataFrame dans les pandas qui ressemble à quelque chose comme:

    A   B   C
0   1 NaN   2
1 NaN   3 NaN
2 NaN   4   5
3 NaN NaN NaN

Comment puis-je obtenir la première valeur non nulle à partir de chaque ligne? E. g. pour le haut, j'aimerais obtenir: [1, 3, 4, None] (ou l'équivalent de la Série).

InformationsquelleAutor Dave Challis | 2015-08-05
  1. 9

    C'est vraiment une manière désordonnée pour ce faire, utilisez d'abord first_valid_index pour obtenir la validité de colonnes, de convertir le retour de la série à un dataframe, nous pouvons donc appeler apply ligne sage et index retour à l'original df:

    In [160]:
def func(x):
    if x.values[0] is None:
        return None
    else:
        return df.loc[x.name, x.values[0]]
pd.DataFrame(df.apply(lambda x: x.first_valid_index(), axis=1)).apply(func,axis=1)
​
Out[160]:
0     1
1     3
2     4
3   NaN
dtype: float64

    MODIFIER

    Un peu le moyen le plus propre:

    In [12]:
def func(x):
    if x.first_valid_index() is None:
        return None
    else:
        return x[x.first_valid_index()]
df.apply(func, axis=1)

Out[12]:
0     1
1     3
2     4
3   NaN
dtype: float64
    • L'utilisation de df mondial ici me fait un peu mal au cœur. Vraiment, vous voulez une combinaison de @yangjie réponse et celle-ci. Je vais poster une combinaison, mais n'hésitez pas à voler les meilleurs morceaux (si vous pensez qu'il y a de tout!)
    • Je pense que vraiment il faut juste effectuer une itération sur les df une fois
    • Maintenant vous êtes en train de parler. C'est maintenant vraiment bon. +1 (pourquoi ne pas simplement effacer votre première itération?)
    • J'aime laisser mon processus de pensée, il montre une approche itérative pour améliorer ma réponse, parfois, il suffit de montrer la réponse finale seulement ne le démontre pas comment modérer votre approche et les réponses aux commentaires
    • oui le lambda est inutile, cheers
    InformationsquelleAutor EdChum
  2. 29

    Vous n'avez pas besoin de se compliquer la vie avec first_valid_index:

    df.bfill(axis=1).iloc[:, 0]
    • Génial solution à mon problème. Merci. Comment aurais-je obtenir le nom de la colonne de la première valeur non nulle?
    • c'est intelligent !
    • génial !! merci +1
    InformationsquelleAutor Andy Jones
  3. 10

    Je vais peser ici car je pense que c'est une bonne affaire plus vite que les méthodes proposées. argmin donne l'indice de la première False valeur dans chaque ligne du résultat de np.isnan dans un vectorisé façon, qui est la partie la plus difficile. Il repose toujours sur une boucle Python pour extraire les valeurs, mais le look est très rapide:

    def get_first_non_null(df):
    a = df.values
    col_index = np.isnan(a).argmin(axis=1)
    return [a[row, col] for row, col in enumerate(col_index)]

    EDIT:
    Voici une entièrement vectorisé solution qui est peut être une bonne affaire plus rapide encore en fonction de la forme de l'entrée. Mise à jour de l'analyse comparative ci-dessous. 

    def get_first_non_null_vec(df):
    a = df.values
    n_rows, n_cols = a.shape
    col_index = np.isnan(a).argmin(axis=1)
    flat_index = n_cols * np.arange(n_rows) + col_index
    return a.ravel()[flat_index]

    Si une ligne est complètement nul, la valeur correspondante sera nulle également.
    Voici quelques comparaisons avec les unutbu la solution:

    df = pd.DataFrame(np.random.choice([1, np.nan], (10000, 1500), p=(0.01, 0.99)))
#%timeit df.stack().groupby(level=0).first().reindex(df.index)
%timeit get_first_non_null(df)
%timeit get_first_non_null_vec(df)
1 loops, best of 3: 220 ms per loop
100 loops, best of 3: 16.2 ms per loop
100 loops, best of 3: 12.6 ms per loop
In [109]:


df = pd.DataFrame(np.random.choice([1, np.nan], (100000, 150), p=(0.01, 0.99)))
#%timeit df.stack().groupby(level=0).first().reindex(df.index)
%timeit get_first_non_null(df)
%timeit get_first_non_null_vec(df)
1 loops, best of 3: 246 ms per loop
10 loops, best of 3: 48.2 ms per loop
100 loops, best of 3: 15.7 ms per loop


df = pd.DataFrame(np.random.choice([1, np.nan], (1000000, 15), p=(0.01, 0.99)))
%timeit df.stack().groupby(level=0).first().reindex(df.index)
%timeit get_first_non_null(df)
%timeit get_first_non_null_vec(df)
1 loops, best of 3: 326 ms per loop
1 loops, best of 3: 326 ms per loop
10 loops, best of 3: 35.7 ms per loop
    • Sur l'ensemble de ces réponses, c'est le plus rapide, un par un facteur de 5 ou de 10.
    • Petite correction est nécessaire, en retour, = [a[row, col] pour la ligne, le col à énumérer(col_index)]
    • Fixe. Merci pour cette remarque
    • Merci @JoeCondron - j'ai essayé moi-même et il est en effet plus rapide, vous apprécierez l'ajout de cette.
    • Cool. Pouvez-vous changer pour la accepté de répondre? Je ne suis pas sûr de comment cela fonctionne
    • une faute de frappe: %timeit get_frst_non_null(df)
    • Deux fautes de frappe.. j'ai besoin d'être plus prudent. Merci pour cette remarque.

    InformationsquelleAutor JoeCondron
  4. 9

    Ici est une autre façon de faire:

    In [183]: df.stack().groupby(level=0).first().reindex(df.index)
Out[183]: 
0     1
1     3
2     4
3   NaN
dtype: float64

    L'idée ici est d'utiliser stack pour déplacer les colonnes dans une rangée niveau de l'indice:

    In [184]: df.stack()
Out[184]: 
0  A    1
   C    2
1  B    3
2  B    4
   C    5
dtype: float64

    Maintenant, si vous groupe par la première ligne de niveau -- c'est à dire l'indice d'origine -- et prendre la première valeur de chaque groupe, vous avez essentiellement à obtenir le résultat souhaité:

    In [185]: df.stack().groupby(level=0).first()
Out[185]: 
0    1
1    3
2    4
dtype: float64

    Tout ce que nous devons faire est de revisiter le résultat (à l'aide de l'indice d'origine) afin de
    inclure les lignes qui sont complètement NaN:

    df.stack().groupby(level=0).first().reindex(df.index)
    InformationsquelleAutor unutbu
  5. 4

    Ce n'est pas nouveau, mais c'est une combinaison des meilleurs morceaux de @yangie de l'approche avec une compréhension de liste, et @EdChum de df.appliquer approche que je pense est le plus facile à comprendre.

    Tout d'abord, les colonnes à nous voulons recevoir nos valeurs de?

    In [95]: pick_cols = df.apply(pd.Series.first_valid_index, axis=1)

In [96]: pick_cols
Out[96]: 
0       A
1       B
2       B
3    None
dtype: object

    Maintenant, comment choisit-on les valeurs?

    In [100]: [df.loc[k, v] if v is not None else None 
    ....:     for k, v in pick_cols.iteritems()]
Out[100]: [1.0, 3.0, 4.0, None]

    C'est ok, mais nous voulons vraiment l'index pour correspondre à l'original DataFrame:

    In [98]: pd.Series({k:df.loc[k, v] if v is not None else None
   ....:     for k, v in pick_cols.iteritems()})
Out[98]: 
0     1
1     3
2     4
3   NaN
dtype: float64
    • Je suis un peu surpris il n'y a pas moyen d'aller d' pick_cols pour le résultat final. Que serait cette opération doit être appelé en pensez-vous?
    • J'ai mis à jour ma réponse, cette itération de juste une fois, vous avez pour tester si le first_valid_index est None pour gérer la ligne avec tous les NaNs
    InformationsquelleAutor LondonRob
  6. 2

    Ici est une solution en ligne:

    [row[row.first_valid_index()] if row.first_valid_index() else None for _, row in df.iterrows()]

    Edit:

    Cette solution itère sur les lignes de df. row.first_valid_index() étiquette de retour pour le premier non-NA/valeur null, ce qui sera utilisée comme index pour obtenir le non null premier élément de chaque ligne.

    Si il n'y a pas de valeur non null dans la ligne, row.first_valid_index() en aurait Aucun, ne peut donc pas être utilisé comme indice, j'ai donc besoin d'un if-else déclaration.

    J'ai emballé le tout dans une compréhension de liste pour des raisons de concision.

    • Ce qui est excellent. Un peu d'explication sur ce qui se passe serait ce vraiment utile de répondre. Aussi, c'est une honte que vous avez à vérifier first_valid_index() deux fois. Peut-être que si vous perdez un peu de concision, vous gagnerez en lisibilité et en efficacité.
    • Ouais, je ne suis pas heureux avec l'obtention de first_valid_index() deux fois aussi bien. Merci pour les conseils, je vais peut-être mettre à jour plus tard.
    InformationsquelleAutor yangjie
  7. 2

    JoeCondron réponse (EDIT: avant sa dernière édition!) c'est cool mais il y a de la marge pour une amélioration significative en évitant les non-vectorisé énumération:

    def get_first_non_null_vect(df):
    a = df.values
    col_index = np.isnan(a).argmin(axis=1)
    return a[np.arange(a.shape[0]), col_index]

    L'amélioration est faible si le DataFrame est relativement plat:

    In [4]: df = pd.DataFrame(np.random.choice([1, np.nan], (10000, 1500), p=(0.01, 0.99)))

In [5]: %timeit get_first_non_null(df)
10 loops, best of 3: 34.9 ms per loop

In [6]: %timeit get_first_non_null_vect(df)
10 loops, best of 3: 31.6 ms per loop

    ... mais peut être sur un slim DataFrames:

    In [7]: df = pd.DataFrame(np.random.choice([1, np.nan], (10000, 15), p=(0.1, 0.9)))

In [8]: %timeit get_first_non_null(df)
100 loops, best of 3: 3.75 ms per loop

In [9]: %timeit get_first_non_null_vect(df)
1000 loops, best of 3: 718 µs per loop

    Par rapport à JoeCondron est vectorisé version, le moteur d'exécution est très similaire (ce qui est encore légèrement plus rapide pour les slim DataFrames, et légèrement plus lent pour les grandes).

    InformationsquelleAutor Pietro Battiston
  8. 2

    groupby dans axis=1

    Si l'on fait passer un callable qui renvoie la même valeur, on regroupe toutes les colonnes. Cela nous permet d'utiliser groupby.agg qui nous donne la first méthode qui rend ce facile

    df.groupby(lambda x: 'Z', 1).first()

     Z
0  1.0
1  3.0
2  4.0
3  NaN

    Cela renvoie d'un dataframe avec le nom de la colonne de la chose, j'étais de retour dans mon appelable

    lookup, notna, et idxmax

    df.lookup(df.index, df.notna().idxmax(1))

array([ 1.,  3.,  4., nan])

    argmin et de tranchage

    v = df.values
v[np.arange(len(df)), np.isnan(v).argmin(1)]

array([ 1.,  3.,  4., nan])
    InformationsquelleAutor piRSquared
  9. 1
    df=pandas.DataFrame({'A':[1, numpy.nan, numpy.nan, numpy.nan], 'B':[numpy.nan, 3, 4, numpy.nan], 'C':[2, numpy.nan, 5, numpy.nan]})

df
     A    B    C
0  1.0  NaN  2.0
1  NaN  3.0  NaN
2  NaN  4.0  5.0
3  NaN  NaN  NaN

df.apply(lambda x: numpy.nan if all(x.isnull()) else x[x.first_valid_index()], axis=1).tolist()
[1.0, 3.0, 4.0, nan]
    InformationsquelleAutor bhamu