À l'aide de l' __appel__ méthode d'une métaclasse au lieu de __new__?

La réponse directe à votre question est: quand vous voulez faire plus que juste personnaliser la création de l'instance, ou si vous voulez séparer ce que la classe ne de comment il est créé.

Voir ma réponse à La création d'un singleton en Python et les discussions associées.

Il y a plusieurs avantages.

1. Il vous permet de séparer ce qui le classe ne à partir des détails de comment il est créé. La métaclasse classe et sont chacun responsable d'une chose.

2. Vous pouvez écrire le code une fois dans une métaclasse, et de l'utiliser pour la personnalisation de plusieurs classes de comportement d'appel, sans se soucier de l'héritage multiple.

3. Les sous-classes peuvent remplacer les comportements dans leurs __new__ méthode, mais __call__ sur une métaclasse n'a pas à même appel __new__ à tous.

4. Si il y a travaux d'installation, vous pouvez le faire dans le __new__ méthode de la métaclasse, et il se produit seulement une fois, au lieu de chaque fois que la classe est appelée.

Il y a certainement beaucoup de cas où la personnalisation de __new__ fonctionne tout aussi bien si vous n'êtes pas inquiet au sujet du principe de responsabilité unique.

Mais il y a d'autres cas d'utilisation qui doivent arriver plus tôt, lorsque la classe est créée, plutôt que lorsque l'instance est créée. C'est quand ceux-ci viennent dans de jouer qu'une métaclasse est nécessaire. Voir Quels sont vos (béton) des cas d'utilisation pour les metaclasses en Python? pour beaucoup de grands exemples.

Les différences subtiles de devenir un peu plus visible lorsque vous observez attentivement l'ordre d'exécution de ces méthodes.

class Meta_1(type):
    def __call__(cls, *a, **kw):
        print "entering Meta_1.__call__()"
        rv = super(Meta_1, cls).__call__(*a, **kw)
        print "exiting Meta_1.__call__()"
        return rv

class Class_1(object):
    __metaclass__ = Meta_1
    def __new__(cls, *a, **kw):
        print "entering Class_1.__new__()"
        rv = super(Class_1, cls).__new__(cls, *a, **kw)
        print "exiting Class_1.__new__()"
        return rv

    def __init__(self, *a, **kw):
        print "executing Class_1.__init__()"
        super(Class_1,self).__init__(*a, **kw)

Noter que le code ci-dessus ne fait pas ne rien d'autre que le journal de ce que nous faisons. Chaque méthode diffère à son parent de la mise en œuvre c'est à dire sa valeur par défaut. Donc, à côté de la journalisation en fait, c'est comme si vous aviez simplement déclaré les choses comme suit:

class Meta_1(type): pass
class Class_1(object):
    __metaclass__ = Meta_1

Et maintenant, nous allons créer une instance de Class_1

c = Class_1()
# entering Meta_1.__call__()
# entering Class_1.__new__()
# exiting Class_1.__new__()
# executing Class_1.__init__()
# exiting Meta_1.__call__()

Donc si type est le parent de Meta_1 on peut imaginer une pseudo mise en œuvre de type.__call__() en tant que tel:

class type:
    def __call__(cls, *args, **kwarg):

        # ... a few things could possibly be done to cls here... maybe... or maybe not...

        # then we call cls.__new__() to get a new object
        obj = cls.__new__(cls, *args, **kwargs)

        # ... a few things done to obj here... maybe... or not...

        # then we call obj.__init__()
        obj.__init__(*args, **kwargs)

        # ... maybe a few more things done to obj here

        # then we return obj
        return obj

De l'avis de l'ordre d'appel ci-dessus que Meta_1.__call__() (ou dans ce cas type.__call__()) est donné la possibilité d'influer sur si oui ou non les appels à Class_1.__new__() et Class_1.__init__() sont finalement fait. Au cours de son exécution Meta_1.__call__() pourrait renvoyer un objet qui n'a même pas été touché par l'un ou l'autre. Prenez l'exemple de cette approche pour le pattern singleton:

class Meta_2(type):
    __Class_2_singleton__ = None
    def __call__(cls, *a, **kw):
        # if the singleton isn't present, create and register it
        if not Meta_2.__Class_2_singleton__:
            print "entering Meta_2.__call__()"
            Meta_2.__Class_2_singleton__ = super(Meta_2, cls).__call__(*a, **kw)
            print "exiting Meta_2.__call__()"
        else:
            print ("Class_2 singleton returning from Meta_2.__call__(), "
                    "super(Meta_2, cls).__call__() skipped")
        # return singleton instance
        return Meta_2.__Class_2_singleton__

class Class_2(object):
    __metaclass__ = Meta_2
    def __new__(cls, *a, **kw):
        print "entering Class_2.__new__()"
        rv = super(Class_2, cls).__new__(cls, *a, **kw)
        print "exiting Class_2.__new__()"
        return rv

    def __init__(self, *a, **kw):
        print "executing Class_2.__init__()"
        super(Class_2, self).__init__(*a, **kw)

Observons ce qui se passe lorsque plusieurs reprises d'essayer de créer un objet de type Class_2

a = Class_2()
# entering Meta_2.__call__()
# entering Class_2.__new__()
# exiting Class_2.__new__()
# executing Class_2.__init__()
# exiting Meta_2.__call__()

