Analyse Des Données Avec Python [PDF]

Zitiervorschau

ÉCOLE SUPÉRIEURE DE GESTION ET D’ADMINISTRATION DES ENTREPRISES Agrément définitif par Arrêté n°4677/MES/CAB du 05 Juillet 2017 Accréditée par le Conseil Africain et Malgache pour l’Enseignement Supérieur (CAMES) BP : 2339 – Brazzaville – CONGO E-mail : [email protected] Site web : www.esgae.org

Département Licence

ANALYSE DES DONNÉES AVEC PYTHON

Parcours Licence 3 – Administration Bases de Données

Enseignants Equipe pédagogique

SUPPORT DE COURS

Analyse de données avec python Ce document a été produit par : M. PREFILS NGUENGORO KEKARAT INGENIEUR INFORMATICIEN.

ANALYSE DE DONNES AVEC PYTHON

Année-Académique : 2021-2022

OBJECTIF GENERAL : Cet enseignement vise à fournir à l’étudiant l’ensemble des connaissances nécessaires pour analyser et visualiser les données avec python.

OBJECTIFS SPECIFIQUES : Au terme de cet enseignement l’étudiant doit être capable : • • • • • • • •

D’utiliser les bibliothèques scientifiques de python; D’analyser des données avec Numpy ; De lire un dataset avec Pandas/explorer un dataframe ; De manipuler des données avec Pandas ; D’apprendre à traiter les valeurs manquantes ; D’apprendre à tracer, personnaliser et interpréter des courbes à partir des données réelles ; De créer le diagramme en barres, les graphiques à nuages de points, les histogrammes et les boites à moustaches ; De traiter des projets concrets et réel de data science.

CONTENU CHAPITRE I :INTRODUCTION CHAPITRE II : RAPPEL PYTHON CHAPITRE III :

BIBLIOTHEQUE NUMPY

CHAPITRE IV : ANALYSE DE DONNEES AVEC NUMPY CHAPITRE V : BIBLIOTHEQUE PANDAS CHAPITRE VI : MANIPULATION DE DONNEES AVEC PANDAS CHAPITRE VII : SERIES AVEC PANDAS

M.Prefils NGUENGORO Ingénieur Informaticien

2

ANALYSE DE DONNES AVEC PYTHON CHAPITRE VIII : DATAFRAMES AVEC PANDAS CHAPITRE IX : GRAPHIQUE/LES COURBES CHAPITRE X : DIAGRAMMES EN BARRES ET GRAPHIQUES A NAUGE DEPOINTS CHAPITRE XI : HISTOGRAMMES ET BOITES A MOUSTACHES

M.Prefils NGUENGORO Ingénieur Informaticien

3

ANALYSE DE DONNES AVEC PYTHON

Table des matières CHAPITRE I : INTRODUCTION ............................................................................................. 6 1.

INSTALLATION PYTHON + JUPYTER NOTEBOOK .............................................. 6

2.

Présentation Jupyter Notebook........................................................................................ 7

CHAPITRE II : RAPPEL PYTHON.......................................................................................... 8 1.

Variables & Types de données ........................................................................................ 8

2.

Listes et dictionnaires ...................................................................................................... 8

3.

Conditions IF/ELSE ........................................................................................................ 9

4.

Boucles FOR ................................................................................................................. 10

5.

Fonctions Python ........................................................................................................... 11

CHAPITRE III : Bibliothèque Numpy ..................................................................................... 12 1.

Introduction à Numpy ................................................................................................... 12

Variables prédéfinies ............................................................................................................ 12 Variable pi : NumPy permet d’obtenir la valeur de pi ..................................................... 12 2.

Tableaux avec Numpy ................................................................................................... 12

3.

Taille d’un tableau ......................................................................................................... 12

4.

Lescture d’un dataset avec numpy ................................................................................ 13

5.

Types de données avec Numpy ..................................................................................... 13

6.

Extraction d’une valeur depuis un tableau Numpy ...................................................... 14  Slicing des tableaux 2D ............................................................................................. 14

7.

Extraction d’un vecteur de valeurs depuis un tableau Numpy ...................................... 15

CHAPITRE IV : Analyse de données avec Numpy ................................................................. 15 1.

Objectifs ........................................................................................................................ 15

2.

Comparaisons ................................................................................................................ 16

3.

Sélection des éléments .................................................................................................. 16

Fonctions trigonométriques .................................................................................................. 17 Fonctions hyperboliques ....................................................................................................... 17 Fonctions diverses ................................................................................................................ 18 Fonctions utiles pour les nombres complexes ...................................................................... 18 CHAPITRE V : Bibliothèque Pandas....................................................................................... 18 1.

Introduction ................................................................................................................... 18

2.

Présentation du dataset .................................................................................................. 18

CHAPITRE VI : Manipulation de données avec pandas ......................................................... 20 1.

Introduction ................................................................................................................... 20

2.

Transformation d’une colonne ...................................................................................... 20

3.

Opérations mathématiques entre colonnes .................................................................... 20 M.Prefils NGUENGORO Ingénieur Informaticien

4

ANALYSE DE DONNES AVEC PYTHON CHAPITRE VII : Séries avec Pandas ...................................................................................... 22 1.

Structures de données .................................................................................................... 22

2.

Indexage avec des entiers .............................................................................................. 22

3.

Réindexation d’un objet séries ...................................................................................... 22

4.

Trie d’un objet séries ..................................................................................................... 22

5.

Transformation d’une colonne ...................................................................................... 22

6.

Alignement des données ................................................................................................ 23

CHAPITRE VIII : DataFrames avec pandas ............................................................................ 23 1.

Index partagé par toutes les colonnes ............................................................................ 23

2.

Methode Apply() ........................................................................................................... 23

CHAPITRE IX : Graphique : les courbes ................................................................................ 24 1.

Introduction ................................................................................................................... 24

