Département informatique et télécommunications

Ndeye Fatou NGOM

Python pour l’analyse de données

Création, importation et description de tables de données
(2023-2024)

Table des matières

1 Généralités 2
1.1 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Nom d’une variable . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Mots clés réservés . . . . . . . . . . . . . . . . . . . . . 2
1.2 Affectation de valeurs . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Assignation simple . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Déréférencement . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Entrée sortie . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Opérations de base . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.1 Opérations numériques . . . . . . . . . . . . . . . . . . 4
1.3.2 Operateurs logiques . . . . . . . . . . . . . . . . . . . 4
1.4 Types de données . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4.1 Les chaînes de caractères . . . . . . . . . . . . . . . . . 6
1.4.2 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.3 Les dictionnaires . . . . . . . . . . . . . . . . . . . . . 11

2 Premier pas avec Numpy 12

2.1 Vecteurs avec Numpy . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Matrices avec Numpy . . . . . . . . . . . . . . . . . . . . . . 18

3 Premier pas avec MatplotLib 23

4 Premier Pas avec Pandas 25

4.1 Séries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.2 DataFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.2.1 Dataframe à partir de données générées . . . . . . . . 26
4.2.2 Dataframe à partir de sources de données externes . . 27
4.2.3 Importation d’un fichier . . . . . . . . . . . . . . . . . 28
4.2.4 Importer un fichier texte . . . . . . . . . . . . . . . . . 28
4.2.5 Importer un fichier excel . . . . . . . . . . . . . . . . . 29
4.3 Description des variables . . . . . . . . . . . . . . . . . . . . . 31
4.3.1 Description des variables quantitatives . . . . . . . . . 31
4.3.2 Description des variables qualitatives . . . . . . . . . . 35
4.3.3 Analyse descriptive croisée . . . . . . . . . . . . . . . . 36

5 Premier pas avec le module seaborn 37

6 Gestion des bases de données 41

1 GÉNÉRALITÉS Tuto Python AD

1 Généralités
1.1 Les variables
1.1.1 Nom d’une variable
Les noms de variables (ou tout autre objet Python) débutent par une
lettre majuscule ou minuscule (A-Z ou a-z) ou _ (souligné) suivie de 0, 1 ou
plusieurs lettres, chiffres ou soulignés. Python est sensible
– aux majuscules et minuscules : VAR1 et var1 désignent deux va-
riables distinctes,
– à l’écrasement de nom : définir un objet nomObjet masque la fonc-
tion buil in abs(), fonction que l’on retrouve en déréférençant l’objet
avec del abs.
Warning : pylab ( numpy and matplotlib ) and symbolic math ( sympy )
are both enabled at the same time . Some pylab functions are
going to be overrided by the sympy module ( e . g . plot )
Depuis Python 3, il est possible d’utiliser tout caractère Unicode.
# -* - coding : utf -8 -* -
"""
Created on Mon Mar 19 01:44:17 2018

@author : ndefangom
"""

1.1.2 Mots clés réservés

– Réservés : ne peuvent être utilisés pour definir des identifiants de
variable, fonctions, modules ....
– Liste des mots clés
help ( " keywords " )
False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass

1.2 Affectation de valeurs

L’affectation consiste à attribuer une valeur à une variable. Sous Python,
elle peut être simple ou multiple.

EPT page 2 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

1.2.1 Assignation simple

– Assignation simple
– Typage automatique
a =5
# a est automatiquement typé en interne en entier
b =5.0
# b est automatiquement typé en float
– Typage explicite
a = float (5)
– Assigner la même valeur à plusieurs variables
a = b = c = 5 # = > a , b , c valent 5
a ,b , c = 5 ,6 ,7 # = > a =5 , b =6 , c =7
a,b = b, c # permutation
d = (20 , ’ Marie ’) # Tuple
a, b = d # = > a =20 , b = ’ Marie ’

1.2.2 Déréférencement
– Typage dynamique : python accède aux données en mode réfé-
rence.
a = 10 # -> création donnée 10 référencée par a
type ( a ) # -> int
id ( a ) # -> adresse mémoire
b = a # -> b pointe sur la même donnée
id ( b ) # -> pointe sur la même donnée
a = ’c ’ # -> création de ’a ’
type ( a ) # -> chaîne caractères
id ( a ) # -> pointe sur une autre donnée
– Déréférencer un objet
del objet # ou
del ( objet )
del objet . attr ou delattr ( objet , ’ attr ’) # attribut

1.2.3 Entrée sortie

L’interaction avec l’utilisateur se fait à l’aide des commandes qui suivent
– Saisie : input() qui retourne une chaîne qui pourra être converti si
besoin en float.
a = input ( " Saisir une valeur " )
# conversion de la chaîne a en float
a = float ( a )

EPT page 3 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

