Metaprogrammierung mit Python

Einführung in die Metaprogrammierung in Python. Verstehen Sie den Typ \ _ \ _ new \ _ \ _, \ _ \ _ metaclass \ _ \ _, um die Metaprogrammierung zu verstehen Da es notwendig ist, werde ich es separat in Blöcken einführen

Die Klassendefinition war eine Instanz vom Typ

Um die Metaprogrammierung in Python zuerst zu verstehen Sie müssen verstehen, dass die Klassendefinition eine Instanz vom Typ war.

Das Folgende ist das gleiche Verhalten bei der Definition der normalen Klasse und der Typklasse.

class Hoge(object):

    def function1(self, args):
        return args

    def function2(self, args):
        return args + 50

def func1(self, args):
    return args


def func2(self, args):
    return args + 50


# type(Klassenname, übergeordnete Klasse, Mitgliedsattribute)Wird sein
Hoge = type('Hoge', (object, ), {'function1': func1, 'function2': func2})

Wie Sie oben sehen können, war die Klassendefinition tatsächlich eine Instanz vom Typ. type (Hoge) gibt type zurück und isinstance (Hoge, type) gibt True zurück.

Über \ _ \ _ init \ _ \ _ und \ _ \ _ new \ _ \ _

Wenn eine Instanz in Python erstellt wird, wird \ _ \ _ init \ _ \ _ aufgerufen und die Instanz initialisiert. Wie Sie sehen können, gibt es vor \ _ \ _ init \ _ \ _ einen impliziten \ _ \ _ neuen \ _ \ _ Prozess. In diesem \ _ \ _ new \ _ \ _ wird der obige Typ automatisch instanziiert und die Klasse definiert.

Über \ _ \ _ Metaklasse \ _ \ _

Ich habe oben erklärt, dass der Typ in \ _ \ _ new \ _ \ _ instanziiert wird. Sie können die Instanziierung dieses Typs durch eine andere Definition ersetzen. Das wird \ _ \ _ Metaklasse \ _ \ _ sein. Sie können die Klasse beim Instanziieren des Typs erweitern, indem Sie eine Funktion oder Klasse in \ _ \ _metaclass \ _ \ _ definieren

class HogeMeta(type):

    def __new__(mcs, name, bases, dictionary):
        cls = type.__new__(mcs, name, bases, dictionary)
        setattr(cls, 'member1', 10)
        setattr(cls, 'member2', 20)
        return cls

class Hoge(object):

    __metaclass__ = HogeMeta

print Hoge().member1   -> 10
print Hoge().member2   -> 20

Stichprobe

Verwalten Sie mehrere Skill-Klassendefinitionen in der Meta-Klasse. Beim Abrufen einer beliebigen Klasse mit Skill_key.

class AttackSkill(object):
    name = u'Übergroßer Angriff'


class HealSkill(object):
    name = u'Wiederherstellung'


class PoisonSkill(object):
    name = u'Giftangriff'


class SkillMeta(type):

    def __new__(mcs, name, bases, dictionary):
        cls = type.__new__(mcs, name, bases, dictionary)
        skills = {'attack': AttackSkill,
                  'heal': HealSkill,
                  'poison': PoisonSkill}
        cls.SKILLS = skills
        return cls


class Skills(object):

    __metaclass__ = SkillMeta

    SKILLS = {}

    @classmethod
    def get(cls, skill_key):
        return cls.SKILLS[skill_key]

Skill = Skills.get

print Skill('attack').name   ->Übergroßer Angriff
print Skill('heal').name     ->Wiederherstellung

Zusammenfassung

Die Beispielmethode kann durch Kombinieren von Funktionen und Diktaten ohne Verwendung der Meta-Programmierung durchgeführt werden. Ersteres ist erweiterbarer und kann präzise geschrieben werden. Da alles in der Klasse abgeschlossen ist, ist es auch sehr objektorientiert.

Referenz

http://www.yunabe.jp/docs/python_metaclass.html