Métaprogrammation avec Python

Présentation de la métaprogrammation en Python. Comprendre le type, \ _ \ _ nouveau \ _ \ _, \ _ \ _ métaclasse \ _ \ _ pour comprendre la métaprogrammation Puisqu'il est nécessaire, je vais l'introduire séparément en blocs

La définition de classe était une instance de type

Pour comprendre d'abord la métaprogrammation en Python Vous devez comprendre que la définition de classe était une instance de type.

Ce qui suit est le même comportement dans la définition de la classe normale et de la classe de type.

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(Nom de classe, classe parent, attributs de membre)Sera
Hoge = type('Hoge', (object, ), {'function1': func1, 'function2': func2})

Comme vous pouvez le voir ci-dessus, la définition de classe était en fait une instance de type. type (Hoge) renvoie le type et isinstance (Hoge, type) renvoie True.

À propos de \ _ \ _ init \ _ \ _ et \ _ \ _ nouveau \ _ \ _

Lorsqu'une instance est créée en Python, \ _ \ _ init \ _ \ _ est appelée et l'instance est initialisée. Comme vous pouvez le voir, il y a un processus \ _ \ _ nouveau \ _ \ _ implicite avant \ _ \ _ init \ _ \ _. Dans ce \ _ \ _ nouveau \ _ \ _, le type ci-dessus est automatiquement instancié et la classe est définie.

À propos de \ _ \ _ metaclass \ _ \ _

J'ai expliqué ci-dessus que le type est instancié dans \ _ \ _ new \ _ \ _, Vous pouvez remplacer l'instanciation de ce type par une autre définition. Ce sera \ _ \ _ metaclass \ _ \ _. Vous pouvez étendre la classe lors de l'instanciation de type en définissant une fonction ou une classe dans \ _ \ _metaclass \ _ \ _

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

échantillon

Gérez plusieurs définitions de classes de compétences dans la classe Meta, Lors de l'obtention d'une classe arbitraire avec skill_key.

class AttackSkill(object):
    name = u'Attaque surdimensionnée'


class HealSkill(object):
    name = u'récupération'


class PoisonSkill(object):
    name = u'Attaque empoisonnée'


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   ->Attaque surdimensionnée
print Skill('heal').name     ->récupération

Résumé

La méthode d'exemple peut être réalisée en combinant des fonctions et des dictionnaires sans utiliser la programmation Meta. Le premier est plus extensible et peut être rédigé de manière concise. De plus, puisque tout est terminé dans la classe, il est fortement orienté objet.

référence

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