Prototypage d`interfaces par langage de script Le Python, c`est bon

Prototypage d’interfaces par langage de script
Le Python, c’est bon
Cours 3 : Classes, exceptions et tests
1 Classes
On consid`ere ici que vous avez des notions de langage objets. En particulier,
vous savez ce qu’est une classe, un attribut et une m´ethode.
1.1 Premi`eres d´efinitions
Une classe :
class UneClasse:
""" ne fait rien
mais alors absolument rien.
"""
pass
Une petite introspection de la classe nous montre qu’il y a d´ej`a des choses
de d´efinies :
help(UneClasse)
print dir(UneClasse) #que fait dir ?
Regardons ¸ca de plus prˆet :
print UneClasse.__doc__
print UneClasse.__module__
print UneClasse
cr´eons une instance de UneCLasse et affectons lui un attribut (on peut le
faire)
x = UneClasse()
help(x)
print x
1

print dir(x)
print x.__dict__ #qu’est ce que __dict__ ?
print x.unTruc #donne une erreur : __dict__ est toujours d´efini.
x.titre = "C’est la vie, Cui Cui"
print x.__dict__ # RTFM : http://docs.python.org/index.html
del x.titre
print x.__dict__
1.2 Faisons ¸ca bien : notre premier h´eritage
La classe la plus haute de python est la classe object. Faisons h´eriter notre
nouvelle classe d’objet (il est recommand´e de toujours le faire).
class MaClasse(object):
""" une classe tres classe
fait peu de chose pour l’instant.
"""
titre = "C’est la vie, Cui Cui"
Y’a-t-il du changement ?
help(MaClasse)
print dir(MaClasse)
print MaClasse
print MaClasse.__dict__
L’attribut titre est un attribut de classes. Amusons-nous un peu avec.
Commen¸cons par cr´eer une instance de MaClasse.
x = MaClasse()
La suite (´edifiante) vous montre les diff´erences entre attribut de classe et
attribut d’instance `a la sauce python.
print "instance x : ", x.titre,"| classe : ", MaClasse.titre
x.titre = "Cure toujours"
print "instance x : ", x.titre,"| classe : ", MaClasse.titre
y = MaClasse()
z = MaClasse()
2

print "instance x : ", x.titre, "| instance y : ", y.titre,\
"| instance z : ", z.titre, " | classe : ", MaClasse.titre
MaClasse.titre = "Goldorak est mort"
print "instance x : ", x.titre, "| instance y : ", y.titre,\
"| instance z : ", z.titre, " | classe : ", MaClasse.titre
x.__class__.titre = "C’est la vie, Cui cui" # __class__ ?
print "instance x : ", x.titre, "| instance y : ", y.titre, \
"| instance z : ", z.titre, " | classe : ", MaClasse.titre
print x.__dict__, x.__class__.__dict__
del x.titre
print "instance x : ", x.titre, "| instance y : ", y.titre, \
"| instance z : ", z.titre, " | classe : ", MaClasse.titre
´
Etonnant, non ?
1.3 M´ethodes et variables cach´ees
Construisons une classe un peu plus ´etoff´ee.
class MaTresClasse(object):
""" Une classe plutot bien fournie
On a une variable cach´ee, une m´ethode et un constructeur
"""
paroles = "Oh non non non j’ai bronz´e,\
mes potes voudront plus me parler,"
__laSuite = "Oh non non non `a la f^ete de Chlo´e\
je me suis trop amus´e,"
def __init__(self):
self.__class__.titre = "Cure toujours"
def desParoles(self):
return self.__laSuite
def __setitem__(self, attribut, valeur):
setattr(self, attribut, valeur)
Le premier param`etre de toute m´ethode dans une classe est une r´ef´erence `a
l’instance consid´er´ee. Par convention, on l’appelle self.
Les variables, commen¸cant par “ ” mais ne finissant pas par “ ” sont des
variables priv´ees. On ne peut y acc´eder que de l’int´erieur de la classe.
x = MaTresClasse()
print x.desParoles()
print x.__laSuite # erreur
print x.__dict__, x.__class__.__dict__
3

Les m´ethodes, attributs ou autre commen¸cant et finissant par “ ” (comme
“ dict ”, “ bases ” ou encore “ name ”) ont une signification sp´eciale. Re-
gardez la section 2.3.2 du Python reference manual pour une description rapide
des noms avec “ ” et surtout la partie 3.4 pour une liste des m´ethodes que l’on
peut utiliser dans les classes. En particulier le constructeur init .
Ces m´ethodes ne sont pas obligatoires (notre premi`ere classe ne contenait
pas de constructeur) mais permettent `a nos classes d’avoir des comportants
sympathiques (comme d’avoir une longueur avec len par exemple).
L’exemple suivant montre l’utilisation que l’on peut faire de “ setitem ”,
ainsi que l’ajout d’attribut de classes `a la vol´ee.
x["paroles"] = "La calendre est super enfonc´ee,\
et la peinture a bien morfl´e,"
x["titre"] = "Goldorak est mort"
x.plusDeParoles = "Le moteur gauche s’est fait la malle.\
On dirait un kart `a p´edales !"
print x.__dict__
MaTresClasse.toujoursDesParoles = "J’ai ´ecout´e la compagnie Cr´eole\
et j’ai tap´e du pied,"
print x.toujoursDesParoles
print MaTresClasse.__dict__
1.4 H´eritages
L’h´eritage multiple est autoris´e en python. L’exemple suivant vous montre un
comment cela fonctionne. Recherchez de la documentation sur la Diamond rule
de l’h´eritage dans python.
Il montre ´egalement que lorsque l’on surcharge une fonction la fonction du
ou des parents n’est pas automatiquement appel´ee.
class A(object):
classe = "A"
def __init__(self):
self.variable = "OUI"
class B(A):
pass
class Bprim(A):
def __init__(self):
pass
4

class Bsecond(A):
def __init__(self):
A.__init__(self)
print dir(B())
print dir(Bprim())
print dir(Bsecond())
class C(object):
classe = "C"
class D(B,C):
pass
print D.classe
class Cprim(A):
classe = "diamond Rule"
class Dprim(B,Cprim):
pass
print Dprim.classe
2 Exceptions
Vous avez sˆurement d´ej`a rencontr´e des exceptions lors de vos premiers essais en
python :
print uneVariableNonAffectee # une erreur
La gestion des erreur se fait en python en utilisant les mots cl´es try et except.
try:
print uneVariableNonAffectee
except:
print "une erreur"
La s´equence ci-apr`es vous montre la syntaxe `a utiliser. Jouez un peu avec.
x = []
try:
print x[1]
except IndexError:
print "L’indice n’existe pas"
except (TypeError, NameError):
5