Programmation orientée Objet

Auteur : Nahla Zaaboub Haddar

Auditoire : Première Année Mastère SINT
Laboratoire : MIRACL
Année univ. : 2020-2021

1
Plan du cours

 Introduction
 Rappel des bases du language Python
 Programmation objet
 Structures de données
 Visualisation de données
 Extraction et filtrage de données

2
INTRODUCTION

3
Qu’est ce que le calcul scientifique ?

 Le calcul scientifique est l'utilisation de l‘ordinateur (la

calculatrice) et des langages de programmation pour résoudre un
problème numérique

 Les problèmes à résoudre sont souvent mathématiques

 La résolution consiste à :

 Développer un algorithme pour traiter le problème

 Implémenter l’algorithme pour le calcul
 Effectuer la simulation numérique en produisant des données
 Valider le comportement de la méthode et les résultats obtenus
 Analyser les performances du calcul
 Analyser et visualiser les résultats
4
 Le calcul scientifique repose sur l'utilisation de scalaires, de
vecteurs et de matrices et de tout outil mathématique qui leur est
associé (produit, transposé, extremum, etc.)

5
 Plusieurs langages et outils de programmations
peuvent être mis en œuvre pour le calcul scientifique :
 Python

 Java

 MatLab

 Meaple

 …

6
RAPPEL DES BASES DU
LANGAGE PYTHON

7
Qu’est ce que Python ?

 Python est un langage de

programmation inventé en
1991 par Guido van Rossum

 Il est source libre

 Il est un langage objet

interprété, multi-paradigmes et
multi-plateformes

 Il est doté de typage

dynamique fort + gestion
automatique de la mémoire par
ramasse-miettes + système de
gestion d'exceptions
8
 Il possède de nombreuses
bibliothèques optimisées destinées
au calcul numérique (numpy, scipy,
pandas, mathplotlib, pyml, etc.).

 Il permet le travail en mode

interactif ou fichier.

9
Environnements de développement avec
Python

 Python : IDLE
 Anaconda:JupyterNote
book
 PyCharm
 Spyder (Scientific
Python
DevelopmentEnvironme
nt)
 Eclipse+pluginPyDev
 Atom
 …
10
Popularité du langage python

Les top 10 des langages de programmation

(IndexTIOBE, juin 2020)
11
 Popularité du langage python

 Les top 5 des spécialistes Python

 Reddit

 Spotify

 Youtube

 Dropbox

12
Accents

Le langage Python s’appuie sur la langue anglaise et il faut lui préciser

explicitement lorsque le programme contient des accents. Le message
suivant indique que c’est le cas :
SyntaxError: Non-ASCII character ’\xe9’ in file pl.py on line 7, but no encoding
declared; see http://www.python.org/peps/pep-0263.html for details

Il faut ajouter en première ligne du programme :

# coding: latin-1

Ou pour insérer tout caractère, latin ou asiatique :

# coding: utf-8

13
Commentaires

 Tout ce qui suit # ou entre "' "' est ignoré (ou presque)
par Python
 # pour un commentaire sur une seule ligne
 "' "' pour un commentaire sur plusieurs lignes

 Les commentaires servent à

 expliquer ce qui se passe dans une portion de code
 documenter qui a écrit le code ou d’autres informations
 désactiver une ligne de code (peut-être temporairement)

14
Mots-clés

and del from not while

as elif global or with
assert else if pass yield
break except import class exec
in raise continue finally is
isinstance return def for lambda
try

15
Variables

Une variable est caractérisée par :

 un identificateur : il peut contenir des lettres, des chiffres, des
blancs soulignés mais il ne peut commencer par un chiffre.
Minuscules et majuscules sont différenciées. Il est aussi unique.
 un type : c’est une information sur le contenu de la variable qui
indique à l’interpréteur Python la manière de manipuler cette
information.
 Convention de nommage (PEP 20) : var ma_variable
print ( )
La fonction print () permet d’afficher le contenu de n’importe quelle variable

va = 10
print(va) # affiche le contenu de la variable va
16
Types numériques et opérations
arithmétiques
 Types numériques :
 int : type entier, compris entre 2 milliards

 float : type réel, environ 15 chiffres de précision (Il est

possible d’augmenter la précision en utilisant gmpy).

 Opérations arithmétiques :
+ Addition * Multiplication / Division

- Soustraction ** Puissance // Division entière

% Modulo

17
 Il est préférable d’écrire des opérations sur le même type. Dans le
cas contraire, le type float l’emporte sur le type int.

