J'ai le DataFrame suivant avec des colonnes et un index nommés:

  'a'     'a*'    'b'    'b*'
1  5      NaN     9      NaN
2  NaN    3       3      NaN
3  4      NaN     1      NaN
4  NaN    9       NaN    7

La source de données a entraîné la copie légèrement différente de certains en-têtes de colonne. Par exemple, comme ci-dessus, certains en-têtes de colonne sont une chaîne et certains sont la même chaîne avec un caractère «*» supplémentaire.

Je souhaite copier toutes les valeurs (qui ne sont pas nulles) des colonnes a* et b* vers a et b, respectivement.

Existe-t-il un moyen efficace d'effectuer une telle opération?

4
hamslice 20 nov. 2018 à 12:16

3 réponses

Meilleure réponse

Utilisez np.where

df['a']= np.where(df['a'].isnull(), df['a*'], df['a'])
df['b']= np.where(df['b'].isnull(), df['b*'], df['b'])

Production:

     a  a*  b   b*
0   5.0 NaN 9.0 NaN
1   3.0 3.0 3.0 NaN
2   4.0 NaN 1.0 NaN
3   9.0 9.0 7.0 7.0
5
AkshayNevrekar 20 nov. 2018 à 09:21

L'utilisation de fillna() est beaucoup plus lente que np.where mais a l'avantage d'être uniquement pandas. Si vous voulez une méthode plus rapide et la garder pandas pure, vous pouvez utiliser combine_first() qui, selon la documentation, est utilisé pour:

Combinez les valeurs de la série en choisissant d'abord les valeurs de la série appelante. L'index de résultat sera l'union des deux index

Traduction: il s'agit d'une méthode conçue pour faire exactement ce qui est demandé dans la question.

Comment l'utiliser?

df['a'].combine_first(df['a*'])

Performances:

df = pd.DataFrame({'A': [0, None, 1, 2, 3, None] * 10000, 'A*': [4, 4, 5, 6, 7, 8] * 10000})

def using_fillna(df):
    return df['A'].fillna(df['A*'])

def using_combine_first(df):
    return df['A'].combine_first(df['A*'])

def using_np_where(df):
    return np.where(df['A'].isnull(), df['A*'], df['A'])

def using_np_where_numpy(df):
    return np.where(np.isnan(df['A'].values), df['A*'].values, df['A'].values)

%timeit -n 100 using_fillna(df)
%timeit -n 100 using_combine_first(df)
%timeit -n 100 using_np_where(df)
%timeit -n 100 using_np_where_numpy(df)

1.34 ms ± 71.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
281 µs ± 15.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
257 µs ± 16.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
166 µs ± 10.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3
user3471881 20 nov. 2018 à 10:12

Pour de meilleures performances, utilisez numpy.isnan et convertissez Series en tableaux numpy par {{X1} }:

df['a'] = np.where(np.isnan(df['a'].values), df['a*'].values, df['a'].values)
df['b'] = np.where(np.isnan(df['b'].values), df['b*'].values, df['a'].values)

Une autre solution générale s'il existe uniquement des paires avec / sans * dans les colonnes de DataFrame et est nécessaire de supprimer les colonnes *:

Créez d'abord MultiIndex par {{ X1}} avec ajout *val:

df.columns = (df.columns + '*val').str.split('*', expand=True, n=1)

Et puis sélectionnez par DataFrame.xs pour les DataFrames, donc DataFrame.fillna travail très agréable:

df = df.xs('*val', axis=1, level=1).fillna(df.xs('val', axis=1, level=1))
print (df)
     a    b
1  5.0  9.0
2  3.0  3.0
3  4.0  1.0
4  9.0  7.0

Performances : (dépend du nombre de valeurs manquantes et de la longueur de DataFrame)

df = pd.DataFrame({'A': [0, np.nan, 1, 2, 3, np.nan] * 10000, 
                   'A*': [4, 4, 5, 6, 7, 8] * 10000})

def using_fillna(df):
    df['A'] = df['A'].fillna(df['A*'])
    return df

def using_np_where(df):
    df['B'] = np.where(df['A'].isnull(), df['A*'], df['A'])
    return df

def using_np_where_numpy(df):
    df['C'] = np.where(np.isnan(df['A'].values), df['A*'].values, df['A'].values)
    return df

def using_combine_first(df):
    df['D'] = df['A'].combine_first(df['A*'])
    return df

%timeit -n 100 using_fillna(df)
%timeit -n 100 using_np_where(df)
%timeit -n 100 using_combine_first(df)
%timeit -n 100 using_np_where_numpy(df)

1.15 ms ± 89.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
533 µs ± 13.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
591 µs ± 38.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
423 µs ± 21.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2
jezrael 20 nov. 2018 à 10:23