Académique Documents
Professionnel Documents
Culture Documents
Slides 5
Slides 5
Classes
Python permet le paradigme Programmation Orienté Objet (POO).
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 :
Données
vec1 = (3, 4)
vec2 = (1, -3)
Fonctions
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 OO : définir un nouveau type Vecteur pour grouper les
données d'un vecteur et le fonction qui agissent dessus.
Vecteur
x
y
longueur()
Classes
Paradigme OO : définir un nouveau type Vecteur pour grouper les
données d'un vecteur et le fonction qui agissent dessus.
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 : Chat
nom
chat1 = Chat('Felix', 5) age
chat2 = Chat('Cléo', 7)
affiche_age()
chat1.affiche_age()
print(chat.nom)
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)
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()
●
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
class Rectangle:
def __init__(self, p1, p2): p2 = Vecteur
self.p1 = p1 x=5
self.p2 = p2 y=4
def aire(self):
largeur = self.p2.x – self.p1.x
hauteur = self.p2.y – self.p1.y aire()
return largeur * hauteur
rect = Rectangle(a, b)
print(rect.aire())
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
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'>"
repr(x) x.__repr__()
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__
...