– Affichage : print ()
print ( arguments , sep = ’ ’ , end = ’\ n ’ , file = sys . stdout )
lees paramètres sep, end et file sont facultatifs.
– Remarques : on peut passer autant d’argument(s) que l’on veut
(contrairement à la fonction disp de MATLAB/Octave qui est limitée
à 1 argument.

1.3 Opérations de base

1.3.1 Opérations numériques
– opérateurs classiques : addition (+), soustraction (-), multiplication
(*), division (/) qui retourne toujours un float (Pyhton 3)
– division entière tronquée : //
– puissance : **
– modulo (reste de la division entière) :
– Remarque : les opérateurs de pré et post incrémentation/décrémen-
tation ++ et – n’existent plus sous Python mais on peut utiliser à la
place +=1 et -=1
- v = 1
- v += 1
- v -= 1
- v *= 100
- v /= 100
- v %= 2

Remarque 1 En python, l’opérateur ˆ ne calcule pas l’exposant, mais fait

une opération sur la représentation binaire des nombres entiers.

Les parenthèses permettent d’indiquer dans quelle ordre faire les opérations
dans un calcul. En général, les expressions non parenthésées utilisant les
opérations de base sont évaluées en tenant compte de l’ordre suivant
1. ** : Elevation à la puissance,
2. * / % // : multiplication, division, modulo et division entière,
3. + - : addition et soustraction.

1.3.2 Operateurs logiques

Les opérateurs logiques retournent les valeurs True ou False. On dis-
tingue les classes d’oparateurs suivantes
– opérateurs de comparaison : == (égal), != (différent), < (infé-
rieur), <= (inférieur ou égal), > (supérieur), >=(supérieur ou égal)
– comparaison d’objets : is (même objet), in (membre du container)

EPT page 4 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

– opérateurs logiques (ci-après selon leur ordre de priorité) : not (né-

gation logique), and (et logique), or (ou logique)
Python permet aussi de chainer les comparaisons
19 < age < 23
# est équivalente à
age >19 and age <23

1.4 Types de données

Python est un langage à typage
– dynamique : pas besoin de déclarer explicitement les variables utili-
sées, le type d’une variable peut changer au cours de son utilisation ;
– fort : l’interpréteur peut signaler des erreurs de type (1000 + "8000").
Le type d’un objet peut être connu à l’aide de la syntaxe Type(objet)
ou %whose.
Les Types simples (solaires, atomiques) permettent de stocker une seule
données contrairement aux types container.
– bool : booléen (état vrai ou faux)
– int : entier
– float : réel flottant
– complex : complexe flottant
La conversion de type de données se fait à l’aide de la syntaxe suivant
nouveau_type(objet).
# integer
a = 5
type ( a )
# float
c = 5.0
type ( c )
d = float (5); type ( d )
# complex
e = a + bj
e . real
e . imag
type ( e )
# booleen
t = ( a > 5)
type ( t )
% whos # liste des variables
Sous Python, trois groupes de types conteneurs sont à distinguer.
– Les séquences : chaînes, liste, tuple ;
– Les ensembles : set et frozenset,
– les map (hash) : dictionnaire.

EPT page 5 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

Pour l’affection, il est préférable d’utiliser la fonction copy plutôt qu’une

affectation directe.

Le script qui suit illustre quelques types complexes.

Listing 1 L =[1 ,2 ,5]

print ( " le type L est " , type ( L ))
t =(1 ,2 ,3)
print ( " le type t est " , type ( t ))
d = L ={ " E " :1 , " E2 " :2 , " E3 " :5}
print ( " le type d est " , type ( d ))
d2 ={ " E " :[1 ,6 ,9] , " E2 " :(2 ,8) , " E3 " :{5 ,5}}

le type L est <class ’list’>

le type t est <class ’tuple’>
le type d est <class ’dict’>

1.4.1 Les chaînes de caractères

– len(chaine) : nombre de carac-
Une chaîne de caractère est un tères,
objet délimité par des apos- – str(nombre) : conversion en
trophes ’ ou guillemets " de type chaîne
immutable (pas modifiable).
– ord(caractère) : code ASCII
Une sous chaine peut être ex-
traite avec du caractère
– chr(code-ASCII) : caractère
chaine [ debut : fin ] code-ASCII
# slicing
– min(chaîne), max(chaîne) :
– Premier caractère : indice 0 plus petit ou le plus grand ca-
ractère de chaîne
Le formatage permet de composer des chaînes de caractères incorporant
des données de types entier, flottant et chaîne. Sous C, Matlab ou octave :
fonction sprint
– Syntaxe
’ chaîne avec spécifications de conversion
%s %d %o %x %f %e’ %
( valeurs , variables ou expressions )
– Spécification de conversion
– %s pour une chaîne
– %d, %o ou %x pour un entier, respectivement en base décimale,
octale ou hexadécimale
– %f ou %e pour un flottant, respectivement en notation fixe ou no-
tation scientifique avec exposant
Le script qui suit réserve de l’espace mémoire pour stocker une variable
de type string(str) contenant la chaine de caractère ’Fatou va au marche’

EPT page 6 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

c = " Fatou va au marché "

print ( c )

Fatou va au marché

Séparons les caractères de la chaîne à l’aide de la fonction split()

L1 = c . split ()
L2 = c . split ( " \ t " )
print ( " L1 " , L1 , " \ n L2 " , L2 )

L1 [’Fatou’, ’va’, ’au’, ’marché’]

L2 [’Fatou va au marché’]

D’autres fonctions de Python que l’on peut appliquer aux chaînes de

caractères sont
– join() : permet de créer une nouvelle chaine à partir d’une liste desous-
chaine et d’un séparateur.
– find() : permet de vérifier si une sous-chaine donnée est présente ou
non dans la chaine principale. Elle renvoie l’indice de départ de la
première occurrence si la sous-chaine est trouvée ou bien -1 dans le cas
contraire.
– count() : permet de compter le nombre d’occurrences d’une sous-
chaine dans la chaine principale.
– lower() : permet de mettre une chaine de caractère en minuscule. Elle
ne modifie pas directement la chaine de caractère mais renvoie une
copie modifiée.
– upper() : permet de mettre une chaine de caractère en majuscule.
Elle ne modifie pas directement la chaine de caractère mais renvoie
une copie modifiée.
– title() : permet de mettre la première lettre de chaque mot en ma-
juscule et les autres en minuscule. Elle ne modifie pas directement la
chaine de caractère mais renvoie une copie modifiée.
– replace() : renvoie une copie la chaine de caractère C en remplaçant
une sous-chaine donnée par une autre.
– index() : fait la même chose que la méthode find() mais contraire-
ment à cette dernière, elle renvoie une value Error au lieu de -1 si la
sous-chaine recherchée n’est pas trouvée.

Le module WordCloud peut être utilisé pour générer des nuages de

mots.
import pandas as pd
import matplotlib . pyplot as plt
from wordcloud import WordCloud
# Charger le contenu du fichier dans un DataFrame

EPT page 7 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

Figure 1 – Exemple d’un nuage de mots généré à partir d’un fichier texte

fichier = " Afrique . txt "

df = pd . read_csv ( fichier , sep = " \ t " , header = None )

# Concaténer les colonnes en une seule chaîne de texte

text = df [ df . columns [0]]. str . cat ( sep = ’ ’)

# Créer le nuage de mots

wordcloud = WordCloud ( width =800 , height =400 , background_color = " white " ). genera

# Afficher le nuage de mots

plt . figure ( figsize =(10 , 5))
plt . imshow ( wordcloud , interpolation = " bilinear " )
plt . axis ( " off " )
plt . show ()

1.4.2 Les listes

Une liste est tableau dynamique en lecture écriture d’objets hétérogènes.
Parmi les mécanismes associés figurent : plages d’indices, indices négatifs,
liste de listes, concaténation et réplication.
Un point fort d’une liste est la capacité de pouvoir stocker une collection
ordonnée (séquence) et dynamiquement modifiable d’éléments hétérogènes.
# definition d ’ une liste
L =[1 ,2 ,3 ,4 ,5 ,6]
type ( L ) # -> list """
# Accès indicé
a = L [0]
print ( a )
# modification possible
L [0]=1
print ( L )

EPT page 8 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

# une liste
L =[1 , 6 , 9 , 90 , 7]
– un élément à la fois # inversion
– à la fin : .append(elem) L . reverse ()
– n’importe où : .in- # ajout d ’ un élément
sert(indice,elem) L . append (8)
print ( L ) # - >[1 , 6 , 9 , 90 , 7 , 8]
– plusieurs éléments d’un
# insertion à l ’ indice 2
coup : L . insert (2 ,90)
– à la fin :.extend([elem...]) ou print ( L ) # -> [1 , 6 , 90 , 9 , 90 , 7 , 8]
liste+=[elem...] # inserer plusieurs éléments
– au début : liste[ :0]=[elem...] # étendre
L . extend ([110 ,50])
print ( L ) # -> [8 , 7 , 9 , 90 , 1 , 110 , 50]

# suppression elt n4
del L [4]
– Supprimer des éléments print ( L ) # - >[1 , 6 , 90 , 9 , 7 , 8]
– fonction : del(liste[...]) ; # acces + suppression elt n1
– méthodes : .remove(elem) a = L . pop (1) # l ’ element supprime a disparu de la
et .pop(indice). print ( a ) # - >6
– Vider complètement la liste : print ( L ) # - >[1 , 90 , 9 , 7 , 8]
# Vider la liste avec clear
clear
L . clear ()
print ( L ) # -> []
Le type liste facilite la recherche d’élément, la recherche d’index, le comp-
tage, le retrait de valeurs. Ce mécanisme fonctionne avec tout type d’objet
(tuple, chaîneĚ) pourvu qu’une comparaison soit possible.
# la liste
L =[1 ,2 ,3 ,0 ,4 ,5 ,6 ,7 ,0]
# verifier si la liste contient 0
t = 0 in L
print ( t ) # -> True
# index des valeurs 0
id = L . index (0)
print ( id )
# compter le nombre de 0 dans la liste
n = L . count (0)
print ( n )
# retrait de 0 dans la liste
L . remove (0)
# retire le premier 0 que la méthode trouvera
print ( L )
L . remove (0)
print ( L )
Une chaîne peut être transformée en liste pour réaliser des traitements
sophistiqués. Toutes les opérations sur les listes sont possibles par la suite.

EPT page 9 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

C = str ( input ( " Entrer du text " ))

print ( C ) # -> aaaaaaaaa
type ( C ) # -> str
# conversion en liste
L = list ( C )
type ( L ) # -> liste
print ( L )
# decoupage par separateur
C2 = C . split ( " " ) # espace comme separateur
# -> [ ’ a ’, ’a ’, ’a ’, ’a ’,
’a ’ , ’a ’ , ’a ’ , ’a ’ , ’a ’ , ’a ’]
print ( C2 )
# former une chaîne
C3 = " -" . join ( C2 ) # fusion avec le separateur " -"
# -> [ ’ aaaaaaaaaaaaaaaa ’]
Considérons la liste des étudiants d’une classe

Listing 2 ListEt =[ " Andre " , " Mariama " , " Michel " ," Fatou " ," Ousseynou " ,
" Awa " ," Abdou " ," Demba " ," Astou " ," Magatte " ,
" Daouda " ," Alimatou " ," Ameth " ," Mouhamed " ,
" Babacar " , " Angel " ," Khadija " ," Ngone " ," Ousmane " ]
print ( ListEt )

[’Andre’, ’Mariama’, ’Michel’, ’Fatou’, ’Ousseynou’,

’Awa’, ’Abdou’, ’Demba’, ’Astou’, ’Magatte’, ’Daouda’,
’Alimatou’, ’Ameth’, ’Mouhamed’, ’Babacar’, ’Angel’,
’Khadija’, ’Ngone’, ’Ousmane’]

Ajoutons l’étudiant Marie à la fin de la liste des étudiants, enlevons

l’étudiant Fatou à la liste et affichons la nouvelle liste
ListEt . append ( " Marie " )
ListEt . remove ( " Fatou " )
Liste2 = ListEt . reverse ()
print ( ListEt )
print ( Liste2 )

#liste 1
[’Andre’, ’Mariama’, ’Michel’, ’Fatou’, ’Ousseynou’,
’Awa’, ’Abdou’, ’Demba’, ’Astou’, ’Magatte’, ’Daouda’,
’Alimatou’, ’Ameth’, ’Mouhamed’, ’Babacar’,
’Angel’, ’Khadija’, ’Ngone’, ’Ousmane’, ’Marie’]
#Liste 2: liste 1 inversée
[’Marie’, ’Ousmane’, ’Ngone’, ’Khadija’, ’Angel’,
’Babacar’, ’Mouhamed’, ’Ameth’, ’Alimatou’, ’Daouda’,
’Magatte’, ’Astou’, ’Demba’, ’Abdou’, ’Awa’,
’Ousseynou’, ’Michel’, ’Mariama’, ’Andre’]

EPT page 10 N.F. Ngom

1 GÉNÉRALITÉS Tuto Python AD

Affichons quelques sous listes

Listing 3 Liste = ListEt

Liste1 = Liste [1:6]
Liste2 = Liste [:4]
Liste3 = Liste [4:]
Liste4 = Liste [1:4]+ Liste [6:]

