Partie 3 : Orientee objet
Pr. [Link]
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: [Link]
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 [Link] = "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
[Link]
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)
[Link](1, 5)
[Link](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
[Link]
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
[Link]
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: [Link]
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):
[Link](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/[Link]", "w")
print(type(mon_fichier))
# affiche <class ’_io.TextIOWrapper’>
with open(’files/[Link]’, ’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/[Link]’, ’w’) as mon_fichier
print(mon_fichier.write(’bonjour’))
# affiche 7 (nombre de caractères écrits)
#mode lecture
with open(’files/[Link]’, ’r’) as mon_fichier:
print(mon_fichier.read())
# affiche bonjour
Python : Fichier Json
Considérons le fichier [Link] suivant:
Pour lire le contenu de [Link] et le stocker dans un dictionnaire
{
import json "nom":
"wick",
contenu = {}
"prenom":
with open(’files/[Link]’) as f: contenu = [Link](f) "john",
"age": "45"
print(contenu)
# affiche {’nom’: ’wick’, ’prenom’: ’john’, ’age’: ’ 45’} }
print(contenu[’nom’]) # affiche wick
Pour ecrire dans [Link], on utilise la mthode dump
import json
entry = { "ville": "New York"}
#Le contenu precedent est ecrase.
with open(’files/[Link]’, ’w’) as f:
[Link](entry, f)
import json
entry = { "ville": "New York"}
with open(’files/[Link]’, ’a’) as f:
[Link](entry, f)