Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Bonjour à tous,
en fait, je souhaitais remonter un vieux post. Celui-ci :
http://groups.google.fr/group/fr.comp.lang.python/browse_thread/thread/7fde7231705c24e6
Mais il est trop vieux et n'existe plus dans mon lecteur de news. Donc
j'en créé un nouveau.
Le posteur original du message demandais comment obtenir les attributs
d'un objet. J'avais proposé de faire :
print obj.__dict__
On (Bruno en l'occurrence) avait rectifié en disant ceci :
« Ca ne renverra que les attributs de l'instance. Pour avoir tous les
attributs de l'objet, utilise dir(obj). »
Voici mes questions :
1) Je ne saisi pas trop la différence dans cette phrase entre "attributs
de l'instance" et "attributs de l'objet".
Plus exactement, je ne saisi
pas trop la différence dans cette phrase entre "instance" et "objet".
Pour moi, un objet c'est toujours une instance de quelque chose. Donc
pour moi dire "attribut d'instance" ou "attribut d'objet" c'est censé
être la même chose. Est-ce possible d'avoir une explication sur ce point ?
2) J'ai l'impression que dir() affiche bien plus que les attributs d'un
objet.
Par exemple avec ceci
#-----------------------
class Mc(object):
version = '1.0'
obj = Mc()
#-----------------------
dir(Mc) et dir(obj) me donneront (entre autres) 'version' comme
"attribut". Mais pour moi version est un attribut de Mc uniquement, mais
pas de obj.
Bien sûr, obj.version va me renvoyer '1.0' mais lors de la
recherche de l'attribut, c'est dans l'objet classe Mc que version sera
trouvé et non dans l'objet obj. Est-ce correct ?
Dans ce cas, si obj désigne un objet quelconque (classe ou instance
etc...), existe-t-il une instruction pour afficher uniquement tous les
attributs qui appartiennent à obj et seulement ceux qui appartiennent à
obj ?
Bonjour à tous,
en fait, je souhaitais remonter un vieux post. Celui-ci :
http://groups.google.fr/group/fr.comp.lang.python/browse_thread/thread/7fde7231705c24e6
Mais il est trop vieux et n'existe plus dans mon lecteur de news. Donc
j'en créé un nouveau.
Le posteur original du message demandais comment obtenir les attributs
d'un objet. J'avais proposé de faire :
print obj.__dict__
On (Bruno en l'occurrence) avait rectifié en disant ceci :
« Ca ne renverra que les attributs de l'instance. Pour avoir tous les
attributs de l'objet, utilise dir(obj). »
Voici mes questions :
1) Je ne saisi pas trop la différence dans cette phrase entre "attributs
de l'instance" et "attributs de l'objet".
Plus exactement, je ne saisi
pas trop la différence dans cette phrase entre "instance" et "objet".
Pour moi, un objet c'est toujours une instance de quelque chose. Donc
pour moi dire "attribut d'instance" ou "attribut d'objet" c'est censé
être la même chose. Est-ce possible d'avoir une explication sur ce point ?
2) J'ai l'impression que dir() affiche bien plus que les attributs d'un
objet.
Par exemple avec ceci
#-----------------------
class Mc(object):
version = '1.0'
obj = Mc()
#-----------------------
dir(Mc) et dir(obj) me donneront (entre autres) 'version' comme
"attribut". Mais pour moi version est un attribut de Mc uniquement, mais
pas de obj.
Bien sûr, obj.version va me renvoyer '1.0' mais lors de la
recherche de l'attribut, c'est dans l'objet classe Mc que version sera
trouvé et non dans l'objet obj. Est-ce correct ?
Dans ce cas, si obj désigne un objet quelconque (classe ou instance
etc...), existe-t-il une instruction pour afficher uniquement tous les
attributs qui appartiennent à obj et seulement ceux qui appartiennent à
obj ?
Bonjour à tous,
en fait, je souhaitais remonter un vieux post. Celui-ci :
http://groups.google.fr/group/fr.comp.lang.python/browse_thread/thread/7fde7231705c24e6
Mais il est trop vieux et n'existe plus dans mon lecteur de news. Donc
j'en créé un nouveau.
Le posteur original du message demandais comment obtenir les attributs
d'un objet. J'avais proposé de faire :
print obj.__dict__
On (Bruno en l'occurrence) avait rectifié en disant ceci :
« Ca ne renverra que les attributs de l'instance. Pour avoir tous les
attributs de l'objet, utilise dir(obj). »
Voici mes questions :
1) Je ne saisi pas trop la différence dans cette phrase entre "attributs
de l'instance" et "attributs de l'objet".
Plus exactement, je ne saisi
pas trop la différence dans cette phrase entre "instance" et "objet".
Pour moi, un objet c'est toujours une instance de quelque chose. Donc
pour moi dire "attribut d'instance" ou "attribut d'objet" c'est censé
être la même chose. Est-ce possible d'avoir une explication sur ce point ?
2) J'ai l'impression que dir() affiche bien plus que les attributs d'un
objet.
Par exemple avec ceci
#-----------------------
class Mc(object):
version = '1.0'
obj = Mc()
#-----------------------
dir(Mc) et dir(obj) me donneront (entre autres) 'version' comme
"attribut". Mais pour moi version est un attribut de Mc uniquement, mais
pas de obj.
Bien sûr, obj.version va me renvoyer '1.0' mais lors de la
recherche de l'attribut, c'est dans l'objet classe Mc que version sera
trouvé et non dans l'objet obj. Est-ce correct ?
Dans ce cas, si obj désigne un objet quelconque (classe ou instance
etc...), existe-t-il une instruction pour afficher uniquement tous les
attributs qui appartiennent à obj et seulement ceux qui appartiennent à
obj ?
Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la question.
J'ai vraiment voulu dire ça dans mon message ?
Méta-MCI (MVP) a écrit :
Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la question.
J'ai vraiment voulu dire ça dans mon message ?
Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la question.
J'ai vraiment voulu dire ça dans mon message ?
Francois a écrit :1) Je ne saisi pas trop la différence dans cette phrase entre
"attributs de l'instance" et "attributs de l'objet".
Effectivement, la formulation n'était pas très heureuse. Traduction :
attributs appartenant en propre à l'instance, et attributs accessible
via l'objet.
L'ensemble des attributs d'un objet se compose de l'ensemble des
attributs appartenant en propre à cet objet (généralement stockés dans
le __dict__) *et* de l'ensemble des attributs appartenant à sa classe
(et aux superclasses d'icelle). Sans compter ce qui peut être retourné
par __getattr__ ou __getattribute__ si ceux-ci ont été surchargés.
2) J'ai l'impression que dir() affiche bien plus que les attributs
d'un objet.
Non. A vrai dire, il n'est même pas garantie que dir() retourne
l'intégralité des attributs accessibles via l'objet.
Bien sûr, obj.version va me renvoyer '1.0' mais lors de la recherche
de l'attribut, c'est dans l'objet classe Mc que version sera trouvé et
non dans l'objet obj. Est-ce correct ?
En l'occurrence, oui. Mais en tant qu'utilisateur de obj, ce n'est pas
ton problème. Les properties, par exemple, sont des attributs de la
classe, même si elles sont destinées à être interrogées sur l'instance.
Idem pour les méthodes.
Dans ce cas, si obj désigne un objet quelconque (classe ou instance
etc...), existe-t-il une instruction pour afficher uniquement tous les
attributs qui appartiennent à obj et seulement ceux qui appartiennent
à obj ?
obj.__dict__ - si obj à un __dict__, of course.
Francois a écrit :
1) Je ne saisi pas trop la différence dans cette phrase entre
"attributs de l'instance" et "attributs de l'objet".
Effectivement, la formulation n'était pas très heureuse. Traduction :
attributs appartenant en propre à l'instance, et attributs accessible
via l'objet.
L'ensemble des attributs d'un objet se compose de l'ensemble des
attributs appartenant en propre à cet objet (généralement stockés dans
le __dict__) *et* de l'ensemble des attributs appartenant à sa classe
(et aux superclasses d'icelle). Sans compter ce qui peut être retourné
par __getattr__ ou __getattribute__ si ceux-ci ont été surchargés.
2) J'ai l'impression que dir() affiche bien plus que les attributs
d'un objet.
Non. A vrai dire, il n'est même pas garantie que dir() retourne
l'intégralité des attributs accessibles via l'objet.
Bien sûr, obj.version va me renvoyer '1.0' mais lors de la recherche
de l'attribut, c'est dans l'objet classe Mc que version sera trouvé et
non dans l'objet obj. Est-ce correct ?
En l'occurrence, oui. Mais en tant qu'utilisateur de obj, ce n'est pas
ton problème. Les properties, par exemple, sont des attributs de la
classe, même si elles sont destinées à être interrogées sur l'instance.
Idem pour les méthodes.
Dans ce cas, si obj désigne un objet quelconque (classe ou instance
etc...), existe-t-il une instruction pour afficher uniquement tous les
attributs qui appartiennent à obj et seulement ceux qui appartiennent
à obj ?
obj.__dict__ - si obj à un __dict__, of course.
Francois a écrit :1) Je ne saisi pas trop la différence dans cette phrase entre
"attributs de l'instance" et "attributs de l'objet".
Effectivement, la formulation n'était pas très heureuse. Traduction :
attributs appartenant en propre à l'instance, et attributs accessible
via l'objet.
L'ensemble des attributs d'un objet se compose de l'ensemble des
attributs appartenant en propre à cet objet (généralement stockés dans
le __dict__) *et* de l'ensemble des attributs appartenant à sa classe
(et aux superclasses d'icelle). Sans compter ce qui peut être retourné
par __getattr__ ou __getattribute__ si ceux-ci ont été surchargés.
2) J'ai l'impression que dir() affiche bien plus que les attributs
d'un objet.
Non. A vrai dire, il n'est même pas garantie que dir() retourne
l'intégralité des attributs accessibles via l'objet.
Bien sûr, obj.version va me renvoyer '1.0' mais lors de la recherche
de l'attribut, c'est dans l'objet classe Mc que version sera trouvé et
non dans l'objet obj. Est-ce correct ?
En l'occurrence, oui. Mais en tant qu'utilisateur de obj, ce n'est pas
ton problème. Les properties, par exemple, sont des attributs de la
classe, même si elles sont destinées à être interrogées sur l'instance.
Idem pour les méthodes.
Dans ce cas, si obj désigne un objet quelconque (classe ou instance
etc...), existe-t-il une instruction pour afficher uniquement tous les
attributs qui appartiennent à obj et seulement ceux qui appartiennent
à obj ?
obj.__dict__ - si obj à un __dict__, of course.
Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la question.
J'ai vraiment voulu dire ça dans mon message ?
Méta-MCI (MVP) a écrit :
Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la question.
J'ai vraiment voulu dire ça dans mon message ?
Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un protocole
descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la question.
J'ai vraiment voulu dire ça dans mon message ?
Francois a écrit :Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un
protocole descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la
question. J'ai vraiment voulu dire ça dans mon message ?
Non. Michel essaie d'attirer ton attention sur le fait que "attribut"
peut être compris de deux façons différentes:
- un objet référencé par le __dict__ (ou les slots) d'un autre objet
- un objet accessible par la syntaxe obj.attribut
Dans la mesure où Python propose pas mal de façons de customiser la
résolution d'attributs (les descripteurs - notamment les properties et
les méthodes -, __getattr__ et __getattribute__ ), les deux notions
peuvent être totalement disjointes.
Francois a écrit :
Méta-MCI (MVP) a écrit :
Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un
protocole descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la
question. J'ai vraiment voulu dire ça dans mon message ?
Non. Michel essaie d'attirer ton attention sur le fait que "attribut"
peut être compris de deux façons différentes:
- un objet référencé par le __dict__ (ou les slots) d'un autre objet
- un objet accessible par la syntaxe obj.attribut
Dans la mesure où Python propose pas mal de façons de customiser la
résolution d'attributs (les descripteurs - notamment les properties et
les méthodes -, __getattr__ et __getattribute__ ), les deux notions
peuvent être totalement disjointes.
Francois a écrit :Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un
protocole descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la
question. J'ai vraiment voulu dire ça dans mon message ?
Non. Michel essaie d'attirer ton attention sur le fait que "attribut"
peut être compris de deux façons différentes:
- un objet référencé par le __dict__ (ou les slots) d'un autre objet
- un objet accessible par la syntaxe obj.attribut
Dans la mesure où Python propose pas mal de façons de customiser la
résolution d'attributs (les descripteurs - notamment les properties et
les méthodes -, __getattr__ et __getattribute__ ), les deux notions
peuvent être totalement disjointes.
C'est simplement qu'apparemment, tu ne saisis pas (encore...) très bien
le modèle objet de Python:
attribut de classe n'est pas hyper-tranchée non plus: tu peux avoir des
attributs calculés définis au niveau de la classe qui vont renvoyer des
valeurs différentes en fonction de l'instance. Ou pas, comme dans
l'exemple ci-dessus... Donc demander à ne récupérer que les attributs
d'une instance n'a pas forcément grand sens...
C'est simplement qu'apparemment, tu ne saisis pas (encore...) très bien
le modèle objet de Python:
attribut de classe n'est pas hyper-tranchée non plus: tu peux avoir des
attributs calculés définis au niveau de la classe qui vont renvoyer des
valeurs différentes en fonction de l'instance. Ou pas, comme dans
l'exemple ci-dessus... Donc demander à ne récupérer que les attributs
d'une instance n'a pas forcément grand sens...
C'est simplement qu'apparemment, tu ne saisis pas (encore...) très bien
le modèle objet de Python:
attribut de classe n'est pas hyper-tranchée non plus: tu peux avoir des
attributs calculés définis au niveau de la classe qui vont renvoyer des
valeurs différentes en fonction de l'instance. Ou pas, comme dans
l'exemple ci-dessus... Donc demander à ne récupérer que les attributs
d'une instance n'a pas forcément grand sens...
Bruno Desthuilliers a écrit :Francois a écrit :Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un
protocole descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la
question. J'ai vraiment voulu dire ça dans mon message ?
Non. Michel essaie d'attirer ton attention sur le fait que "attribut"
peut être compris de deux façons différentes:
- un objet référencé par le __dict__ (ou les slots) d'un autre objet
- un objet accessible par la syntaxe obj.attribut
Dans la mesure où Python propose pas mal de façons de customiser la
résolution d'attributs (les descripteurs - notamment les properties et
les méthodes -, __getattr__ et __getattribute__ ), les deux notions
peuvent être totalement disjointes.
Ok, je comprends. En customisant (avec __getattr__ et getattribute__
etc) on peut rendre les deux notions disjointes.
Mais, sans trop vouloir
rentrer dans le détail, ça peut avoir un intérêt ?
(sûrement que oui)
Je peux comprendre qu'on veuille «surcharger» les références et
affectations d'attributs pour que ça affiche des messages d'info par
exemple pour trouver un bug. Mais customiser au point que l'on ne passe
plus par __dict__ j'ai du mal à imaginer un intérêt.
Bruno Desthuilliers a écrit :
Francois a écrit :
Méta-MCI (MVP) a écrit :
Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un
protocole descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la
question. J'ai vraiment voulu dire ça dans mon message ?
Non. Michel essaie d'attirer ton attention sur le fait que "attribut"
peut être compris de deux façons différentes:
- un objet référencé par le __dict__ (ou les slots) d'un autre objet
- un objet accessible par la syntaxe obj.attribut
Dans la mesure où Python propose pas mal de façons de customiser la
résolution d'attributs (les descripteurs - notamment les properties et
les méthodes -, __getattr__ et __getattribute__ ), les deux notions
peuvent être totalement disjointes.
Ok, je comprends. En customisant (avec __getattr__ et getattribute__
etc) on peut rendre les deux notions disjointes.
Mais, sans trop vouloir
rentrer dans le détail, ça peut avoir un intérêt ?
(sûrement que oui)
Je peux comprendre qu'on veuille «surcharger» les références et
affectations d'attributs pour que ça affiche des messages d'info par
exemple pour trouver un bug. Mais customiser au point que l'on ne passe
plus par __dict__ j'ai du mal à imaginer un intérêt.
Bruno Desthuilliers a écrit :Francois a écrit :Méta-MCI (MVP) a écrit :Plutôt qu'une réponse, j'ai une question :
- est-il vraiment judicieux de faire une recherche, avec un
protocole descripteur qui peut donner des attributs calculés ?
Je suis désolé, mais je ne comprends pas du tout le sens de la
question. J'ai vraiment voulu dire ça dans mon message ?
Non. Michel essaie d'attirer ton attention sur le fait que "attribut"
peut être compris de deux façons différentes:
- un objet référencé par le __dict__ (ou les slots) d'un autre objet
- un objet accessible par la syntaxe obj.attribut
Dans la mesure où Python propose pas mal de façons de customiser la
résolution d'attributs (les descripteurs - notamment les properties et
les méthodes -, __getattr__ et __getattribute__ ), les deux notions
peuvent être totalement disjointes.
Ok, je comprends. En customisant (avec __getattr__ et getattribute__
etc) on peut rendre les deux notions disjointes.
Mais, sans trop vouloir
rentrer dans le détail, ça peut avoir un intérêt ?
(sûrement que oui)
Je peux comprendre qu'on veuille «surcharger» les références et
affectations d'attributs pour que ça affiche des messages d'info par
exemple pour trouver un bug. Mais customiser au point que l'on ne passe
plus par __dict__ j'ai du mal à imaginer un intérêt.