b = Class_2()
# Class_2 singleton returning from Meta_2.__call__(), super(Meta_2, cls).__call__() skipped

c = Class_2()
# Class_2 singleton returning from Meta_2.__call__(), super(Meta_2, cls).__call__() skipped

print a is b is c
True

Maintenant observer cette mise en œuvre à l'aide d'une de la classe de __new__() méthode pour essayer de faire la même chose.

import random
class Class_3(object):

    __Class_3_singleton__ = None

    def __new__(cls, *a, **kw):
        # if singleton not present create and save it
        if not Class_3.__Class_3_singleton__:
            print "entering Class_3.__new__()"
            Class_3.__Class_3_singleton__ = rv = super(Class_3, cls).__new__(cls, *a, **kw)
            rv.random1 = random.random()
            rv.random2 = random.random()
            print "exiting Class_3.__new__()"
        else:
            print ("Class_3 singleton returning from Class_3.__new__(), "
                   "super(Class_3, cls).__new__() skipped")

        return Class_3.__Class_3_singleton__ 

    def __init__(self, *a, **kw):
        print "executing Class_3.__init__()"
        print "random1 is still {random1}".format(random1=self.random1)
        # unfortunately if self.__init__() has some property altering actions
        # they will affect our singleton each time we try to create an instance 
        self.random2 = random.random()
        print "random2 is now {random2}".format(random2=self.random2)
        super(Class_3, self).__init__(*a, **kw)

Avis que cette mise en œuvre, même si avec succès l'enregistrement d'un singleton sur la classe, n'empêche pas __init__() d'être appelé, de ce qui se passe implicitement dans type.__call__() (type étant la valeur par défaut métaclasse si aucun n'est spécifié). Cela peut conduire à des effets indésirables:

a = Class_3()
# entering Class_3.__new__()
# exiting Class_3.__new__()
# executing Class_3.__init__()
# random1 is still 0.282724600824
# random2 is now 0.739298365475

b = Class_3()
# Class_3 singleton returning from Class_3.__new__(), super(Class_3, cls).__new__() skipped
# executing Class_3.__init__()
# random1 is still 0.282724600824
# random2 is now 0.247361634396

c = Class_3()
# Class_3 singleton returning from Class_3.__new__(), super(Class_3, cls).__new__() skipped
# executing Class_3.__init__()
# random1 is still 0.282724600824
# random2 is now 0.436144427555

d = Class_3()
# Class_3 singleton returning from Class_3.__new__(), super(Class_3, cls).__new__() skipped
# executing Class_3.__init__()
# random1 is still 0.282724600824
# random2 is now 0.167298405242

print a is b is c is d
# True

J'ai pensé à un étoffé Python 3 version de pyroscope la réponse pourrait être pratique pour quelqu'un de copier, coller et hack avec (probablement moi, quand je me retrouve sur cette page à la recherche de nouveau dans 6 mois). Il est tiré de cet article:

class Meta(type):
@classmethod
def __prepare__(mcs, name, bases, **kwargs):
print('  Meta.__prepare__(mcs=%s, name=%r, bases=%s, **%s)' % (
mcs, name, bases, kwargs
))
return {}
def __new__(mcs, name, bases, attrs, **kwargs):
print('  Meta.__new__(mcs=%s, name=%r, bases=%s, attrs=[%s], **%s)' % (
mcs, name, bases, ', '.join(attrs), kwargs
))
return super().__new__(mcs, name, bases, attrs)
def __init__(cls, name, bases, attrs, **kwargs):
print('  Meta.__init__(cls=%s, name=%r, bases=%s, attrs=[%s], **%s)' % (
cls, name, bases, ', '.join(attrs), kwargs
))
super().__init__(name, bases, attrs)
def __call__(cls, *args, **kwargs):
print('  Meta.__call__(cls=%s, args=%s, kwargs=%s)' % (
cls, args, kwargs
))
return super().__call__(*args, **kwargs)
print('** Meta class declared')
class Class(metaclass=Meta, extra=1):
def __new__(cls, myarg):
print('  Class.__new__(cls=%s, myarg=%s)' % (
cls, myarg
))
return super().__new__(cls)
def __init__(self, myarg):
print('  Class.__init__(self=%s, myarg=%s)' % (
self, myarg
))
self.myarg = myarg
super().__init__()
def __str__(self):
return "<instance of Class; myargs=%s>" % (
getattr(self, 'myarg', 'MISSING'),
)
print('** Class declared')
Class(1)
print('** Class instantiated')

Sorties:

** Meta class declared
Meta.__prepare__(mcs=<class '__main__.Meta'>, name='Class', bases=(), **{'extra': 1})
Meta.__new__(mcs=<class '__main__.Meta'>, name='Class', bases=(), attrs=[__module__, __qualname__, __new__, __init__, __str__, __classcell__], **{'extra': 1})
Meta.__init__(cls=<class '__main__.Class'>, name='Class', bases=(), attrs=[__module__, __qualname__, __new__, __init__, __str__, __classcell__], **{'extra': 1})
** Class declared
Meta.__call__(cls=<class '__main__.Class'>, args=(1,), kwargs={})
Class.__new__(cls=<class '__main__.Class'>, myarg=1)
Class.__init__(self=<instance of Class; myargs=MISSING>, myarg=1)
** Class instantiated

Une autre grande ressource mis en évidence par le même article est David Beazley de PyCon 2013 Python 3 Métaprogrammation tutoriel.