!pip install pynsee

⚠️ pandas offre la possibilité d’importer des données directement depuis un url. C’est l’option prise dans ce tutoriel. Si vous préfèrez, pour des raisons d’accès au réseau ou de performance, importer depuis un poste local, vous pouvez télécharger les données et changer les commandes d’import avec le chemin adéquat plutôt que l’url.

Nous suivrons les conventions habituelles dans l’import des packages

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pynsee.download

Pour obtenir des résultats reproductibles, on peut fixer la racine du générateur pseudo-aléatoire.

np.random.seed(123)

Au cours de cette démonstration des principales fonctionalités de pandas, et lors du chapitre suivant, je recommande de se référer régulièrement aux ressources suivantes:

• L’aide officielle de pandas. Notamment, la page de comparaison des langages est très utile
• La cheatsheet suivante, issue de ce post

Logique de pandas

L’objet central dans la logique pandas est le DataFrame. Il s’agit d’une structure particulière de données à deux dimensions, structurées en alignant des lignes et colonnes. Les colonnes peuvent être de type différent.

Un DataFrame est composé des éléments suivants:

• l’indice de la ligne ;
• le nom de la colonne ;
• la valeur de la donnée ;

Structuration d’un DataFrame pandas, empruntée à https://medium.com/epfl-extension-school/selecting-data-from-a-pandas-dataframe-53917dc39953:

Le concept de tidy data, popularisé par Hadley Wickham via ses packages R, est parfaitement pertinent pour décrire la structure d’un DataFrame pandas. Les trois règles sont les suivantes:

• Chaque variable possède sa propre colonne ;
• Chaque observation possède sa propre ligne ;
• Une valeur, matérialisant une observation d’une variable, se trouve sur une unique cellule.

::: {.cell .markdown} [^2]: En R, les deux formes de dataframes qui se sont imposées récemment sont les tibbles (package dplyr) et les data.tables (package data.table). dplyr reprend la syntaxe SQL de manière relativement transparente ce qui rend la syntaxe très proche de celle de pandas. Cependant, alors que dplyr supporte très mal les données dont la volumétrie dépasse 1Go, pandas s’en accomode bien. Les performances de pandas sont plus proches de celles de data.table, qui est connu pour être une approche efficace avec des données de taille importante. :::

Concernant la syntaxe, une partie des commandes python est inspirée par la logique SQL. On retrouvera ainsi des instructions relativement transparentes.

Il est vivement recommandé, avant de se lancer dans l’écriture d’une fonction, de se poser la question de son implémentation native dans numpy, pandas, etc. En particulier, la plupart du temps, s’il existe une solution implémentée dans une librairie, il convient de l’utiliser.

Les Series

En fait, un DataFrame est une collection d’objets appelés pandas.Series. Ces Series sont des objets d’une dimension qui sont des extensions des array-unidimensionnels numpy. En particulier, pour faciliter le traitement de données catégorielles ou temporelles, des types de variables supplémentaires sont disponibles dans pandas par rapport à numpy (categorical, datetime64 et timedelta64). Ces types sont associés à des méthodes optimisées pour faciliter le traitement de ces données.

Il ne faut pas négliger l’attribut dtype d’un objet pandas.Series car cela a une influence déterminante sur les méthodes et fonctions pouvant être utilisées (on ne fait pas les mêmes opérations sur une donnée temporelle et une donnée catégorielle) et le volume en mémoire d’une variable (le type de la variable détermine le volume d’information stocké pour chaque élément ; être trop précis est parfois néfaste).

Il existe plusieurs types possibles pour un pandas.Series. Le type object correspond aux types Python str ou mixed. Il existe un type particulier pour les variables dont le nombre de valeurs est une liste finie et relativement courte, le type category. Il faut bien examiner les types de son DataFrame, et convertir éventuellement les types lors de l’étape de data cleaning.

Indexation

La différence essentielle entre une Series et un objet numpy est l’indexation. Dans numpy, l’indexation est implicite ; elle permet d’accéder à une donnée (celle à l’index situé à la position i). Avec une Series, on peut bien-sûr utiliser un indice de position mais on peut surtout faire appel à des indices plus explicites. Par exemple,

taille = pd.Series(
    [1.,1.5,1],
    index = ['chat', 'chien', 'koala']
)