#Liste1
[’Ousmane’, ’Ngone’, ’Khadija’, ’Angel’, ’Babacar’]
#Liste2
[’Marie’, ’Ousmane’, ’Ngone’, ’Khadija’]
#Liste3
[’Angel’, ’Babacar’, ’Mouhamed’, ’Ameth’, ’Alimatou’,
’Daouda’, ’Magatte’, ’Astou’, ’Demba’, ’Abdou’, ’Awa’, ’
Ousseynou’, ’Michel’, ’Mariama’, ’Andre’]
#Liste4
[’Ousmane’, ’Ngone’, ’Khadija’, ’Mouhamed’, ’Ameth’,
’Alimatou’, ’Daouda’, ’Magatte’, ’Astou’, ’Demba’,
’Abdou’, ’Awa’, ’Ousseynou’, ’Michel’,
’Mariama’, ’Andre’]

Trouvons l’indice de l’étudiant Michel dans la liste

Liste . index ( " Michel " )

#liste
[’Marie’, ’Ousmane’, ’Ngone’, ’Khadija’, ’Angel’, ’Babacar’, ’Mouhamed’, ’Ameth’, ’Al
#indice de l’étudiant Michel
16

1.4.3 Les dictionnaires

Un dictionnaire est une collection nonŰordonnée (non indicée) d’ob-
jets s’appuyant sur le mécanisme associatif clé valeur. Ce type correspond
aux tableaux associatifs ou tableaux de hachage(hash) d’autres langages et
n’existe pas sous MATLAB/Octave.
# definition
d ={ ’ Etud1 ’ :15 , ’ Etud2 ’:4 , ’ Etud3 ’ :89}
# affichage des éléments
print ( d ) # -> { ’ Etud1 ’: 15 , ’ Etud2 ’: 4 , ’ Etud3 ’: 89}
# ou
print ( d . items ())
# > dict_items ([( ’ Etud1 ’, 15) , ( ’ Etud2 ’, 4) , ( ’ Etud3 ’, 89)])
# nombre d ’ éléments
print ( len ( d )) # -> 3

EPT page 11 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

# liste des clés

print ( d . keys ()) # -> dict_keys ([ ’ Etud1 ’, ’ Etud2 ’, ’ Etud3 ’])
# liste des valeurs
print ( d . values ())
# -> dict_values ([15 , 4 , 89])
Le script qui suit illustre l’accès aux éléments d’un dictionnaire. Accès
aux éléments d’un dictionnaire
# definition
d ={ ’ Etud1 ’ :15 , ’ Etud2 ’:4 , ’ Etud3 ’ :89}
print ( d ) # - >{ ’ Etud1 ’: 15 , ’ Etud2 ’: 4 , ’ Etud3 ’: 89}
# ajouter un élément
d [ " Pierre " ]=12; print ( d )
# -> { ’ Etud1 ’: 15 , ’ Etud2 ’: 4 , ’ Etud3 ’: 89 , ’ Pierre ’: 12}
# ajout d ’ un bloc d ’ éléments
d . update ({ ’ Marie ’ :18 , ’ Jean ’ :20})
# - >{ ’ Etud1 ’: 15 , ’ Etud2 ’: 4 , ’ Etud3 ’: 89 , ’ Pierre ’: 12 , ’ Marie ’: 18 , ’ Jean ’:
# verifier la presence d ’ une clé
t = ’ Fatou ’ in d
print ( t ) # -> False
# suppression par clé
del d [ ’ Jean ’]
print ( d )
# - >{ ’ Etud1 ’: 15 , ’ Etud2 ’: 4 , ’ Etud3 ’: 89 , ’ Pierre ’: 12 , ’ Marie ’: 18}
d . clear () # vide le dictionnaire

2 Premier pas avec Numpy

Numpy est un package de Python spécialisé dans la manipulation des
tableaux (array) : vecteurs et matrices. Numpy propose un grand nombre
de routines plus performants que les les modules standard de Poython pour
l’algèbre linéaire, le calcul statistique, la recherche et l’extraction de données.

Le listing qui suit décrit le module numpy et liste ses méthodes associées.
import numpy as np
help ( np )

Help on package numpy:

NAME
numpy

DESCRIPTION
NumPy
=====

EPT page 12 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

Provides
1. An array object of arbitrary homogeneous items
2. Fast mathematical operations over arrays
3. Linear Algebra, Fourier Transforms, Random Number Generation

How to use the documentation

----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
‘the NumPy homepage <[Link]

We recommend exploring the docstrings using

‘IPython <[Link] an advanced Python shell with
TAB-completion and introspection capabilities. See below for further
instructions.

The docstring examples assume that ‘numpy‘ has been imported as ‘‘np‘‘::

>>> import numpy as np

Code snippets are indicated by three greater-than signs

De la même manière une description détaillée d’une méthode de numpy

peut être obtenue avec la fonction d’aide help
help ( np . array )

Examples
--------
>>> [Link]([1, 2, 3])
array([1, 2, 3])

Upcasting:

>>> [Link]([1, 2, 3.0])

array([ 1., 2., 3.])

More than one dimension:

>>> [Link]([[1, 2], [3, 4]])

array([[1, 2],
[3, 4]])

EPT page 13 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

Minimum dimensions 2:

>>> [Link]([1, 2, 3], ndmin=2)

array([[1, 2, 3]])

Type provided:

>>> [Link]([1, 2, 3], dtype=complex)

array([ 1.+0.j, 2.+0.j, 3.+0.j])

2.1 Vecteurs avec Numpy

%sectionVecteur avec Numpy Importons le module numpy à l’aide de la
syntaxe suivante
import numpy as np
où np est l’alias utilisé pour accéder aux routines de la librairie numpy.
La création manuelle du vecteur à partir [] pour délimiter les valeurs et array
v = np . array ([ v1 , v2 ....])
Nous donnons quelques exemples de vecteurs crée à l’aide du module
Numpy dans le listing qui suit
# creating 1 D array
import numpy as np
# creation du vecteur
a = np . array ([0 , 1 , 2 , 3])
a
array ([0 , 1 , 2 , 3])
# dimension
a . ndim
# nombre de lignes et de colonnes
a . shape
len ( a )
# nombre totale de valeurs
a . size
# interactive help
np . array ?
np . lookfor ( ’ create array ’) # looking for something
np . con *?
Le typage de données avec Numpy peut être implicite ou explicite. Il est
aussi possible de créer un array d’objets complexes autres que les types de
base. Une illustration est donnée dans le listing qui suit.
# création et typage implicite
a = np . array ([1 ,2 ,4])
print ( a . dtype ) # int32
# création et typage explicite

EPT page 14 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

a = np . array ([1 ,2 ,4] , dtype = float )

print ( a . dtype ) # float64
print ( a )
# vecteur de booléens
e = np . array ([ True , False , False , True ])
# -> string
f = np . array ([ ’ Bonjour ’ , ’ Hello ’ , ’ Hallo ’ ,])
# Complex
d = np . array ([1+2 j , 3+4 j , 5+6*1 j ])
# vecteur d ’ objets Python
a = np . array ([{ " A " :(45 ,2000)} , " B " :(5 ,1000)} , " C " :(50 ,3000)}])
Le listing qui suit illustre la génération de séquences à l’aide des fonctions
arange, linspace et random.
# Generation sequence
a = np . arange (1000)
b = np . arange ( start =0 , stop =1000)
# suite arithmétique de raison step
a = np . arange ( start =0 , stop =10 , step =2)
# suite linéaire
a = np . linspace ( start =0 , stop =10 , nim =5)
# vecteur de valeurs identique
a = np . ones ( shape =5)
# répétition 5 fois
a = np . full ( shape =5 , fill_value =3.2)
# nombre aleatoire
# distribution uniforme
a = np . random . rand (4)
# distribution gaussienne
b = np . random . randn (4)
# fixer le germe
np . random . seed (1234)
Lorsque les données sont stockées dans un fichier texte, la fonction loadtxt
permet de les charger et la fonction savetxt peut être utilisée pour les sau-
vegarder.
# typage exlicite
a = np . loadtxt ( " vecteur . txt " , dtype = float )
# liste de valeurs
L =[1.5 ,6.5 ,4.8]
# conversion à partir d ’ une liste
print ( type ( a ))
Le redimensionnement d’un vecteur peut se faire par
– le rajout d’une valeur en dernière position,
– la suppression d’une valeur via son indice,
– la concaténation de deux vecteurs.
# vecteur de valeurs

EPT page 15 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

a = np . array ([1.0 ,1.1 ,3.2 ,4.5])