2.

Création d’une courbe ................................................................................................... 24

3.

Definition du domaine des axes .................................................................................... 25

4.

Ajout d’un titre .............................................................................................................. 25

5.

Ajout d’une legende ...................................................................................................... 25

6.

Labels sur les axes ......................................................................................................... 25

7.

Affichage de plusieurs courbes ..................................................................................... 26

CHAPITRE X : Diagramme en barres et graphiques à nuage de points .................................. 26 CHAPITRE XI : Histogrammes et boites à moustaches .......................................................... 28

M.Prefils NGUENGORO Ingénieur Informaticien

5

ANALYSE DE DONNES AVEC PYTHON

CHAPITRE I : INTRODUCTION 1. INSTALLATION PYTHON + JUPYTER NOTEBOOK  Anaconda est donc une distribution Python, faite pour la Data Science.  Il installera donc : Python et les librairies de Data Science dont nous aurons besoin : Matplotlib, Scipy, Numpy, Pandas , le notebook Jupyter, que je vous conseille vivement d'utiliser. Installation sous windows :  Téléchargez le fichier d'installation pour Windows ou MacOs, puis lancez-le en double-cliquant sur le fichier qui s'est téléchargé.  Répondez aux questions qui vous sont posées. Les options par défaut sont en général acceptables, pas besoin de les modifier. Une fois l'installation terminée, vérifiez que tout s'est bien passé en lançant le programme Jupyter. Installation sous Lunix  Téléchargez l’installeur pour Linux.  Entrez l’instruction suivante dans la commande :  bash ~/Downloads/Anaconda3-5.3.0-Linux-x86_64.h

 L’installeur affiche : “In order to continue the installation process, please review the license agreement.” Affichez les termes de la licence d’utilisation, scrollez tout en bas et cliquez sur yes pour accepter.  Répondez "yes" à la question qui suit :  Do you wish the installer to prepend the Anaconda3 install location to PATH in your /home/ec2-user/.bashrc ? [yes|no]

 La commande précédente a ajouté au fichier .bashrc le chemin (le dossier) dans lequel se trouve Anaconda. Ainsi, vous pourrez lancer Anaconda directement en tapant seulement "anaconda" dans votre console ! Cette opération prendra effet au redémarrage de votre ordinateur, ou dès l’exécution de cette commande :  source .bashrc

 Vérifiez que tout s’est bien passé en lançant le programme Jupyter Lancer Jyputer  Sous macOS, lancez Anaconda Navigator via le Launchpad.  Sous Linux, ouvrez une console et lancez : anaconda-navigator.  Sous Windows, lancez Anaconda Navigator depuis votre liste de programmes.

M.Prefils NGUENGORO Ingénieur Informaticien

6

ANALYSE DE DONNES AVEC PYTHON

2. Présentation Jupyter Notebook Jupyter Notebook est un outil puissant qui permet aux utilisateurs du langage Python de créer et de partager des documents interactifs contenant du code dynamique et exécutable, des visualisations de contenus, des textes de documentation et des équations. Le terme "notebook" est lié au caractère intrinsèque de l’outil qui permet d’écrire des petits bouts de code exécutable (appelés "cellules"), de les documenter pour expliquer ce qu’ils font et d’afficher les données résultant de leur exécution. Tout cela est stocké dans un document partageable avec d’autres utilisateurs. C’est donc particulièrement pratique pour prototyper des algorithmes ou tester des bouts de code, afin d’analyser les résultats et éventuellement de les ajouter à votre projet principal. Avec un notebook, pas besoin d’organiser son code en fonction, avec un main, etc. Vous avez juste besoin d’écrire votre code dans les blocs prédéfinis et de l’exécuter, pour "faire tourner du Python". Jupyter Notebook pour l’analyse de données Jupyter Notebook est une application très populaire pour l’ensemble des personnes travaillant dans l’analyse de données. Il permet à une équipe de pouvoir créer et partager des rapports sous forme de document/code, facilitant ainsi la productivité et la collaboration.

M.Prefils NGUENGORO Ingénieur Informaticien

7

ANALYSE DE DONNES AVEC PYTHON

CHAPITRE II : RAPPEL PYTHON 1. Variables & Types de données  Les variables numériques Les variables numériques peuvent être décomposées en deux types bien distincts :  Les entiers, qui correspondent à l’ensemble des nombres entiers positifs ou négatifs (1, 2, 0, 123, -3, etc.) ;  Les nombres décimaux, qui, en plus des entiers, incluent l’ensemble des nombres décimaux (2,50 ; 5,99 ; -1,20 ; 2/3 ; etc.).  Les chaises de caractère Vous allez à présent explorer un peu plus les chaînes de caractères, qui permettent de stocker du texte dans vos variables. Tout d’abord, un peu de sémantique : nous appelons cela des chaînes de caractères, car Python ne considère pas ces variables comme du texte en tant que tel, mais comme un ensemble de caractères mis bout à bout. Voilà comment vous pouvez définir des chaînes de caractères en Python : ville = "Brazzaville" film = 'intouchables' stringVide = ""

2. Listes et dictionnaires

M.Prefils NGUENGORO Ingénieur Informaticien

8