taille.head()

chat     1.0
chien    1.5
koala    1.0
dtype: float64

Cette indexation permet d’accéder à des valeurs de la Series via une valeur de l’indice. Par exemple, taille['koala']:

taille['koala']

1.0

L’existence d’indice rend le subsetting particulièrement aisé, ce que vous pouvez expérimenter dans les TP

Pour transformer un objet pandas.Series en array numpy, on utilise la méthode values. Par exemple, taille.values:

taille.values

array([1. , 1.5, 1. ])

Un avantage des Series par rapport à un array numpy est que les opérations sur les Series alignent automatiquement les données à partir des labels. Avec des Series labélisées, il n’est ainsi pas nécessaire de se poser la question de l’ordre des lignes. L’exemple dans la partie suivante permettra de s’en assurer.

Valeurs manquantes

Par défaut, les valeurs manquantes sont affichées NaN et sont de type np.nan (pour les valeurs temporelles, i.e. de type datatime64, les valeurs manquantes sont NaT).

On a un comportement cohérent d’agrégation lorsqu’on combine deux DataFrames (ou deux colonnes). Par exemple,

x = pd.DataFrame(
    {'prix': np.random.uniform(size = 5),
     'quantite': [i+1 for i in range(5)]
    },
    index = ['yaourt','pates','riz','tomates','gateaux']
)
x

y = pd.DataFrame(
    {'prix': [np.nan, 0, 1, 2, 3],
     'quantite': [i+1 for i in range(5)]
    },
    index = ['tomates','yaourt','gateaux','pates','riz']
)
y

x + y

donne bien une valeur manquante pour la ligne tomates. Au passage, on peut remarquer que l’agrégation a tenu compte des index.

Il est possible de supprimer les valeurs manquantes grâce à dropna(). Cette méthode va supprimer toutes les lignes où il y a au moins une valeur manquante. Il est aussi possible de supprimer seulement les colonnes où il y a des valeurs manquantes dans un DataFrame avec dropna() avec le paramètre axis=1 (par défaut égal à 0).

Il est également possible de remplir les valeurs manquantes grâce à la méthode fillna().

Le DataFrame pandas

Le DataFrame est l’objet central de la librairie pandas. Il s’agit d’une collection de pandas.Series (colonnes) alignées par les index. Les types des variables peuvent différer.

Un DataFrame non-indexé a la structure suivante:

Alors que le même DataFrame indexé aura la structure suivante:

Les attributs et méthodes utiles

Pour présenter les méthodes les plus pratiques pour l’analyse de données, on peut partir de l’exemple des consommations de CO2 communales issues des données de l’Ademe. Cette base de données est exploitée plus intensément dans le TP.

L’import de données depuis un fichier plat se fait avec la fonction read_csv:

df = pd.read_csv("https://koumoul.com/s/data-fair/api/v1/datasets/igt-pouvoir-de-rechauffement-global/convert")
df

L’affichage des DataFrames est très ergonomique. On obtiendrait le même output avec display(df)². Les premières et dernières lignes s’affichent automatiquement. Autrement, on peut aussi faire:

• head qui permet, comme son nom l’indique, de n’afficher que les premières lignes ;
• tail qui permet, comme son nom l’indique, de n’afficher que les dernières lignes
• sample qui permet d’afficher un échantillon aléatoire de n lignes. Cette méthode propose de nombreuses options.

Dimensions et structure du DataFrame

Les premières méthodes utiles permettent d’afficher quelques attributs d’un DataFrame.

df.axes

[RangeIndex(start=0, stop=35798, step=1),
 Index(['INSEE commune', 'Commune', 'Agriculture', 'Autres transports',
        'Autres transports international', 'CO2 biomasse hors-total', 'Déchets',
        'Energie', 'Industrie hors-énergie', 'Résidentiel', 'Routier',
        'Tertiaire'],
       dtype='object')]

df.columns

Index(['INSEE commune', 'Commune', 'Agriculture', 'Autres transports',
       'Autres transports international', 'CO2 biomasse hors-total', 'Déchets',
       'Energie', 'Industrie hors-énergie', 'Résidentiel', 'Routier',
       'Tertiaire'],
      dtype='object')