# ajouter une valeur placée en dernière position
a = np . append (a ,10)
# supression via indice
b = np . delete (a ,2)
# redimens ionnemen t
a . resize ( new_shape =5)
# concatenation de deux vecteurs
x = np . array ([1 ,2 ,3 ,4])
y = np . array ([5 ,7 ,8 ,9])
z = np . append (x , y )
Mis à part, les singletons, les vecteurs générés sont de type [Link].
Nous pouvons accéder aux éléments d’un vecteurs à l’aide des indices.
# vecteur
v = np . array ([4 ,7 ,9 ,3 ,6.8 ,9 ,7 ,9.0])
# toutes les valeurs
print ( v )
print ( v (:)) # debut à fin
# dernière valeur
print ( v [0]) # le premier indice est 0
# plage d ’ indices contigus
print ( v [1:3])
# extrêmes , début à 3
print ( v [:3])
# extrême 2 à fin
print ( v (2:))
# indice négatif
print ( v [ -1])
# indices négatifs
print ( v [ -3:])
La notation générique de l’accès indicé est : début :pas :fin.
# vecteur
v = np . array ([4 ,7 ,9 ,3 ,6.8 ,9 ,7 ,9.0])
# valeur 1 à 3 avec un pas 1
print ( v [1:4:1])
# le pas de 1 est implicite
print ( v [1:4])
# 0 à 2 avec un pas de 2
print ( v [0:3:2])
# 3 à 1 avec un pas de -1
print ( v [3:0: -1])
# inverser un vecteur
print ( v [:: -1])
Le script qui suit illustre l’accès aux éléments d’un vecteur par conditions.
# extraction avec vecteur de booléens
# si b est trop court , tout le reste est considéré false

EPT page 16 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

b = np . array ([ False , True , False , True , False ] , dtype = bool )

print ( v [ b ])
# condition pour l ’ extraction
print ( v [v <7])
# cond vecteur de booleen
b =v <7
print ( b )
print ( tpe ( b ))
# utiliser la fonction extrac ()
print ( np . extrac (v <7 , v ))
Pour trier les éléments d’un vecteur, la fonction sort peut être utilisée.
# recherche valeur max
print ( np . max ( v ))
# recherche indice de valeur max
print ( np . argmax ( v ))
# tri des valeurs
print ( np . sort ( v ))
# valeurs distinctes
a = np . array ([1 ,2 ,6 ,7 ,9 ,1])
print ( np . unique ( a ))
Numpy intègre des fonctions pour réaliser des statistiques simples. Pour
des statistiques plus évolués, la bibliothèque scipy est plus adaptée.
# vecteur
v = np . array ([4 ,7 ,9 ,3 ,6.8 ,9 ,7 ,9.0])
# moyenne
print ( np . mean ( v ))
# mediane
print ( np . median ( v ))
# variance
print ( np . var ( v ))
# somme
print ( np . sum ( v ))
# somme cumulée
print ( np . cumsum ( v ))
Les calculs se font éléments par éléments entre vecteurs.
# deux vecteurs
x = np . array ([1 ,1 ,1 ,1 ,0 ,0 ,0 ,9])
y = np . array ([1 ,7 ,9 ,1 ,0 ,4 ,0 ,9])
# multiplication
z=x*y
z2 =2* x
# addition
a=x+y
# soustraction
s =x - y
# comparaison

EPT page 17 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

b =x > y
print ( b )
# operations logiques
a = np . array ([ True , True , False , True ] , dtype = bool )
a = np . array ([ True , True , True , True ] , dtype = bool )
# ET logique
np . logical_and (a , b )
# OU exclusi logique
np . logical_xor (a , b )
Certaines fonctions matricielles s’appliquent aux vecteurs. Une multipli-
cation matricielle se fait avec vdot.
# deux vecteurs
x = np . array ([1 ,1 ,1 ,1 ,0 ,0 ,0 ,9])
y = np . array ([1 ,7 ,9 ,1 ,0 ,4 ,0 ,9])
# produit scalaire
z = np . vdot (x , y )
np . sum ( x * y )
# norme d ’ un vecteur
n = np . linalg . norm ( x )
import math
h = math . sqrt ( np . sum ( x **2))
Un vecteur de valeurs peut être considéré comme un ensemble de valeurs.
# operations ensemblistes
# deux vecteurs
x = np . array ([1 ,1 ,1 ,1 ,0 ,0 ,0 ,9])
y = np . array ([1 ,7 ,9 ,1 ,0 ,4 ,0 ,9])
# intersection
print ( np . intersect1d (x , y ))
# union mais pas concatenation
print ( np . union1d (x , y ))
# difference
print ( np . setdiff1d (x , y ))

2.2 Matrices avec Numpy

La création manuelle d’une matrice à partir d’un ensemble de valeurs se
fait de la manière suivant
a = np . array ([[ vecteur1 ] ,.. ,[ vecteurn ]])
Le script qui suit illustre la création manuelle de matrices avec des valeurs
de types différents.
# matrice
a = np . array ([[1 ,3] ,[4 ,5]])
# typage explicite
b = np . array ([[1 ,3] ,[4 ,5]] , dtype = float )
# type de la structure

EPT page 18 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

print ( type ( a )) # -> numpy . ndarray

# type des données
print ( a . dtype ) # float64
# nombre de dimensions
print ( a . ndim )
# nombre de lignes , col
print ( a . shape )
# nombre totale de valeurs
print ( a . size )
Parmi les fonctions de Numpy permettant de générer des matrices re-
marquables figurent
– ones : matrice unitaire,
– zeros : matrices de valeurs nulles,
– eye : matrice identité,
– diag : diagonale.
np . ones ((3 ,3))
np . zeros ((2 ,2))
np . eye (3)
np . diag ( np . array (([1 ,2 ,3 ,4])))
Le chargement de données à partir d’un fichier peut se faire à l’aide de la
fonction load et la sauvegarde à partir de la fonction savetxt. Une illustration
de ces fonction est donnée par le script qui suit
# charger à partir d ’ un fichier , typage explicite
# separateur de colonne
a = np . loadtxt ( " matrice . txt " , delimiter = " ’\ t " , dtype = float )
print ( a )

# liste de valeurs
L =[2 ,7.0 ,1]
print ( type ( L ))
# conversion à partir d ’ une liste ( asarray () , reshape ())
a = np . asarray (L , dtype = float ). reshape (2 ,2)
print ( a )
Parmi les fonctionnalités disponibles pour redimensionner une matrice
figure,
– Ajouter une ligne,
– ajouter une colonne,
– insertion et suppression de lignes ou colonnes,
– modifier la dimension d’une matrice.
Une illustration de quelques fonctionnalités est donnée par le script qui suit.
# matrice de valeurs
a = np . array ([[1 ,3.0] ,[0 ,0.8] ,[3 ,4.1]])
# ajouter une ligne en bas
b = np . array ([[6 ,4]])
c = np . append (a ,b , axis =0)

EPT page 19 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

print ( c )
# ajouter une colonne à droite
d = np . array ([[3.0] ,[1.8] ,[3.1]])
print ( np . apend (a ,d , axis =1))
# insertion
print ( np . insert (a ,1 ,b , axis =0))
# suppresion
print ( np . delete (a ,1 , axis =0))
# modifier la dimension d ’ une matrice
h = np . resize (a , new_shape =(2 ,3))
Le redimensionnement peut être réalisé à l’aide de la fonction reshape.
La fonction reshape (n,m) réorganise la matrice en n lignes et m colonnes
comme illustré dans le script qui suit.
# vecteur
a = np . arange (0 ,10)
# convertir le vecteur en matrice
a = np . arange (0 ,10). reshape (2 ,5)
print ( a )
# matrice de valeur identiques
a = np . zeros ( shape =(2 ,5))
print ( a )
# ou
a = np . full ( shape (2 ,4) , fill_value =0.1)
print ( a )
L’accès aux éléments d’une matrice peut être fait à l’aide des indices.
# vecteurs
v = np . array ([[1 ,2.1] ,[3 ,5.0] ,[5 ,5.6]])
# affichage de la matrice
print ( v )
# ou
print ( v [: ,:])
# accès indicé
print ( v [0 ,0])
# dernière valeur
print ( v [ v . shape [0] -1 , v . shape [1] -1])
# plage d ’ indices
print ( v [0:2 ,:])
# debut à 2
print ( v [:2 ,:])
# extrême , ligne 1 à fin
print ( v [1: ,:])
# indice négatif
print ( v [ -1 ,:])
# indices négatifs
print ( v [ -2: ,:])
Les éléments d’une matrice peuvent être triés. Il est aussi très simple de
rechercher des valeurs.

EPT page 20 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

# recherche valeur max des lignes ( axis =0)

print ( np . max (v , axis =0))
# recherche de valeur max de colonnes
print ( np . max (v , axis =1))
# recherche indice de valeur max
# des lignes pour chaque colonne
print ( np . argmax (v , axis =0))
# tri des lignes pour chaque colonne
print ( np . sort (v , axis =0))
# recuperation des indices triés
print ( np . argsort (v , axis =0))
Nous pouvons accéder aux valeurs de la matrice sans avoir à recourir aux
indices (ligne par ligne, colonne par colonne). Une illustration est donnée
dans le script qui suit.
# iterateur : accès ligne par ligne
s =0.0
for x in np . nditer ( v ):
print ( x )
s=s+x
print ( " Somme = " ,s )
# accès colonne par colonne
s =0.0
for x in np . nditer (v , order = " F " ):
print ( x )
s=s+x
print ( " Somme = " ,s )
Le script qui suit illustre des calculs réalisés selon une colonne ou une
ligne d’une matrice.
# moyenne des lignes pour chaque colonnes
print ( np . mean (v , axis =0))
# moyenne des colonnes pour chaque ligne
print ( np . mean (v , axis =1))
# somme cumulée des valeurs en ligne pour chaque colonne
print ( np . cumsum (v , axis =0))
# matrice de corrélation
m = np . corrcoef (v , rowvar =0)
print ( m )
Numpy intègre plusieurs fonctions matricielles pour l’algèbre linéaire. Des
exemples sont données dans le script qui suit.
# transposition
print ( np . transpose ( x ))
# multiplication
print ( np . dot (x , y ))
# determinant
print ( np . linalg . det ( y ))
# inversion

