Python POO

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)

Python POO

Transféré par

Droits d'auteur :

Formats disponibles

Python POO

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python POO

Transféré par

Droits d'auteur :

Formats disponibles

Partie 3 : Orientee objet

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

• Déclarer une classe :

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

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

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

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

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

• Java: this, implicite

• Python: self, explicite

– Exercice : Écrire distance, set_location, et

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

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

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

• Comment permettrait-on de construire un

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

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

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

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

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

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

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

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

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

• Python prend également en charge héritage multiple

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

classe Point3D (Point):

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

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

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

# affiche <class ’_io.TextIOWrapper’>

• Pour fermer le fichier

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

Considérons le fichier fichier.json suivant:

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

Vous aimerez peut-être aussi

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

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