df.index

RangeIndex(start=0, stop=35798, step=1)

Pour connaître les dimensions d’un DataFrame, on peut utiliser quelques méthodes pratiques:

df.ndim

2

df.shape

(35798, 12)

df.size

429576

Pour déterminer le nombre de valeurs uniques d’une variable, plutôt que chercher à écrire soi-même une fonction, on utilise la méthode nunique. Par exemple,

df['Commune'].nunique()

33338

pandas propose énormément de méthodes utiles. Voici un premier résumé, accompagné d’un comparatif avec R

::: {.cell .markdown} [^4]: Le principe d’indice n’existe pas dans dplyr. Ce qui s’approche le plus des indices, au sens de pandas, sont les clés en data.table.

Statistiques agrégées

pandas propose une série de méthodes pour faire des statistiques agrégées de manière efficace.

On peut, par exemple, appliquer des méthodes pour compter le nombre de lignes, faire une moyenne ou une somme de l’ensemble des lignes

df.count()

INSEE commune                      35798
Commune                            35798
Agriculture                        35736
Autres transports                   9979
Autres transports international     2891
CO2 biomasse hors-total            35798
Déchets                            35792
Energie                            34490
Industrie hors-énergie             34490
Résidentiel                        35792
Routier                            35778
Tertiaire                          35798
dtype: int64

df.mean()

/tmp/ipykernel_955/3698961737.py:1: FutureWarning:

The default value of numeric_only in DataFrame.mean is deprecated. In a future version, it will default to False. In addition, specifying 'numeric_only=None' is deprecated. Select only valid columns or specify the value of numeric_only to silence this warning.

Agriculture                        2459.975760
Autres transports                   654.919940
Autres transports international    7692.344960
CO2 biomasse hors-total            1774.381550
Déchets                             410.806329
Energie                             662.569846
Industrie hors-énergie             2423.127789
Résidentiel                        1783.677872
Routier                            3535.501245
Tertiaire                          1105.165915
dtype: float64

df.sum()

INSEE commune                      0100101002010040100501006010070100801009010100...
Commune                            L'ABERGEMENT-CLEMENCIATL'ABERGEMENT-DE-VAREYAM...
Agriculture                                                          87909693.748185
Autres transports                                                     6535446.082616
Autres transports international                                      22238569.279024
CO2 biomasse hors-total                                              63519310.715902
Déchets                                                              14703580.140421
Energie                                                              22852033.998225
Industrie hors-énergie                                               83573677.443527
Résidentiel                                                          63841398.384566
Routier                                                             126493163.530568
Tertiaire                                                            39562729.439236
dtype: object

df.nunique()

INSEE commune                      35798
Commune                            33338
Agriculture                        35576
Autres transports                   9963
Autres transports international     2883
CO2 biomasse hors-total            35798
Déchets                            11016
Energie                             1453
Industrie hors-énergie              1889
Résidentiel                        35791
Routier                            35749
Tertiaire                           8663
dtype: int64

df.quantile(q = [0.1,0.25,0.5,0.75,0.9])

/tmp/ipykernel_955/3249153178.py:1: FutureWarning:

The default value of numeric_only in DataFrame.quantile is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.

Il faut toujours regarder les options de ces fonctions en termes de valeurs manquantes, car ces options sont déterminantes dans le résultat obtenu.

Les exercices de TD visent à démontrer l’intérêt de ces méthodes dans quelques cas précis.

Le tableau suivant récapitule le code équivalent pour avoir des statistiques sur toutes les colonnes d’un dataframe en R.

La méthode describe permet de sortir un tableau de statistiques agrégées:

df.describe()

Méthodes relatives aux valeurs manquantes

Les méthodes relatives aux valeurs manquantes peuvent être mobilisées en conjonction des méthodes de statistiques agrégées. C’est utiles lorsqu’on désire obtenir une idée de la part de valeurs manquantes dans un jeu de données

df.isnull().sum()

INSEE commune                          0
Commune                                0
Agriculture                           62
Autres transports                  25819
Autres transports international    32907
CO2 biomasse hors-total                0
Déchets                                6
Energie                             1308
Industrie hors-énergie              1308
Résidentiel                            6
Routier                               20
Tertiaire                              0
dtype: int64

