ALGORITHMIQUE ET
PROGRAMMATION
Année Académique:
2022/2023
Niveau:
C2A1 : Cycle 2, Première Année
Filière : Master GPE
UNIVERSITE DE YAOUNDE II -SOA
Enseignant :
Dr WANSOUWE WANBITCHING
INFORMATIONS GÉNÉRALES
¢ Intitulé : Algorithmique et Programmation
Code :
Cours magistral : 10 heures
Travaux dirigés / pratiques : 15 heures
¢ Éléments constitutifs de l'Unité d'Enseignement
Cours magistral : soyez attentifs!
Travaux Dirigés : Exercices
Travaux Pratiques : le plus intensif possible
Travail Personnel de l'étudiant
ORGANISATION DU COURS
¢ Organisation des évaluations
Exercices et Travaux Pratiques
Questions de cours
Parfois des QCM
¢ Types d'évaluation
TPE : Travail à faire à la maison
CC : 2 -3 heures
Examen : 3 heures
Rattrapage : 3 heures
PLAN
ELEMENTS DE PROGRAMMATION PYTHON
FONCTIONS ET MODULES
PROGRAMMATION ORIENTEE OBJET
GESTION DES FICHIERS ET EXCEPTIONS
4
CHAPITRE 1 : ELEMENTS DE
PROGRAMMATION EN PYTHON
I-GENERALITES SUR LA PROGRAMMATION
• Un programme est la traduction d’un
algorithme dans un langage
compréhensible par l’ordinateur
• On utilise des systèmes de traduction
automatiques, capables de convertir en
nombres binaires des suites de caractères
formant des mots-clés.
• Le système de traduction proprement dit
s’appellera interpréteur ou bien
compilateur, suivant la méthode de
traduction utilisée.
DUCODE SOURCE A SON EXECUTION
COMPILATION
• La compilation consiste à traduire la
totalité du code source en une fois.
• Le compilateur lit toutes les lignes du
programme source et produit une nouvelle
suite de codes appelée programme objet (ou
code objet).
• Celui-ci peut désormais être exécuté
indépendamment du compilateur et être
conservé tel quel dans un fichier (« fichier
exécutable »).
• Exemples : Ada, C, C++ et Fortran, Pascal.
INTERPRETATION
• L’interprétation consiste à traduire chaque
ligne du programme source en quelques
instructions du langage machine, qui sont
ensuite directement exécutées au fur et à
mesure.
• L’interpréteur doit être utilisé chaque fois
que l’on veut faire fonctionner le
programme.
Exemples : Lisp et Prolog.
SEMI - COMPILATION
• Semi – Compilation = Compilation +
Interprétation
• Compilation du code source pour produire
un code intermédiaire, similaire à un
langage machine (mais pour une machine
virtuelle), que l’on appelle bytecode,
• Interprétation du bytecode pour l’exécution
finale.
• Le bytecode est très facile à interpréter en
langage machine.
• Exemples : Python, Java
Généralités sur Python
11
Généralités sur Python
• Langage objet, de nouvelle génération, pseudo -
interprété, portable.
• Libre, ouvert, gratuit.
• Nombreuses “ bibliothèques ” disponibles sur internet.
• Créé par Guido van Rossum en 1991.
• “I chose Python as a working title for the project, being in a slightly
irreverent mood (and a big fan of Monty Python's Flying’Circus)”
Guido Van Rossum
Le langage Python
• Proche de l'algorithmique donc approprié pour :
q l'enseignement
q les applications dans le monde réel
o Moteur de recherche Google, Youtube,
o Laboratoires de recherche (CNRS, INRIA, Univ
o Agences spatiales (NASA…),
o Jeux vidéo, cinéma,
o Finance,
o etc.
• Utilisé dans de nombreuses entreprises pour de
l'informatique d'instrumentation
o Collecte et analyse de données donc pour la Data
Science
Le langage Python
Python 2 (2000) et Python 3 (2008)
– Dans la lignée de Perl :
• Langage « script » : interprété, compilé à la volée en bytecode
(fichiers .ypc)
• Faiblement typé (typage à l’exécution)
• Types de base, listes, dictionnaires
• Programmation fonctionnelle (faible)
• Programmation orientée objet (faiblement typée)
– Forces et faiblesses :
• Les plus : flexibilité, simplicité et rapidité de développement
• Les moins : lent et gourmand en mémoire, peu robuste
Le langage Python
Les variables
Pas de syntaxe particulière pour créer ou “déclarer” une
variable : les variables Python sont automatiquement créées
au moment où on leur assigne une valeur.
Règles usuelles pour le nom de variable :
• commencer par une lettre ou par un underscore ;
• ne contenir que des caractères alphanumériques courants;
• ne pas être un mot réservé de Python,
NB : Python est sensible à la casse et l’opérateur d’affection est
«=»
Exemple : monage = 30 monAge = 30 sont deux variables
distinctes!
Le langage Python
Les types de données de base
1. Les types numériques :
int - type des entiers : a = 1, b = 45, monage = 20
float - type des réels : pi = 3.14, a = 1.0
complex - type des nombres complexes : z = 1+2j
2. Le type chaine de caractères :
str (string) : nom = ‘Latifa’, prenom = ‘Maï’
3. Le type booléen
bool – le type des valeurs booléennes
Exemples : trouve = True, aUnChien = False
Le langage Python
Les opérateurs
1. Les opérateurs arithmétiques
Opérateur Nom
+ Addition
– Soustraction
* Multiplication
/ Division
% Modulo
** Puissance
// Division entière
Le langage Python
Les opérateurs
1. Les opérateurs de chaînes de caractères
• Python dispose de deux opérateurs de chaine
concaténation : +
‘123’ + ‘45’ # ‘12345’
répétition : *
‘abc’ * 2 # ‘abcabc’
Le langage Python
Les opérateurs d’affection simple et composés
Opérateur Exemple Equivalent à Description
= x=1 x=1 affecte 1 à la variable x
ajoute 1 à la dernière valeur connue de x
+= x += 1 x=x+1 et affecte la nouvelle valeur (l’ancienne +
1) à x
enlève 1 à la dernière valeur connue de x
-= x -= 1 x=x–1
et affecte la nouvelle valeur à x
mutliplie par 2 la dernière valeur connue
*= x *= 2 x=x*2
de x et affecte la nouvelle valeur à x
divise par 2 la dernière valeur connue de x
/= x /= 2 x=x/2
et affecte la nouvelle valeur à x
calcule le reste de la division entière de x
%= x %= 2 x=x%2
par 2 et affecte ce reste à x
calcule le résultat entier de la division de
//= x //= 2 x = x // 2
x par 2 et affecte ce résultat à x
élève x à la puissance 4 et affecte la
**= x **= 4 x = x ** 4
nouvelle valeur dans x
Les structures de données
Les listes
• Une liste est une collection ordonnée et modifiable
d’éléments éventuellement hétérogènes.
• Elle est construite à l’aide d’éléments séparés par des
virgules, et entourés de crochets.
Exemples
1. couleurs = [’trèfle’, ’carreau’, ’coeur’, ’pique’]
2. couleurs[1] = 14 # modifie la deuxième valeur
3. list1 = [’a’, ’b’], list2 = [4, 2.718]
list3 = [list1, list2] # crée une liste de listes
print(list3) # [[’a’, ’b’], [4, 2.718]]
Manipulations de listes
• nombres = [17, 38, 10, 25, 72]
• nombres.sort() # trie la liste
• print(nombres) # [10, 17, 25, 38, 72]
• nombres.append(12) # ajoute la valeur 12 à la fin
• nombres.reverse() # inverse la liste
• nombres.remove(38) # retire la valeur 38 de la liste
• print(nombres) # [12, 72, 25, 17, 10]
• print(nombres.index(17)) # livre l’indice d’un nombre
• nombres[0] = 11
• nombres[1:3] = [14, 17, 2]
• print(nombres.pop()) # livre l’élément de tête 10
• print(nombres) # [11, 14, 17, 2, 17]
• print(nombres.count(17)) # nombre d’occurrences
• nombres.extend([1, 2, 3]) # étend la liste
Manipulations de listes
• mots = [’jambon’, ’sel’, ’miel’, ’confiture’, ’beurre’]
• mots[2:4] = [] # effacement par affectation d’une liste
vide
• print(mots) # [’jambon’, ’sel’, ’beurre’]
• mots[1:3] = [’salade’]
• print(mots) # [’jambon’, ’salade’]
• mots[1:] = [’mayonnaise’, ’poulet’, ’tomate’]
• print(mots) # [’jambon’, ’mayonnaise’, ’poulet’,
’tomate’]
• mots[2:2] = [’miel’] # insertion en 3è position
• print(mots) #[’jambon’, ’mayonnaise’, ’miel’, ’poulet’,
’tomate’]
Les tuples
• Un tuple est une collection ordonnée et non modifiable
d’éléments éventuellement hétérogènes.
• Ses éléments sont séparés par des virgules, et entourés de
parenthèses.
Exemples
• Exemples : mon_tuple = (’a’, 2, [1, 3])
mon_tuple[1] #2
t = 123, 456, ‘hello’
Les types séquentiels de données : chaines de caractères, les
listes et les tuples,
Les données qui sont organisées sous la forme de séquence
de caractères ou de valeurs.
Les dictionnaires
• Un dictionnaire est une collection de couples cle : valeur entourée
d’accolades.
• Les dictionnaires constituent un type composite mais ils
n’appartiennent pas aux séquences.
Exemples
• Un dictionnaire vide :
d1 = {} ou d1 = dict()
• Ajout des élements un à un
d1['nom'] = 'Fati'
d1['taille'] = 176
print(d1) # {”nom”: ‘Fati’, ”taille”: 176}
• Définition en extension
d2 = {'a' : 1, 'b' : 2, 'c' : None }
• Utilisation de paramètres nommés
d3 = dict(nom=3, taille=176)
• Utilisation d’une liste de couples clés/valeurs
d4 = dict([(”nom”, 3), (”taille”, 176)])
• Définition en compréhension
d5 = {x: x**2 for x in (2, 4, 6)}
Les dictionnaires
• Un dictionnaire est une collection de couples cle : valeur entourée
d’accolades.
• Les dictionnaires sont modifiables, mais les couples enregistrés
n’occupent pas un ordre immuable;
• Une clé pourra être de tout type excepté les listes et les dictionnaires.
• Les valeurs pourront être de n’importe quel type: valeurs numériques,
séquences, dictionnaires, mais aussi des fonctions, des classes ou des
instances.
Les ensembles
• Un ensemble est une collection itérable non ordonnée d’éléments
hachables distincts.
• Pour créer un ensemble, on utilise une paire d’accolades { } en plaçant
les différents éléments de l’ensemble entre ces accolades et en les
séparant avec une virgule ou à l’aide du mot clé set.
Exemples
• X, Y = set(’abcd’), set(’sbds’)
• print(”X =”, X) # X = {’a’, ’c’, ’b’, ’d’}
• print(”Y =”, Y) # Y = {’s’, ’b’, ’d’} : un seul élément ’s’
• print(’c’ in X) # True
• print(’a’ in Y) # False
• print(X - Y) # {’a’, ’c’}
• print(Y - X) # {’s’}
• print(X | Y) # {’a’, ’c’, ’b’, ’d’, ’s’} (Union )
• print(X & Y) # {’b’, ’d’} (Intersection)
Les ensembles
• Un ensemble est une collection itérable non ordonnée d’éléments
hachables distincts.
Remarques
• Les ensembles ou sets forment un autre type de données composites
Python.
• Un ensemble est une collection d’éléments non ordonnée, sans index et
qui ne peut pas posséder l’élément dupliqué.
• Une des utilisations les plus courantes des ensembles est de les utiliser
pour supprimer des valeurs doublons à partir d’un autre type de
données.
Structures de contrôle et itérations
Instruction conditionnelle
Instruction « if …elif… else »
Syntaxe :
if « condition 1 » :
sequence
elif « condition 2 » :
sequence
else :
sequence
Exemple
a = float(input("le nombre a : "))
if a > 0 :
print(‘ Le nombre est positif’)
elif a < 0 :
print(‘Le nombre est négatif’)
else :
print(‘le nombre est nul’)
Itérations
Instruction « while … »
Syntaxe
while « condition » :
sequence
Exemple
i=0
while i < 5:
print("i = {}".format(i))
i=i+1
print("Fin de la boucle avec i = {}".format(i))
Itérations
Boucle « for … »
Syntaxe
for item in items :
sequence
1. Exemple 1 de boucle for :
for x in [0, 1, 2 ,3]:
print("x = {}".format(x))
2. Exemple 2 de boucle for avec range :
for x in range(4):
print("x = {}".format(x))
3. Exemple 3 de boucle for :
for word in ["calcul","scientifique","en","python"]:
print(word)
Exercices : voir notebook
Exercices
1. Créer une liste L1 des entiers naturels pairs inférieurs ou
égaux à 50.
2. Créer une liste L2 des racines carrées des éléments de L1
Chapitre 2: Fonctions et Modules
I. Fonctions
I. 1. Définition et Syntaxe
I. 2. Passage de paramètres
I. 3. Fonctions récursives
I. 4. Fonction lambda
Définition et Syntaxe
Une fonction correspond à un ensemble d’instructions créées pour
effectuer une tâche précise, regroupées ensemble et exécutables à
l’aide d’un appel.
On distingue deux grands types de fonctions
1. Les fonctions prédéfinies
Exemples : print(), type(), input(), len(), etc.
2. Les fonctions définies par l’utilisateur
La syntaxe de définition est :
def nom_function (parametres_eventuels):
sequence
return resultat
Définition et Syntaxe
def nom_function (parametres_eventuels):
sequence
return resultat
Exemple :
def square(number):
return number**2
Le mot clé return termine l’execution d’une fonction.
Une fonction peut ne pas avoir de return: c’est le cas des
procédures. Dans ce cas, l'indentation permet d'identifier la fin de
la fonction
def example_b():
print('example_a is running')
print('returning value "a"')
Le passage des paramètres
Paramètres par défaut
Utiliser des valeurs par défaut pour les paramètres de fonctions permet
aux utilisateurs d’appeler cette fonction en passant en omettant de passer
les arguments relatifs aux paramètres possédant des valeurs par défaut.
def difference(a=10, b) :
return a-b
Appel : difference(5) --------- # 5
mais difference(20,6)------- # 14
Le passage des paramètres non définis
La syntaxe *args permet d’indiquer lors de la définition d’une fonction
qu’elle peut accepter un nombre variable d’arguments
Exemple
def somme(*args):
s=0
for n in args :
s+= n
print(‘la somme est:’, s)
Appel : somme(2,5) --- ----# 7
somme(4, 7, 8) ----- # 19
Le passage des paramètres non définis
La syntaxe **kwargs permet d’indiquer lors de la définition d’une fonction
qu’elle peut accepter un nombre variable d’arguments mais comme
dictionnaire.
Exemple
def pres (**kwargs):
for i, j in kwargs.items() :
print(i, j)
Appel : pres(prenom = ‘Pierre ’, age = 27, sexe = ‘Masculin’)
Retour de plusieurs valeurs
Il est possible de retourner plusieurs valeurs à l’issue de l’exécution d’une
fonction en Python.
Pour cela, on utilise return en séparant les valeurs retournées par une
virgule.
Exemple
def ordre(a,b):
if a < b :
return a, b
else:
return b, a
Appel : ordre(20,50) -------- # (20,50)
ordre(15,3) ----------# (3,15)
Fonctions récursives
Les fonctions récursives s’appellent elles-mêmes.
Exemple
def factoriel(n):
if n < = 1 :
return 1
else:
return n* factoriel(n-1)
Appel : factoriel(0) -------- # 1
factoriel(3) --------- # 6
Variables globales et variables locales
• En Python, une variable peut avoir une portée locale ou une portée
globale.
• Les variables définies dans une fonction sont locales : elles ne sont
utilisées qu’à l’intérieur de la fonction
Exemple
def portee_locale() :
x = 10
print(x)
Appel: portee_locale() --------------# 10
Mais print(x) ---------------------# Erreur
Les variables définies en dehors de toute fonction sont:
o appelées des variables globales
o utilisables à travers l’ensemble du script
o accessibles en lecture à l’intérieur des fonctions et nécessitent le mot
clé global pour modifications.
Quelques fonctions utiles
input() : permet de dialoguer et d’échanger des données avec l’utilisateur.
On va pouvoir passer un message en argument de cette fonction.
Exemple :
prenom = input(‘Rentrez votre prénom : ’)
dir() : 1- utilisée sans argument, renvoie la liste des variables et des
fonctions (ou plus exactement des objets et des méthodes) disponibles dans
l’espace de portée courant.
2- Avec une donnée en argument, elle renverra la liste des méthodes
disponibles pour ce type de donnée.
len() : donne la longueur de l’objet passé en paramètre.
type() : livre le type de l’objet passé en paramètre.
Quelques fonctions utiles
Les fonctions de conversion
Elles permettent de modifier le type de certaines variables, c’est-à-dire de
les “convertir”.
Ces fonctions portent le nom du type de donnée souhaitée : str(); int(),
float(), complex(), bool(); tuple(), list(), dict(), set().
Exemples :
list(‘Paul’)-----------# [‘P’, ‘a’, ‘u’, ‘l’]
float(’20’) -----------# 20.0
bool(‘False’) -------# True
bool(False) -------# False
Les fonctions mathématiques
Les plus courantes sont : range(), round(), sum(), min(), max()
range() : génère une suite de nombres paramètres
range(n) = 0,1,2,...n-1 range(n,m) = n, n+1,..., m-1
range(n,m,p) : n, n+p, n+2p, ... (avec une valeur maximale = m)
round() : arrondit à l’entier le plus proche avec un degré de précision (un
II - Modules Python
II. Introduction
II. 1. Définition
II. 2. Création de modules
II. 3. Importation de modules
II. 4. Modules standards
Définition
On appelle module, tout fichier constitué de code
Python importé dans un autre fichier ou script.
Les modules permettent la séparation et donc une
meilleure organisation du code.
En Python, on peut distingue selon leur éditeur :
o Les modules standards qui ne font pas partie du
langage en soi mais sont intégrés
automatiquement par Python ;
o Les modules développés par des développeurs
externes qu’on va pouvoir utiliser ;
o Les modules qu’on va développer nous mêmes.
Importation de module
Pour utiliser un module, on doit l’importer dans le
script.
Syntaxe : import nom_du_module
Exemple : import math
Pour utiliser les éléments du module dans notre
script, il faudra préfixer le nom de ces éléments par
le nom du module et un point.
Exemple : math.sqrt(25)
On peut créer un alias pour un nom de module à
l’aide du mot clé as.
Exemple : import pandas as pd
Importation de module
On peut importer uniquement certains éléments du
module.
Syntaxe : from nom_du_module import un_element
Dans ce cas, il ne faudra pas ensuite préfixer le nom
des éléments par le nom du module pour les utiliser
dans notre script principal.
Exemple : from math import sqrt
sqrt(25)
Pour obtenir la liste des éléments d’un module :dir()
Syntaxe : dir(nom_du_module)
Les modules Python Standard
Ce sont les modules préconçus et prêts à l’emploi qui sont
fournis d’office avec Python.
Les modules Python standards à connaitre sont les suivants :
o cgi (Common Gateway Interface) fournit des éléments
permettant à des programmes Python de s’exécuter sur
des serveurs HTTP ;
o datetime fournit des classes pour manipuler de façon
simple ou plus complexe des dates et des heures ;
o json permet l’encodage et le décodage de données au
format JSON ;
o math fournit un ensemble de fonctions permettant de
réaliser des calculs mathématiques complexes ;
o os fournit une manière portable d’utiliser les
fonctionnalités dépendantes du système d’exploitation ;
o pickle permet de sérialiser des objets Python ;
Les modules Python Standard
Ce sont les modules préconçus et prêts à l’emploi qui sont
fournis d’office avec Python.
Les modules Python standards à connaitre sont les suivants :
o random implémente des générateurs de nombres pseudo-
aléatoires pour différentes distributions ;
o re fournit des opérations sur les expressions rationnelles;
o socket fournit un accès à l’interface sockets qui correspond
à un ensemble normalisé de fonctions de communication ;
o sys fournit un accès à certaines variables système utilisées
et maintenues par l’interpréteur, et à des fonctions
interagissant fortement avec ce dernier ;
o urllib.request et urllib.parse permettent d’ouvrir, de lire et
d’analyser des URLs.
Création d’un module
Elle consiste à créer un script Python.
Exemple :
1. Créer un fichier `bonjour.py` (dans le dossier de
référence de Python) contenant :
def disbonjour(nom):
print(nom, ‘vous dit bonjour!’)
2. On va importer notre module dans l’invite de
commande grâce à l’instruction import bonjour.
3. On peut donc accéder aux éléments du module
bonjour.disbonjour()
Remarque : le dossier _pycache_ contenant un fichier de
cache permet d’optimiser les prochaines exécutions
III. Modules pour la science des données
III. 1. Numpy
III. 2. Pandas
III. 3. Matplotlib
Les modules pour la science des données
Le module Numpy :
La structure de données de base dans NumPy est le
ndarray ou tableau à n dimensions.
En programmation, array décrit une collection
d'éléments, semblable à une liste.
Les ndarrays peuvent avoir une ou plusieurs
dimensions.
Nous allons commencer par travailler en dimension
1.
Importation du module Numpy
NumPy est généralement importé en utilisant
l'alias np:
import Numpy as np
La conversion d’une liste en ndarray se fait en
utilisant le constructeur numpy.array().
Pour créer un ndarray 1D, nous pouvons passer
dans une seule liste.
Exemple :
data_ndarray = np.array([5, 10, 15, 20])
Vectorisation dans Numpy
Il est possible de remplacer la boucle for par des
opérations appliquées à plusieurs données à la fois.
Il s’agit du principe de la vectorisation.
Exemple : Somme de vecteurs
Une méthode consiste à utiliser une liste de listes :
Vectorisation dans Numpy
Exemple : Somme de vecteurs
Le calcul séquentiel:
Vectorisation dans Numpy
Séquentiel:
Vectorisation
Importation du module Numpy
Numpy en dimension 2:
data_ndarray = np.array([[5, 10, 15],
[20, 25, 30]])
L'attribut shape nous permet d'obtenir la taille de
l’objet (la matrice).
print(data_ndarray.shape)
Cet attribut livre un tuple constitué du nombre de
lignes et celui de colonnes.
Sélection d’éléments Numpy
Pour la sélection d’une ligne
Méthode de liste de listes Méthode Numpy
sel_lol = data_lol[1] sel_np = data_np[1]
Pour la sélection de plusieurs lignes
sel_lol = data_lol[2:] sel_np = data_np[2:]
Pour la sélection d’un seul élément
sel_lol = data_lol[1][3] sel_np = data_np[1,3]
Sélection d’éléments Numpy
Pour la sélection d’une colonne
Méthode de liste de listes Méthode Numpy
sel_lol =[]
for row in data_lol:
sel_np = data_np[:,3]
col4 = row[3]
sel_lol.append(col4)
Pour la sélection de plusieurs colonnes
Méthode de liste de listes Méthode Numpy
sel_lol = []
for row in data_lol: sel_np = data_np[:,1:3]
col23 = row[1:3]
sel_lol.append(col23)
Sélection d’éléments Numpy
Pour la sélection de plusieurs colonnes spécifiques
Méthode de liste de listes Méthode Numpy
sel_lol =[] cols= [1,3,4]
for row in data_lol:
sel_np = data_np[:,cols]
cols = [row[1],row[3],row[4]]
sel_lol.append(cols)
Exercice : Sélectionner avec les deux méthodes les
cellules ci-dessous
Solution
Sélection de cellules ci-dessous
sel_lol =[]
rows =data_lol[1:] sel_lol =[]
sel_lol =data_lol[2][1:4]
rows =data_lol[1:4]
for row in rows: for row in rows:
col5 = row[4] new_row = row[:3]
sel_lol.append(col5) sel_lol.append(new_row)
sel_np = data_np[2,1:4] sel_np = data_np[1:,4] sel_np = data_np[1:4,:3]
Fonctions et méthodes de Numpy
Les objets numpy disposent de certaines méthodes:
min(), max(), mean(), sum(), etc.
Syntaxe : ndarray.nom_method()
Dans Numpy, il existe des fonctions qui sont à la
fois des méthodes,
Exemples :
Fonction : np.min(objet_numpy)
Méthode : objet_numpy.min()
II. 2. Module pandas
Limites de Numpy
NumPy fournit des structures et des outils
fondamentaux qui facilitent le travail avec les
données
Numpy présente des limites:
o manque de prise en compte des noms de variables
o prise en compte d'un seul type de données par
ndarray (ne peut manipuler à la fois des données
numériques et des chaînes).
Pandas, extension de NumPy, fournit des solutions
à tous ces problèmes et plus encore !
Module pandas
La structure de données principale pandas est
appelée un dataframe.
Les dataframes sont l'équivalent pandas d'un
ndarray Numpy 2D, avec quelques différences clés:
o les valeurs d'axe peuvent avoir des étiquettes de
chaîne, pas seulement des étiquettes numériques.
o les dataframes peuvent contenir des colonnes avec
plusieurs types de données: nombre entier,
flottant et chaîne.
Importation de Pandas
import pandas as pd
Pandas manipule les Series et DataFrames pour
structurer les données et les préparer à diverses
actions analytiques.
Ces deux structures de données sont l’épine dorsale
de Pandas.
Beaucoup de similitude avec les bases de données
relationnelles.
Pandas Series
Les Series structurent des ensembles de données
simples et unidimensionnels en associant chaque
élément de données à une étiquette unique.
Une série se compose de deux tableaux :
o le tableau principal qui contient les données
o le tableau d'index qui contient les étiquettes
appariées.
Exemple
s = pd.Series([10.8,10.7,10.3,7.4,0.25],
index = ['VW','Toyota','Renault','KIA','Tesla‘])
Pandas dataframes
Le DataFrame introduit une nouvelle dimension dans la
structure de données Series.
Pandas dataframes
En plus du tableau d'index, un ensemble de colonnes
strictement organisé fournit aux DataFrames une structure
de type table.
Chaque colonne peut stocker un type de données différent.
Exemple
data = {
'Company':['VW','Toyota','Renault','KIA','Tesla'],
'Cars Sold (millions)' : [10.8,10.7,10.3,7.4,0.25],
'Best Selling Model' : ['Golf','RAV4','Clio','Forte','Model 3']
}
Frame = pd.DataFrame(data)
La structure DataFrame permet de sélectionner et de filtrer
les valeurs en fonction des colonnes et des lignes.
Manipulation des fichiers dans Pandas
Pandas introduit un ensemble de fonctions pour manipuler
des fichiers.
Syntaxe :
Importation des données d’autres formats dans Pandas.
pd.read_filetype = (filename or path)
Exportation des données de Pandas dans d’autres formats.
df.to_filetype = (filename or path)
Read Write
pd.read_csv (‘filename.csv’) df.to_csv (‘filename or path’)
pd.read_excel (‘filename.xlsx’) df.to_excel (‘filename or path’)
pd.read_json (‘filename.json’) df.to_json (‘filename or path’)
pd.read_html (‘filename.htm’) df.to_html (‘filename or path’)
pd.read_sql (‘tablename’) df.to_sql (‘DB Name’)
Sélection dans pandas
La syntaxe générale de sélection dans Pandas est :
df.loc[row_label, column_label]
Sélection d’une colonne Sélection d’une ligne
single_col = df["D"] single_row = df.loc["v"]
single_col = df.loc[:, "D"]
Sélection dans pandas
La syntaxe générale de sélection dans Pandas est :
df.loc[row_label, column_label]
Sélection de plusieurs colonnes Sélection de ++ lignes
mult_cols = df[["A","C", "D"]] mult_rows = df.loc[["v", "w", "x"]]
Récapitulatif de la Sélection dans pandas
Selection par étiquette Syntaxe explicite Raccourci syntaxique
Colonne simple du dataframe df.loc[:,"col1"] df["col1"]
Liste de colonnes du dataframe df.loc[:,["col1", "col7"]] df[["col1", "col7"]]
Sous-ens de colonnes du dataframe df.loc[:,"col1":"col4"]
Ligne simple du dataframe df.loc["row4"]
Liste de lignes du dataframe df.loc[["row1", "row8"]]
Sous-ens de lignes du dataframe df.loc["row3":"row5"] df["row3":"row5"]
Un Seul élément de la série s.loc["item8"] s["item8"]
Liste d'éléments de la série s.loc[["item1","item7"]] s[["item1","item7"]]
Sous ensemble d'éléments de la série s.loc["item2":"item4"] s["item2":"item4"]
Indexation booléenne dans pandas
L’indexation booléenne fonctionne également dans Pandas
Exemple : Soit le dataframe ci-dessous contenant des noms
et des numéros préférés
On s’intéresse aux personnes dont le numéro préféré est 8.
Indexation booléenne dans pandas
L’indexation booléenne fonctionne également dans Pandas
Exemple : Soit le data frame ci-dessous contenant des noms
et des numéros préférés
On s’intéresse aux personnes dont le numéro préféré est 8.
num_bool = df [‘num’] == 8
result = df [num_bool]
Indexation booléenne dans pandas
L’utilisation de .loc
result = df.loc[num_bool, ‘name’]
Indexation booléenne dans pandas
L’utilisation de dataframe.iloc permet de sélectionner en
utilisant les entiers.
Syntaxe : df.iloc[row_index, column_index]
Récapitulatif de la Sélection dans pandas avec iloc
Selection par étiquette Syntaxe explicite Raccourci syntaxique
Colonne simple du dataframe df.iloc[:,3]
Liste de colonnes du dataframe df.iloc[:,[3,5,6]]
Sous-ens de colonnes du dataframe df.iloc[:,3:7]
Ligne simple du dataframe df.iloc[20]
Liste de lignes du dataframe df.iloc[0,3,8]
Sous-ens de lignes du dataframe df.iloc[3:5] df[3:5]
Un Seul élément de la série s.iloc[8] s[8]
Liste d'éléments de la série s.iloc[[2,8,1]] s[[2,8,1]]
Sous ensemble d'éléments de la série s.iloc[2:5] s[2:5]
Gestion des fichiers sous Pandas
Lecture de fichier :
Exemple:
import pandas as pd
f500 = pd.read_csv('f500.csv',index_col=0)
f500.index.name = None
Comme les ndarrays de NumPy, les dataframes ont un
attribut .shape qui renvoie un tuple représentant les
dimensions de chaque axe de l'objet.
Nous utiliserons cela et la fonction type() de Python pour
explorer le dataframe f500.
Méthodes : df.head(), df.tail(), df.info(), df.describe()
II. 3. Module matplotlib
Matplotlib
• Matplotlib est une bibliothèque du langage de
programmation Python destinée à tracer et visualiser des
données sous formes de graphiques, tels que: plots, bar
charts, scatter-plots, etc.
• Pour installer matplotlib :
pip install matplotlib
• Site de référence: matplotlib.org
85
Premier plot
import numpy as np
from matplotlib import pyplot as plt
# importer les outils pour tracer des courbes
# affiche les graphiques dans le notebook
%matplotlib inline
# Exemple de fonction quadratique
x = np.linspace(-1.0,1.0,num=100)
squares = [val ** 2 for val in x]
plt.plot(x,squares)
86
Mise en forme d’un graphique
Titre, nom des axes, limites
import numpy as np
from matplotlib import pyplot as plt
%matplotlib inline
x = np.linspace(-1.0,1.0,num=100)
squares = [val ** 2 for val in x]
linfunc = [1 - abs(val) for val in x]
plt.title('Titre du graphique’)
plt.xlabel('Abscisse’)
plt.ylabel('Coordonnée’)
plt.xlim(-1.2,1.2)
plt.ylim(-0.2,1.2)
plt.plot(x,squares)
plt.plot(x,linfunc)
plt.legend('ab’)
plt.grid()
87
Multiples courbes
Pour visualiser différents tendances ou des fonctions d’une même variable, p.ex. f(t)=t,
g(t)=t2, h(t)=t3, j(t)=30t, etc.
# x axis data
t = np.arange(0., 5., 0.2)
# red dashes, blue squares, green triangles, yellow line
plt.plot(t, t, 'r--’,)
plt.plot(t, t**2, 'bs’)
plt.plot( t, t**3, 'g^’)
plt.plot( t, 30*t, 'y’)
plt.xlabel('x value’)
plt.ylabel('y value’)
plt.ylim(-5,100)
88
Sub - plots
L’utilisation de sub-plots facilite la comparaison et l’analyse des résultats
x = np.linspace(0, 2 * np.pi, 360)
y = np.sin(x ** 2)
fig, axs = plt.subplots(2)
fig.suptitle('Vertically stacked subplots’)
axs[0].plot(x, y)
axs[1].plot(x, -2*y)
89
Sub - plots
L’utilisation de sub-plots facilite la comparaison et l’analyse des résultats
x = np.linspace(0, 2 * np.pi, 360)
y = np.sin(x ** 2)
fig, axs = plt.subplots(1,2, sharey = True)
fig.suptitle(‘Horizontally stacked subplots’)
axs[0].plot(x, y)
axs[1].plot(x, -2*y)
90
Echelle logarithmique
# x axis data
t = np.arange(0., 10., 0.5)
# red dashes, blue squares, green triangles, yellow line
plt.plot(t, t**2, 'b’)
plt.plot( t, np.exp(t), 'r’)
plt.xlabel('x value’)
plt.ylabel('y value (log scale)’)
plt.yscale(‘log’)
Plt.grid()
TPE : Laquelle des courbes
est la function exponentielle
? 91
Bar - graph
§ facilite la comparaison des valeurs associées à divers groupes
ou classes, surtout si ces différences ne sont pas trop petites.
§ permet aussi de comparer des valeurs à différents moments.
pays = ['USA','DE','UK','CA’]
obesity = [30,16,20,18]
x = np.arange(len(pays))
plt.bar(x, obesity)
plt.xticks(x,pays)
plt.title('Obesity prevalence’)
plt.xlabel('Country’)
plt.ylabel('Population percentage')
92
Scatter plot
Ou X-Y plot, il permet de déterminer la relation entre deux
variables. P.ex., si les deux augmentent en même temps, on peut
dire qu’elles sont positivement correlées.
temp = [14.2, 16.4, 11.9, 15.2, 18.5, 22.1, 19.4, 25.1, 23.4,
18.1, 22.6, 17.2]
vente_glace = [215, 325, 185, 332, 406,522, 412, 614, 544,
421, 445,408]
plt.scatter(temp,vente_glace)
plt.ylim(0,750)
plt.xlabel('Temperature à midi (degrées)') plt.ylabel('Total
des ventes’)
plt.title('Vente de glace en fonction de la ' 'temperature de
la journée')
93
Exportation de graphique
• Exporter les résultats pour documenter ou créer un
rapport.
import numpy as np
from matplotlib import pyplot as plt
%matplotlib inline
a = [1,3,5,3] # plotting the curves for
b = [1,5,7,4] # different values of a/b
delta = np.pi/2
t = np.linspace(-np.pi,np.pi,300)
for i in range(0,4):
x = np.sin(a[i] * t + delta)
y = np.sin(b[i] * t)
plt.subplot(2,2,i+1)
plt.plot(x,y)
plt.suptitle('Courbes de Lissajous’)
plt.savefig('Lissajous.png')
94
Gestion des axes
xlabel(): accepte une valeur de chaîne, qui est définie comme
étiquette de l'axe des x.
ylabel(): accepte une valeur de chaîne, qui est définie comme
étiquette de l'axe y.
title(): accepte une valeur de chaîne, qui est définie comme
titre du tracé.
plt.plot(first_twelve['DATE'], first_twelve['VALUE'])
plt.xticks(rotation=90)
plt.xlabel('Month')
plt.ylabel('Unemployment Rate')
plt.title('Monthly Unemployment Trends, 1948')
plt.show()
Chapitre 3: Gestion des fichiers et des exceptions
Gestion des fichiers
Python permet de manipuler les fichiers.
Il existe différents modes d’ouverture des fichiers :
r : en lecture seule
w : en écriture avec remplacement
a : écriture avec ajout en fin de fichier
x : lecture et écriture
r+ : lecture et écriture dans un même fichier
Exemple : Créer un fichier ‘donnees.txt’ contenant 5 lignes
fic = open(‘donnees.txt’, ‘r’)
fic.close()
if fic.closed :
print(‘Fichier est fermé’)
else:
print(‘Fichier encore ouvert’)
Les méthodes read(), readline() et readlines()
La lecture des fichiers peut se faire de plusieurs façons:
read() : permet de faire une lecture « en bloc »
fic = open(‘donnees.txt’, ‘r’)
content = fic.read()
print(content)
fic.close()
readline() : permet de faire une lecture une ligne à la fois
fic = open(‘donnees.txt’, ‘r’)
line = fic.readline()
print(line)
line = fic.readline()
print(line)
fic.close()
Les méthodes read(), readline() et readlines()
La lecture des fichiers peut se faire de
plusieurs façons:
readlines() : permet de faire une lecture de
plusieurs lignes
fic = open(‘donnees.txt’, ‘r’)
lines = fic.readlines()
print(lines)
fic.close()
Utilisation de with … as
L’ouverture des fichiers peut se faire à l’aide
de with … as.
Dans ce cas, il n’est plus nécessaire d’utiliser
la fonction close().
with open(‘donnees.txt’, ‘r’) as fic:
content= fic.read()
print(content)
Ecriture dans un fichier
L’ouverture des fichiers fait à l’aide de with
… as.
Pour l ’écriture, on utilise le paramètre ’w’.
with open(‘donnees.txt’, ‘w’) as fic:
nombre = 15
fic.write(str(nombre))
fic.write(‘\n Bonjour, chers tous!\n’)
fic.write(‘ Et bon séjour ici!\n’)
Exceptions en Python
Python permet de gérer les erreurs (exceptions):
La syntaxe est : try … except (+ else, finally)
Exemple:
age = input(‘quel âge as-tu?’)
try :
age = int(age)
except:
print(‘L’âge indiqué est incorrect’)
else :
print(‘Tu as’, age, ‘ans’)
finally:
print(‘Fin de programme’)
Types d’exceptions en Python
Il existe différents types d’exceptions:
ValueError, nameError, typeError, ZeroDivisionError, OSError,
AssertionError
Exemple:
Nombre1 = 150
Nombre2 = input(‘Faites entrer le second ’)
try :
Nombre2 = int(Nombre2)
Print(‘Resultat ={ }’. Format(Nombre1/Nombre2))
except ZeroDivisionError :
print(‘Vous ne pouvez pas diviser par zéro’)
except ValueError :
print(‘Vous devez faire entrer un nombre’)
except :
print(‘Valeur incorrecte’)
finally:
