Chez le même éditeur

Machine Learning avec Scikit-Learn

3e édition
Aurélien Géron
Dunod, 2023

Deep Learning avec Keras et TensorFlow

3e édition
Aurélien Géron
Dunod, 2024

Python 3
2e édition
Bob Cordeau, Laurent Pointal
Dunod, 2020
 Édition : Matthieu Daniel et Aleksandra Czarnecka

NOUS NOUS ENGAGEONS EN FAVEUR DE L’ENVIRONNEMENT :

Nos livres sont imprimés sur des papiers certifiés

pour réduire notre impact sur l’environnement.

Le format de nos ouvrages est pensé

afin d’optimiser l’utilisation du papier.

Depuis plus de 30 ans, nous imprimons 70 %

de nos livres en France et 25 % en Europe
et nous mettons tout en œuvre pour augmenter
cet engagement auprès des imprimeurs français.

Nous limitons l’utilisation du plastique sur nos

ouvrages (film sur les couvertures et les livres).

© Dunod, 2024
11 rue Paul Bert, 92240 Malakoff
[Link]
ISBN 978-2-10-085976-4
 Table des matières

Avant-propos................................................................................................... 11

Les fondamentaux du langage Python

1 Python, ses origines et son environnement........................................ 17

1. Histoire, origines et évolution : de la naissance à la version 3.12............ 17
1.1 Les origines et l’évolution du langage............................................. 18
1.2 La rencontre entre Python et la data science.................................. 18
1.3 L’évolution actuelle.......................................................................... 19
1.4 Le futur de Python........................................................................... 20
2. Python vs R vs le reste du monde.......................................................... 20
2.1 R..................................................................................................... 21
2.2 Outils de traitement de flux............................................................ 23
2.3 SAS................................................................................................. 24
2.4 Les autres langages........................................................................ 25
3. Comment développer en Python ?......................................................... 25
4. Les outils pour coder en Python............................................................. 28
4.1 Python et PyPi................................................................................ 28
4.2 Anaconda........................................................................................ 29
4.3 IPython............................................................................................ 32
4.4 Visual Studio Code, Spyder et PyCharm......................................... 33
4.5 Jupyter notebooks.......................................................................... 35
4.6 JupyterLab ...................................................................................... 40
5. Les packages pour la data science......................................................... 42
5.1 Les packages pour la gestion des données
et le calcul numérique..................................................................... 42
5.2 Les packages pour la visualisation des données............................. 43
5.3 Les packages pour le machine learning et le deep learning............ 44
5.4 Les packages pour le big data......................................................... 44
5.5 Autres packages pour la data science............................................. 45

2 Python from scratch...................................................................................... 47

1. Principes de base.................................................................................... 47
1.1 Un langage interprété, de haut niveau et orienté objet................... 47
1.2 Python 2 ou Python 3...................................................................... 48
6 Table des matières

2. Les interpréteurs : Python et IPython..................................................... 49

2.1 L’interpréteur Python – une calculatrice évoluée............................. 49
2.2 L’interpréteur IPython – une ouverture vers plus de possibilités....... 50
3. La base pour commencer à coder.......................................................... 54
3.1 Les principes................................................................................... 54
3.2 Un langage tout objet..................................................................... 56
3.3 Les commentaires.......................................................................... 56
3.4 Les conventions de nommage........................................................ 57
3.5 Les règles de codage...................................................................... 57
3.6 Les opérateurs logiques.................................................................. 58
4. Les structures (tuples, listes, dictionnaires)............................................ 58
4.1 Les tuples....................................................................................... 59
4.2 Les listes......................................................................................... 59
4.3 Les chaînes de caractères – des listes de caractères..................... 61
4.4 Les dictionnaires............................................................................. 63
5. La programmation (conditions, boucles…)............................................. 63
5.1 Les conditions................................................................................. 64
5.2 Les boucles..................................................................................... 66
6. Les fonctions.......................................................................................... 68
6.1 Généralités...................................................................................... 68
6.2 Les arguments d’une fonction........................................................ 69
6.3 Les docstrings................................................................................. 70
6.4 Les retours multiples...................................................................... 71
6.5 Les fonctions lambda...................................................................... 72
7. Les classes et les objets......................................................................... 72
7.1 Qu’est-ce qu’une classe ?............................................................... 73
7.2 Comment définir une classe ?......................................................... 73
7.3 Aller plus loin sur les classes........................................................... 74
8. Les packages et les modules.................................................................. 74
8.1 Un peu de vocabulaire.................................................................... 74
8.2 Installer un package........................................................................ 75
8.3 Charger un package ou un module dans votre code....................... 75
8.4 Créer son propre module/package.................................................. 76
9. Aller plus loin.......................................................................................... 77
9.1 La gestion des exceptions.............................................................. 77
9.2 Les expressions régulières............................................................. 79
9.3 Les décorateurs.............................................................................. 80
 Table des matières 7

La préparation et la visualisation des données

avec Python

3 Python et les données (NumPy et Pandas)................................................. 85