ANALYSE DE DONNES AVEC PYTHON  Une liste est une structure de données qui contient une série de valeurs. Python autorise la construction de liste contenant des valeurs de types différents (par exemple entier et chaîne de caractères), ce qui leur confère une grande flexibilité. Une liste est déclarée par une série de valeurs (n'oubliez pas les guillemets, simples ou doubles, s'il s'agit de chaînes de caractères) séparées par des virgules, et le tout encadré par des crochets. En voici quelques exemples : >>> animaux = ["girafe", "tigre", "singe", "souris"] >>> tailles = [5, 2.5, 1.75, 0.15] >>> mixte = ["girafe", 5, "souris", 0.15] >>> animaux ['girafe', 'tigre', 'singe', 'souris'] >>> tailles [5, 2.5, 1.75, 0.15] >>> mixte ['girafe', 5, 'souris', 0.15]

 Les dictionnaires se révèlent très pratiques lorsque vous devez manipuler des structures complexes à décrire et que les listes présentent leurs limites. Les dictionnaires sont des collections non ordonnées d'objets, c'est-à-dire qu'il n'y a pas de notion d'ordre (i.e. pas d'indice). On accède aux valeurs d'un dictionnaire par des clés. Ceci semble un peu confus ? Regardez l'exemple suivant : >>> ani1 = {} >>> ani1["nom"] = "girafe" >>> ani1["taille"] = 5.0 >>> ani1["poids"] = 1100 >>> ani1 {'nom': 'girafe', 'taille': 5.0, 'poids': 1100}

3. Conditions IF/ELSE Cette notion est l'une des plus importante en programmation. L'idée est de dire que si telle variable a telle valeur alors faire cela sinon cela. Prenons un exemple, on va donner une valeur à une variable et si cette valeur est supérieur à 5, alors on va incrémenter la valeur de 1 >>> a = 10 >>> if a > 5: ... a = a + 1 ... >>> a 11

 Condition if et else Il est possible de donner des instructions quelque soit les choix possibles avec le mot clé else.

>>> a = 20 >>> if a > 5: ... a = a + 1 ... else: ... a = a - 1

M.Prefils NGUENGORO Ingénieur Informaticien

9

ANALYSE DE DONNES AVEC PYTHON ... >>> a 21

 Condition elif Il est possible d'ajouter autant de conditions précises que l'on souhaite en ajoutant le mot clé elif , contraction de "else" et "if", qu'on pourrait traduire par "sinon".

>>> a = 5 >>> if a > 5: ... a = a ... elif a == ... a = a ... else: ... a = a ... >>> a 1005

+ 1 5: + 1000 - 1

4. Boucles FOR En programmation, on est souvent amené à répéter plusieurs fois une instruction. Incontournables à tout langage de programmation, les boucles vont nous aider à réaliser cette tâche de manière compacte et efficace. Imaginez par exemple que vous souhaitiez afficher les éléments d'une liste les uns après les autres. Dans l'état actuel de vos connaissances, il faudrait taper quelque chose du style : animaux = ["girafe", "tigre", "singe", "souris"] print(animaux[0]) print(animaux[1]) print(animaux[2]) print(animaux[3])

Si votre liste ne contient que 4 éléments, ceci est encore faisable mais imaginez qu'elle en contienne 100 voire 1000 ! Pour remédier à cela, il faut utiliser les boucles. Regardez l'exemple suivant :

>>> animaux = ["girafe", "tigre", "singe", "souris"] >>> for animal in animaux: ... print(animal) ... girafe tigre singe souris

Commentons en détails ce qu'il s'est passé dans cet exemple : La variable animal est appelée variable d'itération, elle prend successivement les différentes valeurs de la liste animaux à chaque itération de la boucle. On verra un peu plus loin dans ce chapitre que l'on peut choisir le nom que l'on veut pour cette variable. Celle-ci est créée par Python la première fois que la ligne contenant le for est exécutée (si elle existait déjà son

M.Prefils NGUENGORO Ingénieur Informaticien

10

ANALYSE DE DONNES AVEC PYTHON contenu serait écrasé). Une fois la boucle terminée, cette variable d'itération animal ne sera pas détruite et contiendra ainsi la dernière valeur de la liste animaux (ici la chaîne de caractères souris). Notez bien les types des variables utilisées ici : animaux est une liste sur laquelle on itère, et animal est une chaîne de caractères car chaque élément de la liste est une chaîne de caractères. Nous verrons plus loin que la variable d'itération peut être de n'importe quel type selon la liste parcourue. En Python, une boucle itère toujours sur un objet dit séquentiel (c'est-à-dire un objet constitué d'autres objets) tel qu'une liste. Nous verrons aussi plus tard d'autres objets séquentiels sur lesquels on peut itérer dans une boucle. D'ores et déjà, prêtez attention au caractère deux-points « : » à la fin de la ligne débutant par for. Cela signifie que la boucle for attend un bloc d'instructions, en l’occurrence toutes les instructions que Python répétera à chaque itération de la boucle. On appelle ce bloc d'instructions le corps de la boucle. Comment indique-t-on à Python où ce bloc commence et se termine ? Cela est signalé uniquement par l'indentation, c'est-à-dire le décalage vers la droite de la (ou des) ligne(s) du bloc d'instructions.

5. Fonctions Python Lors de vos analyses de données, vous allez régulièrement être amené à utiliser plusieurs fois des groupes d’instructions dans un but très précis. Un des principes fondamentaux pour tout programmeur informatique est d’avoir un maximum de résultats pour un minimum d’efforts : un dicton dit même qu’un bon programmeur est un programmeur fainéant. C’est grâce à ce principe un peu "paresseux", mais sacrément efficace qu’est venue l’idée des fonctions. Les fonctions permettent de regrouper plusieurs instructions dans un bloc qui sera appelé grâce à un nom. Les fonctions ne sont pas spécifiques à Python, elles sont présentes dans tous les langages informatiques. Elles permettent en particulier :  De réutiliser une portion de code déjà écrite via le nom de la fonction – il n’est donc pas nécessaire de réécrire toute la portion de code à chaque fois ;  D’alléger un code et de le rendre plus lisible ! Il existe de nombreuses fonctions préexistantes en Python ! En plus de celles déjà vues, il y a par exemple :  len() : une fonction qui renvoie la longueur d’un élément. Vous vous souvenez des chaînes de caractères ? Utiliser cette fonction sur une chaîne de caractères permet par exemple de savoir combien de caractères cette dernière contient ;  type() : permet d’afficher le type d’une variable ;  pow(a, b) : permet de calculer a puissance b. Elle est équivalente à l’écriture a**b;  abs() : retourne la valeur absolue d’un nombre. Voici quelques exemples pour illustrer l’utilisation de ces fonctions :

