Partie 3 : Orientee objet

Pr. Y.ABOUQORA

1
 Récapitulatif

Listes
Dictionnaires
Sets
Si Else
Boucles
Fonctions
Classes
Exercices
 Agenda

Classes
Champs
Methodes objet
Constructeurs
Surcharges
Exceptions
Heritage
Exercices
 POO, Définition d'une classe

• Python a été construit comme un langage procédural

– La POO existe et fonctionne bien, mais se sent un peu plus
"collée"
– Java fait probablement mieux les classes que Python (gasp)

• Déclarer une classe :

class nom:
déclarations
 Les champs

Nom = valeur

– Exemple: point.py
1
class Point: 2
x = 0 class Point:
3 x = 0
y = 0 y = 0
# principale
p1 = Point()
p1.x = 2
p1.y = -5

– peut être déclaré directement à l'intérieur de la classe (comme

indiqué ici) ou dans les constructeurs (plus fréquent)

– Python n'a pas vraiment d'encapsulation ou de champs privés

• compte sur l'appelant pour "être gentil" et ne pas déranger le contenu
des objets
 Utiliser une classe

import class
– les programmes clients doivent importer les classes qu'ils
utilisent

point_main.py
1 from Point import *
2
3 # principale
4 p1 = Point()
5 p1.x = 7
6 p1.y = -3
se ...
pt
8 # Les objets Python sont dynamiques (peuvent ajouter
9 des champs à tout moment !)
di p1.name = "Tyler Durden"
x
 Méthodes d'objet

def Nom(self, paramètre, ..., paramètre):

déclarations

– self doit être le premier paramètre de toute méthode objet

• représente le "paramètre implicite" (this en Java)

– doit accéder aux champs de l'objet via le self référence

class Point:
def translate(self, dx, dy):
self.x += dx
self.y += dy
...
 Paramètre "Implicite" (self)

• Java: this, implicite

public void translate (int dx, int dy) {
x + dx =; // this.x += dx;
y += dy; // this.y += dy;
}

• Python: self, explicite

def traduire(self, dx, dy):
self.x + = Dx
self.y += jour

– Exercice : Écrire distance, set_location, et

distance_de_origine méthodes.
 Exercice Réponse

point.py
1 from math import *
2
3 class Point:
4 x = 0
5 y = 0
6
se def set_location(self, x, y):
pt self.x = x
8 self.y = y
9
di def distance_from_origin(self):
x return sqrt(self.x * self.x + self.y * self.y)
11
12 def distance(self, other):
13 dx = self.x - other.x
14 dy = self.y - other.y
15 return sqrt(dx * dx + dy * dy)
16
17
 Méthodes de classe

• Un client peut appeler les méthodes d'un objet de deux

manières :
– (la valeur de self peut être un paramètre implicite ou
explicite)

1) objet.méthode(paramètres)
ou
2) Class.méthode(objet, paramètres)

• Exemple:
p = Point(3, -4)
p.translate(1, 5)
Point.translate(p, 1, 5)
 Constructeurs

def __init__(self, paramètre, ..., paramètre):

déclarations

– un constructeur est une méthode spéciale avec le nom

__init__

– Exemple:

class Point :
def __init__(self, x, y):
self.x = x
self.y = y
...

• Comment permettrait-on de construire un

Point() sans paramètres à obtenir (0, 0) ?
 Plus sur les champs

point.py
1 class Point:
2 def __init__(self, x,
3 y):
4 self.x = x
5 self.y = y
...

>>> p = Point(5, -2)

>>> p.x
5
>>> p.y
-2

les champs peuvent être déclarés directement à l'intérieur de la classe, ou

simplement dans le constructeur comme indiqué ici (plus courant)
 toString et __str__

def __str__(self):
return chaîne de caractères