x1 = 5.5
x2 = 6
y1 = 3.3
y2 = 7
d = ((x1-x2)**2 + (y1-y2)**2) ** 0.5 # distance euclidienne
q = 5/3 # q vaut 1.6666666666666667
q = 5//3 # q vaut 1
r = 5%3 # r vaut 2
n=5
n += 10 # n vaut 15
18
Instructions conditionnelles

 Les instructions conditionnelles permettent de faire

dépendre une séquence d’instructions d’une condition.
 Les instructions concernées doivent être décalées
(indentées) par rapport aux mots-clés if et else.
 La condition est évaluée à l’une des valeurs True ou
False.

if <condition> :
… # instructions si la condition est vraie (ligne indentée)
else :
… # instructions si la condition est fausse (ligne indentée)

19
 Il est possible d’assembler les conditions avec les
opérateurs logiques and, or et not.
 Les opérateurs de comparaisons ou d’appartenance
sont ==, !=, <, >, <=, >=, in.
 Il est possible d’imbriquer plusieurs tests à l’aide du
mot-clé elif
if a > b :
 Exemples : print(a)
if x > 0 : a=0 elif a< b:
y = log (x) if (y == 1 or x == 2) : print(b)
else : a = max(x,y ) else :
y = log(-x) print(0)
20
Boucle for

 La boucle for parcourt les éléments d’une séquence

(liste, tuple, …).
 Elle répète une séquence d’instructions autant de fois
que le nombre d’élément dans la liste.
for <element> in <sequence> :
… # instructions à répéter (ligne indentée)

 Exemple :
for i in [1,2,3,4,5]:
print(i**2)

21
Boucle for

 La boucle for la plus couramment utilisée est celle qui

parcourt une liste d’entiers.
 Elle utilise la fonction range( ) :
 range(b) énumère les entiers 0,1,2, …,b-1
 range(a,b) énumère les entiers a,a+1, …, b-1
 range(a,b,c) énumère les entiers a, a+c, a+2c, …, a+nc où n
est le plus grand entier vérifiant a +nc < b si c est positif et a +nc
> b si c est négatif.
 Exemple :
for x in range (2, 5) :
print(x , x**2)
22
break et continue

 break et continue sont deux instructions qui viennent

perturber le déroulement d’une boucle.
 L’instruction break arrête la boucle à l’endroit même où
elle est exécutée.
 L’instruction continue passe directement à l’itération
suivante sans exécuter les lignes suivantes.
m = [ 5, 6, 3, 6, 7] m = [ 0, 5, 6, 3, 6, 7]
for v in m : s=1
if (v%3)==0 : for e in m :
print(v) if e == 0 :
break continue
s *= e
23
Boucle while

 Une boucle while exécute une suite d’instructions tant

qu’une certaine condition est vraie.
while <condition> :
… # instructions à répéter (ligne indentée)

 Exemple :
x = 10
while x > 0 :
print(x)
x -= 1
24
Chaînes de caractères

On utilise les chaînes de caractères pour représenter

toutes les informations qui ne sont pas numériques (du
texte le plus souvent). Elles apparaissent entre guillemets
simples ou doubles.
 Opérations
Des opérations sont disponibles + et *
s = ’abc’ + ’def’ # s vaut ’abcdef’
s = ’abc’ * 3 # s vaut ’abcabcabc’
s+= ‘d’ # s vaut ’abcabcabcd’

25
Manipulation des chaînes de caractères

 Fonctions de chaînes de caractères :

s = "programmation objet"
n = len (s) # n vaut 19, la longueur de s
t = s.lower() # t vaut "programmation objet", minuscules
t = s.upper() # t vaut "PROGRAMMATION OBJET",
# majuscules
liste = s.split(sep=" ") # découpe s en utilisant " " comme séparateur.
# liste vaut ["programmation", "objet"]
t = s.replace ("a", "_") # remplace toutes les occurrences de "a" par "_"
# t vaut "progr_mm_tion objet"
n = s.find ("a") # retourne la position de la première occurrence de
# "a" dans s, -1 si "a" n’est pas trouvé. n vaut 5
26
Manipulation des chaînes de caractères

 Les chaînes de caractères peuvent être indexées (i.e.

on peut accéder aux caractères par leur position)
 le premier caractère d’une chaîne étant à la position 0
 Il n’existe pas de type distinct pour les caractères, un
caractère est simplement une chaîne de longueur 1

word = 'Python'
s = word[0] # s vaut 'P'
s = word[5] # s vaut 'n‘
s = word[-1] # dernier caractère. s vaut 'n‘
s = word[-2] # avant dernier caractère. s vaut 'o'