EPT page 21 N.F. Ngom

2 PREMIER PAS AVEC NUMPY Tuto Python AD

print ( np . linalg . inv ( y ))

# resolution d ’ équation
# Ya = z
z = np . array ([4.6 ,1.0])
print ( np . linalg . solve (y , z ))
# verification
print ( np . dot ( np . linalg . inv ( y ) , z ))
# matrice symetrique avec XTX
s = np . dot ( np . transpose ( x ) , x )
print ( s )
# val et vec propre d ’ une matrice symetrique
print ( np . linalg . eigh ( s ))
Le listing qui suit génère une matrice, calcule le rang de la matrice, le
determinant de la matrice, l’inverse de la matrice, les valeurs propres de la
matrice et les vecteurs propres de la matrice.

Listing 4 # rang de A
np . linalg . matrix_rank ( A )
# determinent de A
np . linalg . det ( A )
# inverse de A
np . linalg . inv ( A )
# Valeurs propres de A
np . linalg . eig ( A )[0]
# Vecteurs propres de A
np . linalg . eig ( A )[1]

#A
[[ 1 2 3 4]
[ 5 6 7 8]
[ 0 1 1 1]
[-2 -5 3 7]]
#rang de A
4
#determinent de A
-16.000000000000007
#inverse de A
[[-2.50000000e-01 2.50000000e-01 -1.00000000e+00 1.11022302e-16]
[ 1.37500000e+00 -3.75000000e-01 -7.50000000e-01 -2.50000000e-01]
[-4.00000000e+00 1.00000000e+00 4.50000000e+00 5.00000000e-01]
[ 2.62500000e+00 -6.25000000e-01 -2.75000000e+00 -2.50000000e-01]]
#Valeurs propres de A
array([ 7.76407287+6.71358078j, 7.76407287-6.71358078j,
-0.73482213+0.j , 0.20667639+0.j ])

#Vecteurs propres de A

EPT page 22 N.F. Ngom

3 PREMIER PAS AVEC MATPLOTLIB Tuto Python AD

array([[ 0.2775653 +0.06952086j, 0.2775653 -0.06952086j,

-0.57656968+0.j , -0.16939327+0.j ],
[ 0.74627698+0.j , 0.74627698-0.j ,
0.51019882+0.j , -0.13886963+0.j ],
[ 0.09229233-0.00481586j, 0.09229233+0.00481586j,
-0.5129463 +0.j , 0.82723717+0.j ],
[-0.08967323+0.58703719j, -0.08967323-0.58703719j,
0.37967178+0.j , -0.51739714+0.j ]])

3 Premier pas avec MatplotLib

Une description détaillée de MatplotLib est disponible au niveau de la
documentation de Python.
import matplotlib as plt
help ( plt )

Help on package matplotlib:

NAME
matplotlib - An object-oriented plotting library.

DESCRIPTION
A procedural interface is provided by the companion pyplot module,
which may be imported directly, e.g.::

import [Link] as plt

or using ipython::

ipython

at your terminal, followed by::

In [1]: %matplotlib
In [2]: import [Link] as plt

.........

Le listing qui suit affiche la courbe sinus sur l’intervalle -2pi, 2pi.
# importer les modules
import numpy as np
import matplotlib . pyplot as plt
n =100 # on affecte a la variable n la valeur de 100

EPT page 23 N.F. Ngom

3 PREMIER PAS AVEC MATPLOTLIB Tuto Python AD

X = np . linspace ( - np . pi , np . pi , n )
# renvoie n =100 valeur prie entre - pi et pi
régulièrement séparé par la même valeur affecter à X
C = np . cos ( X )
# affecte a la variable c cos ( x )
plt . figure ()
# cree une figure
plt . plot (X , C )
# trace la courbe f ( x )= c
plt . xlabel ( " temps " )
# donne le nom " temps " a l ’ axe des abscisse
plt . ylabel ( " cos " )
# donne le nom " cos " a l ’ axe des ordonnée
plt . title ( " cos sur [ - pi , pi ] " )
# donne le nom " cos sur [ - pi , pi ]" comme titre de la figure
plt . show ()
# affiche la figure
De la même, on peut afficher un sinue sur -2pi, 2pi
import numpy as np
import matplotlib . pyplot as plt
n =100
X = np . linspace ( -2* np . pi ,2* np . pi , n )

# fonction f ( x ) = sin ( x )
S = np . sin ( X )
plt . figure ()
plt . plot (X , S )
plt . xlabel ( " temps " )
plt . ylabel ( " sin " )
plt . title ( " sin sur [ -2* pi ,2* pi ] " )
plt . show ()

# fonction f ( x ) = cos (2 x ) + sin (4 x )

X = np . linspace ( -2* np . pi ,2* np . pi , n )
F = np . cos (2* X )+ np . sin (4* X )
plt . figure ()
plt . plot (X , F )
plt . xlabel ( " temps " )
plt . ylabel ( " sin_cos " )
plt . title ( " sin_cos sur [ -2* pi ,2* pi ] " )
plt . show ()
MatplotLib permet de générer aussi des courbes 3D
import numpy as np
import matplotlib . pyplot as plt
from mpl_toolkits . mplot3d import Axes3D
fig = plt . figure ()
ax = Axes3D ( fig , au to _ad d_ to _fi gu re = False )

EPT page 24 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

fig . add_axes ( ax )
X = np . arange ( -4 ,4 ,0.25)
Y = np . arange ( -4 ,4 ,0.25)
X , Y = np . meshgrid (X , Y )
R = np . sqrt ( X **2+ Y **2)
Z = np . sin ( R )
ax . plot_surface (X ,Y ,Z , rstride =1 , cstride =1 , cmap = plt . cm . hot )
ax . contourf (X ,Y ,Z , zdir = " z " , offset = -2 , cmap = plt . cm . hot )
ax . set_zlim ( -2 ,2)
plt . show ()

4 Premier Pas avec Pandas

A travers les objets de Pandas (Series, DataFrame), il est possible de
– Lire, écrie, créer et exporter des tables de données à partir
de fichiers textes (séparateurs, .csv, format fixe ou compressé), binaire
(HDF5 avec Pytable), HTML...
– Gérer une table : sélection de lignes ou colonnes, transformation,
réorganisation par niveau d’un facteur, imputation élémentaire de don-
nées manquantes ....
– Faire des statistiques élémentaires uni et bi-variées, tri à plat
(nombre de modalités, de valeurs nulles, de valeurs manquantes...),
détection de valeurs atypiques,
– Manipuler des tables : concaténations, fusions, jointures, tri, gestion
des types et format...

4.1 Séries
La classe Séries est l’association de deux arrays unidimensionnels. Ce
type a été introduit principalement pour des applications en économétrie et
Finance où Python est largement utilisée.
Nous allons dans la suite tester deux manières différentes de créer une série.
# serie cree a partire d ’ un tableau ,
# pandas attribue aux elements de la serie des index
L =[1 ,2 ,3 ,4 ,6]
s2 = pd . Series ( L )
s2
0 1
1 2
2 3
3 4
4 6
dtype : int64
# # serie cree a partire d ’ un dictionnaire ,
# les clés du dictionnaire sont utilisées comme i
E1 1

EPT page 25 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

E2 2
E3 3
E4 4
E5 6
dtype : int64

4.2 DataFrame
Les objets DataFrame sont des objets Pyhton spécifiques au module pan-
[Link] DataFrames sont très rapides lorsqu’il y a moins de 10 mil-
lions d’observations et que le fichier texte qui décrit les données
n’est pas plus gros que 10Mo.
Un DataFrame est une matrice où chaque colonne est une Series de même
type. En d’autres termes, un tableau bi-dimensionnel avec des index de lignes
ou colonnes ou une listt de Series partageant le même index.

Il existe plusieurs manières de créer les objets data frames : à partir de

listes, à partir de séries, à partir de dictionnaires, à partir de source de don-
nées externes. Toutefois la fonction de base est la fonction DataFrame()avec
les paramètres qui suivent
– append : nouvel index par concaténation,
– diff : difference ensembliste,
– union : union ensembliste,
– isin : vrai si la valeur est dans la liste,
– delete : suppression de l ?index i,
– drop : suppression d ?une valeur d ?index,
– ism onotonic : vrai si les valeurs sont croissantes,
– is_unique : vrai si toutes les valeurs sont différentes,
– unique : tableau des valeurs uniques de l ?index.

4.2.1 Dataframe à partir de données générées

Le listing qui suit crée un DataFrame à partir d’une liste.

