Dataframes et indexation

Quand on boucle sur un dataframe, on boucle sur les noms des colonnes :

for x in df:
  print(x) # imprime le nom de la colonne
  

On peut boucler sur les lignes d'un dataframe, chaque ligne se comportant comme un namedtuple :

• for x in df.itertuples():
    print(x.A) # Imprime la valeur courante de la colonne A de df
      

• mais attention, itération sur un dataframe est lent. Mieux vaut utiliser des opérations vectorielles ! Si on ne peut pas, préférer utiliser apply.
• on ne peut pas modifier un dataframe sur lequel on boucle.

Accès à une colonne :

• df['A'] : renvoie la Series correspondant à la colonne de label A :

  
  a1    1.1
  a2    2.7
  a3    5.3
      

Attention :

• df.loc[:, 'A'] : renvoie une series
• df.loc[:, ['A']] : renvoie un dataframe.
• df.iloc[3, :] : renvoie une series.

df['A'][0:3] : les 3 premières valeurs des 3 premières lignes de la colonne 'A' (sous forme de Series).

Accès à un sous-ensemble du dataframe avec les noms des lignes et colonnes :

• df.loc['a2'] : renvoie la Series correspondant à la ligne d'index a2 :

  
  A     2.7
  B    10.0
  C     5.4
  D     7.0
      

• df.loc[['a2', 'a3'], ['A', 'C']] : renvoie un dataframe avec un sous-ensemble des lignes et des colonnes :

  
        A    C
  a2  2.7  5.4
  a3  5.3  1.5
      

• df.loc[:,['A', 'C']] : toutes les lignes et seulement les colonnes A et B.
• df.loc['a2', 'C'] : accès à la valeur de la ligne a2 et de la colonne C : 5.4.
• df.at['a2', 'C'] : autre façon recommandée d'accéder à la valeur de la ligne a2 et de la colonne C : 5.4.
• on peut aussi faire une affectation pour changer la valeur : df.at['a2', 'C'] = 7.
• on peut aussi utiliser des indices numériques : df.at[0, 1] (ou même un mélange des deux).

Accès à un sous-ensemble du dataframe avec les numéros des lignes et colonnes :

• df.iloc[1] : renvoie la deuxième ligne.
• df.iloc[1:3,[0, 2]] : renvoie le dataframe avec les lignes 1 à 3 exclue, et les colonnes numéros 0 et 2.
• df.iloc[:,2:4] : renvoie toutes les lignes et les colonnes 2 à 4 exclue.
• df.iloc[1,2] : renvoie la valeur à la ligne 2 et la colonne 3.
• df.iat[1,2] : renvoie la valeur à la ligne 2 et la colonne 3, mais c'est la façon recommandée d'accéder aux valeurs.
• on peut aussi faire une affectation pour changer la valeur : df.iat[1, 2] = 7.

Type récupéré lors de l'accès par colonne d'une dataframe : si df est un dataframe avec 'A' parmi ses colonnes :

• df.loc[:,['A']] est un dataframe (avec une seule colonne).
• df.loc[:,'A'] est une series, comme df['A'].

Accès à certaines colonnes et certaines lignes par numéros : df.loc[:,['A', 'b']].iloc[0:2]

Quand on veut adresser une cellule d'un dataframe en utilisant à la fois un numéro de ligne et un nom de colonne :

• df.loc[df.index[3], 'A']
• ou alors df.iloc[3, df.columns.get_loc('A')]

Accès selon une condition :

• df[df['A'] > 2] : renvoie un dataframe avec seulement les lignes où la condition est vérifiée :

  
        A   B    C   D
  a2  2.7  10  5.4   7
  a3  5.3   9  1.5  15
      

• en fait, on peut faire df[booleanVect] où booleanVect est un vecteur de booléens de taille le nombre de lignes de df pour récupérer les lignes où le booléen est True.
• attention :
  • df[df['A'] > 2] : attention, ce n'est pas une copie qui est renvoyée, mais une vue, donc, on ne peut pas modifier le résultat !
  • df.loc[df['A'] > 2,:] : c'est une copie qui est renvoyée ici.
• condition avec booléens : utiliser & (AND), | (OR), ^ (XOR), - (NOT) :
  • df2 = df[(df['A'] > 2) & - (df['B'] < 6)] (attention : parenthèses nécessaires).
  • Autre exemple : df2 = df[(df['A'] == 'a') & numpy.logical_not(pandas.isnull(df['b']))]
• df[df['A'].isin([5.3, 2.7])] : renvoie un dataframe avec seulement les lignes où la valeur de A est parmi celles listées.
• pandas.isnull(df['A']) ou aussi df['A'].isnull() : pour tester les valeurs nulles d'une colonne d'un dataframe.
• on peut tester si une valeur est nulle par pandas.isna(df.iloc[0, 0]) (attention, numpy.isnan() en revoie une exception sur une valeur de type string).
• df['A'].isna() : renvoie une series de booleens qui indique si le champ est nan, identique à df['A'].isnull()
• df.query('A > 2 and B < 10') : permet d'utiliser des conditions complexes (renvoie un nouveau dataframe, le dataframe d'origine est inchangé).
• df.query('X == "c"') : quand il y a des chaînes de caractères dans les colonnes.
• df.query("X == 'c'") : est équivalent.
• df.query('`A.1` < 2') : mettre entre backquotes des noms de colonnes qui ne sont pas des identiants (mais attention, mots clefs r
• numpy.where(df['A'] < 5)[0] : renvoie une array numpy des index (de 0 à n - 1) où la condition est vérifiée.
• df.iloc[numpy.where(df['A'] < 5)[0], :] : renvoie un dataframe des lignes où la condition est vérifiée.

s.index.to_list() : donne la liste des valeurs de l'index

Quand on a 2 index de dataframes :

• ind1.intersection(ind2) : les index communs.
• ind1.union(ind2) : la réunion des index.
• ind1.difference(ind2) : les index présents dans ind1, mais pas dans ind2.
• ind1.symmetric_difference(ind2) : la différence symétrique entre les 2 index

Réindexation d'un dataframe :

• df.reset_index() : renvoie un dataframe réindexé de 0 à n - 1, mais conserve une colonne index avec les anciennes valeurs de l'index !
• df.reset_index(drop = True) : renvoie un dataframe réindexé de 0 à n - 1
• df.reset_index(drop = True, inplace = True) : modifie le dataframe directement.
• Pour un dataframe qui a une colonne 'A' : df.set_index('A') renvoie un dataframe où l'index est la colonne A et la colonne A a disparu du dataframe lui-même
• df.set_index(['A', 'B']) : déplace les colonnes A et B du dataframe dans l'index plutôt que dans le dataframe.

Pour compter le nombre de lignes pour lesquelles on a une valeur : (df['A'] == 'x').sum()

Sampling d'un dataframe :

• df.sample(frac = 0.1) : retourne un dataframe avec 10% des lignes de départ, sans remise.
• df.sample(frac = 1) : fait un shuffling des lignes.
• df.sample(frac = 0.5, axis = 1): retourne 50% des colonnes.