On trouvera aussi la référence à isna() qui est la même méthode que isnull().

Graphiques rapides

Les méthodes par défaut de graphique (approfondies dans la partie visualisation) sont pratiques pour produire rapidement un graphique, notamment après des opérations complexes de maniement de données.

En effet, on peut appliquer la méthode plot() directement à une pandas.Series:

df['Déchets'].plot()
df['Déchets'].hist()
df['Déchets'].plot(kind = 'hist', logy = True)

plt.figure()
fig = df['Déchets'].plot()
fig
#plt.savefig('plot_base.png', bbox_inches='tight')

plt.figure()
fig = df['Déchets'].hist()
fig
#plt.savefig('plot_hist.png', bbox_inches='tight')

plt.figure()
fig = df['Déchets'].plot(kind = 'hist', logy = True)
fig
#plt.show()
#plt.savefig('plot_hist_log.png', bbox_inches='tight')

<AxesSubplot: ylabel='Frequency'>

La sortie est un objet matplotlib. La customisation de ces figures est ainsi possible (et même désirable car les graphiques matplotlib sont, par défaut, assez rudimentaires), nous en verrons quelques exemples.

Accéder à des éléments d’un DataFrame

Sélectionner des colonnes

En SQL, effectuer des opérations sur les colonnes se fait avec la commande SELECT. Avec pandas, pour accéder à une colonne dans son ensemble on peut utiliser plusieurs approches:

• dataframe.variable, par exemple df.Energie. Cette méthode requiert néanmoins d’avoir des noms de colonnes sans espace.
• dataframe[['variable']] pour renvoyer la variable sous forme de DataFrame ou dataframe['variable'] pour la renvoyer sous forme de Series. Par exemple, df[['Autres transports']] ou df['Autres transports']. C’est une manière préférable de procéder.

Accéder à des lignes

Pour accéder à une ou plusieurs valeurs d’un DataFrame, il existe deux manières conseillées de procéder, selon la forme des indices de lignes ou colonnes utilisés:

• df.loc: utilise les labels
• df.iloc: utilise les indices

iloc va se référer à l’indexation de 0 à N où N est égal à df.shape[0] d’un pandas.DataFrame. loc va se référer aux valeurs de l’index de df.

Par exemple, avec le pandas.DataFrame df_example:

df_example = pd.DataFrame(
    {'year': [2012, 2014, 2013, 2014], 'sale': [55, 40, 84, 31]})
df_example

• df_example.loc[1, :] donnera la première ligne de df (ligne où l’indice month est égal à 1) ;
• df_example.iloc[1, :] donnera la deuxième ligne (puisque l’indexation en Python commence à 0) ;
• df_example.iloc[:, 1] donnera la deuxième colonne, suivant le même principe.

Principales manipulation de données

L’objectif du TP pandas est de se familiariser plus avec ces commandes à travers l’exemple des données des émissions de C02.

Les opérations les plus fréquentes en SQL sont résumées par le tableau suivant. Il est utile de les connaître (beaucoup de syntaxes de maniement de données reprennent ces termes) car, d’une manière ou d’une autre, elles couvrent la plupart des usages de manipulation des données

Opérations sur les colonnes: select, mutate, drop

Les DataFrames pandas sont des objets mutables en langage Python, c’est-à-dire qu’il est possible de faire évoluer le DataFrame au grès des opérations. L’opération la plus classique consiste à ajouter ou retirer des variables à la table de données.

df_new = df.copy()

La manière la plus simple d’opérer pour ajouter des colonnes est d’utiliser la réassignation. Par exemple, pour créer une variable x qui est le log de la variable Agriculture:

df_new['x'] = np.log(df_new['Agriculture'])

Il est possible d’appliquer cette approche sur plusieurs colonnes. Un des intérêts de cette approche est qu’elle permet de recycler le nom de colonnes.

vars = ['Agriculture', 'Déchets', 'Energie']

df_new[[v + "_log" for v in vars]] = np.log(df_new[vars])
df_new

Il est également possible d’utiliser la méthode assign. Pour des opérations vectorisées, comme le sont les opérateurs de numpy, cela n’a pas d’intérêt.