27
Manipulation des chaînes de caractères

 Il est aussi possible de « trancher » (slice en anglais)

une chaîne.
 Accéder à une chaîne par un indice permet d’obtenir un
caractère, trancher permet d’obtenir une sous-chaîne
s = word[2:5] # caractères à partir de la position 2 (incluse) à 5 (exclue)
# s vaut 'tho'
 Les valeurs par défaut des indices de tranches sont :
 le premier indice vaut zéro par défaut (i.e. lorsqu’il est omis),
 le deuxième correspond par défaut à la taille de la chaîne de
caractères :
s = word[:2] # du début jusqu’à la position 2 (exclue). s vaut 'Py'
s = word[4:] # de la position 4 (incluse) jusqu’à la fin. s vaut 'on'
s = word[-2:] # de l’avant dernière position jusqu’à la fin. s vaut 'on' 28
Caractères spéciaux

 Certains caractères sont invisibles dans un éditeur de

texte même si leur usage est courant.
 \n : passage à la ligne
 \t : tabulation
 \r : retour chariot (uniquement sous Windows)
 \\ : \
 On nettoie souvent les lignes en utilisant l’instruction
strip( ). Cette fonction retire des extrémités tous les
carctères qui sont dans la chaîne passée en argument.
s.strip ("\r\n\t ")

29
Instructions d’E/S

 La fonction input() bloque le déroulement du

programme et attend une saisie au clavier. Elle retourne
une chaîne de caractères
 Exemple :
name = input('Qui êtes-vous ?')
print('Bienvenue', name)
 La fonction print() permet d’afficher des données
(constantes, variables, expressions) séparées par des
virgules (une virgule = un espace)

30
Instructions d’E/S

 Si nous voulons lire un nombre entier de l’utilisateur,

nous devons le convertir de chaîne à nombre avec la
fonction int()
 Exemple :
an_cour = 2018
an_nais = input('Année de naissance :')
age = an_cour - int(an_nais)
print('Vous avez', age, 'ans')

 La conversion d’une valeur entrée par l’utilisateur peut

se faire avec la fonction eval() en Python 3.
an_nais= eval(input("Donnez votre année de naissance : "))
print("Votre age est ", 2018 - an_nais)
31
Affichage formaté de nombres et de chaînes

 Le langage Python permet également d’afficher des informations

selon un format :
n=5
s = "un entier {}".format(n) # s vaut 'un entier 5'
x = 5.56568
s = "un réel {}".format(x) # s vaut 'un réel 5.56568'
s = "un réel {:.2f}".format(x) # s vaut 'un réel 5.57'
ch = "voilà"
s = "un réel {} et une chaîne de caractères {}".format(x,ch)
# s vaut 'un réel 5.56568 et une chaîne de caractères voilà'
s = "une chaîne {1} et un réel {0}".format(x,ch)
# s vaut 'une chaîne voilà et un réel 5.56568'
s = "{:10s} une chaîne sur 10 positions".format(ch)
32
# s vaut 'voilà une chaîne sur 10 positions'
Listes

 Les listes sont des séquences d’objets de n'importe quel

type.
 On peut mélanger différents types d’objets dans une liste.
 Une liste peut être modifiée par l’ajout ou la suppression
d’un objet, ou par le remplacement d’un objet de la liste.
 On accède à un élément d’une liste par son indice.

liste = [ ] # liste est une liste vide

liste = [’ab’, 4, 5.5, [’Z’, 5] ] # affectation d’une liste à la variable liste
liste[1] = 10 # liste vaut [’ab’, 10, 5.5, [’Z’, 5] ]
x = liste [2] # x vaut 5.5
t = liste[1:3] # t vaut [10, 5,5]
x = liste [-2] # x vaut 5,5 33
Listes

 Opérations fréquentes
 Addition +
 Multiplication *
 in et not in
 del : supprime des objets d’une liste

liste = [0,1,2] + [3,4,5] # liste vaut [0,1,2,3,4,5]

liste = [0,1,2] * 3 # liste vaut [0,1,2,0,1,2,0,1,2]
liste += [14,15] # liste vaut [0,1,2,0,1,2,0,1,2, 14, 15]
b = 14 in liste # b vaut True
del liste [0:9] # liste vaut [14,15]

34
Listes

 Opérations fréquentes
 len ( t ) : renvoie la taille de la liste t
 min(t), max(t), sum(t) : renvoient respectivement le minimum, le