– équivalent à Java toString (convertit l'objet en chaîne)

– invoqué automatiquement lorsque str ou print est appelé

Exercice : Écrivez un __str__ méthode pour Point les objets

que les chaînes de retours comme "(3, -14)"

def __str__(self):
return "(" + str(self.x) + ", " + str(self.y) + ")"
 Classe de points complète

point.py
1
2 from math import *
3
4 class Point:
5 def __init__(self, x, y):
6 self.x = x
se self.y = y
pt
8 def distance_from_origin(self):
9 return sqrt(self.x * self.x + self.y * self.y)
di
x def distance(self, other):
11 dx = self.x - other.x
12 dy = self.y - other.y
13 return sqrt(dx * dx + dy * dy)
14
15 def translate(self, dx, dy):
16 self.x += dx
17 self.y += dy
18
19 def __str__(self):
20 return "(" + str(self.x) + ", " + str(self.y) + ")"
21
 Surcharge de l'opérateur

• surcharge de l'opérateur: vous pouvez définir des

fonctions afin que les opérateurs intégrés de Python
puissent être utilisés avec votre classe.
• Voir également: http://docs.python.org/ref/customization.html
Operator Class Method Operator Class Method
- __neg__(self, other) == __eq__(self, other)
+ __pos__(self, other) != __ne__(self, other)
* __mul__(self, other) < __lt__(self, other)
/ __truediv__(self, other) > __gt__(self, other)
Opérateurs unaires <= __le__(self, other)
- __neg__(self) >= __ge__(self, other)
+ __pos__(self)
 Exercise

• Exercer: Écrire une classe Fraction pour représenter des

nombres rationnels comme 1/2 et -3/8.

• Les fractions doivent toujours être conservées sous forme réduite ;

par exemple, enregistrez 4/12 comme 1/3 et 6/-9 comme -2/3.
– Astuce : Une fonction GCD (plus grand diviseur commun) peut être
utile.

• Définir ajouter et multiplier méthodes qui acceptent un autre

Fraction en paramètre et modifier l'existant Fraction en
l'ajoutant/multipliant par ce paramètre.

• Définir +, *, ==, et < les opérateurs.

 Génération d'exceptions

raise ExceptionType("message")
– utile lorsque le client utilise votre objet de manière
inappropriée
les types: ArithmeticError, AssertionError, IndexError,
NameError, SyntaxError, TypeError, ValueError

– Exemple:
class BankAccount:
...
def deposit(self, amount):
if amount < 0:
raise ValueError("negative amount")
...
 Héritage

class Nom(superclasse):
déclarations

– Exemple:
classe Point3D(Point): # Point3D étend Point
z = 0
...

• Python prend également en charge héritage multiple

classer Nom(superclasse, ..., superclasse):
déclarations
(si > 1 superclasse a le même champ/méthode, les conflits sont résolus dans l'ordre de gauche à
droite)
 Appel de méthodes de superclasse

• méthodes : classe.méthode(objet, paramètres)

• constructeurs : classe.__init__(paramètres)

classe Point3D (Point):

z = 0
def __init__(self, x, y, z):
Point.__init__(self, x, y)
self.z = z

def translate(self, dx, dy, dz):

Point.translate(self, dx, dy)
self.z += dz
 Python : gestion de fichiers

• La variable crée est une instance de la classe TextIOWrapper

mon_fichier = open("files/fichier.txt", "w")

print(type(mon_fichier))

# affiche <class ’_io.TextIOWrapper’>

with open(’files/fichier.txt’, ’w’) as mon_fichier:
print(mon_fichier.write(’bonjour’))
# affiche 7 (nombre de caract`eres ´ecrits)

• Pour écrire dans le fichier (le contenu précèdent sera écrasé), on utilise la méthode write
mon_fichier.write(’bonjour’)

• Pour fermer le fichier

mon_fichier.close()

• On peut utiliser with ... as pour faire l’ouverture et fermeture

#mode ecriture
with open(’files/fichier.txt’, ’w’) as mon_fichier
print(mon_fichier.write(’bonjour’))
# affiche 7 (nombre de caractères écrits)

#mode lecture
with open(’files/fichier.txt’, ’r’) as mon_fichier:
print(mon_fichier.read())
# affiche bonjour
 Python : Fichier Json

Considérons le fichier fichier.json suivant:

Pour lire le contenu de fichier.json et le stocker dans un dictionnaire
{
import json "nom":
"wick",
contenu = {}
"prenom":
with open(’files/fichier.json’) as f: contenu = json.load(f) "john",
"age": "45"
print(contenu)
# affiche {’nom’: ’wick’, ’prenom’: ’john’, ’age’: ’ 45’} }
print(contenu[’nom’]) # affiche wick

Pour ecrire dans fichier.json, on utilise la mthode dump

import json
entry = { "ville": "New York"}
#Le contenu precedent est ecrase.
with open(’files/fichier.json’, ’w’) as f:
json.dump(entry, f)

import json
entry = { "ville": "New York"}
with open(’files/fichier.json’, ’a’) as f:
json.dump(entry, f)