Was sind (konkrete) Anwendungsfälle für Metaklassen?

Ich wurde gebeten, die gleiche Frage vor kurzem, und kam mit mehreren Antworten. Ich hoffe es ist OK diesen thread wieder zu beleben, als wollte ich näher auf einige der Anwendungsfälle erwähnt, und fügen Sie ein paar neue.

Meisten Metaklassen ich habe gesehen, eines von zwei Dingen tun:

1. Registrierung (eine Klasse hinzufügen, um eine Daten-Struktur):

   models = {}
   
   class ModelMetaclass(type):
       def __new__(meta, name, bases, attrs):
           models[name] = cls = type.__new__(meta, name, bases, attrs)
           return cls
   
   class Model(object):
       __metaclass__ = ModelMetaclass

   Wann immer Sie eine Unterklasse Model Ihre Klasse registriert ist, in der models Wörterbuch:

   >>> class A(Model):
   ...     pass
   ...
   >>> class B(A):
   ...     pass
   ...
   >>> models
   {'A': <__main__.A class at 0x...>,
    'B': <__main__.B class at 0x...>}

   Dies kann auch durchgeführt werden mit der Klasse Dekorateure:

   models = {}
   
   def model(cls):
       models[cls.__name__] = cls
       return cls
   
   @model
   class A(object):
       pass

   Oder mit einer expliziten Registrierung Funktion:

   models = {}
   
   def register_model(cls):
       models[cls.__name__] = cls
   
   class A(object):
       pass
   
   register_model(A)

   Eigentlich, das ist so ziemlich das gleiche: Sie erwähnen Klasse Dekorateure ungünstig, aber es ist wirklich nichts anderes als syntaktischer Zucker für ein Funktions-Aufruf in einer Klasse, so gibt es keine Magie über es.

   Eh, der Vorteil von Metaklassen in diesem Fall ist die Vererbung, wie Sie arbeiten, für die keine Unterklassen, während die anderen Lösungen funktionieren nur für Unterklassen explizit eingerichtet bzw. registriert werden.

   >>> class B(A):
   ...     pass
   ...
   >>> models
   {'A': <__main__.A class at 0x...> # No B :(

2. Refactoring (ändern von Klassen-Attribute oder neue hinzufügen):

   class ModelMetaclass(type):
       def __new__(meta, name, bases, attrs):
           fields = {}
           for key, value in attrs.items():
               if isinstance(value, Field):
                   value.name = '%s.%s' % (name, key)
                   fields[key] = value
           for base in bases:
               if hasattr(base, '_fields'):
                   fields.update(base._fields)
           attrs['_fields'] = fields
           return type.__new__(meta, name, bases, attrs)
   
   class Model(object):
       __metaclass__ = ModelMetaclass

   Wann immer Sie eine Unterklasse Model und definieren einige Field Attribute, injiziert werden Sie mit Ihrem Namen (für mehr informative Fehlermeldungen, zum Beispiel), und gruppiert in einem _fields Wörterbuch (für die einfache iteration, suchen, ohne durch alle class-Attribute und-alle Ihre Basisklassen Attribute jedes mal):

   >>> class A(Model):
   ...     foo = Integer()
   ...
   >>> class B(A):
   ...     bar = String()
   ...
   >>> B._fields
   {'foo': Integer('A.foo'), 'bar': String('B.bar')}

   Wieder, diese kann getan werden (ohne Vererbung) mit einer Klasse decorator:

   def model(cls):
       fields = {}
       for key, value in vars(cls).items():
           if isinstance(value, Field):
               value.name = '%s.%s' % (cls.__name__, key)
               fields[key] = value
       for base in cls.__bases__:
           if hasattr(base, '_fields'):
               fields.update(base._fields)
       cls._fields = fields
       return cls
   
   @model
   class A(object):
       foo = Integer()
   
   class B(A):
       bar = String()
   
   # B.bar has no name :(
   # B._fields is {'foo': Integer('A.foo')} :(

   Oder explizit:

   class A(object):
       foo = Integer('A.foo')
       _fields = {'foo': foo} # Don't forget all the base classes' fields, too!

   Obwohl das im Widerspruch zu Ihrem eintreten für lesbar und wartbar non-meta-Programmierung, dies ist viel mehr umständlich, redundant und fehleranfällig:

   class B(A):
       bar = String()
   
   # vs.
   
   class B(A):
       bar = String('bar')
       _fields = {'B.bar': bar, 'A.foo': A.foo}

Haben als die gemeinsamen und konkreten Anwendungsfälle, die nur in Fällen, wo Sie absolut verwenden MÜSSEN Metaklassen sind, wenn Sie möchten, ändern Sie den Namen der Klasse oder eine Liste von Basisklassen, denn einmal definiert, werden diese Parameter sind fest in der Klasse, und kein Dekorateur oder Funktion kann unbake.

class Metaclass(type):
    def __new__(meta, name, bases, attrs):
        return type.__new__(meta, 'foo', (int,), attrs)

class Baseclass(object):
    __metaclass__ = Metaclass

class A(Baseclass):
    pass

class B(A):
    pass

print A.__name__ # foo
print B.__name__ # foo
print issubclass(B, A)   # False
print issubclass(B, int) # True

Dies kann hilfreich sein, den Rahmen für die Erteilung von Warnungen, wenn Klassen mit ähnlichen Namen oder unvollständige Vererbung Bäume sind definiert, aber ich kann nicht denken, ein Grund, neben trolling tatsächlich verändern sich diese Werte. Vielleicht David Beazley können.

Sowieso in Python 3, Metaklassen haben auch die __prepare__ - Methode, die können Sie bewerten den Klasse Körper in einem mapping andere als ein dict und unterstützen so bestellt Attribute, überladene Attribute und andere böse cool stuff:

import collections

class Metaclass(type):

    @classmethod
    def __prepare__(meta, name, bases, **kwds):
        return collections.OrderedDict()

    def __new__(meta, name, bases, attrs, **kwds):
        print(list(attrs))
        # Do more stuff...

class A(metaclass=Metaclass):
    x = 1
    y = 2

# prints ['x', 'y'] rather than ['y', 'x']

class ListDict(dict):
    def __setitem__(self, key, value):
        self.setdefault(key, []).append(value)

class Metaclass(type):

    @classmethod
    def __prepare__(meta, name, bases, **kwds):
        return ListDict()

    def __new__(meta, name, bases, attrs, **kwds):
        print(attrs['foo'])
        # Do more stuff...

class A(metaclass=Metaclass):

    def foo(self):
        pass

    def foo(self, x):
        pass

# prints [<function foo at 0x...>, <function foo at 0x...>] rather than <function foo at 0x...>

Könnte man argumentieren bestellt Parametern erreicht werden kann, mit der Schöpfung Zähler, und überladen kann simuliert werden mit default-Argumenten:

import itertools

class Attribute(object):
    _counter = itertools.count()
    def __init__(self):
        self._count = Attribute._counter.next()

class A(object):
    x = Attribute()
    y = Attribute()

A._order = sorted([(k, v) for k, v in vars(A).items() if isinstance(v, Attribute)],
                  key = lambda (k, v): v._count)

class A(object):

    def _foo0(self):
        pass

    def _foo1(self, x):
        pass

    def foo(self, x=None):
        if x is None:
            return self._foo0()
        else:
            return self._foo1(x)

Abgesehen davon, dass viel mehr hässlich, es ist auch weniger flexibel: was ist, wenn Sie bestellten literal Attribute, wie Ganzzahlen und strings? Was ist, wenn None ist ein Gültiger Wert für x?

Hier ist eine kreative Art zu lösen das erste problem:

import sys

class Builder(object):
    def __call__(self, cls):
        cls._order = self.frame.f_code.co_names
        return cls

def ordered():
    builder = Builder()
    def trace(frame, event, arg):
        builder.frame = frame
        sys.settrace(None)
    sys.settrace(trace)
    return builder

@ordered()
class A(object):
    x = 1
    y = 'foo'

print A._order # ['x', 'y']

Und hier ist eine kreative Art und Weise zu lösen, die zweite:

_undefined = object()

class A(object):

    def _foo0(self):
        pass

    def _foo1(self, x):
        pass

    def foo(self, x=_undefined):
        if x is _undefined:
            return self._foo0()
        else:
            return self._foo1(x)

Aber das ist viel, VIEL voodoo-er als eine einfache Metaklasse (vor allem das erste, das wirklich schmilzt dein Gehirn). Mein Punkt ist, schauen Sie auf Metaklassen, Fremd-und counter-intuitive, aber Sie können auch sehen Sie als den nächsten Schritt der evolution in den Programmiersprachen: Sie müssen nur passen Sie Ihre Denkweise. Nach allem, könnten Sie wahrscheinlich alles tun, was in C, einschließlich der Definition eines struct mit funktionspointern und übergeben Sie als erstes argument für seine Funktionen. Eine person zu sehen, C++ für die erste Zeit könnte sagen, "was ist das für Magie? Warum ist der compiler implizit übergeben this zu Methoden, aber nicht regelmäßig und statische Funktionen? Es ist besser, explizit und ausführlich über Ihre Argumente". Aber dann, Objekt-orientierte Programmierung ist viel leistungsfähiger, wenn Sie es bekommen; und so ist diese, äh... quasi-Aspekt-orientierte Programmierung, denke ich. Und wenn Sie verstehen, metaclasses, eigentlich sind Sie sehr einfach, also warum nicht verwenden Sie, wenn bequem?

Und schließlich Metaklassen sind toll, und die Programmierung sollte Spaß machen. Mit standard-Programmier-Konstrukte und design-Muster, ist die ganze Zeit langweilig und langweilig, und behindert Ihre Phantasie. Ein wenig Leben! Hier ist ein metametaclass, nur für Sie.

class MetaMetaclass(type):
    def __new__(meta, name, bases, attrs):
        def __new__(meta, name, bases, attrs):
            cls = type.__new__(meta, name, bases, attrs)
            cls._label = 'Made in %s' % meta.__name__
            return cls 
        attrs['__new__'] = __new__
        return type.__new__(meta, name, bases, attrs)

class China(type):
    __metaclass__ = MetaMetaclass

class Taiwan(type):
    __metaclass__ = MetaMetaclass

class A(object):
    __metaclass__ = China

class B(object):
    __metaclass__ = Taiwan

print A._label # Made in China
print B._label # Made in Taiwan

InformationsquelleAutor der Antwort Dan Gittik

Beginnen wir mit Tim Peters classic Zitat:

Metaklassen sind tiefer Magie als 99%
der Benutzer sollte jemals sorgen machen. Wenn
Sie Fragen sich, ob Sie Sie brauchen, die Sie
nicht (die Leute, die Sie tatsächlich benötigen
Sie wissen mit Sicherheit, dass Sie
Sie brauche, und brauche nicht eine
Erklärung, warum). Tim Peters
(c.l.p post 2002-12-22)

Gesagt, dass ich (regelmäßig) laufen über echte Verwendungen von Metaklassen. Die eine, die den Sinn kommt, ist in Django, wo Sie alle Ihre Modelle Erben von Modellen.Modell. Modelle.Modell trägt wiederum einige ernsthafte Magie, um wickeln Sie Ihre DB-Modelle mit Djangos ORM Güte. Die Magie geschieht durch Metaklassen. Es erstellt alle Arten von exception-Klassen, manager-Klassen, etc. etc.

Sehen django/db/models/base.py, class ModelBase() für den Anfang der Geschichte.

InformationsquelleAutor der Antwort Peter Rowell

Dachte ich das gleiche gerade gestern und ganz Zustimmen. Die Komplikationen, die in dem code verursacht, der durch versuche zu machen, mehr deklarative Regel machen die codebase, die schwieriger zu pflegen, schwieriger zu Lesen und weniger pythonic meiner Meinung nach.
Es auch erfordert in der Regel eine Menge kopieren.copy()ing (Pflege, Vererbung und kopieren von Klasse zu Instanz) und bedeutet, dass Sie schauen müssen, in viele Orte, um zu sehen, was Los ist, (immer auf der Suche von metaclass-up), die sich gegen die python Getreide auch.
Ich habe Kommissionierung durch formencode und sqlalchemy-code zu sehen, wenn eine solche deklarativen Stil, der es Wert war und seine eindeutig nicht. Ein solcher Stil sollte überlassen werden, um Deskriptoren (wie Eigentum und Methoden) und unveränderliche Daten.
Ruby hat eine bessere Unterstützung für solche deklarative Stile und ich bin froh, dass die core-Sprache python ist nicht nach unten dieser Strecke.

Ich sehen kann für das Debuggen verwenden, fügen Sie eine Metaklasse alle Ihre Basisklassen, um umfangreichere Infos.
Ich sehe auch, dass Ihre Verwendung nur in (sehr) großen Projekten, um loszuwerden, einige boilerplate code (aber auf den Verlust von Klarheit). sqlalchemy für Beispiel verwenden Sie Sie an anderer Stelle, hinzufügen einer bestimmten benutzerdefinierten Methode für alle Unterklassen basierend auf einem Attribut mit dem Wert in Ihrer Klasse definition
e.g ein Spielzeug Beispiel

class test(baseclass_with_metaclass):
    method_maker_value = "hello"

hätte eine Metaklasse, die generiert einer Methode in dieser Klasse mit besonderen Eigenschaften auf Basis von "hello" (sagen, eine Methode, die Hinzugefügt "Hallo" an das Ende der Zeichenkette). Es könnte gut für die Wartbarkeit sicherstellen, dass Sie nicht haben, um zu schreiben, eine Methode in jeder Unterklasse, die Sie machen, anstatt alles, was Sie zu definieren, ist method_maker_value.

Die Notwendigkeit dieser ist so selten, wenn und nur spart ein wenig Tipparbeit, dass es nicht wirklich eine überlegung Wert, es sei denn, Sie haben eine ausreichend große Basis zu nutzen.

InformationsquelleAutor der Antwort David Raznick

Du nie absolut müssen Verwendung einer Metaklasse, da kann man immer konstruieren Sie eine Klasse, die tut, was Sie wollen mit der Vererbung oder aggregation der Klasse, die Sie ändern möchten.

Das heißt, es kann sehr nützlich sein in Smalltalk und Ruby zu ändern, können Sie eine vorhandene Klasse, aber Python nicht mag, das zu tun, direkt.

Gibt es eine hervorragende DeveloperWorks Artikel auf metaclassing in Python, die helfen könnten. Die Wikipedia-Artikel ist auch ziemlich gut.

InformationsquelleAutor der Antwort Charlie Martin

Metaklassen sind nicht zu ersetzen-Programmierung! Sie sind nur ein trick, das zu automatisieren oder machen Sie mehr elegant einige Aufgaben. Ein gutes Beispiel HIERFÜR ist Pygments syntax-highlighting-Bibliothek. Es hat eine Klasse namens RegexLexer dem der Benutzer festgelegt werden, sind das sogenannte Lexing Regeln wie reguläre Ausdrücke in einer Klasse. Eine Metaklasse ist, können Sie die Definitionen in eine sinnvolle parser.

Sind Sie wie Salz; es ist einfach zu viel.

InformationsquelleAutor der Antwort Benjamin Peterson

Einige GUI-Bibliotheken haben Probleme, wenn mehrere threads versuchen, mit Ihnen zu interagieren. tkinter ist ein Beispiel dafür; und zwar kann man explizit behandelt das problem mit events und Warteschlangen, kann es viel einfacher zu verwenden der Bibliothek in einer Weise ignoriert, dass das problem insgesamt. Siehe -- die Magie der metaclasses.

Können dynamisch umschreiben eine ganze Bibliothek nahtlos, so dass es funktioniert wie erwartet, in einer Multithread-Anwendung kann sehr hilfreich sein in einigen Fällen. Die safetkinter - Modul, das mit Hilfe einer Metaklasse bereitgestellt durch die threadbox Modul -- Veranstaltungen und Warteschlangen nicht notwendig.

Einem ordentlichen Aspekt der threadbox ist, dass es egal ist welche Klasse es-Klone. Es bietet ein Beispiel dafür, wie alle base-Klassen berührt werden können, durch eine Metaklasse, wenn nötig. Ein weiterer Vorteil ist, dass kommt mit Metaklassen ist, dass Sie Erben von den Klassen als gut. Programme, die selbst schreiben-warum nicht?

InformationsquelleAutor der Antwort Noctis Skytower

Dies ist eine geringfügige, aber... eine Sache, die ich gefunden habe Metaklassen nützlich ist um eine Funktion aufzurufen, wenn eine Unterklasse erstellt wird. Ich kodifiziert diese in eine Metaklasse, die sieht für ein __initsubclass__ Attribut: immer, wenn eine Unterklasse erstellt wird, werden alle übergeordneten Klassen, die definieren, dass die Methode aufgerufen wird, mit __initsubclass__(cls, subcls). Dies ermöglicht die Erstellung einer übergeordneten Klasse, die registriert dann alle Unterklassen mit einigen globalen Registrierung läuft invariante prüft auf Unterklassen, wenn Sie definiert sind, führen late-binding-Operationen, usw... alles ohne manuell aufrufen von Funktionen oder zum erstellen von benutzerdefinierten Metaklassen, die Sie durchführen, jede dieser einzelnen Aufgaben.

Wohlgemerkt, ich habe langsam kommen, um zu erkennen, das implizite magicalness dieses Verhalten ist eher unerwünscht, da es zu unerwarteten, wenn man bei der definition einer Klasse aus dem Zusammenhang gerissen... und so habe ich verschoben, Weg von der Nutzung, die Lösung für etwas ernstes neben initialisieren eines __super Attribut für jede Klasse und Instanz.

InformationsquelleAutor der Antwort Eli Collins

Scheint es eine legitime Nutzung beschrieben hier - Rewriting Python Docstrings mit einer Metaklasse.

InformationsquelleAutor der Antwort mistermarko