maximum et la somme des éléments de t

t = [2, -5, 7, 1.8]

taille = len (t) # taille vaut 4
m = max(t) # m vaut 7
n = min(t) # n vaut -5

35
Listes

 Opérations fréquentes
 t.count(x) : renvoie le nombre d’éléments égaux à x dans t

 t.reverse( ) : retourne la liste t inversée

 t.sort( ) : trie la liste t

 t.append(x) : ajoute x à la liste t

 s.join(t) : si t est une liste de chaînes de caractères, cette

instruction les colle toutes ensemble séparées par s

 t.remove(e) : supprime l’élément e de la liste t

36
Listes

 Exemples :

t = ['Java', 'Python', 'C', 'C++', 'Java']

n = t.count('Java') # n vaut 2
t.reverse( ) # t vaut ['Java', 'C++', 'C', 'Python', 'Java']
t.sort( ) # t vaut ['C', 'C++', 'Java', 'Java', 'Python']
t.append ('Php') # t vaut ['C', 'C++', 'Java', 'Java', 'Python', 'Php']
s='; '.join (t) # s vaut C; C++; Java; Java; Python; Php

37
Listes en compréhension

 On dit qu’on construit une liste en compréhension

lorsqu’on la définit par application d’une fonction à une
séquence d’éléments.
 Exemples :
liste = [ 2*i+1 for i in range (0,5) ] # liste vaut [1, 3, 5, 7, 9]
liste = [ 2*i+1 for i in range (0,10) if i % 3 == 0 ] # liste vaut [1, 7, 13]
liste = [ (x,y) for x in range (0,3) for y in range (0,2) ]
# liste vaut [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]
liste = [ [ 0 if i!=j else 1 for i in range (0,3) ] for j in range (0,3) ]
# liste vaut [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

38
Tuples

 Le tuple est un autre type standard de séquence.

 Les tuples sont immuables et peuvent contenir des
objets de types différents
t=() # tuple vide
t = (5) # t est une variable de type int qui vaut 5
t = (5, ) # t est un tuple qui contient l’élément 5
t = (5, 0.8 , 'code', [1, 2, 3]) # les éléments de t sont de types différents
x = t[0] # x vaut 5
u = t[0:2] # u vaut (5,0.8)
u[0] = -1 # erreur ; les tuples sont immuables

39
Tuples

 Opérations fréquentes
 Addition +
 Multiplication *
 in et not in

t = (0,1,2) + (3,4,5) # t vaut (0,1,2,3,4,5)

t = (0,1,2) * 3 # t vaut (0,1,2,0,1,2,0,1,2)
t += (14,15) # t vaut (0,1,2,0,1,2,0,1,2, 14, 15)
b = 14 in t # b vaut True

40
Tuples

 Opérations fréquentes
 len ( t )
 min(t), max(t), sum(t)
 t.count(x)
 s.join(t)

t = 2, -5, 7, 1.8
taille = len (t) # taille vaut 4
m = max(t) # m vaut 7
n = min(t) # n vaut -5
t = ('Java', 'Python', 'C', 'C++', 'Java')
n = t.count('Java') # n vaut 2
s='; '.join (t) # s vaut Java; Python; C; C++; Java
41
Tuples, empaquetage et dépaquetage

 On peut omettre les parenthèses rondes lors de la

création d’un tuple
 La virgule est dans ce cas utilisée comme un caractères
syntaxique permettant de séparer les éléments les uns
des autres.
 Cette technique s’appelle empaquetage automatique
 Exemple :
t = 1, 2, 3 # t vaut (1, 2 , 3)

42
Tuples, empaquetage et dépaquetage

 On peut également utiliser l’opérateur virgule dans la

partie gauche d’une assignation dont l’expression droite
retourne un tuple. On parle alors de dépaquetage
automatique.
 Exemples :
a, b = 2, 0 # a vaut 2 et b 0 dépaquetage automatique
t = 1, 2, 3 # t vaut (1,2,3) empaquetage automatique
a, b, c = t # a vaut 1, b 2 et c 3 dépaquetage automatique

43
Ensembles

 Un ensemble en Python est une collection d'objets sans

répétition et sans ordre (donc sans numérotage)
 On les note comme en maths avec des accolades {...}.
Les éléments sont de types quelconques.
 Exemples : {5,3,-8,2} {'o','e','y','u','a','i'} {5,'foo',(3,-2),7.4}
 L'ensemble vide se note set() et non { }
 L'opérateur in permet de savoir si un objet appartient à