M.Prefils NGUENGORO Ingénieur Informaticien

11

ANALYSE DE DONNES AVEC PYTHON

CHAPITRE III : Bibliothèque Numpy 1. Introduction à Numpy La bibliothèque NumPy (http://www.numpy.org/) permet d’effectuer des calculs numériques avec Python. Elle introduit une gestion facilitée des tableaux de nombres. Pour utiliser NumPy, vous devez au préalable vous placer dans un environnement qui comprend cette bibliothèque, voir Introduction à Python. Il faut au départ importer le package numpy avec l’instruction suivante : import numpy as np

Variables prédéfinies Variable pi : NumPy permet d’obtenir la valeur de pi np.pi 3.141592653589793

2. Tableaux avec Numpy Les tableaux (en anglais, array) peuvent être créés avec numpy.array(). On utilise des crochets pour délimiter les listes d’éléments dans les tableaux a = np.array([1, 2, 3, 4])

Affichage :

a array([1, 2, 3, 4]) type(a) numpy.ndarray

3. Taille d’un tableau La fonction numpy.shape() (forme, en anglais) renvoie la taille du tableau.

a = np.array([2,5,6,8]) np.shape(a)

M.Prefils NGUENGORO Ingénieur Informaticien

12

ANALYSE DE DONNES AVEC PYTHON (4,) b = np.array([[1, 2, 3], [4, 5, 6]]) np.shape(b) (2, 3)

4. Lescture d’un dataset avec numpy  Lecture dans un fichier texte

>>> b = np.loadtxt('data_a.txt')

 Lecture dans un fichier binaire.

>>> c = np.load('data_a.npy')

5. Types de données avec Numpy

Le type de données - dtype dans NumPy est différent des types de données primitives dans Python, par exemple, dtype a le type avec une résolution plus élevée qui est utile dans le calcul des données.

M.Prefils NGUENGORO Ingénieur Informaticien

13

ANALYSE DE DONNES AVEC PYTHON

6. Extraction d’une valeur depuis un tableau Numpy Lors de la manipulation des tableaux, on a souvent besoin de récupérer une partie d’un tableau. Pour cela, Python permet d’extraire des tranches d’un tableau grâce une technique appelée slicing (tranchage, en français). Elle consiste à indiquer entre crochets des indices pour définir le début et la fin de la tranche et à les séparer par deux-points : a = np.array([12, 25, 34, 56, 87]) a[1:3] array([25, 34])

Dans la tranche [n:m], l’élément d’indice n est inclus, mais pas celui d’indice m. Un moyen pour mémoriser ce mécanisme consiste à considérer que les limites de la tranche sont définies par les numéros des positions situées entre les éléments, comme dans le schéma ci-dessous :

Il est aussi possible de ne pas mettre de début ou de fin. a[1:] array([25, 34, 56, 87]) a[:3] array([12, 25, 34]) a[:] array([12, 25, 34, 56, 87])

 Slicing des tableaux 2D a = np.array([[1, 2, 3], [4, 5, 6]]) a[0,1] 2 a[:,1:3] array([[2, 3], [5, 6]]) a[:,1]

M.Prefils NGUENGORO Ingénieur Informaticien

14

ANALYSE DE DONNES AVEC PYTHON array([2, 5]) a[0,:] array([1, 2, 3])

7. Extraction d’un vecteur de valeurs depuis un tableau Numpy

8. Extraction d’un tableau de valeurs depuis un tableau Numpy Un point important à prendre en compte lorsque nous manipulons les tableaux, et de façon générale lorsque nous manipulons des objets, est que lorsque nous affectons un tableau T1 à un autre tableau T2, le résultat de cette affectation n’est pas la copie des valeurs stockées dans T1 dans le tableau T2, mais seulement la copie de l’adresse où est stocké T1 dans la variable T2 ! En d’autres termes, après l’affectation de T1 à T2, les deux tableaux pointent vers les mêmes adresses mémoire et la modification de l’un des deux tableaux affecte l’état de l’autre tableau. L’exemple de programme suivant montre ce qui se passe réellement lors de l’affectation d’un tableau dans un autre. import numpy as np

vecteur_1 = np.array([1,2,3]) vecteur_2 = vecteur_1 vecteur_2[2] = 99 print("vecteur_1 =", vecteur_1) print("vecteur_2 =", vecteur_2)

CHAPITRE IV : Analyse de données avec Numpy 1. Objectifs l’analyse des données nécessitent d’organiser ces dernières dans un format plus au moins commun et qui correspond au format table. Également, avec la croissance incessante des sources de données, la taille des fichiers où ces données sont stockées devient de plus en plus M.Prefils NGUENGORO Ingénieur Informaticien

15

ANALYSE DE DONNES AVEC PYTHON conséquente. Avec la bibliothèque Pandas, le Data Scientist peut s’affranchir de toutes ces questions relatives au format et à la taille des données pour ne se concentrer que sur le problème à résoudre.

2. Comparaisons

L’opérateur de comparaison d’égalité == permet de vérifier si deux quantités sont égales ou non. L’opérateur == renvoie True si les quantités sont égales et false si les quantités ne sont pas égales. Nous pouvons utiliser l’opérateur == avec la fonction all() pour vérifier si tous les éléments des deux tableaux sont égaux ou non. L’exemple de code suivant nous montre comment nous pouvons comparer deux tableaux pour l’égalité avec l’opérateur == en Python.

3. Sélection des éléments numpy.select(condlist, choicelist, default=0) Renvoie un tableau tiré des éléments de la liste de sélection, en fonction des conditions. La liste des conditions qui déterminent à partir de quel tableau de la liste de sélection les éléments de sortie sont extraits. Lorsque plusieurs conditions sont satisfaites, la première rencontrée dans condlist est utilisée. Choicelist : La liste des tableaux à partir desquels les éléments de sortie sont extraits. Il doit être de la même longueur que condlist. Default : L'élément inséré dans la sortie lorsque toutes les conditions sont évaluées à False. Condlist :

4. Comparaisons avec plusieurs conditions La fonction numpy.where() est utilisée pour sélectionner certains éléments d’un tableau après avoir appliqué une condition spécifiée. Supposons que nous ayons un scénario dans lequel nous devons spécifier plusieurs conditions dans une seule fonction numpy.where(). Nous pouvons utiliser l’opérateur & à cette fin. Nous pouvons spécifier plusieurs conditions à l’intérieur de la fonction numpy.where() en enfermant chaque condition dans une paire de parenthèses et en utilisant un opérateur & entre elles.

5. Remplacement des valeurs dans un tableau numpy Si nous devons remplacer toutes les valeurs supérieures à un certain seuil dans un tableau Numpy, nous pouvons utiliser la fonction numpy.clip(). Nous pouvons spécifier les limites supérieure et inférieure d’un tableau en utilisant la fonction numpy.clip(). La fonction numpy.clip() renvoie un tableau où les éléments inférieurs à la limite spécifiée sont remplacés par la limite la plus basse. Les éléments supérieurs à la limite spécifiée sont remplacés par la plus grande limite. L’exemple de code suivant nous montre comment remplacer des valeurs à l’intérieur d’un tableau NumPy par la fonction numpy.clip(). import numpy as np

array = np.array([1,2,3,4,5,5,6,7,8,8,9,9]) result = np.clip(array, 0, 5)

M.Prefils NGUENGORO Ingénieur Informaticien

16

ANALYSE DE DONNES AVEC PYTHON print(result)

6. Remplacement des chaines de caractères vides Nous pouvons utiliser la méthode replace() du type de données str pour remplacer des sous-chaînes dans une sortie différente. replace() accepte deux paramètres, le premier paramètre est le modèle de regex avec lequel vous voulez faire correspondre les chaînes de caractères, et le second paramètre est la chaîne de remplacement pour les chaînes de caractères correspondantes. Il y a également un troisième paramètre optionnel dans replace() qui accepte un entier pour fixer le count maximum de remplacements à exécuter. Si vous mettez 2 comme paramètre count, la fonction replace() ne fera correspondre et ne remplacera que 2 instances dans la chaîne.

7. Conversion des types de données Après la création de l’instance de données, vous pouvez changer le type de l’élément en un autre type avec la méthode astype(), comme par exemple de entier à flottant et ainsi de suite. >>> import numpy as np >>> test = np.array([11, 12, 13, 14], dtype="int32") >>> x = test.astype('float32') >>> x array([11., 12., 13., 14.], dtype=float32) >>> test, test.dtype (array([11, 12, 13, 14]), dtype('int32'))

8. Calculs mathématiques avec Numpy Fonctions trigonométriques numpy.sin(x) sinus numpy.cos(x) cosinus numpy.tan(x) tangente numpy.arcsin(x) arcsinus numpy.arccos(x) arccosinus numpy.arctan(x) arctangente Fonctions hyperboliques numpy.sinh(x) sinus hyperbolique numpy.cosh(x) cosinus hyperbolique numpy.tanh(x) tangente hyperbolique numpy.arcsinh(x) arcsinus hyperbolique numpy.arccosh(x) arccosinus hyperbolique numpy.arctanh(x) arctangente hyperbolique

M.Prefils NGUENGORO Ingénieur Informaticien

17

ANALYSE DE DONNES AVEC PYTHON Fonctions diverses x**n x à la puissance n, exemple : x**2 numpy.sqrt(x) racine carrée numpy.exp(x) exponentielle numpy.log(x) logarithme népérien numpy.abs(x) valeur absolue numpy.sign(x) signe

Fonctions utiles pour les nombres complexes numpy.real(x) partie réelle numpy.imag(x) partie imaginaire numpy.abs(x) module numpy.angle(x) argument en radians numpy.conj(x) complexe conjugué

CHAPITRE V : Bibliothèque Pandas 1. Introduction Pandas est une bibliothèque open-source permettant la manipulation et l’analyse de données de manière simple et intuitive en Python. Elle a été développée par Wes McKinney en 2008 alors qu’il travaillait chez AQR Capital Management. À la fin de l’année 2009, elle a été mise en open source et est aujourd’hui activement utilisée dans le domaine de la Big data et de la data science car celle-ci offre des performances et une productivité élevée à ces utilisateurs.

2. Présentation du dataset Un Dataset est une structure de données bidimensionnelle, c'est-à-dire que les données sont alignées de façon tabulaire en lignes et en colonnes.

3. Lecture d’un fichier CSV avec pandas Pour lire le fichier il existe la fonction pandas read_csv(): >>> import pandas as pd >>> data = pd.read_csv('fichier.csv')

4. Exploration du DataFrame Le Dataframe est une structure de données qui organise les données en lignes et en colonnes, ce qui en fait une structure de données bidimensionnelle. Vous pouvez l’imaginer comme une

M.Prefils NGUENGORO Ingénieur Informaticien

18

ANALYSE DE DONNES AVEC PYTHON feuille de calcul ou une table SQL, ou encore un dictionnaire d’objets Series. C’est généralement l’objet pandas le plus utilisé. Comme une série, un Dataframe peut être construit à partir de nombreux types différents :  Un dict de ndarrays 1D, listes, dicts, ou Series ;  Un numpy.ndarray bidimensionnelle ;  Un ndarray strucuré ;  Une série ;  Ou encore un autre Dataframe.

5. Selection d’une ligne L' .loc indexeur renverra une seule ligne sous forme de série lorsqu'il reçoit une seule étiquette de ligne. >>> df.loc['Ligne1'] state TX color green food Lamb age 2 height 70 score 8.3 Name: Niko, dtype: object

6. Types de données pandas Les types ne sont pas natifs des pandas. Ils sont le résultat d'un couplage architectural étroit entre pandas et numpy. le type d'une colonne ne doit en aucun cas être lié au type python de l'objet contenu dans la colonne. Nous avons ici un pd.Series avec des flottants. Le type sera float . Ensuite, nous utilisons astype pour le "lancer" pour objecter. 7. Sélection de plusieurs lignes Pour sélectionner plusieurs lignes, placez toutes les étiquettes de ligne que vous souhaitez sélectionner dans une liste et transmettez-la à .loc. Sélectionnons Ligne1 et Ligne2.

8. Sélection d’une colonne

Pour sélectionner une seule colonne de données, mettez simplement le nom de la colonne entre les crochets. Choisissons la colonne alimentaire : >>> df[col1] Jane Steak Niko Lamb Aaron Mango Penelope Apple Dean Cheese Christina Melon Cornelia Beans Name: col1, dtype: object

9. Sélection de plusieurs colonnes

M.Prefils NGUENGORO Ingénieur Informaticien

19

ANALYSE DE DONNES AVEC PYTHON Il est possible de sélectionner plusieurs colonnes avec juste l'opérateur d'indexation en lui passant une liste de noms de colonnes. Sélectionnons Col1, Col2 et Col3: >>> df[['Col1', 'Col2', 'Col3']]

CHAPITRE VI : Manipulation de données avec pandas 1. Introduction Pandas est la librairie incontournable pour manipuler les données. Elle permet de manipuler aussi bien les données sous forme de tables qu’elle peut récupérer ou exporter en différents formats. Elle permet également de créer facilement des graphes.

2. Transformation d’une colonne La meilleure façon de convertir une ou plusieurs colonnes d'un DataFrame en valeurs numériques est d'utiliser pandas. to_numeric() . Cette fonction essaiera de changer des objets non numériques (tels que des chaînes) en nombres entiers ou en virgule flottante, selon le cas.

3. Opérations mathématiques entre colonnes  Lors des opérations sur les dataframes, les noms des lignes et des colonnes sont automatiquement alignés : df1 = pandas.DataFrame({'A': [1, 2], 'B': [3, 4]}, index = ['a', 'c']) df2 = pandas.DataFrame({'A': [1, 2], 'C': [7, 5]}, index = ['b', 'c']) df1 + df2 donne : A B C a NaN NaN NaN b NaN NaN NaN c 4.0 NaN NaN

 Opérations possibles : df1 + df2 2 * df + 3 1 / df : opération élément par élément. df ** 2 : carré de chaque élément. pour des dataframes booléens comme pandas.DataFrame({'A': [1, 0, 0], 'B': [0, 1, 1]}, dtype = bool) : -df : not. df1 & df2 : et. df1 | df2 : ou. df1 ^ df2 : ou exclusif.

M.Prefils NGUENGORO Ingénieur Informaticien

20

ANALYSE DE DONNES AVEC PYTHON opérations de comparaison : df1.eq(df2), df1.ne(df2), df1.lt(df2), df1.le(df2), df1.lt(df2), df1.le(df2) : égalité, non égalité, =. Ils renvoient des dataframes booléens. on peut aussi faire df1 == df2, mais attention, cela renvoie aussi un dataframe de booléens. réductions booléennes : : renvoie une série avec un élément par colonne qui est True si toutes les valeurs sont > 0

(df > 0).all()

(df > 0).any()

: renvoie une série avec un élément par col

Tout système d'exploitation qui supporte des interfaces graphiques doit constamment surveiller l'environnement afin de détecter des événements tels que la pression sur une touche du clavier ou sur un bouton de la souris. Le système d'exploitation en informe alors les programmes en cours d'exécution. Chaque programme détermine ensuite s'il doit répondre à ces événements.

4. Trie d’un DataFrame  Tri selon les étiquettes de lignes ou de colonnes : : renvoie un dataframe avec les lignes triées par ordre décroissant des labels (le défaut est ascendant) : df.sort_index(axis = 0, ascending = False)

a3 a2 a1

A 5.3 2.7 1.1

B 9 10 2

C 1.5 5.4 3.3

D 15 7 4

df.sort_index(axis = 1, ascending = False)

triées par ordre décroissant des labels :

a1 a2 a3

D 4 7 15

C 3.3 5.4 1.5

B 2 10 9

: renvoie un dataframe avec les colonnes

A 1.1 2.7 5.3

 Tri selon les valeurs :

: renvoie un dataframe avec les lignes triées de telle sorte que la colonne 'C' soit dans l'ordre croissant :

df.sort_values(by = 'C')

a3 a1 a2

A 5.3 1.1 2.7

B 9 2 10

C 1.5 3.3 5.4

D 15 4 7

M.Prefils NGUENGORO Ingénieur Informaticien

21

ANALYSE DE DONNES AVEC PYTHON

CHAPITRE VII : Séries avec Pandas 1. Structures de données Les DataFrames Un dataFrame est une structure de données très importante dans pandas. Un dataFrame est un tableau à deux dimensions. On peut même dire que c'est une collection de « Series pandas ».

2. Indexage avec des entiers L'indexation des Pandas DataFrame peut être effectués par leur position d’index. class pandas.Index(data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs) pd.Index([1, 2, 3]) Int64Index([1, 2, 3], dtype='int64')

3. Réindexation d’un objet séries : renvoie un dataframe réindexé de 0 à n - 1, mais conserve une colonne index avec les anciennes valeurs de l'index !

df.reset_index()

df.reset_index(drop = True)

: renvoie un dataframe réindexé de 0 à n - 1

df.reset_index(drop = True, inplace = True)

: modifie le dataframe directement.

Pour un dataframe qui a une colonne 'A' : df.set_index('A') renvoie un dataframe où l'index est la colonne A et la colonne A a disparu du dataframe lui-même

4. Trie d’un objet séries Pour trier une série de pandas, la méthode Series.sort_values () est utilisée. Syntaxe: Series.sort_values (axis = 0, ascending = True, inplace = False, kind = ‘quicksort’, na_position = ‘last’) Trié

5. Transformation d’une colonne La meilleure façon de convertir une ou plusieurs colonnes d'un DataFrame en valeurs numériques est d'utiliser pandas. to_numeric() . Cette fonction essaiera de changer des objets non numériques (tels que des chaînes) en nombres entiers ou en virgule flottante, selon le cas.

M.Prefils NGUENGORO Ingénieur Informaticien

22

ANALYSE DE DONNES AVEC PYTHON

6. Alignement des données La bibliothèque Pandas est utile pour effectuer une analyse exploratoire des données en Python. Un dataframe pandas représente les données dans un format tabulaire. Nous pouvons effectuer des opérations sur les données et les afficher. Dans cet article, nous allons aligner les colonnes sur la gauche dans Pandas. Lorsque nous affichons le dataframe, nous pouvons aligner les données dans les colonnes sur la gauche, la droite ou le centre. import pandas as pd

data = {'Name' : ['Tania', 'Ravi', 'Surbhi', 'Ganesh'], 'Articles' : [50, 30, 45, 33], 'Location' : ['Kanpur', 'Kolkata', 'Kolkata', 'Bombay']} df = pd.DataFrame(data) display(df)

CHAPITRE VIII : DataFrames avec pandas 1. Index partagé par toutes les colonnes data.loc[(data["col1"]=="Femme") & (data["col2"]=="Not Graduate") & (data["col3 "]=="Y"), ["Gender","Education","Loan_Status"]]

2. Methode Apply() C’est l’une des principales fonctions pour jouer avec les données et créer de nouvelles variables. apply retourne une valeur après avoir passé chaque ligne / colonne d’un DataFRame avec une fonction. La fonction peut être une fonction par défaut ou alors définie par l’utilisateur. Par exemple, ici, apply peut être utilisé pour trouver les valeurs manquantes de chaque ligne et colonne : # Créer une nouvelle fonction qui détermine si la valeur en paramètre est manquante: def num_missing(x): return sum(x.isnull()) # On applique cette fonction pour chaque colonne: print("Valeurs manquantes par colonne:")

M.Prefils NGUENGORO Ingénieur Informaticien

23

ANALYSE DE DONNES AVEC PYTHON print(data.apply(num_missing, axis=0)) #axis=0 définit que la fonction sera bien appliquée sur chaque colonne # Puis application pour chaque ligne: print("\nValeurs manquantes par ligne:") print(data.apply(num_missing, axis=1).head()) #axis=1 définit que la fonction sera bien appliquée sur chaque ligne

CHAPITRE IX : Graphique : les courbes 1. Introduction Pour tracer des courbes, Python n’est pas suffisant et nous avons besoin des bibliothèques NumPy et matplotlib utilisées dans ce cours. Si vous ne disposez pas de ces bibliothèques, vous pouvez consulter la page Introduction à Python pour installer l’environnement adapté à ce cours. Dans cette page, nous présentons deux syntaxes : la syntaxe « PyLab » qui est proche de celle de Matlab et la syntaxe « standard » qui est recommandée dans les nouvelles versions de matplotlib. Pour la syntaxe « PyLab », il suffit de faire : from pylab import *

Il est alors possible d’accéder directement aux fonctions de NumPy et matplotlib. Pour la syntaxe « standard », il faut importer le package numpy et le module pyplot de matplotlib. On doit alors préciser les bibliothèques lors des appels des fonctions. Pour en savoir plus sur la notion d’importation, vous pouvez consulter la page Modules et importations.

2. Création d’une courbe L’instruction plot() permet de tracer des courbes qui relient des points dont les abscisses et ordonnées sont fournies dans des tableaux. import numpy as np import matplotlib.pyplot as plt x = np.array([1, 3, 4, 6]) y = np.array([2, 3, 5, 1]) plt.plot(x, y)

M.Prefils NGUENGORO Ingénieur Informaticien

24

ANALYSE DE DONNES AVEC PYTHON plt.show()

3. Definition du domaine des axes Il est possible fixer indépendamment les domaines des abscisses et des ordonnées en utilisant les fonctions xlim() et ylim() xlim(xmin, xmax) ylim(ymin, ymax)

Exemple1 :

import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 2*np.pi, 30) y = np.cos(x) plt.plot(x, y) plt.xlim(-1, 5) plt.show()

