salut à tous,
j'ai un probleme avec les dicionnaires. Je vous explique :
J'ai créer les classes suivantes :
Vous me semblez fâché avec l'orthographe. (cela m'arrive aussi)
(j'utilise le mot 'abstrait' pour dire 'non visuel', pas dans le sens
objet 'abstrait')
Point : modélise un point abstrait.
OK
VisualElement : cette classe définit un élement visuel abstrait (au
sens objet cette fois-ci). La méthode principale de cette classe est
'respresent(abstractObject)' qui prends en argument un objet abstrait
a représenter à l'écran , et qui le lie à l'objet visuelle qui le
represente (l'instance appelante). Cette liaison est implémentée sous forme
de dictionnaire associatif où les clés seraient les objets abstraits (les
points) et où les valeurs seraient les élements visuels (points visuels).
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
Le problème c'est que quand j'essaye de lier un objet abstrait à un
objet visuel à l'aide de la méthode VisualElement.represent(), j'ai une
exception du type : 'unhashable instance'
Voici l'appelant qui déclanche l'exception :
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
def __init__(self,application,P=Point(),ray,color="red") :
"""
arguments are : the application using the visual point, the point
represented,
and it's color (red by default)
"""
VisualElement.__init__(self,application,color)
Point.__init__(self,P.x,P.y)
###> ci-dessous la ligne appelante :
self.represent(P)
self.ULx = P.x - ray
self.ULy = P.y - ray
self.BRx = P.x + ray
self.BRy = P.y + ray
Voici la classe qui possède cette méthode :
class VisualElement :
Moi je n'utiliserais que des classes modernes :
representants = {}
def __init__(self,application,color="black") :
self.app = application
self.item_n = 0
self.color = color
def represent(self,abstractObject) :
""" this methode attaches a Visual Element to an abstract object
passed as an argument"""
self.represented = abstractObject
###> la ligne ci-aprés déclanche l'excpetion :
VisualElement.representants[abstractObject] = self
Toute aide sera grandement appréciée.
Le code en entier pour ceux qui veulent debuger :
from Tkinter import *
class Point :
def __init__ (self,x=0,y=0) :
Aie les indentations sont perdues dans le copier coller
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y - P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé. Vous n'utilisez pas
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Pour ce genre d'algorithme il me semble qu'avec
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Finalement un Point == deux coordonnées x et y.
Il me semble que dans le cas de votre application multiplier les classes
salut à tous,
j'ai un probleme avec les dicionnaires. Je vous explique :
J'ai créer les classes suivantes :
Vous me semblez fâché avec l'orthographe. (cela m'arrive aussi)
(j'utilise le mot 'abstrait' pour dire 'non visuel', pas dans le sens
objet 'abstrait')
Point : modélise un point abstrait.
OK
VisualElement : cette classe définit un élement visuel abstrait (au
sens objet cette fois-ci). La méthode principale de cette classe est
'respresent(abstractObject)' qui prends en argument un objet abstrait
a représenter à l'écran , et qui le lie à l'objet visuelle qui le
represente (l'instance appelante). Cette liaison est implémentée sous forme
de dictionnaire associatif où les clés seraient les objets abstraits (les
points) et où les valeurs seraient les élements visuels (points visuels).
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
Le problème c'est que quand j'essaye de lier un objet abstrait à un
objet visuel à l'aide de la méthode VisualElement.represent(), j'ai une
exception du type : 'unhashable instance'
Voici l'appelant qui déclanche l'exception :
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
def __init__(self,application,P=Point(),ray,color="red") :
"""
arguments are : the application using the visual point, the point
represented,
and it's color (red by default)
"""
VisualElement.__init__(self,application,color)
Point.__init__(self,P.x,P.y)
###> ci-dessous la ligne appelante :
self.represent(P)
self.ULx = P.x - ray
self.ULy = P.y - ray
self.BRx = P.x + ray
self.BRy = P.y + ray
Voici la classe qui possède cette méthode :
class VisualElement :
Moi je n'utiliserais que des classes modernes :
representants = {}
def __init__(self,application,color="black") :
self.app = application
self.item_n = 0
self.color = color
def represent(self,abstractObject) :
""" this methode attaches a Visual Element to an abstract object
passed as an argument"""
self.represented = abstractObject
###> la ligne ci-aprés déclanche l'excpetion :
VisualElement.representants[abstractObject] = self
Toute aide sera grandement appréciée.
Le code en entier pour ceux qui veulent debuger :
from Tkinter import *
class Point :
def __init__ (self,x=0,y=0) :
Aie les indentations sont perdues dans le copier coller
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y - P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé. Vous n'utilisez pas
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Pour ce genre d'algorithme il me semble qu'avec
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Finalement un Point == deux coordonnées x et y.
Il me semble que dans le cas de votre application multiplier les classes
salut à tous,
j'ai un probleme avec les dicionnaires. Je vous explique :
J'ai créer les classes suivantes :
Vous me semblez fâché avec l'orthographe. (cela m'arrive aussi)
(j'utilise le mot 'abstrait' pour dire 'non visuel', pas dans le sens
objet 'abstrait')
Point : modélise un point abstrait.
OK
VisualElement : cette classe définit un élement visuel abstrait (au
sens objet cette fois-ci). La méthode principale de cette classe est
'respresent(abstractObject)' qui prends en argument un objet abstrait
a représenter à l'écran , et qui le lie à l'objet visuelle qui le
represente (l'instance appelante). Cette liaison est implémentée sous forme
de dictionnaire associatif où les clés seraient les objets abstraits (les
points) et où les valeurs seraient les élements visuels (points visuels).
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
Le problème c'est que quand j'essaye de lier un objet abstrait à un
objet visuel à l'aide de la méthode VisualElement.represent(), j'ai une
exception du type : 'unhashable instance'
Voici l'appelant qui déclanche l'exception :
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
def __init__(self,application,P=Point(),ray,color="red") :
"""
arguments are : the application using the visual point, the point
represented,
and it's color (red by default)
"""
VisualElement.__init__(self,application,color)
Point.__init__(self,P.x,P.y)
###> ci-dessous la ligne appelante :
self.represent(P)
self.ULx = P.x - ray
self.ULy = P.y - ray
self.BRx = P.x + ray
self.BRy = P.y + ray
Voici la classe qui possède cette méthode :
class VisualElement :
Moi je n'utiliserais que des classes modernes :
representants = {}
def __init__(self,application,color="black") :
self.app = application
self.item_n = 0
self.color = color
def represent(self,abstractObject) :
""" this methode attaches a Visual Element to an abstract object
passed as an argument"""
self.represented = abstractObject
###> la ligne ci-aprés déclanche l'excpetion :
VisualElement.representants[abstractObject] = self
Toute aide sera grandement appréciée.
Le code en entier pour ceux qui veulent debuger :
from Tkinter import *
class Point :
def __init__ (self,x=0,y=0) :
Aie les indentations sont perdues dans le copier coller
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y - P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé. Vous n'utilisez pas
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Pour ce genre d'algorithme il me semble qu'avec
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Finalement un Point == deux coordonnées x et y.
Il me semble que dans le cas de votre application multiplier les classes
On Mon, 20 Dec 2004 17:49:38 +0100, chahnaz.ourzikene wrote:salut à tous,
j'ai un probleme avec les dicionnaires. Je vous explique :
J'ai créer les classes suivantes :
Vous me semblez fâché avec l'orthographe. (cela m'arrive aussi)(j'utilise le mot 'abstrait' pour dire 'non visuel', pas dans le sens
objet 'abstrait')
Point : modélise un point abstrait.
OK
VisualElement : cette classe définit un élement visuel abstrait (au
sens objet cette fois-ci). La méthode principale de cette classe est
'respresent(abstractObject)' qui prends en argument un objet abstrait
a représenter à l'écran , et qui le lie à l'objet visuelle qui le
represente (l'instance appelante). Cette liaison est implémentée sous
forme
de dictionnaire associatif où les clés seraient les objets abstraits
(les
points) et où les valeurs seraient les élements visuels (points
visuels).
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans
le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Aie les indentations sont perdues dans le copier coller
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y -
P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé.
Vous n'utilisez pas d'instruction global et c'est bien
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Et que se passe-t-il si list est vide ?
Pour ce genre d'algorithme il me semble qu'avec
import Numeric as N
suivi de help(N) on devrait trouver son bonheur.
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet, on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
Il me semble que dans le cas de votre application multiplier les classes
ne s'impose pas. Vous b'auriez pas fait beaucoup de java dans une vie
antérieure ? (:-) et quelle expérience avez-vous en Fortran ?
Il y a plus loin dans le code une utilisation subtile de méthode et
d'attribut avec le même nom (ou presque) qui m'échappe.
Je vous conseillerais de passer pylint sur votre module et de poser
votre question lorsque pylint vous donnera un score d'au moins 7
(j'esp-re que vous n'utilisez pas les tabulations pour indenter car
alors votre premier score pylint sera négatif) (pylint est sur
logilab.org)
On Mon, 20 Dec 2004 17:49:38 +0100, chahnaz.ourzikene wrote:
salut à tous,
j'ai un probleme avec les dicionnaires. Je vous explique :
J'ai créer les classes suivantes :
Vous me semblez fâché avec l'orthographe. (cela m'arrive aussi)
(j'utilise le mot 'abstrait' pour dire 'non visuel', pas dans le sens
objet 'abstrait')
Point : modélise un point abstrait.
OK
VisualElement : cette classe définit un élement visuel abstrait (au
sens objet cette fois-ci). La méthode principale de cette classe est
'respresent(abstractObject)' qui prends en argument un objet abstrait
a représenter à l'écran , et qui le lie à l'objet visuelle qui le
represente (l'instance appelante). Cette liaison est implémentée sous
forme
de dictionnaire associatif où les clés seraient les objets abstraits
(les
points) et où les valeurs seraient les élements visuels (points
visuels).
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans
le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Aie les indentations sont perdues dans le copier coller
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y -
P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé.
Vous n'utilisez pas d'instruction global et c'est bien
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Et que se passe-t-il si list est vide ?
Pour ce genre d'algorithme il me semble qu'avec
import Numeric as N
suivi de help(N) on devrait trouver son bonheur.
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet, on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
Il me semble que dans le cas de votre application multiplier les classes
ne s'impose pas. Vous b'auriez pas fait beaucoup de java dans une vie
antérieure ? (:-) et quelle expérience avez-vous en Fortran ?
Il y a plus loin dans le code une utilisation subtile de méthode et
d'attribut avec le même nom (ou presque) qui m'échappe.
Je vous conseillerais de passer pylint sur votre module et de poser
votre question lorsque pylint vous donnera un score d'au moins 7
(j'esp-re que vous n'utilisez pas les tabulations pour indenter car
alors votre premier score pylint sera négatif) (pylint est sur
logilab.org)
On Mon, 20 Dec 2004 17:49:38 +0100, chahnaz.ourzikene wrote:salut à tous,
j'ai un probleme avec les dicionnaires. Je vous explique :
J'ai créer les classes suivantes :
Vous me semblez fâché avec l'orthographe. (cela m'arrive aussi)(j'utilise le mot 'abstrait' pour dire 'non visuel', pas dans le sens
objet 'abstrait')
Point : modélise un point abstrait.
OK
VisualElement : cette classe définit un élement visuel abstrait (au
sens objet cette fois-ci). La méthode principale de cette classe est
'respresent(abstractObject)' qui prends en argument un objet abstrait
a représenter à l'écran , et qui le lie à l'objet visuelle qui le
represente (l'instance appelante). Cette liaison est implémentée sous
forme
de dictionnaire associatif où les clés seraient les objets abstraits
(les
points) et où les valeurs seraient les élements visuels (points
visuels).
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans
le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Aie les indentations sont perdues dans le copier coller
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y -
P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé.
Vous n'utilisez pas d'instruction global et c'est bien
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Et que se passe-t-il si list est vide ?
Pour ce genre d'algorithme il me semble qu'avec
import Numeric as N
suivi de help(N) on devrait trouver son bonheur.
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet, on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
Il me semble que dans le cas de votre application multiplier les classes
ne s'impose pas. Vous b'auriez pas fait beaucoup de java dans une vie
antérieure ? (:-) et quelle expérience avez-vous en Fortran ?
Il y a plus loin dans le code une utilisation subtile de méthode et
d'attribut avec le même nom (ou presque) qui m'échappe.
Je vous conseillerais de passer pylint sur votre module et de poser
votre question lorsque pylint vous donnera un score d'au moins 7
(j'esp-re que vous n'utilisez pas les tabulations pour indenter car
alors votre premier score pylint sera négatif) (pylint est sur
logilab.org)
"F. Petitjean" a écrit dans le message de news:
41c72f9b$0$10120$
Point : modélise un point abstrait.
OK
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans
lesens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de Point.
Votre explication est "buzzword compliant" : classe abstraite,
Il se compose de cooronnées (x,y), et de quelques attributs supplémentaires
qui permettent de l'afficher correctement sur un écran et de pouvoir le
retrouver facilement (pour lui changer de couleur par exemple ou de
taille...). Or, la couleur, la taille, et l'affichage à l'écran ne concerne
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels. Cette
classe regroupe donc tous les attributs nécessaires pour la visualition à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
Voir plus haut. Mais peut être qu'une solution plus simple existe !
Faîtes une recherche sur une classe Bunch proposée par Alex Martelli sur
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Je n'ai pas encore eu l'occasion d'étudier cette classe. Un internaute m'a
suggérer sur le forum dédié à python du site www.developpez.com d'utiliser
justement ce type de classe pour que ma fonction de hachage puisse se faire
sans difficulté sur mes objets, du moment qu'ils en héritent. (la classe
object implémente une methode __hash__ il me semble...).
Il y a actuellement sur comp.lang.python un fil sur les objets hachables
Aie les indentations sont perdues dans le copier coller
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y -
P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
C'est une erreur, merci de l'avoir signalé. le bon argument est P bien sûre.if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé.
Non, autre erreur. Elle doit être initialisée à 0. Le code n'est pas fini
car je suis bloqué par cet affaire de dictionnaire !!
Ne jamais aller trop vite : une fois que laméthode est tapée on ajoute
Vous n'utilisez pas d'instruction global et c'est bien
J'essaye d'éviter au maximum le couplage pour un maximum de cohésion. (c'est
bien les bons termes ??)farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Et que se passe-t-il si list est vide ?
le return P ne se fait qu'à la sortie de la boucle for. Si la liste est vide
P devrait valoir None... ( à gérer par l'appelant ). Je pense que le mieux
c'est de lever une exception.
Tout à fait d'accord avec vous sur ce point.
Pour ce genre d'algorithme il me semble qu'avec
import Numeric as N
suivi de help(N) on devrait trouver son bonheur.
Je ne connais pas encore les différents modules python, ni toutes les
structures de données et classes buil-in qu'il supporte.
Effectivement il n'y a pas que le dictionnaire pour obtenir une
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet, on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
ça pourrait être une solution, mais je préfère (essayer de) mener la logique
objet jusqu'au bout dans mon application.
Un des principes qu'on retrouve dans l'Extreme Programming (par exemple
Il me semble que dans le cas de votre application multiplier les classes
ne s'impose pas. Vous b'auriez pas fait beaucoup de java dans une vie
antérieure ? (:-) et quelle expérience avez-vous en Fortran ?
C'est encore pire, j'ai fait beaucoup de C ! passer de la conception
fonctionnelle et l'analyse structurelle à l'analyse et la conception objet
n'a pas été trés evidente. Avant python j'ai essayé le C++ et ça m'a fait un
peu d'entrainement pour aborder la POO.Il y a plus loin dans le code une utilisation subtile de méthode et
d'attribut avec le même nom (ou presque) qui m'échappe.
Ce que je fais souvent c'est donner le même nom à un attribut d'instance et
à un argument de méthode. Ce que je fais moins souvent c'est de donner le
même nom à un attribut d'instance et à une méthode... ça serait quand même
un peu confus, et pour moi, et pour l'interprete python qui n'aurait
surement pas apprécié.
Vous n'êtes pas sans savoir qu'une méthode python est un attribut de
Je vous conseillerais de passer pylint sur votre module et de poser
votre question lorsque pylint vous donnera un score d'au moins 7
pylint est un outil d'analyse de code python ?
oui et c'est Français et free software (et pur python)
Sous emacs c'est quand même plus pratique de mettre des tabulations...
surtout que je crois qu'il les converti automatiquement en 4 espaces
blancs..(à vérifier..)
Merci d'avoir pris la peine d'analyser le code et d'avoir pris la peine de
le lire. Merci pour également pour vos suggestions.
il n'y a pas de quoi.
Y.Chaouche.
"F. Petitjean" <littlejohn.75@noos.fr> a écrit dans le message de news:
41c72f9b$0$10120$636a15ce@news.free.fr...
Point : modélise un point abstrait.
OK
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans
le
sens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de Point.
Votre explication est "buzzword compliant" : classe abstraite,
Il se compose de cooronnées (x,y), et de quelques attributs supplémentaires
qui permettent de l'afficher correctement sur un écran et de pouvoir le
retrouver facilement (pour lui changer de couleur par exemple ou de
taille...). Or, la couleur, la taille, et l'affichage à l'écran ne concerne
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels. Cette
classe regroupe donc tous les attributs nécessaires pour la visualition à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
Voir plus haut. Mais peut être qu'une solution plus simple existe !
Faîtes une recherche sur une classe Bunch proposée par Alex Martelli sur
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Je n'ai pas encore eu l'occasion d'étudier cette classe. Un internaute m'a
suggérer sur le forum dédié à python du site www.developpez.com d'utiliser
justement ce type de classe pour que ma fonction de hachage puisse se faire
sans difficulté sur mes objets, du moment qu'ils en héritent. (la classe
object implémente une methode __hash__ il me semble...).
Il y a actuellement sur comp.lang.python un fil sur les objets hachables
Aie les indentations sont perdues dans le copier coller
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y -
P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
C'est une erreur, merci de l'avoir signalé. le bon argument est P bien sûre.
if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé.
Non, autre erreur. Elle doit être initialisée à 0. Le code n'est pas fini
car je suis bloqué par cet affaire de dictionnaire !!
Ne jamais aller trop vite : une fois que laméthode est tapée on ajoute
Vous n'utilisez pas d'instruction global et c'est bien
J'essaye d'éviter au maximum le couplage pour un maximum de cohésion. (c'est
bien les bons termes ??)
farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Et que se passe-t-il si list est vide ?
le return P ne se fait qu'à la sortie de la boucle for. Si la liste est vide
P devrait valoir None... ( à gérer par l'appelant ). Je pense que le mieux
c'est de lever une exception.
Tout à fait d'accord avec vous sur ce point.
Pour ce genre d'algorithme il me semble qu'avec
import Numeric as N
suivi de help(N) on devrait trouver son bonheur.
Je ne connais pas encore les différents modules python, ni toutes les
structures de données et classes buil-in qu'il supporte.
Effectivement il n'y a pas que le dictionnaire pour obtenir une
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet, on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
ça pourrait être une solution, mais je préfère (essayer de) mener la logique
objet jusqu'au bout dans mon application.
Un des principes qu'on retrouve dans l'Extreme Programming (par exemple
Il me semble que dans le cas de votre application multiplier les classes
ne s'impose pas. Vous b'auriez pas fait beaucoup de java dans une vie
antérieure ? (:-) et quelle expérience avez-vous en Fortran ?
C'est encore pire, j'ai fait beaucoup de C ! passer de la conception
fonctionnelle et l'analyse structurelle à l'analyse et la conception objet
n'a pas été trés evidente. Avant python j'ai essayé le C++ et ça m'a fait un
peu d'entrainement pour aborder la POO.
Il y a plus loin dans le code une utilisation subtile de méthode et
d'attribut avec le même nom (ou presque) qui m'échappe.
Ce que je fais souvent c'est donner le même nom à un attribut d'instance et
à un argument de méthode. Ce que je fais moins souvent c'est de donner le
même nom à un attribut d'instance et à une méthode... ça serait quand même
un peu confus, et pour moi, et pour l'interprete python qui n'aurait
surement pas apprécié.
Vous n'êtes pas sans savoir qu'une méthode python est un attribut de
Je vous conseillerais de passer pylint sur votre module et de poser
votre question lorsque pylint vous donnera un score d'au moins 7
pylint est un outil d'analyse de code python ?
oui et c'est Français et free software (et pur python)
Sous emacs c'est quand même plus pratique de mettre des tabulations...
surtout que je crois qu'il les converti automatiquement en 4 espaces
blancs..(à vérifier..)
Merci d'avoir pris la peine d'analyser le code et d'avoir pris la peine de
le lire. Merci pour également pour vos suggestions.
il n'y a pas de quoi.
Y.Chaouche.
"F. Petitjean" a écrit dans le message de news:
41c72f9b$0$10120$
Point : modélise un point abstrait.
OK
VisualPoint(Point) : représentation visuelle d'un point (abstrait dans
lesens non visuel) à l'écran. Dérive de la
classe Point
Et pourquoi dérivé ?
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de Point.
Votre explication est "buzzword compliant" : classe abstraite,
Il se compose de cooronnées (x,y), et de quelques attributs supplémentaires
qui permettent de l'afficher correctement sur un écran et de pouvoir le
retrouver facilement (pour lui changer de couleur par exemple ou de
taille...). Or, la couleur, la taille, et l'affichage à l'écran ne concerne
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels. Cette
classe regroupe donc tous les attributs nécessaires pour la visualition à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
Voir plus haut. Mais peut être qu'une solution plus simple existe !
Faîtes une recherche sur une classe Bunch proposée par Alex Martelli sur
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Je n'ai pas encore eu l'occasion d'étudier cette classe. Un internaute m'a
suggérer sur le forum dédié à python du site www.developpez.com d'utiliser
justement ce type de classe pour que ma fonction de hachage puisse se faire
sans difficulté sur mes objets, du moment qu'ils en héritent. (la classe
object implémente une methode __hash__ il me semble...).
Il y a actuellement sur comp.lang.python un fil sur les objets hachables
Aie les indentations sont perdues dans le copier coller
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
self.x = x
self.y = y
def squareDistTo(self,P) :
return ((self.x - P.x) * (self.x - P.x)) + ((self.y - P.y) * (self.y -
P.y))
def farestOf(self,list) :
"""list is a list of points to search in """
for P in list :
dist = self.squareDistTo(l)
c'est quoi cet argument "l" ?
C'est une erreur, merci de l'avoir signalé. le bon argument est P bien sûre.if dist > farestDist :
Il me semble que farestDist n'a pas été initialisé.
Non, autre erreur. Elle doit être initialisée à 0. Le code n'est pas fini
car je suis bloqué par cet affaire de dictionnaire !!
Ne jamais aller trop vite : une fois que laméthode est tapée on ajoute
Vous n'utilisez pas d'instruction global et c'est bien
J'essaye d'éviter au maximum le couplage pour un maximum de cohésion. (c'est
bien les bons termes ??)farestDist = dist
farestPoint = P
return P
Difficile de savoir de combien est indenté ce return.
Et que se passe-t-il si list est vide ?
le return P ne se fait qu'à la sortie de la boucle for. Si la liste est vide
P devrait valoir None... ( à gérer par l'appelant ). Je pense que le mieux
c'est de lever une exception.
Tout à fait d'accord avec vous sur ce point.
Pour ce genre d'algorithme il me semble qu'avec
import Numeric as N
suivi de help(N) on devrait trouver son bonheur.
Je ne connais pas encore les différents modules python, ni toutes les
structures de données et classes buil-in qu'il supporte.
Effectivement il n'y a pas que le dictionnaire pour obtenir une
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet, on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
ça pourrait être une solution, mais je préfère (essayer de) mener la logique
objet jusqu'au bout dans mon application.
Un des principes qu'on retrouve dans l'Extreme Programming (par exemple
Il me semble que dans le cas de votre application multiplier les classes
ne s'impose pas. Vous b'auriez pas fait beaucoup de java dans une vie
antérieure ? (:-) et quelle expérience avez-vous en Fortran ?
C'est encore pire, j'ai fait beaucoup de C ! passer de la conception
fonctionnelle et l'analyse structurelle à l'analyse et la conception objet
n'a pas été trés evidente. Avant python j'ai essayé le C++ et ça m'a fait un
peu d'entrainement pour aborder la POO.Il y a plus loin dans le code une utilisation subtile de méthode et
d'attribut avec le même nom (ou presque) qui m'échappe.
Ce que je fais souvent c'est donner le même nom à un attribut d'instance et
à un argument de méthode. Ce que je fais moins souvent c'est de donner le
même nom à un attribut d'instance et à une méthode... ça serait quand même
un peu confus, et pour moi, et pour l'interprete python qui n'aurait
surement pas apprécié.
Vous n'êtes pas sans savoir qu'une méthode python est un attribut de
Je vous conseillerais de passer pylint sur votre module et de poser
votre question lorsque pylint vous donnera un score d'au moins 7
pylint est un outil d'analyse de code python ?
oui et c'est Français et free software (et pur python)
Sous emacs c'est quand même plus pratique de mettre des tabulations...
surtout que je crois qu'il les converti automatiquement en 4 espaces
blancs..(à vérifier..)
Merci d'avoir pris la peine d'analyser le code et d'avoir pris la peine de
le lire. Merci pour également pour vos suggestions.
il n'y a pas de quoi.
Y.Chaouche.
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de
Point.
Votre explication est "buzzword compliant" : classe abstraite,
conception, spécification, ... Vous devriez vous essayer à la méthodologie
Merise que des mauvaises langues de l'époque ont appelée "Méthode éprouvée
pour Retarder Indéfiniment la Sortie des études" ;-)
Il se compose de cooronnées (x,y), et de quelques attributs
supplémentaires
qui permettent de l'afficher correctement sur un écran et de pouvoir le
retrouver facilement (pour lui changer de couleur par exemple ou de
taille...). Or, la couleur, la taille, et l'affichage à l'écran ne
concerne
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels.
Cette
classe regroupe donc tous les attributs nécessaires pour la visualition
à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
simplement obtenus par obj.nom (les noms d'attributs sont les clés de
obj.__dict__) Autrement dit :
class ElementVisuel(object):
"""simplement un vrac d'attributs pour élément susceptible d'être
affiché
"""
pass # pas de code
pt = ElementVisuel()
pt.x, pt.y = (100, 150)
# Tiens ce peut être un Point
pt.color = "red" # ou RGB(...) ou ....
Ce qui importe c'est le nom donné à l'attribut (et son existence bien
sûr). pylint va un peu râler que les attributs ne sont pas définis dans
la méthode __init__ mais ce n'est pas nécessaire : en python on crée des
objets à la volée et on les modifie dynamiquement (par exemple en
ajoutant des attributs)
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
Voir plus haut. Mais peut être qu'une solution plus simple existe !
Faîtes une recherche sur une classe Bunch proposée par Alex Martelli sur
le python cookbook, ou d'autres explications très pertinentes de cet
Italien très cultivé sur les méthodes "Easier to ask forgiveness than
permission" ou "Leap before je-ne-sais-plus-quoi"
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Je n'ai pas encore eu l'occasion d'étudier cette classe. Un internaute
m'a
suggérer sur le forum dédié à python du site www.developpez.com
d'utiliser
justement ce type de classe pour que ma fonction de hachage puisse se
faire
sans difficulté sur mes objets, du moment qu'ils en héritent. (la classe
object implémente une methode __hash__ il me semble...).Aie les indentations sont perdues dans le copier coller
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
(slrn est un lecteur de news (NNTP) en mode texte)
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
vous ajoutez une méthode qui vous semble bien pratique mais qui vous
casse la baraque : la règle citée plus haut n'est plus respectée et
python gueule (trp fort ce python). On peut peut-être rattraper le coup
soit en supprimant cette méthode __eq__, soit en codant une méthode
__hash__ compatible :
def __hash__(self):
return hash((self.x, self.y)) # utilisation d'un tuple
pas testé.
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet,
on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du
même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
ça pourrait être une solution, mais je préfère (essayer de) mener la
logique
objet jusqu'au bout dans mon application.
Un des principes qu'on retrouve dans l'Extreme Programming (par exemple
en français sur http://www.design-up.com ) c'est qu'il vaut mieux être
fainéant, en faire le moins possible : ne coder que ce qui est
strictement nécessaire pour que ça tourne, mais on code de nombreux
tests unitaires pour vérifier que cela fait ce qu'on veut et que cela
rejette de mauvaises entrées/manipulations (en levant les exceptions
adéquates par exemple).
Ce que je fais souvent c'est donner le même nom à un attribut d'instance
et
à un argument de méthode.
Vous n'êtes pas sans savoir qu'une méthode python est un attribut de
l'instance (ou de la classe d'ailleurs) qui est "callable". Il est donc
impossible d'avoir le même nom pour un attribut d'instance et une
méthode, c'est le dernier lien (binding) qui compte.
Ce que je fais moins souvent c'est de donner le
même nom à un attribut d'instance et à une méthode... ça serait quand
même
un peu confus, et pour moi, et pour l'interprete python qui n'aurait
surement pas apprécié.
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de
Point.
Votre explication est "buzzword compliant" : classe abstraite,
conception, spécification, ... Vous devriez vous essayer à la méthodologie
Merise que des mauvaises langues de l'époque ont appelée "Méthode éprouvée
pour Retarder Indéfiniment la Sortie des études" ;-)
Il se compose de cooronnées (x,y), et de quelques attributs
supplémentaires
qui permettent de l'afficher correctement sur un écran et de pouvoir le
retrouver facilement (pour lui changer de couleur par exemple ou de
taille...). Or, la couleur, la taille, et l'affichage à l'écran ne
concerne
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels.
Cette
classe regroupe donc tous les attributs nécessaires pour la visualition
à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
simplement obtenus par obj.nom (les noms d'attributs sont les clés de
obj.__dict__) Autrement dit :
class ElementVisuel(object):
"""simplement un vrac d'attributs pour élément susceptible d'être
affiché
"""
pass # pas de code
pt = ElementVisuel()
pt.x, pt.y = (100, 150)
# Tiens ce peut être un Point
pt.color = "red" # ou RGB(...) ou ....
Ce qui importe c'est le nom donné à l'attribut (et son existence bien
sûr). pylint va un peu râler que les attributs ne sont pas définis dans
la méthode __init__ mais ce n'est pas nécessaire : en python on crée des
objets à la volée et on les modifie dynamiquement (par exemple en
ajoutant des attributs)
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
Voir plus haut. Mais peut être qu'une solution plus simple existe !
Faîtes une recherche sur une classe Bunch proposée par Alex Martelli sur
le python cookbook, ou d'autres explications très pertinentes de cet
Italien très cultivé sur les méthodes "Easier to ask forgiveness than
permission" ou "Leap before je-ne-sais-plus-quoi"
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Je n'ai pas encore eu l'occasion d'étudier cette classe. Un internaute
m'a
suggérer sur le forum dédié à python du site www.developpez.com
d'utiliser
justement ce type de classe pour que ma fonction de hachage puisse se
faire
sans difficulté sur mes objets, du moment qu'ils en héritent. (la classe
object implémente une methode __hash__ il me semble...).
Aie les indentations sont perdues dans le copier coller
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
(slrn est un lecteur de news (NNTP) en mode texte)
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
vous ajoutez une méthode qui vous semble bien pratique mais qui vous
casse la baraque : la règle citée plus haut n'est plus respectée et
python gueule (trp fort ce python). On peut peut-être rattraper le coup
soit en supprimant cette méthode __eq__, soit en codant une méthode
__hash__ compatible :
def __hash__(self):
return hash((self.x, self.y)) # utilisation d'un tuple
pas testé.
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet,
on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du
même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
ça pourrait être une solution, mais je préfère (essayer de) mener la
logique
objet jusqu'au bout dans mon application.
Un des principes qu'on retrouve dans l'Extreme Programming (par exemple
en français sur http://www.design-up.com ) c'est qu'il vaut mieux être
fainéant, en faire le moins possible : ne coder que ce qui est
strictement nécessaire pour que ça tourne, mais on code de nombreux
tests unitaires pour vérifier que cela fait ce qu'on veut et que cela
rejette de mauvaises entrées/manipulations (en levant les exceptions
adéquates par exemple).
Ce que je fais souvent c'est donner le même nom à un attribut d'instance
et
à un argument de méthode.
Vous n'êtes pas sans savoir qu'une méthode python est un attribut de
l'instance (ou de la classe d'ailleurs) qui est "callable". Il est donc
impossible d'avoir le même nom pour un attribut d'instance et une
méthode, c'est le dernier lien (binding) qui compte.
Ce que je fais moins souvent c'est de donner le
même nom à un attribut d'instance et à une méthode... ça serait quand
même
un peu confus, et pour moi, et pour l'interprete python qui n'aurait
surement pas apprécié.
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de
Point.
Votre explication est "buzzword compliant" : classe abstraite,
conception, spécification, ... Vous devriez vous essayer à la méthodologie
Merise que des mauvaises langues de l'époque ont appelée "Méthode éprouvée
pour Retarder Indéfiniment la Sortie des études" ;-)
Il se compose de cooronnées (x,y), et de quelques attributs
supplémentaires
qui permettent de l'afficher correctement sur un écran et de pouvoir le
retrouver facilement (pour lui changer de couleur par exemple ou de
taille...). Or, la couleur, la taille, et l'affichage à l'écran ne
concerne
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels.
Cette
classe regroupe donc tous les attributs nécessaires pour la visualition
à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
simplement obtenus par obj.nom (les noms d'attributs sont les clés de
obj.__dict__) Autrement dit :
class ElementVisuel(object):
"""simplement un vrac d'attributs pour élément susceptible d'être
affiché
"""
pass # pas de code
pt = ElementVisuel()
pt.x, pt.y = (100, 150)
# Tiens ce peut être un Point
pt.color = "red" # ou RGB(...) ou ....
Ce qui importe c'est le nom donné à l'attribut (et son existence bien
sûr). pylint va un peu râler que les attributs ne sont pas définis dans
la méthode __init__ mais ce n'est pas nécessaire : en python on crée des
objets à la volée et on les modifie dynamiquement (par exemple en
ajoutant des attributs)
class VisualPoint (VisualElement,Point):
Double héritage : vous cherchez la difficulté
Voir plus haut. Mais peut être qu'une solution plus simple existe !
Faîtes une recherche sur une classe Bunch proposée par Alex Martelli sur
le python cookbook, ou d'autres explications très pertinentes de cet
Italien très cultivé sur les méthodes "Easier to ask forgiveness than
permission" ou "Leap before je-ne-sais-plus-quoi"
class VisualElement :
Moi je n'utiliserais que des classes modernes :
class VisualElement(object): # cela en jette pour peu d'effort !
Je n'ai pas encore eu l'occasion d'étudier cette classe. Un internaute
m'a
suggérer sur le forum dédié à python du site www.developpez.com
d'utiliser
justement ce type de classe pour que ma fonction de hachage puisse se
faire
sans difficulté sur mes objets, du moment qu'ils en héritent. (la classe
object implémente une methode __hash__ il me semble...).Aie les indentations sont perdues dans le copier coller
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
(slrn est un lecteur de news (NNTP) en mode texte)
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
vous ajoutez une méthode qui vous semble bien pratique mais qui vous
casse la baraque : la règle citée plus haut n'est plus respectée et
python gueule (trp fort ce python). On peut peut-être rattraper le coup
soit en supprimant cette méthode __eq__, soit en codant une méthode
__hash__ compatible :
def __hash__(self):
return hash((self.x, self.y)) # utilisation d'un tuple
pas testé.
Finalement un Point == deux coordonnées x et y.
Si on veut en gérer beaucoup pas besoin de sortir l'artillerie objet,
on
peut se contenter d'un bon tuple des familles (x, y) ou avoir un "axe"
dans un Numeric.array qui contiendrait tous les points considérés.
du genre : points = N.array(coords, N.Float) ou N.Integer
Avec un Numeric.array ou même un array.array vous gagnez éventuellement
pas mal de place en mémoire car tous les éléments sont forcément du
même
type et donc cette information de type n'est pas dupliquée pour chaque
élément.
ça pourrait être une solution, mais je préfère (essayer de) mener la
logique
objet jusqu'au bout dans mon application.
Un des principes qu'on retrouve dans l'Extreme Programming (par exemple
en français sur http://www.design-up.com ) c'est qu'il vaut mieux être
fainéant, en faire le moins possible : ne coder que ce qui est
strictement nécessaire pour que ça tourne, mais on code de nombreux
tests unitaires pour vérifier que cela fait ce qu'on veut et que cela
rejette de mauvaises entrées/manipulations (en levant les exceptions
adéquates par exemple).
Ce que je fais souvent c'est donner le même nom à un attribut d'instance
et
à un argument de méthode.
Vous n'êtes pas sans savoir qu'une méthode python est un attribut de
l'instance (ou de la classe d'ailleurs) qui est "callable". Il est donc
impossible d'avoir le même nom pour un attribut d'instance et une
méthode, c'est le dernier lien (binding) qui compte.
Ce que je fais moins souvent c'est de donner le
même nom à un attribut d'instance et à une méthode... ça serait quand
même
un peu confus, et pour moi, et pour l'interprete python qui n'aurait
surement pas apprécié.
"F. Petitjean" a écrit dans le message de news:
41c81252$0$23374$C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de
Point.Votre explication est "buzzword compliant" : classe abstraite,
conception, spécification, ... Vous devriez vous essayer à la méthodologie
Merise que des mauvaises langues de l'époque ont appelée "Méthode éprouvée
pour Retarder Indéfiniment la Sortie des études" ;-)
C'est une blague n'est-ce pas ?
Vraiment ? Il y a souvent un trait de vérité dans ces "blagues".
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels.
Cetteclasse regroupe donc tous les attributs nécessaires pour la visualition
àl'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
simplement obtenus par obj.nom (les noms d'attributs sont les clés de
obj.__dict__) Autrement dit :
class ElementVisuel(object):
"""simplement un vrac d'attributs pour élément susceptible d'être
affiché
"""
pass # pas de code
pt = ElementVisuel()
pt.x, pt.y = (100, 150)
# Tiens ce peut être un Point
pt.color = "red" # ou RGB(...) ou ....
Ce qui importe c'est le nom donné à l'attribut (et son existence bien
sûr). pylint va un peu râler que les attributs ne sont pas définis dans
la méthode __init__ mais ce n'est pas nécessaire : en python on crée des
objets à la volée et on les modifie dynamiquement (par exemple en
ajoutant des attributs)
Cette pratique est, me semble-t-il, déconséillée (cf "Apprendre à
programmer avec Python" de Gérard Swinnen). Sinon, à quoi sert de créer une
classe si ce n'est pour regrouper sous une seule coupelle des objets
possédants les même attributs et rendants les mêmes services ?? Même si
python offre la possibilité d'en créer à la volée, je préfère m'en passer.
You didn't get the gist of my point :-)
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
(slrn est un lecteur de news (NNTP) en mode texte)
L'idéale serait d'avoir le net sous linux déjà :-)...
&videmment mais tout de même bizarre d'avoir un linux non connecté
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
vous ajoutez une méthode qui vous semble bien pratique mais qui vous
casse la baraque : la règle citée plus haut n'est plus respectée et
python gueule (trp fort ce python). On peut peut-être rattraper le coup
soit en supprimant cette méthode __eq__, soit en codant une méthode
__hash__ compatible :
def __hash__(self):
return hash((self.x, self.y)) # utilisation d'un tuple
pas testé.
Il fallait peut être tester d'abord si en la supprimant le code
compile...Mais je reste scéptique.
Lisez Extreme Programming, TDD (Test driven development) ... on code 5
Je n'ai pas le temps de répondre à la suite
"F. Petitjean" <littlejohn.75@noos.fr> a écrit dans le message de news:
41c81252$0$23374$626a14ce@news.free.fr...
C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de
Point.
Votre explication est "buzzword compliant" : classe abstraite,
conception, spécification, ... Vous devriez vous essayer à la méthodologie
Merise que des mauvaises langues de l'époque ont appelée "Méthode éprouvée
pour Retarder Indéfiniment la Sortie des études" ;-)
C'est une blague n'est-ce pas ?
Vraiment ? Il y a souvent un trait de vérité dans ces "blagues".
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels.
Cette
classe regroupe donc tous les attributs nécessaires pour la visualition
à
l'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
simplement obtenus par obj.nom (les noms d'attributs sont les clés de
obj.__dict__) Autrement dit :
class ElementVisuel(object):
"""simplement un vrac d'attributs pour élément susceptible d'être
affiché
"""
pass # pas de code
pt = ElementVisuel()
pt.x, pt.y = (100, 150)
# Tiens ce peut être un Point
pt.color = "red" # ou RGB(...) ou ....
Ce qui importe c'est le nom donné à l'attribut (et son existence bien
sûr). pylint va un peu râler que les attributs ne sont pas définis dans
la méthode __init__ mais ce n'est pas nécessaire : en python on crée des
objets à la volée et on les modifie dynamiquement (par exemple en
ajoutant des attributs)
Cette pratique est, me semble-t-il, déconséillée (cf "Apprendre à
programmer avec Python" de Gérard Swinnen). Sinon, à quoi sert de créer une
classe si ce n'est pour regrouper sous une seule coupelle des objets
possédants les même attributs et rendants les mêmes services ?? Même si
python offre la possibilité d'en créer à la volée, je préfère m'en passer.
You didn't get the gist of my point :-)
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
(slrn est un lecteur de news (NNTP) en mode texte)
L'idéale serait d'avoir le net sous linux déjà :-)...
&videmment mais tout de même bizarre d'avoir un linux non connecté
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
vous ajoutez une méthode qui vous semble bien pratique mais qui vous
casse la baraque : la règle citée plus haut n'est plus respectée et
python gueule (trp fort ce python). On peut peut-être rattraper le coup
soit en supprimant cette méthode __eq__, soit en codant une méthode
__hash__ compatible :
def __hash__(self):
return hash((self.x, self.y)) # utilisation d'un tuple
pas testé.
Il fallait peut être tester d'abord si en la supprimant le code
compile...Mais je reste scéptique.
Lisez Extreme Programming, TDD (Test driven development) ... on code 5
Je n'ai pas le temps de répondre à la suite
"F. Petitjean" a écrit dans le message de news:
41c81252$0$23374$C'est un problème de concéption (peut être aurais-je dû faire l'analyse
avant...). Je conçois un VisualPoint comme étant une spécification de
Point.Votre explication est "buzzword compliant" : classe abstraite,
conception, spécification, ... Vous devriez vous essayer à la méthodologie
Merise que des mauvaises langues de l'époque ont appelée "Méthode éprouvée
pour Retarder Indéfiniment la Sortie des études" ;-)
C'est une blague n'est-ce pas ?
Vraiment ? Il y a souvent un trait de vérité dans ces "blagues".
pas uniquement les points visuels, mais aussi un grand nombre d'éléments
visuels. D'où l'idée de créer une classe abstraite d'objets visuels.
Cetteclasse regroupe donc tous les attributs nécessaires pour la visualition
àl'écran. C'est donc pour ces raisons que VisualPoint dérive à la fois de
Point et de VisualElement.
OK mais en python les attributs de n'importe quel objet obj sont
simplement obtenus par obj.nom (les noms d'attributs sont les clés de
obj.__dict__) Autrement dit :
class ElementVisuel(object):
"""simplement un vrac d'attributs pour élément susceptible d'être
affiché
"""
pass # pas de code
pt = ElementVisuel()
pt.x, pt.y = (100, 150)
# Tiens ce peut être un Point
pt.color = "red" # ou RGB(...) ou ....
Ce qui importe c'est le nom donné à l'attribut (et son existence bien
sûr). pylint va un peu râler que les attributs ne sont pas définis dans
la méthode __init__ mais ce n'est pas nécessaire : en python on crée des
objets à la volée et on les modifie dynamiquement (par exemple en
ajoutant des attributs)
Cette pratique est, me semble-t-il, déconséillée (cf "Apprendre à
programmer avec Python" de Gérard Swinnen). Sinon, à quoi sert de créer une
classe si ce n'est pour regrouper sous une seule coupelle des objets
possédants les même attributs et rendants les mêmes services ?? Même si
python offre la possibilité d'en créer à la volée, je préfère m'en passer.
You didn't get the gist of my point :-)
Désolé ! ça doit être mon bloc note windows... (je le copie d'un fichier
écrit sous emacs sur linux).
apt-get install slrn
(slrn est un lecteur de news (NNTP) en mode texte)
L'idéale serait d'avoir le net sous linux déjà :-)...
&videmment mais tout de même bizarre d'avoir un linux non connecté
def __eq__(self,P):
return P.x==self.x and P.y==self.y
Et voila! dans votre désir de bien faire, d'avoir une conception objet
vous ajoutez une méthode qui vous semble bien pratique mais qui vous
casse la baraque : la règle citée plus haut n'est plus respectée et
python gueule (trp fort ce python). On peut peut-être rattraper le coup
soit en supprimant cette méthode __eq__, soit en codant une méthode
__hash__ compatible :
def __hash__(self):
return hash((self.x, self.y)) # utilisation d'un tuple
pas testé.
Il fallait peut être tester d'abord si en la supprimant le code
compile...Mais je reste scéptique.
Lisez Extreme Programming, TDD (Test driven development) ... on code 5
Je n'ai pas le temps de répondre à la suite