un ensemble
 L'opération E < F permet de tester si l'ensemble E est
strictement inclus dans l'ensemble F.

44
Construction d’un ensemble

 On peut construire un ensemble :

 En extension : E = {5,2,3,1}

 En compréhension : E = {x*x for x in range(20) if x % 3 == 0}

 Avec la fonction set(...) : E = set('aeiouy')

E = set([5,2,5,6,2])

 En ajoutant un élément à un ensemble E avec la méthode

E.add(x)

 La fonction len(s) retourne le nombre d’éléments d’un ensemble

45
Opérations sur les ensembles

 L’union E U F = {x : x ∈ E ou x ∈ F} se note E | F en
Python.
 L'intersection E ∩ F = {x : x ∈ E et x ∈ F} se note E & F
en Python
 La différence E - F = {x : x ∈ E et x ∉ F} se note E - F
en Python.
 Il est possible d'obtenir un élément d'un ensemble E et
de le supprimer en même temps avec la méthode pop()
 Exemple :
E = {5,2,3,1}
x = E.pop()
46
print(x, E) # renvoie 1 {2, 3, 5}
Mutabilité des ensembles

 Un ensemble construit par set(...) est mutable (on peut

le modifier). Mais ses éléments ne peuvent pas être
mutables.
 On peut faire des ensembles de tuples mais pas
d'ensembles dont les éléments sont des listes ou des
ensembles !

47
Dictionnaires

 Un dictionnaire est un tableau dont les éléments ne

sont plus associés à un indice entier mais à n’importe
quel objet de type immuable (entier, réel, chaîne de
caractères et tuple).
 L’indice s’appelle la clé, il est associé à une valeur.
 Les clés sont uniques au sein d’un dictionnaire, les
valeurs pas nécessairement.
 On peut considérer les dictionnaires comme des
ensembles de paires clé: valeur

48
Dictionnaires

d={} # création d’un dictionnaire vide

d [4] = 'element' # ajout d’un élément
d ['ty'] = 'autre element' # ajout d’un autre élément
d = { 4:'element', 'ty':'autre element' } # cette ligne est équivalente aux trois
#précédentes

49
Dictionnaires

 Opérations fréquentes
Soit d un dictionnaire
 x in d : vérifie si x est une clé de d
 d[k] : désigne la valeur associée à k
 len(d) : renvoie le nombre de clés de d
 min(d), max(d) : renvoient resp. le min. et max. des clés
 del d[k] : supprime la clé k (et la valeur associée)
 d.keys() : retourne les clés de d
 d.values() : retourne les valeurs de d
 d.items() : retourne les couples (clé, valeur) de d
 d.clear() : supprime tous les éléments de d

50
Conversion

 Il est possible de convertir

 une liste en un tuple :
• Exemple :
l=[‘A’,’B’,’C’]
t=tuple(l)
 un tuple en une liste :
• Exemple :
t=(0,1,2)
l=list(t)
 un ensemble en une liste :
• Exemple :
s={'JAVA','Python'}
l=list(s) 51
 une liste en un ensemble :
• Exemple :
l=[0, 1, 2]
s=set(l)
 un tuple en un ensemble :
• Exemple :
t=(0,1,2)
s=set(t)
 un ensemble en un tuple :
• Exemple :
s={'JAVA','Python'}
t=tuple(s)
52
Fonctions

 Les fonctions permettent de reproduire la même tâche

sur des données différentes sans avoir à recopier le
code.

 Elles acceptent des paramètres et retournent des

résultats avec le mot-clé return.

 En Python, il n’y a pas de distinction entre procédure et

fonction : les procédures sont des fonctions qui
retournent la valeur None.

53
Fonctions

 Les fonctions sont des constructions pour structurer les

programmes.
 Elles permettent d’utiliser le code à plusieurs endroits
d’un programme.
def <nom_fonctions>(<liste_paramètres>):
… # instructions (lignes indentées)
 Le corps d’une fonction peut contenir l’instruction return.
Cette instruction termine l'exécution de l'appel de
fonction et "renvoie" le résultat à l'appelant.
 S'il n'y a pas return, la fonction se termine quand le flux
de contrôle atteint la fin de son corps. Elle renvoie
l’objet None 54
Fonctions

 Un paramètre est une entité nommée dans la définition

d’une fonction (ou méthode), décrivant un argument (ou
dans certains cas des arguments) que la fonction
accepte.
 Il n'y a que deux façons de placer des arguments en
python:
 soit grâce à la position des paramètres
 soit grâce à leur nom

55