4. Ajout d’un titre On peut ajouter un titre grâce à l’instruction title() import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 2*np.pi, 30) y = np.cos(x) plt.plot(x, y) plt.title("Fonction cosinus") plt.show()

5. Ajout d’une legende import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 2*np.pi, 30) y = np.cos(x) plt.plot(x, y, label="cos(x)") plt.legend() plt.show()

6. Labels sur les axes Des labels sur les axes peuvent être ajoutés avec les fonctions xlabel() et ylabel()

M.Prefils NGUENGORO Ingénieur Informaticien

25

ANALYSE DE DONNES AVEC PYTHON import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 2*np.pi, 30) y = np.cos(x) plt.plot(x, y) plt.xlabel("abscisses") plt.ylabel("ordonnees") plt.show()

7. Affichage de plusieurs courbes Pour afficher plusieurs courbes sur un même graphe, on peut procéder de la façon suivante : import numpy as np import matplotlib.pyplot as plt

x = np.linspace(0, 2*np.pi, 30) y1 = np.cos(x) y2 = np.sin(x) plt.plot(x, y1) plt.plot(x, y2) plt.show()

CHAPITRE X : Diagramme en barres et graphiques à nuage de points 1. Tracer un diagramme en barres import matplotlib.pyplot as plt names = ['A', 'B', 'C'] # nom des barres values = [1, 10, 100] plt.bar(names, values) ; plt.show() # Tracer

