Python dispose-t-il de classes anonymes ?

Question

Je me demande si Python a quelque chose comme la fonctionnalité des classes anonymes de C#. Pour clarifier, voici un exemple d'extrait C# :

var foo = new { x = 1, y = 2 };
var bar = new { y = 2, x = 1 };
foo.Equals(bar); // "true"

En Python, j'imaginerais quelque chose comme ceci :

foo = record(x = 1, y = 2)
bar = record(y = 2, x = 1)
foo == bar  # true

L'exigence spécifique est de pouvoir créer un objet avec des champs spécifiés dans un contexte d'expression (par exemple, utilisable dans des lambdas et d'autres endroits où les déclarations ne sont pas autorisées), sans déclarations externes supplémentaires, et de pouvoir accéder à des composants individuels par leur nom via la syntaxe normale d'accès aux membres. foo.bar . L'objet créé doit également mettre en œuvre la comparaison structurelle par les noms des composants (et non par position, comme le font les tuples).

En particulier : les tuples ne le sont pas parce que leurs composants ne sont pas nommés ; les classes ne le sont pas parce qu'elles nécessitent une déclaration ; les dicts ne le sont pas parce qu'elles ont des effets indésirables sur la qualité de l'environnement. foo["bar"] pour accéder aux composants.

namedtuple Ce n'est pas le cas, car il faut toujours un nom même si vous définissez le type en ligne, et la comparaison est basée sur la position et non sur le nom. En particulier :

 def foo(): return namedtuple("Foo", "x y")(x = 1, y = 2)
 def bar(): return namedtuple("Foo", "y x")(x = 1, y = 2)
 foo() == bar()   # False because fields are compared in order, and not by name
                  # True would be desired instead

Je sais comment écrire une telle chose en Python si nécessaire. Mais j'aimerais savoir s'il y a quelque chose de ce genre dans la bibliothèque standard de Python, ou dans toute autre bibliothèque tierce populaire.

[EDIT]

Juste pour le plaisir, voici une solution à une seule expression qui combine deux réponses très instructives de Ken et alanlcode, produisant une égalité structurelle sans aucune déclaration extérieure supplémentaire :

type("", (), { \
    "__init__": (lambda self, **kwargs: self.__dict__.update(kwargs)), \
    "__eq__": (lambda self, other: self.__dict__ == other.__dict__) } \
)(x = 1, y = 2)

Techniquement, il répond à toutes les exigences de la question, mais j'espère sincèrement que personne ne l'utilisera jamais (je ne le ferai certainement pas).

Answer 1

Il semble que Python 3.3 ait ajouté exactement cette chose sous la forme de types.SimpleNamespace classe.

Answer 2

La méthode pythique consisterait à utiliser un fichier dict :

>>> foo = dict(x=1, y=2)
>>> bar = dict(y=2, x=1)
>>> foo == bar
True

Il répond à toutes vos exigences sauf que vous devez encore faire foo['x'] au lieu de foo.x .

Si cela pose un problème, vous pouvez facilement définir une classe telle que :

class Bunch(object):
    def __init__(self, **kwds):
        self.__dict__.update(kwds)

    def __eq__(self, other):
        return self.__dict__ == other.__dict__

Ou, un joli et court

class Bunch(dict):
    __getattr__, __setattr__ = dict.get, dict.__setitem__

(mais notez que cette deuxième a des problèmes comme le souligne Alex dans son commentaire !)

Answer 3

1) Voir http://uszla.me.uk/space/blog/2008/11/06 . Vous pouvez créer un objet anonyme avec une syntaxe un peu moche en utilisant la fonction type fonction intégrée :

 anon_object_2 = type("", (), {})()

où le 3ème paramètre est le dict qui contiendra les champs de votre objet.

 foo = type("", (), dict(y=1))()
 foo.y == 1

2) Une autre variante est proposée par Peter Norvig à l'adresse suivante http://norvig.com/python-iaq.html . Elle est également similaire à la réponse postée par Ken.

class Struct:
    def __init__(self, **entries): self.__dict__.update(entries)

>>> options = Struct(answer=42, linelen = 80, font='courier')
>>> options.answer
42

L'avantage de cette méthode est que vous pouvez implémenter l'égalité par le contenu du dict, ce que la première option ne permet pas.

Answer 4

La forme type(...) ne répond pas à l'exigence de comparaison structurelle (sans devenir vraiment laide). La forme dict(...) ne répond pas à l'exigence relative aux accesseurs d'attributs.

El attrdict semble se situer quelque part au milieu :

class attrdict(dict):
    def __init__(self, *args, **kwargs):
        dict.__init__(self, *args, **kwargs)
        self.__dict__ = self

a = attrdict(x=1, y=2)
b = attrdict(y=2, x=1)

print a.x, a.y
print b.x, b.y
print a == b

Mais cela implique de définir une classe spéciale.

OK, je viens de remarquer la mise à jour de la question. Je note juste que vous pouvez spécifier dict pour le paramètre de base et il suffit alors de spécifier le constructeur (dans l'expression de type icky). Je préfère attrdict :-)

Answer 5

Je ne me souviens pas de mémoire s'il y a un intégré mais l'écrire soi-même est plus court que de taper sa question :-)

class record(object):
  def __init__(self, **kwargs): self.__dict__ = kwargs
  def __eq__(self, r2): return self.__dict__ == r2.__dict__
  def __ne__(self, r2): return self.__dict__ != r2.__dict__

foo = record(x=1, y=2)
bar = record(y=2, x=1)
foo == bar  # => true