Listing 5 Dataframe à partir de données générées

import pandas
l =[{ " date " : " 05:11:2024 " , " prix " :1000 , " devise " : " FCFA " , " arrêt " : " Fann " , " Iden
{ " date " : " 10:10:2024 " , " prix " :500 , " devise " : " FCFA " , " arrêt " : " Colobane " , " I
{ " date " : " 05:11:2024 " , " prix " :1000 , " devise " : " FCFA " , " arrêt " : " Mariste " , " Id
{ " date " : " 05:11:2024 " , " prix " :1000 , " devise " : " FCFA " , " arrêt " : " Diamniadio " , "
df = pandas . DataFrame ( l )
df

date prix devise arrêt Identification heure

EPT page 26 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

0 05:11:2024 1000 FCFA Fann 234325 8h00

1 10:10:2024 500 FCFA Colobane 234325 10h00
2 05:11:2024 1000 FCFA Mariste 76544 8h30
3 05:11:2024 1000 FCFA Diamniadio 924325 12h00

Nous allons sauvegarder le dataframe dans un fichier au [Link] à

l’aide du script suivant
df . to_csv ( " fichierTexte . txt " , index = True , sep = " \ t " )
Nous vérifions ensuite si le fichier a été sauvegardé avec le script qui suit
try :
df . to_csv ( " fichierTexte . txt " , index = True , sep = " \ t " )
print ( " Enregistrement du fichier ’ fichierTexte . txt ’ est réussi " )
except IOError :
print ( " Erreur lors de l ’ enregistrement du fichier : " , " fichierTexte . txt "
try :
with open ( " fichierTexte . txt " , " r " ) as fichier :
content = fichier . read ()
print ( " Contenu du fichier :\ n " , content )
except Exception as e :
print ( " Erreur lors de la lecture du fichier ’ fichierTexte . txt ’ " )

Enregistrement du fichier ’[Link]’ est réussi

Contenu du fichier :
date prix devise arrÃłt Identification heure
0 05:11:2024 1000 FCFA Fann 234325 8h00
1 10:10:2024 500 FCFA Colobane 234325 10h00
2 05:11:2024 1000 FCFA Mariste 76544 8h30
3 05:11:2024 1000 FCFA Diamniadio 924325 12h00

Nous pouvons aussi enregistrer le fichier au format csv et le visualiser.

try :
df . to_excel ( ’ fichierTexte . xlsx ’ , index = False )
print ( " Enregistrement du fichier Excel réussi . " )
except Exception as e :
print ( " Erreur lors de l ’ enregistrement du fichier Excel : " , str ( e ))
try :
excel_data = pd . read_excel ( ’ fichierTexte . xlsx ’)
print ( excel_data )
except Exception as e :
print ( " Erreur lors de la lecture du fichier Excel : " , str ( e ))

4.2.2 Dataframe à partir de sources de données externes

L’importation de fichier txt ou csv peut se faire à l’aide de la fonction
read_csv du module pandas.

EPT page 27 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

Listing 6 Création d’un dataframe à partir d’un fichier

# separateur tabulation
df = pandas . read_csv ( " fichier . txt " , sep = " \ t " , header =0 , encoding = " utf -8 " )
# separateur ;
df = pandas . read_csv ( " fichier . csv " , sep = " ; " , header =0 , encoding = utf - " 8 " )

Le paramètre header=0 indique que les noms de variables se trouvent

sur la ligne 0. Si les données ne contiennent pas les données, on met hea-
der=None. Si la table de données importée ne contient pas le nom des co-
lonnes, on peut l’ajouter avec
df . columns =[ " nomVar1 " , " nomVar " , " nomVar3 " , " nomVar4 " ]

4.2.3 Importation d’un fichier

La lecture d’un fichier peut se faire à l’aide de la fonction read_csv. Un
fichier peut être lu en local à partir d’un dossier ou en ligne.
import pandas as pd
# lecture en local
file_path = " Chemin / fichier . csv "
df = pd . read_csv ( file_path , header =0 , sep = " ," )

# lecture en ligne du fichier titanic

url = " https ://.../ datasets / master / titanic . csv "
df = pd . read_csv ( url )
print ( df . head ())
La lecture d’un fichier en local se fait en indiquant le chemin du dossier
où le fichier est stocké et le nom du fichier. La lecture d’un fichier en local
se fait en indiquant l’url du fichier.

4.2.4 Importer un fichier texte

Considérons le fichier [Link].

Listing 7 Lecture du fichier

df = pandas . read_csv ( " marathon . txt " , sep = " \ t " ,

names =[ " ville " , " annee " , " temps " , " secondes " ])
df . describe ()

annee secondes
count 359.000000 359.000000
mean 1989.754875 7933.660167
std 14.028545 385.289830

EPT page 28 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

min 1947.000000 7382.000000

25% 1981.000000 7698.000000
50% 1991.000000 7820.000000
75% 2001.000000 8046.500000
max 2011.000000 10028.000000

Listing 8 Quelques informations de base

# nom des colonnes

print ( df . columns )
# Index ([ ’ ville ’, ’ annee ’, ’ temps ’, ’ secondes ’] , dtype = ’ object ’)

# liste des villes

print ( df [ " ville " ])

# 10 premières années
print ( df [ " annee " ]. head (10))
0 2011
1 2010
2 2009
3 2008
4 2007
5 2006
6 2005
7 2004
8 2003
9 2002
Name : annee , dtype : int64

# un sous ensemble de la table

print ( df . iloc [100:110])

# renommer les noms des colonnes

rename = df . rename ( columns ={ " ville " : " city " , " annee " : " year " })
rename
city year temps secondes
0 PARIS 2011 02:06:29 7589
1 PARIS 2010 02:06:41 7601
2 PARIS 2009 02:05:47 7547

4.2.5 Importer un fichier excel

Nous allons dans la suite considérer le fichier [Link].
Le listing 9 importe les modules de base et lecture du fichier.
Listing 9 Lecture d’un fichier csv

EPT page 29 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

# Importation des modules de base

import matplotlib . pyplot as plt
import pandas
import scipy . stats
import numpy
# voir les graphiques dans le document
% matplotlib inline

# lecture du fichier
tips = pandas . read_csv ( " tips . csv " , header =0 , sep = " ," )

Donnons une une première description des données à l’aide des fonctions
type (renvoie le type de données), shape (renvoie la taille de la variable en
nombre de lignes et nombre de colonnes) et count.

Listing 10 type ( tips )

# pandas . core . frame . DataFrame
$
tips . shape
# (244 , 7)

tips . count ()
# genere
total_bill 244
tip 244
sex 244
smoker 244
day 244
time 244
size 244
dtype : int64

La fonction info donne un résumé des informations sur la table de don-

nées (structure et propriétés de base).
tips . info ()

<class ’[Link]’>
RangeIndex: 244 entries, 0 to 243
Data columns (total 7 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 total_bill 244 non-null float64
1 tip 244 non-null float64
2 sex 244 non-null object
3 smoker 244 non-null object
4 day 244 non-null object

EPT page 30 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

5 time 244 non-null object

6 size 244 non-null int64
dtypes: float64(2), int64(1), object(4)
memory usage: 13.5+ KB

La fonction list convertit l’index en une liste.

list ( tips . columns )
# [ ’ total_bill ’, ’ tip ’, ’ sex ’, ’ smoker ’, ’ day ’, ’ time ’, ’ size ’]

list ( tips )
# [ ’ total_bill ’, ’ tip ’, ’ sex ’, ’ smoker ’, ’ day ’, ’ time ’, ’ size ’]
D’autres fonctions associées aux DataFrame sont
– filter : on sélectionne un sous ensemble de lignes qui vérifient une
condition.
– union : concaténation de deux jeu de données. On peut concaténer les
lignes (concat) ou les colonnes (merge, join, concatenate)
– sort : tri,
– group by : grouper des lignes qui partagent une valeur commune
(une valeur dans une colonne ou plusieurs valeurs dans plusieurs co-
lonnes). On peut conserver chaque groupe, ou calculer une somme, une
moyenne, prendre la ou meilleures valeurs (top per group).
– join : fusionner deux jeux de données en associant les lignes qui par-
tagent une valeur commune,
– pivot : utiliser des valeurs présentes dans une colonne comme nom de
colonnes.

croisé.

4.3 Description des variables

4.3.1 Description des variables quantitatives
Une table de données peut être décrite à l’aide de résumés numériques
ou graphiques.

La fonction describe donne des résumés numériques des colonnes de la

table.
tips . describe ()

total_bill tip size

count 244.000000 244.000000 244.000000
mean 19.785943 2.998279 2.569672
std 8.902412 1.383638 0.951100
min 3.070000 1.000000 1.000000

EPT page 31 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

25% 13.347500 2.000000 2.000000

50% 17.795000 2.900000 2.000000
75% 24.127500 3.562500 3.000000
max 50.810000 10.000000 6.000000

Le script qui suit trace le graphe de la distribution des pourboires en

fonction du montant de la facture : "tip" (montant du pourboire) sur l’axe
des y, "total_bill" (montant total de la facture) sur l’axe des x.
tips . plot . scatter ( " total_bill " , " tip " )
Le script qui suit trace le scatterplot qui une matrice de correspondance
pour toutes les colonnes du DataFrame "tips". Chaque cellule de la ma-
trice contient un graphe liant deux variables (colonnes) du DataFrame. Cela
permet d’observer de manière globale les relations potentielles entre les dif-
férentes variables du jeu de données.
pandas . plotting . scatter_matrix ( tips )
Le listing 11 calcule les éléments suivante d’une colonne de la table :
moyenne, écart type, variance, minimum, maximum, valeur me-
diane, quartiles, quantile.

Listing 11 Résumé numérique

moyenne = tips [ " total_bill " ]. mean ()

moyenne
# 1 9.785942 62295082

ecartType = tips [ " total_bill " ]. std ()

ecartType
# 8.902411 95485685 6

variance = tips [ " total_bill " ]. var ()

variance
# 79.25293 86139782 6

minimum = tips [ " total_bill " ]. min ()

minimum
# 3.07

maximum = tips [ " total_bill " ]. max ()

maximum
# 50.81

valeurMedian = tips [ " total_bill " ]. median ()

valeurMedian
# 17.795

EPT page 32 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

quartiles = tips [ " total_bill " ]. quantile ([0.25 , 0.5 , 0.75])

quartiles
0.25 13.3475
0.50 17.7950
0.75 24.1275
Name : total_bill , dtype : float64

quantile = tips [ " total_bill " ]. quantile ([0.4])

quantile
# 0.4 16.222
# Name : total_bill , dtype : float64

Le script 12 génère les boîtes à moustache associées aux variables et faire

une interprétation à partir des résultats obtenus.

Listing 12 Boîte à moustache

tips . boxplot ()

Figure 2 – Boîte à Moustache (tips)

Le diagramme en boîte (boxplot) affiche la distribution des valeurs pour

les variables total_bill, tip, et size (figure 2).
– Pour la variable total_bill, le premier quartile étant d’environ 13 et
le troisième quartile de 25, la moitié des montants des factures est
comprise entre ces deux montants. Les données sont ainsi un peu dis-
persées. La valeur de la médiane à 17 indique que la moitié des factures
est inférieure à cette valeur. La moustache inférieure va jusqu’à 4 et
celle supérieure jusqu’à 40, d’où une grande variabilité des montants.
De plus, il y a plusieurs points au-dessus de 40, indiquant des valeurs
aberrantes où les montant de factures sont nettement plus élevées.

EPT page 33 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

– Pour la variable tip, la boite s’étend de 2 (premier quartile) à 4

(troisième quartile) avec une médiane à 3, ce qui indique que 50% des
pourboires sont compris dans cette fourchette. Avec une moustache
inférieure à 1 et une supérieure à 7 et une petite boite, on a des don-
nées peu variables et peu dispersées. On note l’existence de valeurs
aberrantes au dessus de 7 (pourboires plus élevés).
– Pour la variable size, la médiane de la boîte est environ à 2, ce qui
signifie que la moitié des groupes sont composés de deux personnes
ou moins. La moustache inférieure va jusqu’à environ 1, tandis que la
moustache supérieure s’étend jusqu’à environ 5, une distribution peu
variable et peu dispersée. Les valeurs aberrantes au-dessus de 5 sont
existantes
Maintenant, générons l’histogramme de la variable total_bill et la courbe
associée à l’histogramme.
tips [ ’ total_bill ’ ]. plot ( kind = " hist " , density = " True " )
tips [ ’ total_bill ’ ]. plot ( kind = " kde " )

Figure 3 – Histogramme de la variable total_bill

En nous basant sur l’allure de l’histogramme de la variable total_bill

(figure 3), nous pouvons supposer que les données suivent une distribution
de type lognormale. Maintenant, faisons un test d’adéquation pour vérifier
cette hypothèse.
from scipy . stats import kstest , lognorm

# Test de Kolmogorov - Smirnov pour la loi lognormale

params_lognorm = lognorm . fit ( tips [ ’ total_bill ’ ])
ks_stat , p_value = kstest ( tips [ ’ total_bill ’] , ’ lognorm ’ , params_lognorm )

# Affichage des résultats

EPT page 34 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

print ( " Test de Kolmogorov - Smirnov pour la loi lognormale : " )

print ( " Statistique de test : " , ks_stat )
print ( "p - value : " , p_value )

Test de Kolmogorov-Smirnov pour la loi lognormale:

Statistique de test: 0.04308570385399735
p-value: 0.7387662645526814

La p-valeur associée au test est supérieure à 0.5, cela suggère que les
données suivent une distribution lognormale.
Les fonctions cov et corr permettent d’étudier les relations entre deux va-
riables.
covariance = tips [ ’ total_bill ’ ]. cov ( tips [ ’ tip ’ ])
print ( covariance )
# 8.323501 62922485 4
# la covariance positive indique l ’ existence d ’ une
# relation linéaire entre les deux variables .

# Corrélation
correlation = tips [ ’ total_bill ’ ]. corr ( tips [ ’ tip ’ ])
print ( correlation )
0. 67 57 341 09 21 136 41 # variables moyennement correlées

4.3.2 Description des variables qualitatives

Donnons une première description de la variable sex à l’aide des fonction
describe, unique et value_count.
tips [ " sex " ]. describe ()
# resultat
count 244
unique 2
top Male
freq 157
Name : sex , dtype : object

tips [ " sex " ]. unique ()

# array ([ ’ Female ’, ’ Male ’] , dtype = object )

tips [ " sex " ]. value_counts ()

# resultat
Male 157
Female 87
Name : sex , dtype : int64
Nous observons que la variable sex est une variable qualitative et a deux
modalites qui sont : Female (avec un effectif de 87) et Male (avec un effectif

EPT page 35 N.F. Ngom

4 PREMIER PAS AVEC PANDAS Tuto Python AD

de 157).

A l’aide de la fonction crosstab, générons la table croisée des fréquences

et la table normalisée des fréquences.
# table croisée des fréquences
pd . crosstab ( tips [ " size " ] , tips [ " smoker " ])

# table normalisée des fréquences

pd . crosstab ( tips [ " sex " ] , tips [ " smoker " ] , normalize = True )

#table croisée
smoker No Yes
sex
Female 54 33
Male 97 60

#table normalisée
smoker No Yes
sex
Female 0.221311 0.135246
Male 0.397541 0.245902
Nous pouvons conclure de ce dernier script que 40% (resp. 22%) de l’échan-
tillon est constitué d’hommes (resp. femmes) qui ne fument pas. Nous en
déduisons aussi que 14% (resp. 24%) de l’échantillon est constitué de femmes
(resp. hommes) qui fument fumeurs.

Maintenant, affichons le diagramme en bâton et le diagramme circulaire.

# diagramme en bâton
tips [ " sex " ]. value_counts (). plot . bar ()
plt . title ( " diagramme en bâton de la varable sex " )
plt . xlabel ( " genre " )
plt . ylabel ( " effectif " )
plt . show ()

# diagramme circulaire
tips [ ’ sex ’ ]. value_counts (). plot . pie ( figsize =(6 ,6) , autopct = " %.2 f " )
plt . title ( ’ digramme circulaire de la variable sex ’)
plt . legend ()
plt . show ()

4.3.3 Analyse descriptive croisée

L’analyse croisée permet d’observer les différences et les similitudes entre
les groupes selon plusieurs variables.

EPT page 36 N.F. Ngom

5 PREMIER PAS AVEC LE MODULE SEABORN Tuto Python AD

Nous allons d’abord, dans cette section, regrouper les données du Data-
Frame "tips" en fonction de la variable qualitative "sex" (sexe) et calculer la
moyenne des variables quantitatives pour chaque groupe. Cela permet d’ob-
tenir la moyenne des différentes variables pour les catégories "male" (homme)
et "female" (femme).
tips . groupby ( " sex " ). mean ()

total_bill tip size

sex
Female 18.056897 2.833448 2.459770
Male 20.744076 3.089618 2.630573

Nous générons ensuite un histogramme pour la variable quantitative

"total_bill" (montant total de l’addition) en fonction de la variable qua-
litative "sex" (sexe). L’objectif est de créer des sous-graphiques séparés pour
chaque catégorie (homme et femme) et afficher la distribution des montants
totaux de l’addition pour chaque groupe.
tips . hist ( column = ’ total_bill ’ , by = ’ sex ’)
plt . show ()
Nous pouvons aussi générer le diagramme en boîte (boxplot) pour chaque
variable quantitative du DataFrame "tips" en fonction de la variable quali-
tative "sex" (sexe). Ce diagramme permet de visualiser la distribution des
valeurs, les médianes, les quartiles et les valeurs aberrantes pour chaque
groupe cible (homme, femme).
84]: tips . boxplot ( by = ’ sex ’)
plt . show ()
Il découle du boxplot que le montant moyen de la facture (total_bill) est
de 20.744 pour les hommes (Males) et de 18.057 pour les femmes (Females).
La moyenne de tip est de 3.09 pour les hommes (Males) et de 2.083 pour
les femmes (Female) tandisque que la variable taille (size) est sensiblement
égal 2.46 pour les femmes (Females) et 2.6 pour les hommes (Males). Une
premère conclusion que l’on peut en tirer est la valeur de totall_bill est en
général plus élevée chez les hommes que les femmes.

5 Premier pas avec le module seaborn

Nous considérons dans cette section, le jeu de données tips.
Importons le module seaborn, ajoutons une ligne de manière à pourvoir voir
les graphiques générés dans le document, puis affichons des histogrammes.

EPT page 37 N.F. Ngom

5 PREMIER PAS AVEC LE MODULE SEABORN Tuto Python AD

Listing 13 import seaborn

% matplotlib inline

seaborn . distplot ( tips . total_bill )

# histogramme et courbe de total_bill dans le meme plan

seaborn . distplot ( tips . total_bill , kde = False )

# renvoie l ’ histogramme de total_bill

seaborn . distplot ( tips . total_bill , hist = False )

# renvoie la courbe de total_bill

seaborn . displot ( tips . total_bill , bins =6 , kde = False )

# renvoie l ’ histogramme des 6 plus grands colonnes de total_bill

Générons les boîtes à moustache

Listing 14 seaborn . boxplot ( tips [ " total_bill " ])

# boite a moustache de total_bill

seaborn . boxplot ( tips [ " tip " ])

# boite a moustache de tip

seaborn . boxplot ( tips [ " size " ])

# boite a moustache de size

Testons les fonctions pointplot, stripplot, factorplot, jointplot et

pairplot.

Listing 15 plt . figure ()

seaborn . pointplot ( data = tips , x = " sex " , y = " total_bill " )
plt . figure ()

plt . figure ()
seaborn . stripplot ( data = tips , x = " total_bill " , y = " sex " )
plt . show ()

plt . figure ()
seaborn . catplot ( data = tips , x = " total_bill " , y = " day " )
# graphique catégorique (" categorical plot ")
plt . show ()

plt . figure ()
seaborn . jointplot ( x = " day " , y = " size " , data = tips , color = " red " )
# graphique joint (" joint plot ")
plt . show ()

EPT page 38 N.F. Ngom

5 PREMIER PAS AVEC LE MODULE SEABORN Tuto Python AD

plt . figure ()
seaborn . pairplot ( tips )
# pairplot des variables
plt . show ()

Figure 4 – Graphe généré par la fonction pointplot des variables total_bill

et sex

Figure 5 – Graphe généré par la fonction stripplot des variables total_bill

et sex
On peut conclure à partir de la figure 5 que les hommes donnent beaucoup
plus de pourboires que les femmes.
La figure 6 montre que les dépenses sont plus élevées surtout le Samedi
(50) et le Dimanche (48). La fréquentation est plus grande le Jeudi, le Samedi
et le Dimanche et beaucoup moins le Vendredi. Cet état de fait conduit à

EPT page 39 N.F. Ngom

5 PREMIER PAS AVEC LE MODULE SEABORN Tuto Python AD

Figure 6 – Graphe généré par la fonction catplot des variables total_bill

et day

supposer que le restaurant est fréquenté par des clients de classe moyenne la
semaine. Et que le Weekend, les clients de classe plus élevée (plus riches) y
sont plus nombreux d’où la hausse des factures.
L’analyse du graphique de la figure 7 montre que le Samedi presque les
groupes de la population avec des effectifs variés sont représentés. Cette
situation est similaire à celle du Dimanche avec moins de groupes à effectifs
élevés. La plupart des groupes du jeudi sont de taille 2, avec quelques groupes
de taille 1, 3, et 4. Il y a peu de fréquentation le Vendredi et la taille des
groupes est généralement 2 et 4. Nous pouvons quelques conclusions
– Il y a plus de fréquentation le Samedi et le Dimanche contrairement,
– la fréquentation la plus faible est notée le Vendredi.
– La taille des groupes les plus fréquents vaut 2, suivi des groupes de
taille 3 et 4,
– les groupes de taille 1, 5 et 6 les plus rares.
– le niveau de fréquentation élevé du weekend se justifie peut être par
plus de disponibilité des clients qui travaillent la semaine.
Générons maintenant la table de contingence des variables sex et smoker
à l ?aide de la fonction heatmap.
conti ngence_t able = pd . crosstab ( tips [ " sex " ] , tips [ " smoker " ])
seaborn . heatmap ( contingency , annot = True )
tipsTableContingence

EPT page 40 N.F. Ngom

6 GESTION DES BASES DE DONNÉES Tuto Python AD

Figure 7 – Graphe généré par la fonction jointplot des variables day et size

6 Gestion des bases de données

Une base de données (database) est un conteneur dans lequel il est pos-
sible de stocker des données de façon structurée. Cette structure permet
au programme informatique connectée de faire des recherches complexes. Un
langage standardisé SQL est dédié à cette structure et permet de faire des re-
cherches, des modifications ou suppression. Il ne faut toutefois pas confondre
une base de données qui est un conteneur et le SGBDR (système de gestion
de base de données relationnelles) qui est un logiciel de gestion de bases de
données.
Le langage SQL permet de créer une table SQL, insérer des données, sélec-
tionner des données, modifier des données et supprimer des données.

Listing 16 Importer le module SQLite

Listing 17 # !/ usr / bin / env python

# -* - coding : utf -8 -* -
import sqlite3 as sq

Établissons une connexion avec la base [Link].

Listing 18 conn = sq . connect ( " flights . db " )

# permet de se connecter a notre base de donnée flights . db
df = pd . read_sql_query ( " select * from airlines limit 5; " , conn )

EPT page 41 N.F. Ngom

6 GESTION DES BASES DE DONNÉES Tuto Python AD

Figure 8 – Graphe généré par la fonction pairplot sur les données tips

# extrait toutes les colonnes de la table airlines

# et affiche seulement les 5 premiers lignes
conn . close ()
# ferme la connexion avec le fichier flights . db
df . shape # la dimension de df
df . count ()
# montre qu ’ il y ’a 9 colonnes et donne
# le nombre de valeurs non nulles de chaque colonnes
df . info () # meme chose que count de maniere plus detaillée

<class ’[Link]’>
RangeIndex: 5 entries, 0 to 4
Data columns (total 9 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 index 5 non-null int64
1 id 5 non-null object
2 name 5 non-null object
3 alias 5 non-null object
4 iata 2 non-null object
5 icao 4 non-null object
6 callsign 2 non-null object
7 country 4 non-null object
8 active 5 non-null object
dtypes: int64(1), object(8)

EPT page 42 N.F. Ngom

6 GESTION DES BASES DE DONNÉES Tuto Python AD

Figure 9 – Table de contingence des variables sex et smoker

memory usage: 488.0+ bytes

Maintenant, établissons la connexion avec la base de données [Link]

et exécutons certaines requêtes.
import sqlite3

# Établir une connexion à la base de données SQLite

conn = sqlite3 . connect ( ’ salaries2010 . db3 ’)

# Créer un curseur pour exécuter les requêtes

cursor = conn . cursor ()

# Exécuter une requête pour obtenir les noms des tables

cursor . execute ( " SELECT name FROM sqlite_master WHERE type = ’ table ’" )
tables = cursor . fetchall ()

# Parcourir les tables et afficher leurs noms

for table in tables :
print ( table [0])

df = pd . read_sql_query ( " select * from salaries limit 5; " , conn )

print ( df . shape )
print ( df . count ())
print ( df . info ())
# Fermer le curseur et la connexion à la base de données
cursor . close ()
conn . close ()

BHEUR_TOT 5

EPT page 43 N.F. Ngom

6 GESTION DES BASES DE DONNÉES Tuto Python AD

TRALCHT 5
TREFF 5
TRNETTOT 5
POND 5
dtype: int64
<class ’[Link]’>
RangeIndex: 5 entries, 0 to 4
Data columns (total 29 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 A6 5 non-null object
1 A17 5 non-null object
2 A38 5 non-null object
3 REGR 5 non-null object
4 DEPR 5 non-null object
5 REGT 5 non-null object
6 DEPT 5 non-null object
7 SEXE 5 non-null object
8 PCS 5 non-null object
9 CONT_TRAV 5 non-null object
10 CONV_COLL 5 non-null object
11 TYP_EMPLOI 5 non-null object
12 DUREE 5 non-null float64
13 DATDEB 5 non-null float64
14 DATFIN 5 non-null float64
15 CPFD 5 non-null object
16 DOMEMPL 5 non-null object
17 DOMEMPL_EM 5 non-null object
18 FILT 5 non-null object
19 AGE 5 non-null float64
20 CS 5 non-null object
21 NB_PER 5 non-null float64
22 NB_PER_N 5 non-null float64
23 NBHEUR 5 non-null float64
24 NBHEUR_TOT 5 non-null float64
25 TRALCHT 5 non-null object
26 TREFF 5 non-null object
27 TRNETTOT 5 non-null object
28 POND 5 non-null float64
dtypes: float64(9), object(20)
memory usage: 1.3+ KB
None

EPT page 44 N.F. Ngom