2. Ajouter des barres d’erreur names = ['Mammifères', 'Reptiles', 'Poissons'] values = [6, 20, 3] ic = [0.5,0.7,0.5] plt.bar(names, values, color = "#A0AAE4", edgecolor="red", linewidth=3, yerr=ic, ecolor = "green",capsize = 10) ; plt.show()

3. Diagramme en barre à barres cumulés import matplotlib.pyplt as plt M.Prefils NGUENGORO Ingénieur Informaticien

26

ANALYSE DE DONNES AVEC PYTHON largeur_barre = 0.8 y1 = [2,8,9,7] y2 = [5,9,4,2] x = range(len(y1)) # position en abscisse des barres # Tracé plt.bar(x, y1, width = largeur_barre, color = "#3ED8C9") plt.bar(x, y2, width = largeur_barre, bottom = y1, color = "#EDFF91") plt.xticks(range(len(y1)), ['A', 'B', 'C', 'D']) ; plt.show()

4. Diagramme en barre à barres regroupés largeur_barre = 0.3 # Largeur de chaque barre : # attention si valeur trop grande, il n'y aura pas de différence entre chaque paquet de barres y1 = [1, 2, 5] y2 = [1, 6, 4] x1 = range(len(y1)) # Position des barres de la catégorie 1 x2 = [i + largeur_barre for i in x1] # Position des barres de la cat 2 import matplotlib.pyplt as plt plt.bar(x1, y1, width = largeur_barre, color = 'orange', # Barres cat 1 edgecolor = 'black', linewidth = 2) plt.bar(x2, y2, width = largeur_barre, color = 'yellow', # Barres cat 2 edgecolor = ['black' for i in y1], linewidth = 2) plt.xticks([r + largeur_barre / 2 for r in range(len(y1))], # Etiquettes ['Qualité', 'Environnement', 'Social']) plt.show() ou : Sans_engrais = [13,15,10] Avec_engrais = [14,10,11] import pandas as pd mydata = pd.DataFrame({"Sans engrais":Sans_engrais,"Avec engrais":Avec_engrais}) mydata.index = ["A","B","C"] from pandas import plotting mydata.plot(kind="bar",rot=30) # Cette fonction fabrique automatiquement un diagramme à barres regroupées à partir d'une dataframe (rot : orientation des étiquettes) plt.show() M.Prefils NGUENGORO Ingénieur Informaticien

