Scribd
Importer
286 vues21 pages

Python POO

Le document présente les concepts de base de la programmation orientée objet en Python. Il introduit les notions de classes, champs, méthodes, constructeurs, héritage et exceptions. Des exemples de classes Point et Fraction sont également fournis pour illustrer ces concepts.

Transféré par

abouqora
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PPTX, PDF, TXT ou lisez en ligne sur Scribd
286 vues21 pages

Python POO

Le document présente les concepts de base de la programmation orientée objet en Python. Il introduit les notions de classes, champs, méthodes, constructeurs, héritage et exceptions. Des exemples de classes Point et Fraction sont également fournis pour illustrer ces concepts.

Transféré par

abouqora
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PPTX, PDF, TXT ou lisez en ligne sur Scribd
Vous êtes sur la page 1/ 21

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)

Vous aimerez peut-être aussi