Cela permet notamment d’enchainer les opérations sur un même DataFrame (notamment grâce au pipe que nous verrons plus loin). Cette approche utilise généralement des lambda functions. Par exemple le code précédent (celui concernant une seule variable) prendrait la forme:

df_new.assign(Energie_log = lambda x: np.log(x['Energie']))

Dans les méthodes suivantes, il est possible de modifier le pandas.DataFrame en place, c’est à dire en ne le réassignant pas, avec le paramètre inplace = True. Par défaut, inplace est égal à False et pour modifier le pandas.DataFrame, il convient de le réassigner.

On peut facilement renommer des variables avec la méthode rename qui fonctionne bien avec des dictionnaires (pour renommer des colonnes il faut préciser le paramètre axis = 1):

df_new = df_new.rename({"Energie": "eneg", "Agriculture": "agr"}, axis=1)

Enfin, pour effacer des colonnes, on utilise la méthode drop avec l’argument columns:

df_new = df_new.drop(columns = ["eneg", "agr"])

Réordonner

La méthode sort_values permet de réordonner un DataFrame. Par exemple, si on désire classer par ordre décroissant de consommation de CO2 du secteur résidentiel, on fera

df = df.sort_values("Résidentiel", ascending = False)

Ainsi, en une ligne de code, on identifie les villes où le secteur résidentiel consomme le plus.

Filtrer

L’opération de sélection de lignes s’appelle FILTER en SQL. Elle s’utilise en fonction d’une condition logique (clause WHERE). On sélectionne les données sur une condition logique. Il existe plusieurs méthodes en pandas.

La plus simple est d’utiliser les boolean mask, déjà vus dans le chapitre numpy.

Par exemple, pour sélectionner les communes dans les Hauts-de-Seine, on peut utiliser le résultat de la méthode str.startswith (qui renvoie True ou False) directement dans les crochets:

df[df['INSEE commune'].str.startswith("92")].head(2)

Pour remplacer des valeurs spécifiques, on utilise la méthode where ou une réassignation couplée à la méthode précédente.

Par exemple, pour assigner des valeurs manquantes aux départements du 92, on peut faire cela

df_copy = df.copy()
df_copy = df_copy.where(~df['INSEE commune'].str.startswith("92"))

et vérifier les résultats:

df_copy[df['INSEE commune'].str.startswith("92")].head(2)
df_copy[~df['INSEE commune'].str.startswith("92")].head(2)

ou alors utiliser une réassignation plus classique:

df_copy = df.copy()
df_copy[df_copy['INSEE commune'].str.startswith("92")] = np.nan

Il est conseillé de filtrer avec loc en utilisant un masque. En effet, contrairement à df[mask], df.loc[mask, :] permet d’indiquer clairement à Python que l’on souhaite appliquer le masque aux labels de l’index. Ce n’est pas le cas avec df[mask]. D’ailleurs, lorsqu’on utilise la syntaxe df[mask], pandas renvoie généralement un warning

Opérations par groupe

En SQL, il est très simple de découper des données pour effectuer des opérations sur des blocs cohérents et recollecter des résultats dans la dimension appropriée. La logique sous-jacente est celle du split-apply-combine qui est repris par les langages de manipulation de données, auxquels pandas ne fait pas exception.

L’image suivante, issue de ce site représente bien la manière dont fonctionne l’approche split-apply-combine

Ce tutoriel sur le sujet est particulièrement utile.

Pour donner quelques exemples, on peut créer une variable départementale qui servira de critère de groupe.

df['dep'] = df['INSEE commune'].str[:2]

En pandas, on utilise groupby pour découper les données selon un ou plusieurs axes. Techniquement, cette opération consiste à créer une association entre des labels (valeurs des variables de groupe) et des observations.

Par exemple, pour compter le nombre de communes par département en SQL, on utiliserait la requête suivante:

SELECT dep, count(INSEE commune)
FROM df
GROUP BY dep;

Ce qui, en pandas, donne:

df.groupby('dep')["INSEE commune"].count()

dep
01    410
02    805
03    318
04    199
05    168
     ... 
91    196
92     36
93     40
94     47
95    185
Name: INSEE commune, Length: 96, dtype: int64

La syntaxe est quasiment transparente. On peut bien-sûr effectuer des opérations par groupe sur plusieurs colonnes. Par exemple,