27

ANALYSE DE DONNES AVEC PYTHON

5. Graphiques à nuage de points :graphique régression linéaire import seaborn as sns import matplotlib.pyplot as plt df = sns.load_dataset('iris') sns.regplot(x=df["sepal_length"], y=df["sepal_width"], fit_reg=True, order=4) plt.show()

6. Couleur et frome des graphiques à nuage de points sns.lmplot( x="sepal_length", y="sepal_width", data=df, fit_reg=False, hue='species', legend=False) plt.legend(loc='lower right') plt.show()

CHAPITRE XI : Histogrammes et boites à moustaches 1. Histogrammes  Réaliser un histogramme avec python # Exemple de valeurs simulées avec numpy from numpy.random import normal as norm x = norm(50,20,57) # Tracé de l'histogramme import matplotlib.pyplot as plt plt.hist(x,color="red",edgecolor='black', linewidth=1.2,bins=20) plt.show()  Histogramme avec courbe de densité - density plot import seaborn as sns # Importer le module seaborn sns.distplot(x, hist=True, kde=True, bins=int(180/5), color = 'darkblue', # bins : épaisseur des bopites hist_kws={'edgecolor':'black'}, kde_kws={'linewidth': 4}) # kde_kws = épaisseur de la courbe plt.show()

2. Boites à moustaches