1. La donnée à l’ère de la data science....................................................... 85
1.1 Le type de données......................................................................... 86
1.2 Le travail de préparation des données............................................. 87
2. Les arrays de NumPy.............................................................................. 87
2.1 Le ndarray de NumPy..................................................................... 88
2.2 Construire un array.......................................................................... 88
2.3 Les types de données dans des arrays........................................... 89
2.4 Les propriétés d’un array................................................................ 90
2.5 Accéder aux éléments d’un array.................................................... 90
2.6 La manipulation des arrays avec NumPy........................................ 91
2.7 Copies et vues d’arrays................................................................... 98
2.8 Quelques opérations d’algèbre linéaire.......................................... 99
2.9 Les arrays structurés....................................................................... 100
2.1. Exporter et importer des arrays...................................................... 101
3. Les objets series et dataframe de Pandas.............................................. 102
3.1 Les objets Series de Pandas........................................................... 102
3.2 Les objets DataFrame de Pandas................................................... 105
3.3 Copie et vue des objets de Pandas................................................. 110

4 La préparation des données et les premières statistiques........................ 113

1. Présentation des données...................................................................... 113
1.1 Les locations Airbnb à Paris............................................................. 114
1.2 Les données des employés de la ville de Boston........................... 114
1.3 Les données des communes d’Île-de-France.................................. 115
1.4 Les données sur les clients d’un opérateur
de télécommunications................................................................... 116
1.5 Les SMS pour la classification de messages indésirables.............. 116
1.6 La base de données des vêtements Fashion-MNIST...................... 117
1.7 Les données de l’indice CAC40 depuis 1987.................................. 118
2. Les outils pour charger les données....................................................... 118
2.1 Importer des données structurées................................................. 118
2.2 Le traitement des données externes
(csv, SQL, xlsx, open data…).......................................................... 119
2.3 Charger et transformer des données non structurées
(images, sons, json, xml…)............................................................. 129
8 Table des matières

3. Décrire et transformer des colonnes...................................................... 135

3.1 Décrire la structure de vos données............................................... 135
3.2 Quelles transformations pour les colonnes de vos données ?....... 137
3.3 Les changements de types............................................................. 137
3.4 Les jointures et concaténations...................................................... 140
3.5 La gestion des doublons de lignes................................................. 143
3.6 La discrétisation.............................................................................. 144
3.7 Les tris............................................................................................ 146
3.8 Le traitement de données temporelles........................................... 147
3.9 Le traitement des données manquantes........................................ 151
3.10 Le traitement des colonnes avec des données qualitatives.......... 155
3.11 Les transformations numériques.................................................. 159
3.12 Échantillonnage des données....................................................... 160
3.13 La construction de tableaux croisés.............................................. 162
4. Extraire des statistiques descriptives..................................................... 163
4.1 Statistiques pour données quantitatives......................................... 163
4.2 Statistiques pour données qualitatives........................................... 166
5. Utilisation du groupby pour décrire des données................................... 167
5.1 Le principe...................................................................................... 167
5.2 Les opérations sur les objets groupby............................................ 167
5.3 Apply : une méthode importante pour manipuler vos groupby....... 168
5.4 Cas concret d’utilisation d’un groupby............................................ 169
6. Aller plus loin : accélération..................................................................... 170
6.1 Parallélisation avec Dask et Pandas................................................ 170
6.2 Accélération du code avec Numba.................................................. 171

5 Data visualisation avec Python.................................................................... 175

1. Construction de graphiques avec Matplotlib........................................... 175
1.1 Utilisation de Matplotlib................................................................... 175
1.2 Afficher des graphiques................................................................... 176
1.3 Les paramètres globaux de Matplotlib et l’exportation
de graphiques.................................................................................. 177
1.4 Utilisation de Matplotlib depuis Pandas.......................................... 179
1.5 Votre premier graphique avec Matplotlib......................................... 180
1.6 Nuage de points avec [Link]..................................................... 183
1.7 Le graphique en bâtons avec [Link]().............................................. 184
1.8 La construction d’un pie chart......................................................... 186
1.9 Les barres d’erreurs avec [Link]()............................................ 187
1.10 La construction d’histogrammes................................................... 188
1.11 Personnaliser vos graphiques Matplotlib....................................... 189
1.12 Créer un graphique animé............................................................. 195
 Table des matières 9

2. Seaborn pour des représentations plus élaborées................................. 196

2.1 Utilisation de Seaborn..................................................................... 196
2.2 Le box plot ou la boîte à moustaches............................................. 197
2.3 Les violons...................................................................................... 199
2.4 Les histplot() de Seaborn................................................................ 200
2.5 Les pairplot() de Seaborn ou la matrice de graphiques................... 201
2.6 Les jointplot().................................................................................. 202
3. Quelques bases de cartographie............................................................ 203
3.1 Installation et utilisation de Cartopy................................................ 204
3.2 Les autres outils.............................................................................. 207
4. Les graphiques interactifs avec d’autres packages et outils................... 209
4.1 Les packages utilisés...................................................................... 209
4.2 Plotly pour la création de visualisation interactives......................... 210
4.3 Création d’une application web avec Dash ou Streamlit................. 212
4.4 Construction d’une application web avec Streamlit........................ 215

Python, le machine learning et le big data

6 Différentes utilisations du machine learning avec Python....................... 219

1. Le machine learning, qu’est-ce que c’est ?............................................. 219
1.1 Les principes et les familles d’algorithmes..................................... 219
1.2 Faire du machine learning................................................................ 221
2. Comment faire du machine learning avec Python.................................. 223
2.1 Scikit-Learn..................................................................................... 223
2.2 TensorFlow...................................................................................... 224
2.3 Keras............................................................................................... 225
2.4 PyTorch........................................................................................... 225
2.5 MLflow............................................................................................ 225
3. Le processus de traitement en machine learning................................... 226
3.1 Le rôle du data scientist pour les traitements machine learning....... 226
3.2 Avant les algorithmes : les données................................................ 226
3.3 Quelques règles à respecter lorsqu’on utilise des algorithmes........ 227
3.4 Le traitement avec Scikit-Learn....................................................... 229
4. L’apprentissage supervisé avec Scikit-Learn........................................... 232
4.1 Les données et leur transformation................................................ 232
4.2 Le choix et l’ajustement de l’algorithme......................................... 239
4.3 Les indicateurs pour valider un modèle.......................................... 246
4.4 L’ajustement des hyperparamètres d’un modèle............................ 254
10 Table des matières

4.5 La construction d’un pipeline de traitement................................... 257

4.6 Passer en production votre modèle d’apprentissage supervisé..... 260
5. L’apprentissage non supervisé................................................................ 263
5.1 Le principe...................................................................................... 263
5.2 Implémentation d’une méthode de clustering avec Python........... 263
5.3 Les méthodes de réduction de dimension..................................... 269
6. L’analyse textuelle avec Python............................................................... 275
6.1 Les données textuelles en Python.................................................. 275
6.2 Le prétraitement des données........................................................ 276
6.3 La mise en place d’un premier modèle prédictif............................ 279
6.4 Aller plus loin................................................................................... 282
7. Le deep learning...................................................................................... 283
7.1 Pourquoi le deep learning ?.............................................................. 283
7.2 Installer votre environnement.......................................................... 284
7.3 Principe d’un réseau de neurones et première utilisation............... 284
7.4 Le deep learning et les réseaux de neurones à convolutions.......... 288
7.5 Aller plus loin : génération de features, transfer learning,
RNN, GAN…................................................................................... 293

7 Python et le big data : tour d’horizon........................................................... 301

1. Est-ce qu’on change tout quand on parle de big data ?.......................... 301
2. Comment traiter de la donnée massive avec Python............................. 303
3. Récupérer des données avec Python..................................................... 304
3.1 Les approches classiques............................................................... 304
3.2 Se connecter aux fichiers HDFS en Python – utilisation
de PyArrow..................................................................................... 304
4. Utilisation d’Apache Spark avec PySpark en Python............................... 306
4.1 Principes de Spark.......................................................................... 306
4.2 Installer une infrastructure Spark.................................................... 308
4.3 Le DataFrame de Spark SQL.......................................................... 310
4.4 Le machine learning avec Spark...................................................... 315

Lexique de la data science............................................................................. 319

Mettre en place votre environnement........................................................... 323

Bibliographie................................................................................................... 327

Index................................................................................................................. 331
 Avant-propos
‹ Pourquoi un ouvrage sur Python en data science ?
Python s’impose depuis quelques années dans de nombreux domaines
comme un langage de programmation de référence. Dans le cadre de la science
des données (data science), il s’avère être un outil de premier plan permettant
d’articuler des projets complexes avec un langage « universel ». Il est aujourd’hui
l’outil idéal pour mettre en place des prototypes et un grand allié du big data, du
machine learning, du deep learning et de l’intelligence artificielle.
Cet ouvrage vous guidera afin d’aborder ce langage simple, et d’approfondir
son utilisation en tant qu’utilisateur data.
L’objectif est de vous donner les outils nécessaires à la compréhension et à
l’utilisation de Python en data science. Si vous êtes ou voulez devenir data scien-
tist, la maîtrise de Python est aujourd’hui un prérequis.
Ce livre va vous permettre de prendre en main ce langage et d’en comprendre
toutes les subtilités afin d’être capable de développer en Python des processus
de data science.
Notre objectif n’est pas ici de présenter des méthodes de manière théorique
mais plutôt d’illustrer l’application de méthodes de data science grâce au langage
Python et à toutes ses spécificités.

‹ À qui s’adresse ce livre ?

Comme son titre l’indique, cet ouvrage s’adresse aux data scientists ou aux
futurs data scientists. De manière plus large, il intéressera tous ceux qui, au
quotidien, traitent des données et tentent de mettre en place des traitements de
données dans des cadres concrets.
Plus spécifiquement, il est destiné :
9 Aux professionnels de la Business Intelligence qui désirent analyser plus fine-
ment leurs données grâce à un nouveau langage.
9 Aux statisticiens (notamment ceux qui utilisent SAS ou R) qui ont besoin de
mettre en place des processus automatisés et qui désirent s’initier à Python.
9 Aux développeurs qui souhaitent acquérir une compétence en data science
avec l’utilisation de Python.
9 Aux étudiants de niveau master en informatique ou en statistique qui désirent
s’initier et se perfectionner au langage Python en travaillant sur des cas
pratiques.
12 Avant-propos

9 Aux analystes et consultants amenés à gérer des projets et des analyses de

données en Python dans le cadre de leurs activités.
Cet ouvrage ne demande pas de connaissances particulières. Néanmoins, la
compréhension des notions de programmation et des connaissances rudimen-
taires en statistique faciliteront l’apprentissage.

‹ Qu’est-ce que la data science et que fait le data scientist ?

Les termes de data science et de data scientist sont assez récents. La data
science ou science des données consiste à résoudre des problèmes complexes
en utilisant de grands volumes de données.
Le data scientist est celui qui mettra en place et fera fonctionner des processus
de data science. Son rôle est de faire le lien entre des problèmes métiers et des
solutions par le biais d’algorithmes et d’infrastructures modernes. À ce titre, il
devra avoir une vision assez large du cadre opérationnel, technique et théorique.
On demande aujourd’hui au data scientist d’être très technique mais il faut garder
en tête que sa principale plus-value sera sa capacité à résoudre des problèmes
qui n’avaient pas de solutions opérationnelles jusqu’alors. Bien entendu, il doit
avoir de bonnes connaissances en statistique, en machine learning, mais aussi
des compétences techniques en développement et une bonne appréhension des
environnements de traitement.

‹ Comment lire ce livre ?

Ce livre est organisé en trois grandes parties qui peuvent être lues séparément
suivant les connaissances et les objectifs du lecteur.
La première partie propose d’acquérir les bases du langage Python et de
découvrir les outils et les principes du langage. Elle se divise en deux chapitres.
Le premier vous permettra de comprendre l’histoire de Python et tous les outils
qui vous aideront à coder en Python (Anaconda, Jupyter notebooks, iPython…).
Le second est une initiation au langage pour maîtriser ou réviser les bases de
Python.
Dans la deuxième partie, tous les outils pour traiter des données avec Python
sont détaillés. En premier lieu, les structures de NumPy et Pandas pour le trai-
tement des données sont introduites. Puis, nous étudierons la préparation des
données et les statistiques élémentaires. Finalement, nous détaillerons l’utilisa-
tion des outils de visualisation des données (notamment Matplotlib, Seaborn et
Plotly).
La dernière partie présente des traitements plus complexes en data science,
basés sur des exemples concrets. L’utilisation du machine learning ou la commu-
nication avec les environnements big data y sont abordés. Dans cette partie, nous
 Avant-propos 13

traiterons des cas de machine learning avec Scikit-Learn, de deep learning avec
Keras et TensorFlow et de traitement de données non structurées. Le dernier
chapitre de ce livre s’intéresse à la communication avec les infrastructures big
data, notamment avec Apache Spark.

‹ Les supports supplémentaires

Cet ouvrage ne se limite pas à sa version papier, tous les contenus et des
contenus supplémentaires sont disponibles en ligne.
L’ensemble des exemples présentés dans cet ouvrage sont disponibles sous
forme de Jupyter notebooks. Ils sont accessibles directement à l’adresse :
[Link]
À cette adresse, vous trouverez de nombreuses informations qui complètent la
lecture de cet ouvrage.
Afin de les lire et de tester vos connaissances, nous vous conseillons d’ins-
taller Anaconda ou Python 3 sur votre ordinateur ou d’utiliser un service du type
MyBinder ou encore Colab de Google.
Tous les détails sur les notebooks, et les environnements à installer sont détail-
lés dans le premier chapitre. Un processus d’installation pas à pas est disponible
dans les annexes du livre.

‹ Remerciements
Je voudrais en premier lieu remercier Olivier Decourt sans lequel ce projet
n’aurait pas pu voir le jour. Merci à mes relecteurs, tout spécialement Jean-Paul
Maalouf, à l’équipe de Dunod et à mon éditeur Jean-Luc Blanc pour sa relecture
minutieuse. Par ailleurs, je voudrais aussi remercier tous ceux qui m’ont permis
de construire cet ouvrage au fil des années, tous ceux que j’ai pu former à Python
avec Stat4decision qui m’ont fourni d’incessants challenges. Merci aussi à la
communauté Python orienté data pour ses échanges passionnants, ses confé-
rences innovantes et ses Meetups de grande qualité. Et pour terminer, je tiens
tout spécialement à remercier mon épouse, Nathalie, et mes deux fils qui m’ont
soutenu tout au long du long processus d’écriture de cet ouvrage.
 PARTIE 1

Les fondamentaux
du langage Python
Python est un langage simple qui doit vous permettre de vous concen-
trer sur la mise en place de processus automatisés en data science.
Néanmoins, il est nécessaire de bien maîtriser son environ­nement.
Cette première partie vous permettra avant tout de comprendre les
spécificités du langage Python au sens large, ses subtilités et ses
bases. Elle vous permettra aussi de mettre en place un environnement
de travail orienté data science afin de maîtriser tous les aspects de
Python en tant que langage pour traiter des données et automatiser
des processus.
 1 Python, ses origines
et son environnement

Dans ce chapitre, nous allons découvrir toutes les pièces nécessaires à la

compréhension et à l’utilisation de Python. Vous y trouverez des explications
sur les installations nécessaires, sur les bonnes pratiques et sur les outils
développés pour vous simplifier la vie lors de votre utilisation du langage
Python.

1. HISTOIRE, ORIGINES ET ÉVOLUTION : DE LA NAISSANCE

À LA VERSION 3.12
Python est né à la fin des années 1980, période extrêmement riche en création
de langages de programmation. C’est Guido van Rossum qui a créé ce langage et
c’est lui qui en parle le mieux (en 1996) :
« Over six years ago, in December 1989, I was looking for a "hobby" program-
ming project that would keep me occupied during the week around Christmas.
My office... woul… closed, but I had a home computer, and not much else on my
hands. I decided to write an interpreter for the new scripting language I had been
thinking about lately: a desce ndant of ABC that would appeal to Unix/C hackers.
I chose Python as a working title for the project, being in a slightly irreverent mood
(and a big fan of Monty Python's Flying’Circus). »1

1. Texte de Guido van Rossum écrit en 1996. Traduction : « Il y a six ans, en décembre 1989, je cherchais un
projet de programmation pour mes loisirs sachant que mon bureau était fermé pendant la période de Nöel.
J’avais un ordinateur à la maison et pas grand-chose d’autre. J’ai donc décidé de créer un interpréteur pour
un nouveau langage de script. J’y pensais déjà depuis un moment : il fallait un héritier de ABC qui serait
attractif pour les hackers utilisateurs de Unix/C. J’ai choisi Python comme nom pour ce projet car j’étais
dans une humeur plutôt provocatrice (et aussi car j’adore le Monty Python's Flying Circus). »
18 Partie 1 Les fondamentaux du langage Python

1.1 Les origines et l’évolution du langage

Dès sa création, Python a été conçu pour mettre à la disposition du plus grand
nombre un outil de développement simple et intuitif pour créer des scripts.

Les cadres de développement de Python

CWI : Le Centrum voor Wiskunde en Informatica d’Amsterdam est le berceau

du langage Python qui se développe comme langage de script pour le projet
­Amoeba. Dans le cadre du CWI, la première version officielle de Python est publiée
(0.9.0) en février 1991. La version 1.0 est aussi publiée dans cette structure.

CNRI : Le Corporation for National Research Initiatives à Reston dans l’état de

­Virginie est le deuxième lieu dans lequel le langage Python s’est développé, à
partir de 1995. Python devient un langage d’apprentissage dans le cadre du projet
­Computer Programming for Everybody.

BeOpen : Après la sortie de la version 1.6 en 2000, l’équipe de développement de

Python change de base et crée l’équipe PythonLabs de BeOpen avec la version 2.0
de Python.

Python Software Foundation : Cette association à but non lucratif est créée en 2001.
Elle va héberger le développement du langage Python à partir de la version 2.1.
Elle est aussi à l’origine de la licence d’utilisation du langage ; la Python Software
­Foundation Licence. En 2008, l’équipe de développement de Python décide de
­publier la version 3.0, qui n’est pas rétro-compatible avec la version 2.

La Python Software Foundation héberge toujours les codes sources du langage, de

nombreuses documentations, le répertoire des packages (PyPi) et gère la licence
d’utilisation.

On voit bien que Python s’est cherché durant toutes les premières années de
développement et que son orientation vers le traitement de la donnée n’a jamais
été central dans son développement au cours de ces trente années.

1.2 La rencontre entre Python et la data science

L’émergence de la data science est récente, et ces nouveaux usages de la
donnée ont souvent eu des difficultés à trouver des outils adaptés. En effet,
le data scientist se doit d’être un bon développeur tout en restant un bon analyste
de données. Il a fallu opter pour un outil qui permette de combiner cette demande
de plus en plus forte de développement et d’automatisation (d’autant plus avec
l’arrivée de l’intelligence artificielle et des objets connectés), avec la nécessité
d’avoir une boîte à outils adaptée aux applications data.
 Python, ses origines et son environnement   Chapitre 1 19

De nombreuses pistes ont été explorées, notamment avec le langage R qui

continue d’être une référence en data science mais qui pouvait paraître trop
orienté vers la statistique pour des data scientists plus dirigés vers le dévelop­
pement. De nombreux autres outils permettant de mettre en place des processus
de data science ont été développés (la plupart propriétaires tels que Matlab ou
SAS), mais il s’avère que Python (qui combine un langage puissant et extrême-
ment simple) a réussi à tirer son épingle du jeu.
La première avancée réelle a été la création du package NumPy (Numerical
Python), qui est toujours aujourd’hui une des pierres angulaires de l’écosystème
Python pour la data science. D’autre part, la mise en place d’environnements
Python orientés data avec notamment Anaconda a aussi permis à toute une
communauté de se créer autour de Python et de la data. Finalement, IPython
et ses notebooks (devenus Jupyter aujourd’hui) ont parachevé l’écosystème afin
de proposer à des data scientists un langage simple mais extrêmement complet
pour la data science. Cet environnement global a abouti au développement de
nombreux packages et de nombreuses API, qui font aujourd’hui de Python le
meilleur outil pour automatiser des traitements de data science.

1.3 L’évolution actuelle

Depuis quelques années, Python a pris une place extrêmement importante
dans le monde du traitement des données. Alors qu’au début des années 2010,
il semblait clair que dans le monde des outils open source de traitement de
données, le logiciel R allait se tailler la part du lion, un changement important a
eu lieu depuis quelques années. L’émergence de Python en tant que langage lié
à la data science, au machine learning, au deep learning et à l’intelligence arti­
ficielle est extrêmement rapide. Grâce à une communauté extrêmement active
sous la bannière PyData et à des évènements fréquents et nombreux (les PyCon,
les PyData, les JupyterCon, les SciPyCon…), le développement du langage prend
une tournure inattendue. Alors qu’on pouvait entendre en 2015 des développeurs
dire que du point de vue du machine learning le développement de Python se
calquait sur celui de R avec quelques mois de retard. Aujourd’hui, c’est R qui
calque ses développements dans le domaine du machine learning, du deep lear-
ning et du big data, sur les packages développés en Python.
L’aventure de Python en data science est donc récente mais ne fait que
commencer car c’est un langage qui s’adapte parfaitement à l’approche menée
par un data scientist, lequel serait « meilleur en programmation qu’un statisticien
et meilleur en statistique qu’un développeur ».
20 Partie 1 Les fondamentaux du langage Python

1.4 Le futur de Python

Le grand développement actuel concerne l’utilisation d’interfaces inter­actives
avec Python comme langage de communication avec des API de plus en plus
évoluées.
Python est de plus en plus utilisé comme un langage pour communiquer avec
d’autres environnements. Ainsi Python permet de communiquer avec Apache
Spark par l’intermédiaire de PySpark, ou avec des écosystèmes de deep lear-
ning tels que TensorFlow ou PyTorch. Les calculs ne se font plus dans le moteur
Python mais dans des moteurs bien plus puissants utilisant des infrastructures
distribuées ou des calculs basés sur des GPU (Graphical Process Units). Cette
tendance prend de plus en plus de place avec la massification des données et les
demandes de traitements en temps réels toujours plus fréquents.
Python ne peut pas répondre seul à ces défis mais, combiné à d’autres outils,
il permet au data scientist de gérer tout l’écosystème de traitement de la donnée
qu’elle soit big, small, smart…

2. PYTHON VS R VS LE RESTE DU MONDE

Si vous lisez cet ouvrage, vous avez forcément entendu parler d’autres outils en
data science. On trouve aujourd’hui un écosystème extrêmement développé dans
ce domaine avec des langage tels que R et Python mais aussi des logiciels plus
classiques comme DSS de Dataiku, Databricks, SAS Viya, Azure machine learning
de Microsoft… En tant que data scientist, vous pourrez être amené à croiser
certains de ces outils dans vos missions. Il est donc important de comprendre où
se situe la force de chacun.
Nous nous concentrons ici sur Python et son utilisation par les data scientists.
Alors pourquoi Python a-t-il une place si spéciale ?
Malgré l’émergence récente du No-Code et du Low-Code, en data science on
s’oriente vers plus de code dans les processus de traitement et Python répond
parfaitement à cette demande. Ainsi, les outils du data scientist se différencient
de plus en plus de ceux de l’analyste BI (business intelligence) qui eux sont de
plus en plus intuitifs. Dans ce contexte, deux outils open source prennent les
devants : Python et R.
Concernant les outils propriétaires, une tendance se généralise. Il s’agit de l’uti-
lisation de langages tels que Python ou R à l’intérieur de ces outils dès qu’on
aura besoin d’effectuer des opérations complexes. Ainsi, DSS de Dataiku, Alteryx,
RapidMiner ou KNIME intègrent des modules pour développer en Python ou en
R. Vos compétences en Python pourront donc être valorisées aussi dans le cadre
de l’utilisation de ces outils.
 Python, ses origines et son environnement   Chapitre 1 21

2.1 R
R et Python sont aujourd’hui les bases indispensables du data scientist. De
plus, l’évolution rapide des deux langages aboutit à une forme de compétition
saine permettant de les rendre de plus en plus complets pour le traitement des
données. Il existe néanmoins des différences qui sont notables et qui orienterons
vos choix lors de la décision du langage à utiliser pour un projet.
R est basé sur un langage créé pour des statisticiens par des statisticiens, il
s’appuie avant tout sur une approche descriptive et de modélisation des données.
Les sorties de R sont des sorties dignes des logiciels de statistiques « classiques »
avec de nombreux détails. Python n’est pas basé sur cette approche, c’est un
langage de programmation visant à automatiser des processus en ne recherchant
qu’à calculer le strict minimum. Dans le cadre des approches actuelles d’applica-
tion de la data science, Python est adapté à d’autres besoins que R.
D’autre part, Python est un langage de programmation extrêmement simple
se basant sur une syntaxe très lisible. Sa compréhension par de nombreux utili-
sateurs est facilitée, ce qui permet une meilleure interaction entre les différents
métiers liés aux systèmes d’information (responsables, développeurs, data scien-
tists, data ingeneer…).
Le tableau suivant s’intéresse à quelques points clé de vos traitements et tente
de comparer l’utilisation que l’on peut en faire avec Python et R. Il s’agit d’une
vision subjective et qui peut être souvent ajustée par l’utilisation de packages
spécifiques.

Propriété R Python

Lisibilité Moins lisible au premier abord Plus lisible, notamment

du code l’indentation
Rapidité Langage interprété donc peu Langage interprété donc peu
rapide (possibilité d’intégrer rapide (possibilité d’intégrer
d’autres langages plus rapides d’autres langages plus
Rcpp) rapides C, cython…)
Préparation Peu pratique avec sa version Efficace grâce au package
des données de base mais extrêmement Pandas
efficace avec l’environnement
Tidyverse
Capacités big De nombreuses API vers De très nombreuses API
data les infrastructures big data vers les infrastructures big
(parfois un peu de retard data avec un développement
au développement) rapide
Gestion Surtout spécialisé sur Très bien adapté notamment
des données les données structurées avec des packages comme
non structurées NumPy ou Scikit-Image
22 Partie 1 Les fondamentaux du langage Python

Propriété R Python

Traitements Clairement le meilleur outil Des possibilités avec SciPy

statistiques et statsmodels
Machine Toutes les méthodes sont Clairement en avance grâce
learning présentes mais manque au package Scikit-Learn
de cohérence (existence
du package caret pour créer
de la cohérence)
Deep learning Reste en deçà de Python La combinaison des
dans ce domaine traitements de données
non structurées et d’API
vers les principaux
environnements deep
learning lui donne un réel
avantage
Visualisation Capacités fortes grâce à ggplot2 Bonnes capacités avec
Matplotlib, Seaborn et Plotly
Construction En avance grâce au package Rattrape son retard avec
d’applications shiny Streamlit et Dash
« web »
Mise Parfois un peu complexe mais Extrêmement simple grâce
en production de plus en plus simplifié aux environnements
de code et à la simplicité du code
La licence GPL v3 PSF (proche BSD)
d’utilisation

Pour résumer, Python est le langage de l’automatisation qui s’intègre parfai-

tement dans un cadre plus large de service informatique et qui s’adapte aux
contextes de l’intelligence artificielle (données non structurées, environnements
complexes). Il reste néanmoins plus faible que R pour un statisticien qui recherche
un logiciel de statistique.
R et Python sont aujourd’hui complémentaires et vous seront nécessaires très
fréquemment pour vos traitements.

Remarque – Comme vous avez pu le voir dans le tableau ci-dessus, Python

et R ne sont pas basés sur la même licence d’utilisation. Ce sont bien entendu
tous les deux des langages open source pour lesquels vous pouvez utiliser ces
outils dans vos activités personnelles et professionnelles de manière libre. Il faut
néanmoins garder en tête une grande différence. La licence de Python est une
licence libre « classique », elle vous permet de réutiliser du code source, de le
modifier, de le commercialiser et d’en faire tout usage sans obligation d’ouverture
de votre code. Il s’agit du type de licence utilisée classiquement pour les langages
 Python, ses origines et son environnement   Chapitre 1 23

de ­programmation. L’ensemble de l’écosystème Python pour la data est basé sur

cette licence. D’un autre côté, R est basé sur une licence plus contraignante, il
s’agit de la licence GPL v3. Celle-ci vous donne des responsabilités par rapport à
la communauté de développement. En effet, si vous utilisez du code source R et
que vous le modifiez pour le distribuer, vous serez forcé de rendre ce code acces-
sible aux utilisateurs (open source). En allant encore plus loin, cette licence est
« ­contaminante », c’est-à-dire que si vous intégrez du code sous licence à votre
code, votre code passe sous licence et doit être open source. Ce point peut ­effrayer
certains développeurs qui se tournent parfois vers Python. Cette différence entre
les deux langages que sont R et Python traduit une différence de développement
du langage entre les deux communautés. Les développeurs de R sont plus dans
une idée de « forcer » les utilisateurs avancés à contribuer au projet alors que les
développeurs Python parient sur une utilisation très large du langage qui aboutira
à plus de contributions pour le développement du langage.

2.2 Outils de traitement de flux

Les autres outils de la data science sont pour la plupart des facilitateurs,
ainsi la majorité de ces outils se basent sur la création de flux (DSS de Dataiku,
RapidMiner, KNIME…) en utilisant votre souris. Ils simplifient la vie des utilisa-
teurs et, suivant vos besoins, pourront vous faire gagner du temps. Cependant,
tout ce que peuvent faire ces outils peut être fait directement avec Python et ils
intègrent tous des moyens d’ajouter du code en Python dans les flux.

Figure 1.1 – Exemple de traitement de flux en data science.

24 Partie 1 Les fondamentaux du langage Python

Ces outils vont vous permettre de créer des analyses, allant de l’acquisition à
l’analyse des données en quelques clics. Par exemple, vous pourrez aller cher-
cher des données dans différents formats dans un premier niveau, vérifier et
fusionner ces données au niveau suivant, transformer les données, les décou-
per et appliquer et valider des modèles prédictifs sur ces données. Tout ceci est
inclus dans un seul flux, comme nous pouvons le voir dans la figure 1.1 (il s’agit
ici de Dataiku).
Python sera donc très différent de ce traitement visuel mais permettra assez
facilement de reproduire ce type de flux sous forme de code. De plus, dès que les
« briques » de vos traitements deviennent plus complexes, l’utilisation de Python
à l’intérieur de chaque brique devient nécessaire.

2.3 SAS
Nous allons nous attarder ici sur un point spécifique car il concerne de nombreux
utilisateurs dans le monde professionnel. Depuis quelque temps, de nombreuses
entreprises décident de migrer leurs infrastructures de l’historique SAS aux nouveaux
venus (R et Python). Il est sans doute utile de clarifier quelques points à ce sujet.
SAS est un logiciel propriétaire spécialisé dans le traitement de données. Il
cumule près de quarante ans d’expérience dans ce domaine et ne peut pas être
remplacé de manière simple dans des entreprises qui se sont souvent basées sur
cet outil pour le traitement de leurs données. Néanmoins, le passage vers un outil
comme Python peut se justifier pour plusieurs raisons :
9 D’un point de vue économique : c’est souvent la première raison invoquée. En
effet, les licences d’utilisation de SAS coûtent très cher. Mais le changement
aussi va coûter cher, il demande de modifier les façons de travailler et une plus
grande prise en charge des infrastructures qu’auparavant.
9 D’un point de vue technologique : c’est le point le plus important. Le passage à
Python va permettre d’accéder à des méthodes de machine learning, de deep
learning et de traitement de données non structurées bien plus puissantes
qu’avec SAS.
Il faut garder en tête que ce changement va amener un certain nombre d’in-
convénients. Principalement le fait que Python est un langage qui va charger les
données en mémoire dans votre machine alors que SAS utilisait un système inter-
médiaire de tables stockées sur de la mémoire physique. Il vous faudra donc
modifier vos habitudes et passer par des requêtes plus élaborées vers vos bases
de données. Ensuite, le processus de transformation et de traitement des données
sera largement simplifié. Vous pouvez voir beaucoup de détails sur la documenta-
tion de Pandas, l’une des composantes centrales de Python, à l’adresse suivante :
[Link]
comparison_with_sas.html
 Python, ses origines et son environnement   Chapitre 1 25

Python va donc vous apporter une flexibilité importante mais il faudra modifier votre
approche de la gestion des données et du développement de code avec Python.

2.4 Les autres langages

Nous avons comparé Python a des outils de data science mais une autre
comparaison intéressante peut se faire par rapport à d’autres langages de
programmation. Aujourd’hui de nombreux langages sont disponibles. On pourra
citer dans l’univers de la data : Julia, MatLab, C/C++, Scala. Ces langages ont tous
leurs spécificités, nous pourrons les classer dans deux catégories :
9 Les langages interprétés tels que MatLab, Julia et Scala qui sont des alterna-
tives crédibles à Python dans un cadre orienté data science.
9 Les langages compilés tels que C, C++, Java qui entrent dans une autre caté-
gorie et qui s’adressent à des développeurs plus chevronnés.
Dans certains cas, ils sont plus efficaces que Python mais ils ne possèdent pas
un environnement de packages et d’API aussi développé que celui de Python.

3. COMMENT DÉVELOPPER EN PYTHON ?

C’est une question récurrente : « Quel logiciel utiliser pour coder en Python ? »
La réponse n’est pas simple et nous devons d’abord déconstruire certains préjugés.
Python n’est pas un logiciel, c’est un langage de programmation ! Donc si vous
voulez coder en Python, il suffit de l’installer, de lancer un terminal de commande
et de taper le mot Python. Vous pouvez commencer à coder. Bien entendu, ça
n’est pas ce que vous allez faire au quotidien.
L’une des solutions pour débuter avec Python est d’installer la version gratuite
d’Anaconda ([Link] Il s’agit d’un environnement de dévelop-
pement multi-plateforme (Linux, Mac, Windows), intégrant un interpréteur Python
mais aussi de multiples fonctionnalités, notamment l’interpréteur IPython, l’IDE
Spyder, les notebooks Jupyter mais aussi des centaines de packages permettant
de débuter rapidement à coder en Python. Si vous commencez votre voyage avec
Python, je ne peux que vous conseiller de partir avec Anaconda. Je reviendrai en
détail sur les procédures d’installation de ces différentes composantes dans la
dernière partie de ce chapitre.
Attention, depuis maintenant quelques années, Anaconda a posé certaines
contraintes sur l’utilisation de certaines composantes de ses outils. Notamment
pour pouvoir installer des packages venant du répertoire hébergé par Anaconda,
et si vous ne le faites pas à titre personnel, il vous faudra une licence payante. On
peut néanmoins l’utiliser sans passer par l’achat d’une licence (nous reviendrons
sur ce point dans le processus d’installation.
26 Partie 1 Les fondamentaux du langage Python

Autre point fondamental : lorsque nous faisons du Python, nous développons

des programmes informatiques. Que votre objectif soit l’analyse d’une petite
base de données ou la construction d’un programme complexe d’intelligence
artificielle, il faudra vous poser un certain nombre de questions liées au déve-
loppement informatique. Ces points ne sont pas spécifiques à Python mais sont
centraux dans votre processus de travail en tant que data scientist.
Développer des outils en Python est un processus de développement simpli-
fié qui permet une réelle agilité dans le développement mais nécessite tout de
même des principes fondamentaux qui vont s’intégrer dans le cadre spécifique
de la data science.
Le processus de traitement d’un problème en data science passe par un certain
nombre d’étapes :
1. La définition du problème métier
2. La transformation du problème métier en un problème data science
3. La recherche et la découverte des sources de données
4. La préparation et la mise en forme des données
5. La construction et l’ajustement de modèles
6. La validation des modèles
7. La réponse à la question et la mise en production des modèles
Toutes ces étapes sont centrales dans le processus de travail du data scientist.
Le développement va intervenir à différentes étapes et Python sera un outil qui
vous accompagnera au mieux lors de toutes ces étapes.
Votre façon de développer dépendra surtout des points (1) et (7). Votre proces-
sus de développement dépendra :
9 Du commanditaire ou du porteur de projet : c’est lui à qui il faudra répondre.
En fonction de son rôle, de son niveau d’expertise, de ses attentes, vous
ne développerez pas de la même manière. Imaginons que la problématique
soulevée émane du CEO de votre entreprise, pour répondre à cette ques-
tion, il faudra mettre à sa disposition des outils qui seront le moins technique
possible, il pourra s’agir d’un rapport « classique » ou d’un outil interactif.
Si cette question vient d’un collègue data scientist, des scripts ou des note-
books seront souvent suffisants pour fournir une réponse satisfaisante.
9 Du livrable attendu : s’il s’agit d’une simple demande ponctuelle sur une
analyse à effectuer, il vous suffira de développer un script simple et de
construire un rapport « figé ». En revanche, si l’attendu (ce qui est de plus en
plus le cas) est un outil interactif ou la mise en production d’un algorithme
avancé de machine learning, vous devrez mettre en place un processus extrê-
mement strict de développement.