df.groupby('dep').mean()

/tmp/ipykernel_955/2644916509.py:1: FutureWarning:

The default value of numeric_only in DataFrameGroupBy.mean is deprecated. In a future version, numeric_only will default to False. Either specify numeric_only or select only columns which should be valid for the function.

A noter que la variable de groupe, ici dep, devient, par défaut, l’index du DataFrame de sortie. Si on avait utilisé plusieurs variables de groupe, on obtiendrait un objet multi-indexé. Sur la gestion des multi-index, on pourra se référer à l’ouvrage Modern Pandas dont la référence est donnée en fin de cours.

Tant qu’on n’appelle pas une action sur un DataFrame par groupe, du type head ou display, pandas n’effectue aucune opération. On parle de lazy evaluation. Par exemple, le résultat de df.groupby('dep') est une transformation qui n’est pas encore évaluée:

df.groupby('dep')

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7f1a30765e20>

Il est possible d’appliquer plus d’une opération à la fois grâce à la méthode agg. Par exemple, pour obtenir à la fois le minimum, la médiane et le maximum de chaque département, on peut faire:

df.groupby('dep').agg(['min',"median","max"])

/tmp/ipykernel_955/2776048488.py:1: FutureWarning:

['INSEE commune', 'Commune'] did not aggregate successfully. If any error is raised this will raise in a future version of pandas. Drop these columns/ops to avoid this warning.

Appliquer des fonctions

pandas est, comme on a pu le voir, un package très flexible, qui propose une grande variété de méthodes optimisées. Cependant, il est fréquent d’avoir besoin de méthodes non implémentées.

Dans ce cas, on recourt souvent aux lambda functions. Par exemple, si on désire connaître les communes dont le nom fait plus de 40 caractères, on peut appliquer la fonction len de manière itérative:

# Noms de communes superieurs à 40 caracteres
df[df['Commune'].apply(lambda s: len(s)>40)]

Cependant, toutes les lambda functions ne se justifient pas. Par exemple, prenons le résultat d’agrégation précédent. Imaginons qu’on désire avoir les résultats en milliers de tonnes. Dans ce cas, le premier réflexe est d’utiliser la lambda function suivante:

df.groupby('dep').agg(['min',"median","max"]).apply(lambda s: s/1000)

/tmp/ipykernel_955/3726729127.py:1: FutureWarning:

['INSEE commune', 'Commune'] did not aggregate successfully. If any error is raised this will raise in a future version of pandas. Drop these columns/ops to avoid this warning.

En effet, cela effectue le résultat désiré. Cependant, il y a mieux: utiliser la méthode div:

import timeit
%timeit df.groupby('dep').agg(['min',"median","max"]).div(1000)
%timeit df.groupby('dep').agg(['min',"median","max"]).apply(lambda s: s/1000)

La méthode div est en moyenne plus rapide et a un temps d’exécution moins variable. Dans ce cas, on pourrait même utiliser le principe du broadcasting de numpy (cf. chapitre numpy) qui offre des performances équivalentes:

%timeit df.groupby('dep').agg(['min',"median","max"])/1000

apply est plus rapide qu’une boucle (en interne, apply utilise Cython pour itérer) mais reste moins rapide qu’une solution vectorisée quand elle existe. Ce site propose des solutions, par exemple les méthodes isin ou digitize, pour éviter de manuellement créer des boucles lentes.

En particulier, il faut noter que apply avec le paramètre axis=1 est en générale lente.

Joindre

Il est commun de devoir combiner des données issues de sources différentes. Nous allons ici nous focaliser sur le cas le plus favorable qui est la situation où une information permet d’apparier de manière exacte deux bases de données (autrement nous serions dans une situation, beaucoup plus complexe, d’appariement flou³).

La situation typique est l’appariement entre deux sources de données selon un identifiant individuel. Ici, il s’agit d’un identifiant de code commune.

Il est recommandé de lire ce guide assez complet sur la question des jointures avec R qui donne des recommandations également utiles pour un utilisateur de Python.

On utilise de manière indifférente les termes merge ou join. Le deuxième terme provient de la syntaxe SQL. En Pandas, dans la plupart des cas, on peut utiliser indifféremment df.join et df.merge

