old-style class: mro ou classes parentes

Bonjour,

J'ai un décorateur de classe qui "clone" la classe recue en argument et y ajoute des méthodes.

Pour cloner la classe en python 3, pas de problèmes:

Code:

---

1 2 3 4 5

_Decorated_dict = {} _Decorated_dict.update(cls.__dict__) # Adds the initial class _Decorated_dict.update(newcls) # Adds the new methods _Decorated = type(cls.__name__, cls.__mro__, _Decorated_dict)

---

En Python2, le problème est que les old-style classes n'ont pas d'attributs __mro__. Je m'en sors pour l'instant en faisant

Code:

---

1 2 3 4

class _Decorated: pass _Decorated.__dict__.update(cls.__dict__) _Decorated.__dict__.update(newcls)

---

Le problème est que je perds les ancêtres de la classe initiale.

1) Est-il possible de récupérer les classes parentes (ou encore mieux, la mro) d'une old-style classe ?

2) Je pourrais également dériver la classe initiale, mais j'ai encore du mal à me convaincre que ca revient au même. En règle générale, quelles peuvent être les différences de comportement entre une sous-classe, et un clone altéré d'une classe ?

Merci d'avance.

Salut,

Les "new-style" class existent depuis Python2.4 et se construisent en héritant la class d'object. Les différences entre 2 et 3 sont sur les noms systèmes (__blabla__).
Les différences entre old-style et new_style sont mentionnées ici sur le Wiki Python.

- W

Merci pour la réponse et le lien Wiztricks !

1) En fait, le second argument de type() doit être __bases__ (et non __mro__ !), et il existe pour les old-style classes.

2) Cette question est un peu tordue, mais je reste curieux de connaitre vos sentiments. Je suis en train de décorer une classe A, quelle sont les différences entre ces 2 approches (hormis les différences évidentes de __name__ et de __module__) ? Existe-t'il de vraies raisons de favoriser la 1ere ?

i) Dériver A

Code:

---

1 2 3 4

class B(A): def blabla(self):pass return B

---

ii) Cloner A et altérer

Code:

---

1 2 3 4 5 6 7

altered = {} altered.update(A.__dict__) def blabla(self):pass altered["blabla"] = blabla B = type(A.__name__, A.__bases__, altered) return B

---

Salut,

Citation:

---

Envoyé par shaiHulud

Qquelle sont les différences entre ces 2 approches (hormis les différences évidentes de __name__ et de __module__) ? Existe-t'il de vraies raisons de favoriser la 1ere ?

---

Dans le premier cas, vous définissez une classe de façon "statique" par opposition la création via "type" qui permet de le faire "dynamiquement".
note: inutile de "cloner".

- W

C'est surtout la différence de classes parentes qui me semble importante !

Dans le second cas, l'objet décoré ressemble plus à l'objet initial (il a la même hiérarchie de classe), donc est "plus dans l'esprit" d'un décorateur. Si un code client manipule les ancêtres ou la mro de A, il risque de planter sur B avec l'héritage i (on pourrait retorquer qu'un tel code utilise des détails d'implémentation).

@wiztricks:

Citation:

---

note: inutile de "cloner"

---

. Je ne suis pas sur de comprendre. A.__dict__ est cloné pour éviter de modifier A in-place (les 2 autres arguments de type (name et base) devraient également être clonés si les strings et tuple étaient mutables).

Citation:

---

Envoyé par shaiHulud

C'est surtout la différence de classes parentes qui me semble importante !

---

Soit vous comparez 2 choses comparables telles que la création d'une sous classe statique/dynamique, soit vous dites l'héritage ne me convient pas et je souhaite autre chose et difficile d'écrire dans ce cas:

Citation:

---

Cette question est un peu tordue, mais je reste curieux de connaitre vos sentiments. Je suis en train de décorer une classe A, quelle sont les différences entre ces 2 approches (hormis les différences évidentes de __name__ et de __module__) ? Existe-t'il de vraies raisons de favoriser la 1ere ?