M.Prefils NGUENGORO Ingénieur Informaticien

28

ANALYSE DE DONNES AVEC PYTHON

 Dans cette partie boîte à moustaches (boxplot), nous prendrons l'exemple d'un jeu de données à simuler : sx = ["M"]*5 + ["F"] * 5 + ["M"] age = [50,60,62,30,40,51,18,74,68,57,35] taille = [163,167,165,170,171,177,180,190,176,178,173] # Voir comment simuler des valeurs import pandas as pd mydata = pd.DataFrame({"age":age,"sx":sx,'taille':taille})  Boites à moustache simple import matplotlib.pyplot as plt plt.boxplot(mydata.age) ; plt.title("Boxplot des âges") ; plt.gca().xaxis.set_ticklabels(['A']) ; plt.show() # Cette dernière ligne plt.gca() permet d'ajouter des étiquettes aux boîtes  Multiples boites à moustaches

import matplotlib.pyplot as plt plt.subplot(121) plt.boxplot(mydata.age) plt.title("boxplot des âges") plt.ylabel('Âges en années') plt.subplot(122) plt.boxplot(mydata.taille) plt.ylim(150, 200) plt.title("boxplot des tailles") plt.ylabel('Tailles en cm') plt.show()

BIBLIOGRAPHIE : M.Prefils NGUENGORO Ingénieur Informaticien

29

ANALYSE DE DONNES AVEC PYTHON

Fabio Nelli Python Data Analytics Data Analysis and Science Using Pandas, matplotlib, and the Python Programming Language , Apprenez à l’analyse de donnée avec python Par Nebra Site du zero, 2012

1.

Salesforce, D. (2016). L’ANALYSE DE VOS DONNEES.

2. M.Nebra. (2012). Apprenez à l’analyse de donnée avec python. Site du zero

M.Prefils NGUENGORO Ingénieur Informaticien

30