Il est aussi possible de réaliser un merge en utilisant la fonction pandas.concat() avec axis=1. Se référer à la documentation de concat pour voir les options possibles.

Reshape

On présente généralement deux types de données:

• format wide: les données comportent des observations répétées, pour un même individu (ou groupe), dans des colonnes différentes
• format long: les données comportent des observations répétées, pour un même individu, dans des lignes différentes avec une colonne permettant de distinguer les niveaux d’observations

Un exemple de la distinction entre les deux peut être emprunté à l’ouvrage de référence d’Hadley Wickham, R for Data Science:

L’aide mémoire suivante aidera à se rappeler les fonctions à appliquer si besoin:

Le fait de passer d’un format wide au format long (ou vice-versa) peut être extrêmement pratique car certaines fonctions sont plus adéquates sur une forme de données ou sur l’autre. En règle générale, avec Python comme avec R, les formats long sont souvent préférables.

Le chapitre suivant, qui fait office de TP, proposera des applications de ces principes

Les pipe

En général, dans un projet, le nettoyage de données va consister en un ensemble de méthodes appliquées à un pandas.DataFrame. On a vu que assign permettait de créer une variable dans un DataFrame. Il est également possible d’appliquer une fonction, appelée par exemple my_udf au DataFrame grâce à pipe:

df = (pd.read_csv(path2data)
            .pipe(my_udf))

L’utilisation des pipe rend le code très lisible et peut être très pratique lorsqu’on enchaine des opérations sur le même dataset.

Quelques enjeux de performance

La librairie Dask intègre la structure de numpy, pandas et sklearn. Elle a vocation à traiter de données en grande dimension, ainsi elle ne sera pas optimale pour des données qui tiennent très bien en RAM. Il s’agit d’une librairie construite sur la parallélisation. Un chapitre dans ce cours lui est consacré Pour aller plus loin, se référer à la documentation de Dask.

Références

• Le site pandas.pydata fait office de référence

• Le livre Modern Pandas de Tom Augspurger: https://tomaugspurger.github.io/modern-1-intro.html

Annexe

import warnings
import os
import requests
import zipfile
from pathlib import Path
from shutil import copyfile, copyfileobj

# import tqdm.auto as tqdma
from tqdm import tqdm
from tqdm.utils import CallbackIOWrapper


def download_pb(url: str, fname: str, total: int = None):
    """Useful function to get request with a progress bar
    Borrowed from https://gist.github.com/yanqd0/c13ed29e29432e3cf3e7c38467f42f51
    Arguments:
        url {str} -- URL for the source file
        fname {str} -- Destination where data will be written
    """
    resp = requests.get(url, stream=True)

    if total is None:
        total = int(resp.headers.get('content-length', 0))

    with open(fname, 'wb') as file, tqdm(
            desc='Downloading: ',
            total=total,
            unit='iB',
            unit_scale=True,
            unit_divisor=1024,
    ) as bar:
        for data in resp.iter_content(chunk_size=1024):
            size = file.write(data)
            bar.update(size)


def unzip_pb(fzip, dest, desc="Extracting"):
    """
    Useful function to unzip with progress bar
    Args:
        fzip: Filename of the zipped file
        dest: Destination where data must be written
        desc: Argument inherited from zipfile.ZipFile
    Returns:
        zipfile.Zipfile(fzip).extractall(dest) with progress
    """

    dest = Path(dest).expanduser()
    Path(dest).mkdir(parents=True, exist_ok=True)

    with zipfile.ZipFile(fzip) as zipf, tqdm(
            desc=desc, unit="B", unit_scale=True, unit_divisor=1024,
            total=sum(getattr(i, "file_size", 0) for i in zipf.infolist()),
    ) as pbar:
        for i in zipf.infolist():
            if not getattr(i, "file_size", 0):  # directory
                zipf.extract(i, os.fspath(dest))
            else:
                with zipf.open(i) as fi, open(os.fspath(dest / i.filename), "wb") as fo:
                    copyfileobj(CallbackIOWrapper(pbar.update, fi), fo)


download_pb('https://github.com/InseeFrLab/Py-Insee-Data/archive/refs/heads/master.zip', 'pynsee.zip')

unzip_pb("pynsee.zip", "pynsee")