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.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert