Data Science with Python

364 Pages·2017·3.36 MB·English

Munich Personal RePEc Archive
Data Science with Python: Algorithm,
Statistics, DataViz, DataMining and
Machine-Learning
Keita, Moussa
February 2017
Online at https://mpra.ub.uni-muenchen.de/76653/
MPRA Paper No. 76653, posted 07 Feb 2017 14:56 UTC
Data Science sous Python
Algorithme, Statistique, DataViz, DataMining et
Machine-Learning
____
Par
Moussa Keita, PhD
Consultant Big Data-Data Science
Umanis Consulting Group, Paris
Février 2017
(Version 1.0)
Résumé
La Data Science est une discipline technique qui associe les concepts statistiques aux
algorithmes puissants de calculs informatiques en vue du traitement et de la
modélisation des données de masse issues des phénomènes de l’observation
(économiques, industriels, commerciaux, financières, managériaux, sociaux, etc..).
En matière de Business Intelligence et de veille stratégique, la Data Science est
devenue un outil incontournable d’aide à la prise de décisions pour les dirigeants.
Elle permet d’exploiter et de valoriser tout le patrimoine informationnel interne et
externe de l’entreprise. Le langage de programmation Python s’est rapidement
imposé, au cours des récentes années, comme un langage de premier choix à la
disposition des Data Scientists pour exploiter le potentiel grandissant du Big Data.
Le gain de popularité dont bénéficie, aujourd’hui, ce langage s’explique en grande
partie par les nombreuses possibilités offertes par ses puissants modules
notamment d’analyses numériques et de calculs scientifiques (numpy, scipy,
pandas), de visualisation de données (matplotlib) mais aussi de Machine Learning
(scikit-learn). Présenté dans une approche hautement pédagogique, ce manuscrit
revisite les différents concepts indispensables à la maitrise de la Data Science sous
Python. Le travail est organisé en sept chapitres. Le premier chapitre est consacré à
la présentation des bases de la programmation sous Python. Dans ce chapitre, nous
présentons notamment les différents éléments de langage qui forment l’ossature du
programme python mais aussi les différents objets de programmation qui en
forment le socle. Le second chapitre est consacré à l’étude des chaînes de caractères
et des expressions régulières. L’objectif de ce second chapitre est de se familiariser
avec le traitement et l’exploitation des chaînes de caractères qui constituenet les
valeurs des variables couramment rencontrées dans les bases de données non
structurées. Le troisième chapitre est consacré à la présentation des méthodes de
gestion de fichiers et de traitements de texte. Le but de ce chapitre est d’approfondir
le précédent chapitre en présentant les méthodes couramment utilisées pour le
traitement des données non structurées qui se présentent généralement sous forme
de fichiers de textes. Le quatrième chapitre est consacré à la présentation des
méthodes de traitement et d’organisation des données initialement stockées sous
forme de tables de données. Le cinquième chapitre est consacré à la présentation
des méthodes classiques d’analyses statistiques (analyses descriptives, tests
statistiques, régression linéaires et logistiques,…). Quant au sixième chapitre, il est
consacré à la présentation des méthodes de datavisualization : histogrammes,
diagrammes en barres, pie-plots, box-plots, scatter-plots, courbes d’évolution,
1
graphiques en 3D,…). Enfin le septième chapitre est consacré à la présentation des
méthodes de datamining et de machine-learning. Dans ce chapitre, nous présentons
notamment les méthodes de réductions de dimensions des données (Analyses en
Composantes Principales, Analyses Factorielles, Analyses des Correspondances
Multiples) mais aussi des méthodes de classification (Classification Ascendante
Hiérarchique, K-Means Clustering, Support Vector Machine, Random Forest).
Toutefois, nous tenons à signaler que le manuscrit est toujours en progression. De ce
fait nous restons ouverts à toutes les critiques et suggestions de nature à améliorer
son contenu.

 Contact info: Email : [email protected]
Nous tenons ici à remercier les auteurs dont les travaux ont été d’un apport considérable à la
rédaction de ce document. Il s’agit notamment de Cordeau et Pointal (2010), Fuchs et Pierre
(2014), Le GOFF(2011), Rakotomalala Ricco, (2015) , Swinnen Gérard,(2010) ainsi que Chris Albon
à travers son site http://chrisalbon.com/.
Codes JEL: C8
Mots clés: Programmation, langage Python, Data science, Traitement et analyses de données,
data visualization.

2
Table des matières
Chapitre 1 : Les bases de la programmation sous
python ............................................................... 21

1.1. Introduction ........................................................................ 21

1.2. Les éléments structurants d’un programme Python ................ 22

1.2.1. Les variables .................................................................................... 22
1.2.1.1. Définir une variable ........................................................................................................ 22
1.2.1.2. Type d’une variable ........................................................................................................ 25
1.2.1.3. Méthodes associées aux variables .................................................................................. 27
1.2.1.3. Les opérateurs arithmétiques et logiques (booléens) ..................................................... 28
1.2.2. Les instructions conditionnelles : la clause « if… else » ........................ 30
1.2.3. Les instructions en boucle ................................................................. 32
1.2.3.1. Les instructions en boucle « while… » ............................................................................. 32
1.2.3.2. Les instructions en boucle « for… in… ».......................................................................... 33
1.2.4. Les instructions break et continue dans une clause « while… » ou « for …
in…» ........................................................................................................ 35
1.2.5. Les mots réservés du langage python ................................................ 35
1.3. Les principaux objets du langage Python ............................... 36

1.4. Etude des objets « liste » ...................................................... 38

1.4.1. Caractéristiques générales des listes .................................................. 38
1.4.1.1. Définition d’un objet liste ............................................................................................... 39
1.4.1.2. Indiçage d’une liste (slicing) ........................................................................................... 40
1.4.3. Les opérations sur les listes ............................................................... 41
1.4.3.1. Déterminer le nombre d’éléments d’une liste ................................................................ 41
1.4.3.2. Additionner des listes ..................................................................................................... 42
1.4.3.3. Démultiplication des éléments d’une liste ...................................................................... 42
1.4.3.4. Modifier ou remplacer les éléments d’une liste .............................................................. 43
1.4.3.5. Ajouter de nouveaux éléments à une liste : fonction append() ....................................... 43
3
1.4.3.6. Insérer de nouveaux éléments dans une liste : fonction insert() ..................................... 44
1.4.3.7. Supprimer un élément d’une liste fonctions remove() ou delete .................................... 44
1.4.3.8. Renvoyer l’indice d’un élément en se basant sur sa valeur :fonction index() .................. 45
1.4.3.9. Compter le nombre d’occurrences d’une valeur dans une liste : fonction count() ........... 45
1.4.3.10. Trier les éléments d’une liste : fonction sort() ............................................................... 45
1.4.3.11. Intervertir l’ordre des éléments dans une liste : fonction reverse()................................ 46
1.4.3.12. Joindre les éléments d’une liste pour former une chaîne de caractères : fonction join() 46
1.4.3.13. Tester l’existence d’un élément dans une liste : fonction in .......................................... 47
1.4.3.14. Récupérer simultanément les indices et les valeurs des éléments d’une liste : fonction
enumerate() ............................................................................................................................... 47
1.4.3.15. Faire la copie d’une liste ............................................................................................... 48
1.4.3.16. Combiner les éléments de deux listes pour former une liste de couple d’éléments :
fonction zip() .............................................................................................................................. 51
1.5. Les fonctions map(), filter() et reduce() pour le traitement des
listes ......................................................................................... 53

1.5.1. La fonction map() ............................................................................. 53
1.5.2. La fonction filter() ............................................................................ 55
1.5.3. La fonction reduce() .......................................................................... 56
1.6. Etude des objets « tuples » ................................................... 57

1.6.1. Définition d’un tuple ........................................................................ 58
1.6.2. Indiçage des tuples (slicing)............................................................... 58
1.7. Etude des objets « set » ........................................................ 59

1.8. Etude des objets « array » ..................................................... 60

1.8.1. Définition d’un array ........................................................................ 61
1.8.1.1. Définition d’un array à 1 dimension ................................................................................ 61
1.8.1.2. Définition d’un array à plusieurs dimensions ................................................................. 62
1.8.1.3. Indiçage d’un array (slicing) ............................................................................................ 62
1.8.2. Déterminer la dimension d’array ....................................................... 63
1.8.3. Les opérations sur les arrays ............................................................. 63
1.8.3.1. Conversion d’un array vectoriel en array matriciel: fonction reshape() et resize()........... 63
4
1.8.3.2. Transposé d'un array matriciel: fonction transpose() ..................................................... 64
1.8.3.3. Création d'un array matriciel rempli de 0 ou 1: fonctions zeros() et ones() ..................... 64
1.8.3.4. Les opérations algébriques (matricielles) sur les arrays .................................................. 64
1.8.3.5. Utilisation de la fonction argsort() sur un array .............................................................. 65
1.9. Etude des objets « dictionnaire » ........................................... 65

1.9.1. Définition d’un dictionnaire .............................................................. 65
1.9.2. Accéder aux éléments d’un dictionnaire (slicing) ................................. 66
1.9.2.1. Slicing d’un dictionnaire dans le cas d’une clé à valeur unique ....................................... 66
1.9.2.2. Slicing d’un dictionnaire dans le cas d’une clé à plusieurs valeurs .................................. 67
1.9.3. Modification de dictionnaire : ajout et suppression de clés ou de valeurs
................................................................................................................ 67
1.9.3.1. Ajout ou modification de clés ou de valeurs ................................................................... 67
1.9.3.2. Suppression de clés ou de valeurs dans un dictionnaire ................................................. 68
1.9.4. Renommer une clé dans un dictionnaire ............................................. 68
1.9.5. Tester l’existence d’une clé dans un dictionnaire : la fonction in ........... 68
1.9.6. Récupérer les clés ou les valeurs d’un dictionnaire (les fonctions keys() et
values()) ................................................................................................... 69
1.10. Etude des fonctions ............................................................ 69

1.10.1. Aperçu général sur quelques fonctions prédéfinies sous python : la
fonction print() et la fonction input() ........................................................... 70
1.10.1.1. La fonction print() ......................................................................................................... 70
1.10.1.2. La fonction input() ........................................................................................................ 70
1.10.2. Les fonctions définies par l’utilisateur .............................................. 71
1.10.2.1. Définir une fonction ....................................................................................................... 71
1.10.2.2. Les fonctions lambda .................................................................................................... 77
1.10.3. Les variables locales et les variables globales .................................... 77
1.10.4. Récupérer la valeur renvoyée par une fonction : l’instruction return ... 79
1.10.5. Utilisation des générateurs de fonction : l’instruction yield ................ 80
1.10.6. Gestion des erreurs et des exceptions lors de la définition d’une
fonction ................................................................................................... 82
5
1.10.6.1. Utilisation des blocs ty-except ...................................................................................... 82
1.10.6.2. Utilisation des clause « else » et « finally » dans une exception .................................... 85
1.10.6.3. Les exceptions déclenchées par l’utilisateur : l’instruction raise ................................... 86
1.10.7. Documenter une fonction ............................................................... 87
1.11. Les modules python ........................................................... 87

1.11.1. Importation d’un module python ..................................................... 88
1.11.2. Utilisation d’un module python ....................................................... 89
1.11.2.1. Quelques utilisations de la fonction math ..................................................................... 89
1.11.2.2. Quelques exemples d’utilisation du module random .................................................... 89
1.11.3. Définir et utiliser son propre module ................................................ 91
1.11.4. Procédure d’installation et d’utilisation des modules externes ........... 91
1.11.5. Désinstaller un module ................................................................... 93
1.12. Aperçu général sur les objets « classe » ................................. 94

1.13. Utilisation du module pickle pour l'enregistrement et le
chargement des objets python .................................................... 95

1.13.1. Utilisation de la fonction Pickler ...................................................... 95
1.13.2. Utilisation de la fonction Unpickler .................................................. 96
Chapitre 2 : Etude des chaînes de caractères et des
expressions régulières ......................................... 97

2.1. Les chaînes de caractères ...................................................... 97

2.1.1. Définition d’une variable de type chaîne de caractères ........................ 97
2.1.2. Indiçage des chaînes de caractères (slicing) ........................................ 98
2.1.3. Déterminer la longueur d’une chaîne de caractères (nombre de
caractères) ................................................................................................ 99
2.1.4. Addition de chaînes de caractères (concaténation) ............................. 99
2.1.5. Modifier la casse d’une chaîne en majuscule, minuscule ou capital :
fonctions upper(), lower() et capitalize() .................................................... 100
2.1.6. Rechercher un caractère (ou un motif) dans une chaîne et renvoyer son
indice : fonction find() .............................................................................. 100
6
2.1.7. Rechercher un caractère (un motif) dans une chaîne et remplacer par un
autre : fonction replace() .......................................................................... 102
2.1.8. Compter le nombre d’occurrence d’un motif dans une chaîne : fonction
count() ................................................................................................... 102
2.1.9. Découper une chaîne de caractères en liste : fonction list() ou fonction
split() ..................................................................................................... 102
2.1.9.1. Cas où les espaces sont traités comme des valeurs (list()) ............................................ 102
2.1.9.2. Cas où les espaces sont traités comme des séparateurs (split()) ...................................103
2.1.10. Les opérations logiques et booléennes sur les chaines de caractères . 104
2.1.10.1. La fonction startwith() ................................................................................................ 104
2.1.10.2. la fonction endwith() .................................................................................................. 105
2.1.10.3. La fonction in ............................................................................................................. 105
2.1.10.4. La fonction islower() ................................................................................................... 105
2.1.10.5. La fonction isupper() .................................................................................................. 105
2.1.10.6. La fonction istitle() ..................................................................................................... 105
2.1.10.7. La fonction isalpha() ................................................................................................... 106
2.1.10.8. La fonction isalnum() ................................................................................................. 106
2.1.10.9. La fonction isdigit() .................................................................................................... 106
2.1.11. Formatage de valeurs à l’intérieur d’une chaine de caractères .......... 107
2.1.11.1. Formatage avec l’opérateur de concaténation "+" ...................................................... 108
2.1.11.2. Utilisation de l’opérateur de formatage "%" % .......................................................... 108
2.1.11.3. Utilisation de la fonction format() ............................................................................... 109
2.1.11.4. Formatage de valeurs indicées et création de variables indicées ................................. 110
2.1.12. Utilisation de l’opérateur antislash \ : mise en forme de la chaîne et
traitement des caractères spéciaux .......................................................... 111
2.2. Etudes des expressions régulières (regex ou re) .................... 112

2.2.1. Définition et rôle des expressions régulières ..................................... 112
2.2.2. Les opérateurs d’expression régulière .............................................. 113
2.2.3. Exemples d’application des opérateurs d’expressions régulières ........ 115
2.2.4. Construire une expression : la fonction compile() .............................. 117
2.2.4.1. Le rôle de la fonction compile() ..................................................................................... 117
7
2.2.4.2. Utilisation de la fonction compile() sans directives ....................................................... 117
2.2.4.3. Utilisation de la fonction compile() avec directives ....................................................... 118
2.2.5. Quelques fonctions associées aux expressions régulières .................. 118
2.2.5.1. La fonction search() ...................................................................................................... 118
2.2.5.2. La fonction match() ..................................................................................................... 120
2.2.5.3. La fonction findall() ....................................................................................................... 121
2.2.5.4. La fonction fonction sub() ............................................................................................. 123
2.2.5.5. La fonction findinter() ................................................................................................... 123
2.2.5.6. La fonction group() ...................................................................................................... 124
2.2.6. Etude de quelques expressions régulières couramment rencontrées .. 126
2.2.6.1. Cas 1 : Correspondance avec une expression exacte uniquement ................................ 126
2.2.6.2. Cas 2 :Correspondance avec un mot ou une expression figurant dans une liste ........... 126
2.2.6.3. Cas 3 :Correspondance avec un mot présentant des variantes orthographiques ou des
caractères spéciaux ................................................................................................................... 127
2.2.6.4. Cas 4 : Correspondance avec une adresse e-mail sur un domaine spécifique ................ 127
2.2.6.5. Cas 5 :Correspondance avec une adresse IP comprise dans une plage ......................... 128
2.2.6.6. Cas 6 : Correspondance avec un format alphanumérique ............................................ 129
2.2.7. Exercices de synthèse sur l’utilisation des regex ............................... 130
Chapitre 3 : Gestion de fichiers et traitements de texte
sous Python ....................................................... 133

3.1. Aperçu général sur quelques modules de gestion de fichiers sous
Python .................................................................................... 133

3.2. Utilisation du module o.s pour la gestion des fichiers et des
répertoires ............................................................................... 133

3.2.1. Définir un répertoire de travail......................................................... 133
3.2.2. Créer un nouveau dossier dans le répertoire défini ............................ 134
3.2.3. Renommer un dossier dans le répertoire .......................................... 134
3.2.4. Supprimer un dossier ...................................................................... 134
3.2.5. Tester si un fichier existe dans le répertoire ...................................... 134
3.2.6. Supprimer un fichier exitant dans le répertoire ................................. 135
8
3.2.7. Lister l'ensemble des fichiers présents dans un répertoire (avec ou sans
extensions) ............................................................................................. 136
3.2.8. Découper le chemin complet : la fonction os.path.split() ................... 136
3.2.9. Recomposer le chemin complet à partir d’un chemin et du nom du
fichier : la fonction os.path.joint() ............................................................. 136
3.2.10. Tester si un chemin existe ............................................................. 137
3.2.11. Tester si un chemin conduit à un fichier .......................................... 137
3.2.12. Tester si le chemin indiqué est un répertoire ................................... 137
3.2.13. Ouvrir un fichier ............................................................................ 137
3.3. Gestion de répertoires et de fichiers : utilisation du module shutil
............................................................................................... 139

3.3.1. Copie de dossier ou de fichiers : avec le module shutil ....................... 139
3.3.1.1. Utilisation de la fonction shutil.copyfile() ..................................................................... 139
3.3.1.2. Utilisation de la fonction shutil.copy ............................................................................ 139
3.3.1.3. Utilisation de la fonction shutil.copyfileobj................................................................... 139
3.3.1.4. Utilisation de la fonction shutil.copystat ...................................................................... 140
3.3.2. Création de fichier archive ZIP ou TAR avec shutil ............................. 140
3.4. Visualiser le contenu du fichier lu : les fonctions read(), read(n),
readline(), readlines(), et xreadlines() ......................................... 141

3.4.1. Utilisation de la fonction read() ....................................................... 141
3.4.2. Utilisation de la fonction readline() .................................................. 141
3.4.3. Utilisation de la fonction readlines() ................................................ 142
3.4.4. Utilisation de la fonction read(n) ..................................................... 142
3.4.5. Utilisation de la fonction xreadlines() ............................................... 142
3.4.6. Gestion des lignes en blank générées par les commandes readline() et
readlines() .............................................................................................. 142
3.5. Découper un texte en une liste de mots : la fonction splitlines()
ou la fonction append() ............................................................. 143

3.5.1. Utilisation de la fonction splitlines() ................................................. 143
9