View
18
Download
0
Category
Preview:
Citation preview
Classes et POO
Classes
Python permet le paradigme Programmation Orienté Objet (POO).
Les objets groupent des données et des méthodes (fonctions) logiquement liées.
Par exemple, pour objets de type list
>>> nombres = [3, 1, 2]
>>> nombres.reverse()
>>> nombres.sort()
>>> nombres.pop()
Classes
Python permet le paradigme Programmation Orienté Objet (POO).
Les objets groupent des données et des méthodes (fonctions) logiquement liées.
Par exemple, pour objets de type list
>>> nombres = [3, 1, 2]
>>> nombres.reverse()
>>> nombres.sort()
>>> nombres.pop()
Données
Fonctions
Classes
Paradigme fonctionnel/procédural :
vec1 = (3, 4)
vec2 = (1, -3)
def longueur(v):
return math.sqrt(v[0]**2 + v[1]**2)
long1 = longueur(vec1)
long2 = longueur(vec2)
print(vec1[0]) # Affiche '3'
Classes
Paradigme fonctionnel/procédural :
vec1 = (3, 4)
vec2 = (1, -3)
def longueur(v):
return math.sqrt(v[0]**2 + v[1]**2)
long1 = longueur(vec1)
long2 = longueur(vec2)
print(vec1[0]) # Affiche '3'
Données
Fonctions
Classes
Paradigme OO : définir un nouveau type Vecteur pour grouper les données d'un vecteur et le fonction qui agissent dessus.
Vecteur
xy
longueur()
Classes
Paradigme OO : définir un nouveau type Vecteur pour grouper les données d'un vecteur et le fonction qui agissent dessus.
vec1 = Vecteur(3, 4) # création d'un objet Vecteur
vec2 = Vecteur(1, -3) # création d'un objet Vecteur
long1 = vec1.longueur()
long2 = vec2.longueur()
print(vec1.x) # affiche 3
Classes
Paradigme fonctionnel/procédural
chat1 = ('Felix', 5)
chat2 = ('Cléo', 7)
def affiche_age(c):
print('{} a {} ans'.format(c[0], c[1]))
affiche_age(chat1)
affiche_age(chat2)
Classes
Paradigme OO :
chat1 = Chat('Felix', 5)
chat2 = Chat('Cléo', 7)
chat1.affiche_age()
print(chat.nom)
Chat
nomage
affiche_age()
Classes
Ces nouveaux types s'appellent classes.
Une nouvelle classe est définie par le mot-clé class.
class NomDeLaClasse:
<instruction 1>
<instruction 2>
.
.
.
<instruction N>
Classes
La définition d'une classe :
class Vecteur:
'''Cette classe représente un vecteur.'''
def __init__(self, a, b):
self.x = a
self.y = b
def longueur(self):
return math.sqrt(self.x**2 + self.y**2)
Création d'instances de la classe = objets :
vec1 = Vecteur(3, 4) # appel de __init__(..., 3, 4)
# aucun argument pour 'self'
print(vec1.x) # Affiche '3'
Classes
class Vecteur:
'''Cette classe représente un vecteur.'''
def __init__(self, a, b):
self.x = a
self.y = b
def longueur(self):
return math.sqrt(self.x**2 + self.y**2)
Finalement, on peut appeler les méthodes sur l'objet :
long = Vecteur.longueur(vec1)
Syntaxe alternative, plus pratique (sans argument explicite pour self):
long = vec1.longueur()
Classes
class Chat:
'''Cette classe représente un chat.'''
def __init__(self, n, a):
self.nom = n
self.age = a
def affiche_age(self):
print('{} a {} ans'.format(self.nom, self.age))
def parle(self):
print('miaou')
monchat = Chat('Felix', 5)
monchat.affiche_age()
monchat.parle()
Classes
Deux syntaxe pour appeler les méthodes :● objet.methode() syntaxe courante (implicitement transformée dans
la deuxième)● Classe.methode(objet)
class Chat :
def parle(self):
print('miaou')
monchat = Chat()
monchat.parle() # Ces deux appels
Chat.parle(monchat) # sont équivalents
Classes
Quelques conventions.
● nom des classes : en « CamelCase »
Vecteur
PlanCartesien
Chat
MainWindow
● nom des objet : en minuscule (avec tirets bas)
vec = Vecteur(1, 2)
vec_longue = Vecteur(35,-43)
plan_cartesien = PlanCartesien()
chat1 = Chat('Felix', 5)
main_win = MainWindow()
Classes
Les méthodes ont toujours un premier argument qui représente, dans la méthode, l'objet = l'instance particulière.
Par convention, on l'appelle self.
...
def presente(self):
print('{} a {} ans'.format(self.nom, self.age))
def parle(self, n):
print('miaou ' * n)
def parle_beaucoup(self):
self.parle(10)
...
Classes
On peut définir des attributs pour les classes aussi (class attributes = attributs de classe), par affectation.
Ils sont en commun pour toutes les objet crée par la classe.
Souvent utilisés pour les « constantes » du type.
class Cercle:
PI = 3.14159
def __init__(self, r):
self.rayon = r
def aire(self):
return Cercle.PI * self.rayon ** 2
print('La valeur de PI est {}'.format(Cercle.PI))
c = Cercle(2.5)
print('rayon = {}, aire = {}'.format(c.rayon, c.aire()))
Classes
Un objet peut être composé par des autres objets.
Exemple : un rectangle est défini par deux points.
a = Vecteur(1, 2)
b = Vecteur(5, 4)
class Rectangle:
def __init__(self, p1, p2):
self.p1 = p1
self.p2 = p2
def aire(self):
largeur = self.p2.x – self.p1.x
hauteur = self.p2.y – self.p1.y
return largeur * hauteur
rect = Rectangle(a, b)
print(rect.aire())
Vecteur
x = 1y = 2
Vecteur
x = 5y = 4
Rectangle
aire()
p2 =
p1 =
Classes
Il n'y a pas d'attributs privés en Python, tout est toujours accessible.
Une convention est de préfixer avec un seule tiret bas les attributs qu'on veut protéger. Mais c'est juste une « suggestion » aux programmateurs.
class Chat:
def __init__(self):
self._age = 0
def set_age(self, age):
self._age = max(age, 0)
def get_age(self):
return self._age
Ce code suggère au programmateur qui veut utiliser la classe Chat, de ne pas toucher à _age et utiliser seulement set_age() et get_age().
Méthodes spéciales
On a rencontré pour la première fois une méthode spéciale __init__ (le constructeur).
Les méthodes spéciales sont identifiées par deux tirets bas à chaque côtés du nom.
class Chat:
def __init__(self, n, a):
self.nom = n
self.age = a
def parle(self, x):
print('miaou ' * x)
La fonctions repr()
La fonction repr() donne une représentation textuelle de n’importe quel objet, sous forme de chaîne.
>>> repr(4)
'4'
>>> def fun(x):
... return x + 2
>>> repr(fun)
'<function fun at 0x7f73ecad1ea0>'
>>> fichier = open('topics.txt')
>>> repr(fichier)
"<_io.TextIOWrapper name='topics.txt' mode='r' encoding='UTF-8'>"
Elle est utilisée dans l’interpréteur pour afficher les objets.
Méthodes spéciales
Pour les instances de classes, la conversion standard donne une chaîne du genre '<nomdumodule.nomdelaclasse object at 0xffff>'.
>>> class Vecteur:
... def __init__(self, x, y):
... self.x = x
... self.y = y
...
>>> p = Vecteur(3, 5)
>>> repr(p)
'<__main__.Vecteur object at 0x7f6d305b9ab8>'
Méthodes spéciales
Pour contrôler cette conversion il faut définir une méthode spéciale __repr__.
>>> class Vecteur:
... def __init__(x, y):
... self.x = x
... self.y = y
... def __repr__(self):
... return 'Vecteur({}, {})'.format(self.x, self.y)
...
>>> v = Vecteur(3, 5)
>>> repr(v)
'Vecteur(3, 5)'
>>> v
Vecteur(3, 5)
Méthodes spéciales
Sous le capot : la fonction repr appelle la méthode spéciale __str__ de l’objet.
repr(x) x.__repr__()
Tout se passe comme repr() était définie avec :
def repr(x):
return x.__repr__()
Méthodes spéciales et opérateurs
Méthodes spéciales
On peut utiliser les opérateurs + - * / < > etc... avec des objets. Par exemple, pour l'operateur + il faut définir une méthode __add__()
class Vecteur:
...
def __add__(self, other):
x = self.x + other.x
y = self.y + other.y
return Vecteur(x, y)
...
>>> v1 = Vecteur(3, 5)
>>> v2 = Vecteur(2, -1)
>>> v1 + v2 # équivalent à v1.__add__(v2)
# v1 est ‘self’ et v2 est ‘other’
Vecteur(5, 4)
Méthodes spéciales
+ __add__
- __sub__
* __mul__
/ __truediv__
// __floordiv__
< __lt__ (less than)> __gt__ (greater than)<= __le__ (less or equal)>= __ge__ (greater or equal)== __eq__
...
Recommended