•Introduction à la programmation orientée objet •interfaces graphiques

Programmation
scientifique
•I
n t r o d u c t i o n à l a
p r o g r a m m a t i o n o r i e n t é e
•i n t e r f a c e s g r a p h i q u e s
Tuesday, March 30, 2010
o b j e t
Programmation
orientée objet
Approche pour de grands programmes
POO conduit à des modules qui peuvent évoluer
indépendemment
La plupart des modules Python (mais aussi matlab
etc..) utilisent la POO: important d’en connaître les
bases
Même vos programmes «simples» en utilisent...
Tuesday, March 30, 2010
Programmation procédurale
Ce dont vous avez l’habitude.
Programme décrit avec explicitement la séquence des opérations
à faire.
Accent sur les algorithmes, les procédures.
Séparation entre procédures et données
Améliorations:
• structuration du code: diviser le programme en blocs de
procédures ou fonctions réutilisables.
• Code organisé autant que possible en blocs structurés,
organisés de manière logique
Tuesday, March 30, 2010
Programmation orientée objet
Définir des types de données qui correspondent à votre problème
Avantages:
•
les types de données sont plus simples à isoler que des
algorithmes
•
les types de données sont plus stables que les algorithmes
qui peuvent évoluer
•
les types de données encapsulent l’implémentation
Stratégie:
•
•
identifier les types de données pour votre problème
•
écrire le programme qui les utilisent...
Tuesday, March 30, 2010
implémenter dans des classes regroupant les définitions des
variables (pour les données) et des algorithmes (méthodes)
pour les traiter.
Programmation objet
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
Quelles fonctions s’appliquent sur ces données?
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Les opérations possibles (méthodes) sur un objet (instance d’une classe) sont
encapsulées dans la classe: protection des données et du code.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
soustraire additionner deux dates
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Les opérations possibles (méthodes) sur un objet (instance d’une classe) sont
encapsulées dans la classe: protection des données et du code.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
soustraire additionner deux dates
distance entre deux points
• un polynome quadratique
• autre chose.…
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Les opérations possibles (méthodes) sur un objet (instance d’une classe) sont
encapsulées dans la classe: protection des données et du code.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
soustraire additionner deux dates
distance entre deux points
Ceci sont différentes «méthodes»
• un polynome quadratique
• autre chose.…
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Les opérations possibles (méthodes) sur un objet (instance d’une classe) sont
encapsulées dans la classe: protection des données et du code.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
soustraire additionner deux dates
distance entre deux points
Ceci sont différentes «méthodes»
additionner, multiplier, soustraire,
évaluer, dériver
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Les opérations possibles (méthodes) sur un objet (instance d’une classe) sont
encapsulées dans la classe: protection des données et du code.
Tuesday, March 30, 2010
Programmation objet
Les objets sont des variables qui ont une identité (la classe) et des fonctions
(les méthodes) qui opèrent sur elles.
Les données peuvent ressembler à de nombreuses choses:
Différentes identités
– soit un vecteur 3x1. Est-ce qu’il représente:
• une date (jour/mois/année)
• un point dans l’espace 3D
– coordonnées cartésiennes
– coordonnées cylindriques
– coordonnées sphériques
• un polynome quadratique
• autre chose.…
soustraire additionner deux dates
distance entre deux points
Ceci sont différentes «méthodes»
additionner, multiplier, soustraire,
évaluer, dériver
Quelles fonctions s’appliquent sur ces données?
Les classes donnent une identité, et associent des fonctions à cette identité (ne
permettent pas à deux dates d’être multipliées).
Les opérations possibles (méthodes) sur un objet (instance d’une classe) sont
encapsulées dans la classe: protection des données et du code.
Tuesday, March 30, 2010
Programmation objet: exemple 1
Exemple: beaucoup d’opérations standards sont associées à des
chaînes de caractères, comme passer cette chaîne en minuscule, en
majuscule, découper la chaîne, etc…
Dans un langage orienté objet, ces opérations sont des propriétés de
l’objet chaîne de caractères, on les appelle des méthodes
>>>original_string = ' un texte '
# enlever l’espace du début et de la fin
>>>string1 = original_string.strip()
# passé en majuscule
>>>string2 = string1.upper()
>>>print string2
>>>UN TEXTE
# test si minuscule ?
>>>string2.lower() == string1
>>>True
Tuesday, March 30, 2010
string2.lower() signifie
“appelle la méthode lower de
l’objet string2“ .
chaque chaîne de caractères est un
objet chaîne de caractères et possède
toutes les méthodes d’un objet de type
chaîne de caractères
Créer une classe en python
class OurClass(object):
"""Class docstring."""
def __init__(self, arg1, arg2):
"""Method docstring."""
self.arg1 = arg1
self.arg2 = arg2
def printargs(self):
"""Method docstring."""
print self.arg1
print self.arg2
Définition (héritage de la classe objet)
«Créateur» d’un objet de
cette classe lors d’une
instance (méthode __init_)
Référence à l’objet instancié
Ici définition d’une méthode, nommée
«printargs»
instance = OurClass('arg1', 'arg2')
print type(instance)
Dans cet exemple nous créons une instance de
<class 'OurClass'>
OurClass, et nous l’appelons instance. Quand
instance.printargs()
nous la créons, nous passons arg1 et arg2 en
arg1
arg2
arguments.
Tuesday, March 30, 2010
Définition d’une classe : Exemple 2
class Point:
‘’’Definition d'un point mathematique’’’
def __init__(self):
self.x=0.0
self.y=0.0
self.z=0.0
Méthode «constructeur»
def affiche(self):
print ‘x=’+str(self.x)+’ y=’ +str(self.y)+’ z=’+str(self.z)
Sauvegarde dans «geometrie.py»
>>>import geometrie
>>>A=Point()
>>>B=Point()
>>>A.x=-5.
>>>A.y=15.
>>>B.x=5
>>>A.affiche()
>>>x=-5. y=15. z=0.
>>>B.affiche()
>>>x=5. y=0. z=0.
Variables(attributs) d’instance
>>>print Point.__doc__
>>> Definition d'un point mathematique
Tuesday, March 30, 2010
Définition d’une classe : Exemple 2
(suite)
class Point:
‘’’Definition d'un point mathematique’’’
def __init__(self,xx=0.,yy=0.,zz=0.):
self.x=xx
self.y=yy
self.z=zz
def affiche(self):
print ‘x=’+str(self.x)+’ y=’ +str(self.y)+’ z=’+str(self.z)
>>>import geometrie
>>>A=Point(-5,15,5)
>>>B=Point(xx=5)
>>>A.affiche()
>>>x=-5. y=15. z=0.
>>>B.affiche()
>>>x=5. y=0. z=0.
>>>A.y
>>>15.
>>>C=Point(-5,15,5)
>>>print(A==C)
>>>0
Tuesday, March 30, 2010
Chaque instance est un
espace de nom distinct
Définition d’une classe : Exemple 2
(suite
2)
!"#$%"&'&(")*+*,*-+&.,&$,*/*#0,*-+&12$+.&3/0##.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!"#$%&$'(()"#*+,%-"+*.)""""""""""""!
!"'/+)/$"0"12345--)-6"758&)6"9::;""!
!"<5=)-=)"0"1#7""""""""""""""""""""!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
=<'>>"#%5-+0
""""???.%5-+"('+,@('+5A/)???
""""B)C"DD5-5+DDE>)<C6"F6"*G0
"""""""">)<C2F"H"F
"""""""">)<C2*"H"*
""""
=<'>>"I)=+'-&<)0
""""???$)=+'-&<)???
""""B)C"DD5-5+DDE>)<C6"'-&6"<'$6",'/G0
"""""""">)<C2'-&"H"'-&
"""""""">)<C2<'$"H"<'$
"""""""">)<C2,'/"H",'/
9$&4:$;;+&+;7&<*&20<:+&;+#3$*7&/&.#0%<)#+&%+;
0=>+7;?&@8$4<*&%A+<B&;+#$&<*+&)*;7$*4+&%+&:$
4:$;;+&40*;)%"#"+?&&
9+;&)*;7$*4+;&%+&:$&4:$;;+&50)*7CD
;+#0*7&%+;&0=>+7;&7#E;&;)2.:+;&F<)&.0;;"%+#0*7
;+<:+2+*7&<*&$77#)=<7&ABA&+7&<*&$77#)=<7&A6A&G
):;&*+&;+#0*7&%07";&%A$<4<*+&2"780%+?
9+&.$#$2E7#+& ;+:H &%";)1*+&70<7+;&:+;&)*;7$*4+;
F<)&;+#0*7&.#0%<)7+;&.$#&4+77+&4:$;;+
9+;&)*;7$*4+;&%+&:$&4:$;;+&I+47$*1:+CD
.0;;"%+#0*7&J&$77#)=<7;&,&:+&.#+2)+#&C&A$*1A&D
%0)7&K7#+&:<)L2K2+&<*&0=>+7&%+&4:$;;+&50)*7CD?
M:&;+#3)#$&/&2"20#);+#&:+;&400#%0**"+;&%+
:A$*1:+&;<."#)+<#&1$<48+&%<&#+47$*1:+?
""""B)C"+$%/J)K)-+$)E>)<CG0
""""""""F="H">)<C2'-&2F"L">)<C2<'$"M9
""""""""*="H">)<C2'-&2*"L">)<C2,'/"M9
""""""""$)+/$-"#%5-+EF=6"*=G
9$&4:$;;+&I+47$*1:+CD&402.0#7+&<*+&2"780%+N
F<)&#+*3+##$&<*&0=>+7&%+&4:$;;+&50)*7CD&$<
.#01#$22+&$..+:$*7?
=<'>>"K'$$)EI)=+'-&<)G0
""""???='$$@"H"$)=+'-&<)".'$+5=/<5)$???
""""B)C"DD5-5+DDE>)<C6"=%5-6"=%+)G0
""""""""I)=+'-&<)2DD5-5+DDE>)<C6
"""""""""""""""=%5-6"=%+)6"=%+)G
"""""""">)<C2=%+)"H"=%+)
@$##+CD&+;7&<*+&4:$;;+&%"#)3"+N&F<)&8"#)7+&:+;
$77#)=<7;&+7&2"780%+;&%+&:$&4:$;;+&I+47$*1:+CD?
'0*&40*;7#<47+<#&%0)7&H$)#+&$..+:&$<
40*;7#<47+<#&%+&:$&4:$;;+&.$#+*7+N&+*&:<)
7#$*;2+77$*7&:$&#"H"#+*4+&%+&:A)*;7$*4+&C;+:HD
4022+&.#+2)+#&$#1<2+*7?
""""B)C">/$C'=)E>)<CG0
""""""""$)+/$-">)<C2=%+)NN9
9$&4:$;;+&@$##+CD&402.0#7+&<*+&2"780%+&%+
.:<;&F<+&;$&4:$;;+&.$#+*7+?&
!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!"#$%&$'(()".$5-=5.'<"0"!!
""""""""
Tuesday, March
30, 2010
!"=%%$B2"B)"9"=%5->">/.2"&'/=,)>"0""
G. Swinnen: Apprendre à programmer
50<#&4#"+#&C0<&)*;7$*4)+#D&<*&0=>+7N&):&;<HH)7
%A$HH+47+#&<*+&4:$;;+&/&<*+&3$#)$=:+?
avec Python
"""""""""""""""=%5-6"=%+)6"=%+)G
"""""""">)<C2=%+)"H"=%+)
7#$*;2+77$*7&:$&#"H"#+*4+&%+&:A)*;7$*4+&C;+:HD
4022+&.#+2)+#&$#1<2+*7?
Définition d’une classe : Exemple 2
(suite
3)
9$&4:$;;+&@$##+CD&402.0#7+&<*+&2"780%+&%+
.:<;&F<+&;$&4:$;;+&.$#+*7+?&
""""B)C">/$C'=)E>)<CG0
""""""""$)+/$-">)<C2=%+)NN9
!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!"#$%&$'(()".$5-=5.'<"0"!!
""""""""
!"=%%$B2"B)"9"=%5->">/.2"&'/=,)>"0""
=>&I"H"#%5-+EO:6;:G
=>&K"H"#%5-+EP:69QG
50<#&4#"+#&C0<&)*;7$*4)+#D&<*&0=>+7N&):&;<HH)7
%A$HH+47+#&<*+&4:$;;+&/&<*+&3$#)$=:+?
9+;&)*;7#<47)0*;&4)L40*7#+&4#"+*7&%0*4
%+<B&0=>+7;&%+&:$&4:$;;+&50)*7CD???
!"?R%S+)>?"$)=+'-&/<'5$)")+"='$$@)"0"
R%5+)I"H"I)=+'-&<)E=>&I6"P::6"Q:G
R%5+)K"H"K'$$)E=>&K6"O:G
???&+7&4+::+;L4)N&+*40#+&%+<B&$<7#+;&0=>+7;?
O07+&,&.$#&40*3+*7)0*N&:+&*02&%A<*+&4:$;;+
4022+*4+&.$#&<*+&:+77#+&2$><;4<:+
!"K%%$B%--@)>"B/"=)-+$)".%/$"=,'=/-)"0
=I"H"R%5+)I2+$%/J)K)-+$)EG
=K"H"R%5+)K2+$%/J)K)-+$)EG
.$5-+"?=)-+$)"B/"$)=+2"0?6"=I2F6"=I2*
.$5-+"?=)-+$)"B/"='$$@"0?6"=K2F6"=K2*
.$5-+"?>/$C2"B/"='$$@"0?6
.$5-+"R%5+)K2>/$C'=)EG
!"#$%
Tuesday, March 30, 2010
9$&2"780%+&7#0<3+@+*7#+CD&H0*47)0**+&.0<#
:+;&0=>+7;&%+;&%+<B&76.+;N&.<);F<+&:$&4:$;;+
@$##+CD&$&8"#)7"&%+&4:$;;+&I+47$*1:+CD?
5$#&40*7#+N&:$&2"780%+&;<#H$4+CD&*+&.+<7&K7#+
)*30F<"+&F<+&.0<#&:+;&0=>+7;&4$##";?
!"#$#%&'()**+*&,&-..#+*%#+&/&.#01#$22+#&$3+4&56780*
Définition d’une classe : Exemple 2
(suite 4)
class Rectangle(Point):
'''Definition rectangle'''
Héritage des propriétés
de la classe Point()
def __init__(self,largeur=1.,hauteur=1.,xx=0.,yy=0.,zz=0.):
self.largeur=largeur
self.hauteur=hauteur
self.coin=Point(xx,yy,zz)
«Surcharge» de la méthode
affiche()
def affiche(self):
print 'Position'
self.coin.affiche()
print 'largeur='+str(self.largeur)+\
' hauteur=' +str(self.hauteur)
>>>mon_rectangle1=Rectangle
>>>mon_rectangle2=Rectangle(largeur=5,hauteur=10)
>>>mon_rectangle3=Rectangle(xx=1.,yy=2.)
>>>mon_rectangle1.affiche()
Position
x=0. y=0. z=0.
largeur=1 hauteur=1
Tuesday, March 30, 2010
Polymorphisme
Idée: Différents types d’objets peuvent implémenter différentes
opérations équivalentes en utilisant les mêmes noms. Les
algorithmes peuvent être implémentés une fois pour toute pour
tous ces types. Grâce à la surcharge.
Exemples
Atomes
atom = Atom(‘C’, Vector(0., 0., 1.))
atom.translateBy(Vector(-1., 1., 0.))
print atom.mass()
print atom.centerOfMass()
Molecules:
molecule = Molecule([atom1, atom2, atom3])
molecule.translateBy(Vector(-1., 1., 0.))
print molecule.mass()
print molecule.centerOfMass()
Tuesday, March 30, 2010
Code générique
def moveToOrigin(something):
cm = something.centerOfMass()
something.translateBy(-cm)
moveToOrigin(atom)
moveToOrigin(molecule)
Programmation objet: surcharge
La surcharge permet à une méthode de nom donné de posséder un
sens différent suivant le type de leurs arguments. Par exemple,
sachant qu’en python un opérateur est une méthode et les types de
variables de classe, l’opérateur + est une méthode qui peut être
surchargée...:
x = 5 +9 # addition entière
s=’’ab’’+’’cd’’ # concaténation de chaines
Python possède des méthodes de surcharge pour :
tous les types (__str__,__float__);
les nombres (__add__,__div__, ...);
les séquences (__len__,__iter__, . . .)
Tuesday, March 30, 2010
Programmation objet: exemple
méthodes spéciale
import numpy as N
class Vector:
def __init__(self, x, y, z):
v = Vector(1., -0.5, 2)
!" v = v.__init__(1., -0.5, 2)
self.array = N.array([x,y,z], N.float)
def __repr__(self):
return 'Vector(%s,%s,%s)' % \
print v
!" print repr(v)
!" print v.__repr__()
(`self.array[0]`, `self.array[1]`,`self.array[2]`)
def __add__(self, other):
s = self.array + other.array
return Vector(s[0], s[1], s[2])
v = v1 + v2
!" v = v1.__add__(v2)
x = v[0]
!" x = v.__getitem__(0)
def __getitem__(self, index):
return self.array[index]
def length(self):
return N.sqrt(N.add.reduce(self.array*self.array))
Tuesday, March 30, 2010
Polymorphisme
class Atom:
class Molecule:
def __init__(self, element, position): def __init__(self, atom_list):
self.element = element
self.atoms = atom_list
self.position = position
def translateBy(self, vector):
self.position += vector
def translateBy(self, vector):
for atom in self.atoms:
atom.translateBy(vector)
def centerOfMass(self):
return self.position
def centerOfMass(self):
sum1 = 0.
sum2 = Vector(0., 0., 0.)
def mass(self):
for atom in self.atoms:
return masses[self.element.lower()]
sum1 += atom.mass()
sum2 += atom.mass()*atom.position
return sum2/sum1
def mass(self):
return N.sum([a.mass()
for a in self.atoms])
Tuesday, March 30, 2010
Héritage
Idée: Souvent un type d’objet est la spécialisation d’un autre.
Il peut hériter les opérations générales et y ajouter les siennes
particulières.
Exemple: chaine peptidique comme un cas spécial de
molécules
class PeptideChain(Molecule):
def __init__(self, residue_list):
self.residues = residue_list
atoms = []
for r in residue_list:
atoms += r.atoms
Molecule.__init__(self, atoms)
def __getitem__(self, index):
return self.residues[index]
Tuesday, March 30, 2010
Programmer en objet
Question centrale: quels sont les «bons» types dans un
programme?
• Demande de la pratique
• Essais erreurs
• Ne pas hésiter à ré-écrire un code pour une meilleure
conception: ça paye toujours dans le long terme
Candidats types objets:
•
•
•
Objets mathématiques: vecteurs, matrices, polynomes
Objets physiques: atomes, molécules, fonctions d’onde
Objets abstraits: algorithmes (par ex intégrateurs), éléments
graphiques
Tuesday, March 30, 2010
Modules
Un module est un fichier (extension .py) qui contient:
•des définition de fonctions
•des définitions de classes
•d’autres définitions (constantes,...)
En général un module «ne fait rien», il donne seulement les définitions
utilisées par d’autres modules ou par des programmes.
Mais en réalité il n’y a pas de réelle distinction entre un module et un
programme: un programme est un module dont e nom est __main__.
Tuesday, March 30, 2010
Module: exemple
File counting.py
def count_atoms_by_element(filename):
element_counts = {}
for line in file(filename):
if line[:6] == 'ATOM ':
element = line[76:78]
element_symbol = element.strip() # element is a two-character string,
# so we need to remove the spaces at the end
element_counts[element_symbol] = element_counts.get(element_symbol, 0) + 1
# count by element
return element_counts
def print_atom_counts(element_counts, element_names):
for element_name in element_names:
print element_name, element_counts.get(element_name.upper(), 0)
File count_atoms_pdb.py
from counting import count_atoms_by_element, print_atom_counts
import sys
filename = sys.argv[1]
element_names = sys.argv[2:]
element_counts = count_atoms_by_element(filename)
print_atom_counts(element_counts, element_names)
Tuesday, March 30, 2010
Où est-ce que Python cherche
pour des modules?
Quand on importe un module Python parcours une liste de répertoires,
s’arrêtant quand il trouve le fichier anvec le bon nom.
La liste des répertoirs parcourus est accessible sous Python:
import sys
print sys.path
Elle peut être changée (MacOS, Linux) en déclarant la variable
environnement PYTHONPATH:
export PYTHONPATH=$HOME/python (bash) or
setenv PYTHONPATH $HOME/python (csh)
Tuesday, March 30, 2010
Interfaces
graphiques
G r a p h i c a l U s e r
I n t e r f a c e ( G U I )
Tuesday, March 30, 2010
interfaces graphiques ?
Boites à outils graphiques
chargé de la gestion des différents composants
de l’interface : bouton, ascenseurs, zone de
texte
chargé de partager le serveur graphique entre les
différentes applications
chargé des primitives de dessin de bas niveau ;
Wikipedia
Tuesday, March 30, 2010
Boites à outils GUI
(Toolkits)
Couche de fonctions faisant le lien entre un
programme et les gestionnaires graphiques de
l’ordinateur (widget toolkit, widget library, GUI
toolkit). Elles viennent de l’OS, du gestionnaire de
fenêtres, ou de systèmes graphiques additionnels.
Propose un ensemble de routines (widgets) aux
programmes sous forme de Application
Programming Interfaces (API) pour tout ce qui est
gestion du graphisme et des interactions utilisateurs.
Tuesday, March 30, 2010
Widgets
Widgets: composants de programmation graphiques (routines)
Les Widgets d’un toolkit se conforment à un choix unifié de
spécifications de design pour l'esthétisme, la facilité
d’utilisation, les performances etc...
Exemple de widgets: la
création d’une fenêtre
simple, la création de
fenêtres avec
ascenseurs, boites de
dialogues, boutons,
etc...
Tuesday, March 30, 2010
Widgets
Actuellement généralement des hiérarchies de
classes (programmation objet).
Familles de composants graphiques:
Conteneurs
Boutons, ascenseurs
Dialogues
Objets graphiques (droites, cercles, etc...)
Transformations
Tuesday, March 30, 2010
Widgets spécialisés
Sur-couches aux toolkits GUI pour des tâches
particulières:
• graphismes scientifiques (matplotlib, mayavi)
• graphisme 3D (Vpython)
• animations (pygame)
• multimedia (pygame)
• simulations
Tuesday, March 30, 2010
GUIs pour Python
•
Parmi lesdifférentes bibliothèqeus graphiques utilisables dans Python
(GTK+, wxPython, Qt. . .), la bibliothèque Tkinter, issue du
langage tcl/Tk est très employée, car elle est installée de base dans toute les
distributions Python.
•
Tkinter facilite la construction de GUI (Graphic User Interface)
simples. Après l’avoir importé, il suffit de créer, configurer et positionner
les widgets utilisés, puis d’entrer dans la boucle principale de gestion des
événements.
Cordeau cours Python IUT Orsay
Tuesday, March 30, 2010
Organisation d’un
toolkit GUI
L’interface utilisateur d’un programme est généralement
construite hiérarchiquement en une cascade de widgets
ajoutés au dessus d’autres widgets.
La plupart des toolkits widgets utilisent la programmation
par événements pour gérer les interaction. Le toolkit traite
les événements utilisateurs, par exemple quand l’utilisateur
clique un bouton.
Quand un événement est détecté il est passé à l’application
où il est traité.
Tuesday, March 30, 2010
Deux styles de programmation
Deux
styles de programmation
Programmation
événementielle
En
programmation
graphique
objet,
on
remplace
le
déroulement
En
programmation
graphique
objet,
on
En programmation graphique objet, on remplace le déroulement
séquentiel
du
script
par
une
boucle
d’événements
:
remplace
le
déroulement
séquentiel
du
script
séquentiel du script par une boucle d’événements :
par une boucle d’événements :
112 / 135
112 /
Tuesday, March 30, 2010
Tk()
exemple!",
simple
= Label(base,Tkinter
text="Bienvenue
fg="red")
pack()
= Button(base,
text="Quit",
command=base.destroy)
from Tkinter import *
.pack()
base = Tk()
texte = Label(base, text="Bienvenue !", fg="red")
texte.pack()
ainloop()
bouton = Button(base, text="Quit", command=base.destroy)
bouton.pack()
base.mainloop()
Tuesday, March 30, 2010
widgets Tkinter (1)
•Tk fenêtre de plus haut niveau
•Frame contenant pour organiser d’autres widgets
•Label zone de message
•Button bouton avec texte ou image
•Message zone d’affichage multi-lignes
•Entry zone de saisie
•Checkbutton bouton à deux états
•Radiobutton bouton à deux états exclusifs
Tuesday, March 30, 2010
widgets Tkinter (2)
•Scale glissière à plusieurs positions
•PhotoImage sert à placer des images sur des widgets
•BitmapImage sert à placer des bitmaps sur des widgets
•Menu associé à un Menubutton
•Menubutton bouton ouvrant un menu d’options
• Scrollbar ascenseur
•Listbox liste de noms à sélectionner
•Text édition de texte multi-lignes
Tuesday, March 30, 2010
widgets Tkinter (3)
•Canvas zone de dessins graphiques ou de photos
•OptionMenu liste déroulante
•ScrolledText widget Text avec ascenseur
• PanedWindow interface à onglets
•LabelFrame contenant avec un cadre et un titre
• Spinbox un widget de s élection multiple
Tuesday, March 30, 2010
Tkinter: gestion de
la géométrie
Tkinter possède trois gestionnaires de positionnement :
Le packer : dimensionne et place chaque widget dans un
widget conteneur selon l’espace requis par chacun d’eux.
Le gridder : dimensionne et positionne chaque widget dans
les cellules d’un tableau d’un widget conteneur.
Le placer : dimensionne et place chaque widget w dans un
widget conteneur exactement selon ce que demande w. C’est
un placement absolu (usage peu fréquent).
Tuesday, March 30, 2010
Tkinter: hello world
# 1er exemple Tk
from Tkinter import *
# La "fenetre" (widget) racine
instance de la
root = Tk()
# Creation d'un champ de texte:
w = Label(root, text="Salut monde cruel !")
# Positionnement du champ:
w.pack()
# "Boucle" principale
root.mainloop()
http://www-gtr.iutv.univ-paris13.fr/Cours/Mat/Python/CoursTk
Tuesday, March 30, 2010
classe Tk
Tkinter: exemple 2
# Exemple simple de bouton Tk
from Tkinter import *
root = Tk()
instance de
def action():
print 'Bouton presse'
b = Button( root, text='Voici un bouton',
command=action )
b.pack()
root.mainloop()
>>>Bouton presse
http://www-gtr.iutv.univ-paris13.fr/Cours/Mat/Python/CoursTk
Tuesday, March 30, 2010
la classe Tk
Tkinter: exemple 3
# 2ieme exemple Tk
from Tkinter import *
class Application:
def __init__(self, parent):
# 1- Cree un widget "cadre"
frame = Frame(parent)
frame.pack()
# 2- Cree un bouton pour quitter
button = Button(frame, text="QUIT",
fg="red",
command=frame.quit)
button.grid(row=0)
# 3- Cree un bouton pour saluer...
salut = Button(frame, text="Salut !",
command=self.salutation)
salut.grid(row=1)
def salutation(self) # appele lorsqu'on appuie le bouton "salut"
print "Salut TOUS !"
# Creation de l'application:
root = Tk()
app = Application(root)
root.mainloop()
Opérateurs de
placement
>>>Salut TOUS !
Tuesday, March 30, 2010
Tkinter: exemple 3
# Exercice utilisant la bibliothèque graphique Tkinter et le module math
#G. Swinnen: Apprendre a programmer avec Python
from Tkinter import *
from math import *
méthode «get»
# définition de l'action à effectuer si l'utilisateur actionne du widget «entree»
# la touche "enter" alors qu'il édite le champ d'entrée :
def evaluer(event):
chaine.configure(text = "Résultat = " + str(eval(entree.get())))
# ----- Programme principal : ----méthode «configure»
fenetre = Tk()
Classe Entry
du widget «chaine»
entree = Entry(fenetre)
Widget «entree» (instance de «Entry»)
entree.bind("<Return>", evaluer)
chaine = Label(fenetre)
Evénement associé
entree.pack()
chaine.pack()
Widget
fenetre.mainloop()
«chaine» (instance)
de la classe «Label»
Tuesday, March 30, 2010
La programmation � OO � graphique
Les bibliothèques graphiques
positionnement
Les classes Le
de widgets
de Tkinter des widgets
Un exemple
Le positionnement
des widgets
Un exemple
Tkinter: exemple 4
� : programmation OO (4/4)
Saisie
�
Saisie : programmation OO (4/4)
Le
ouvre
deux
fenêtres.
On On
saisit
une
note...
Leprogramme
programme
ouvre
deux
fenêtres.
saisit
une
note...
Le
programme
ouvre
deux
fenêtres.
On
saisit
une
note...
...qui ...qui
est reportée
dans ladans
première
fenêtre.fenêtre.
est reportée
la première
...qui est reportée dans la première fenêtre.
Tuesday, March 30, 2010
Tkinter: exemple simple 4.1
L’en-tête et les imports (on utilise le module Pmw, Python Mega Widgets)
#!/bin/env python
# -*- coding: UTF-8 -*"""Programmation OO graphique."""
# auteur : Bob Cordeau
# imports
from Tkinter import *
from tkSimpleDialog import *
import Pmw
Tuesday, March 30, 2010
Tkinter: exemple simple 4.2
Définition d’une classe (que nous nommons «App») pour l’application
graphique.
# classes
class App:
def __init__(self, master):
self.result = Pmw.EntryField(master, entry_width=8,
value=’10’,
label_text=’Affichage retourné: ’,
labelpos=W, labelmargin=1)
self.result.pack(padx=15, pady=15)
Tuesday, March 30, 2010
Tkinter: exemple simple 4.3
Le programme principal
# programme principal ------------------------------------root = Tk()
display = App(root)
retVal = askinteger("Notes",
"Entrez votre note d’info :",
minvalue=0, maxvalue=50)
display.result.setentry(retVal)
root.mainloop()
Tuesday, March 30, 2010
Références
K. Hinsen
G. Swinnen, Apprendre à programmer avec
Python
http://www.voidspace.org.uk/python/articles/
oop_francais.shtml
Tkinter: http://www.iut-orsay.fr/dptmphy/
Pedagogie/coursPython.pdf
Tuesday, March 30, 2010