---

Car je ne sais pas ce que vous voulez faire mais "décorer une classe" en Python s'écrit:

Code:

---

1 2 3

@decorator class A(object): ....

---

ou bien

Code:

---

1 2 3

class A(object): ... B = decorator(A)

---

Après vous faites un peu ce que vous voulez et vous employez votre propre vocabulaire: çà ne me dérange pas plus que çà sauf que vous êtes dans un forum Python donc on peut supposer que vous maîtrisez le jargon Python (çà peut aider pour comprendre ce que vous écrivez).

- W

Merci Wiztricks, et désolé pour les imprécisions.

Je suis effectivement en train de comparer l'héritage (decorator1 ci-dessous) et autre chose (cloner et altérer la classe, plutot que d'en dériver, decorator2 ci-dessous).

Les 2 sont comparables puisqu'ils renvoient tous deux une nouvelle classe avec les mêmes méthodes dans les deux cas (mais pas les mêmes classes parentes).

Code:

---

1 2 3 4 5 6

def decorator1(A): """ Subclass the argument class A """ class B(A): def foo(self):pass return B

---

Code:

---

1 2 3 4 5 6 7 8 9

def decorator2(A): """ Clones the argument class A """ altered = {} altered.update(A.__dict__) def foo(self):pass altered["foo"] = foo B = type(A.__name__, A.__bases__, altered) return B

---

Code:

---

1 2 3 4 5

class A: pass B1 = decorator1(A) B2 = decorator2(A) # Quelles sont les différences entre B1 et B2 ?

---

Quelles sont les différences entre B1 et B2 ?

Citation:

---

Envoyé par shaiHulud

Je suis effectivement en train de comparer l'héritage (decorator1 ci-dessous) et autre chose (cloner et altérer la classe, plutôt que d'en dériver, decorator2 ci-dessous).
...
Quelles sont les différences entre B1 et B2 ?

---

C'est vous qui comparez, donc à vous de le dire.

note: je ne vois pas trop l'intérêt de votre truc sauf à y ajouter "l'héritage" qui existe dans d'autres langages. Comme il y a certainement des bibliothèques qui font çà, il faut aller regarder comment leurs développeurs ont résolu les problèmes.

- W

La vraie question est "jusqu'à quel point une classe décorée doit-elle être semblable à l'originale" ?

• Mon 1er sentiment est que B2 est plus semblable à A que B1, et donc respecte plus l'esprit d'un décorateur. Par example, un code qui prendrait A en argument, et agirait en faisant des hypothèses sur sa MRO, a plus de chances de planter sur B1 que sur B2 (la pertinence / absence de robustesse d'un tel code restant discutable).
• Par contre, B1 permet d'accéder aux méthodes de A qui ont été "surchargées" (via super). B2 le permet uniquement via un code statique (A.foo(B2())). La différence est flagrante lorsque plusieurs décorateurs sont appliqués. Cela dit, la méthode surchargée peut accéder naturellement à A.foo dans le décorateur.

Mais j'ai peut etre raté quelque chose de plus évident. Quel genre de code donnerait des résultats différents sur B1 et sur B2 ?

Citation:

---

Envoyé par shaiHulud

La vraie question est "jusqu'à quel point une classe décorée doit-elle être semblable à l'originale" ?

---

Ça dépend de vos exigences. Idéalement, çà doit être transparent: même signature, même help, ...

Citation:

---

Mais j'ai peut etre raté quelque chose de plus évident. Quel genre de code donnerait des résultats différents sur B1 et sur B2 ?

---

C'est une copie de dictionnaires dans lequel vous allez avoir méthodes et variables associés à des objets éventuellement mutables... donc le nombre de gags est assez ouvert.

- W

Citation:

---

des objets éventuellement mutables

---

Effectivement, c'est suffisament casse-gueule pour ne pas s'y aventurer !
Mais en supposant qu'on puisse faire une copie profonde de A.__dict__, je me demande s'il reste d'autres différences ?

Merci beaucoup !