"158.181.133.199 - 158.181.133.199"

Что такое метаклассы в Python?

Что такое метаклассы и для чего мы их используем?

5074
19 сент. '08 в 9:10
источник поделиться
19 ответов

Метакласс - это класс класса. Класс определяет, как ведет себя экземпляр класса (т.е. Объект), а метакласс определяет поведение класса. Класс является экземпляром метакласса.

В то время как в Python вы можете использовать произвольные вызываемые элементы для метаклассов (как показано в Jerub), лучший подход состоит в том, чтобы сделать его самим классом. type - это обычный метакласс в Python. type сам по себе является классом, и это его собственный тип. Вы не сможете воссоздать что-то вроде type исключительно в Python, но Python немного обманывает. Чтобы создать свой собственный метакласс в Python, вы просто хотите использовать type подкласса.

Метакласс чаще всего используется как фабрика классов. Когда вы создаете объект, вызывая класс, Python создает новый класс (когда он выполняет оператор 'class'), вызывая метакласс. В сочетании с обычными методами __init__ и __new__ метаклассы, таким образом, позволяют создавать "дополнительные вещи" при создании класса, такие как регистрация нового класса в каком-либо реестре или замена класса чем-то совершенно другим.

Когда выполняется оператор class, Python сначала выполняет тело оператора class как обычный блок кода. Результирующее пространство имен (dict) содержит атрибуты будущего класса. Метакласс определяется путем просмотра базовых классов будущего класса (метаклассы наследуются), атрибута __metaclass__ класса (если есть) или глобальной переменной __metaclass__. Затем метакласс вызывается с именем, основами и атрибутами класса, чтобы создать его экземпляр.

Тем не менее, метаклассы фактически определяют тип класса, а не просто фабрику для него, так что вы можете сделать с ними гораздо больше. Например, вы можете определить нормальные методы в метаклассе. Эти метакласс-методы похожи на методы класса в том смысле, что их можно вызывать в классе без экземпляра, но они также не похожи на методы класса в том смысле, что их нельзя вызывать в экземпляре класса. type.__subclasses__() - это пример метода метакласса type. Вы также можете определить обычные "магические" методы, такие как __add__, __iter__ и __getattr__, для реализации или изменения поведения класса.

Вот агрегированный пример из кусочков:

def make_hook(f):
    """Decorator to turn 'foo' method into '__foo__'"""
    f.is_hook = 1
    return f

class MyType(type):
    def __new__(mcls, name, bases, attrs):

        if name.startswith('None'):
            return None

        # Go over attributes and see if they should be renamed.
        newattrs = {}
        for attrname, attrvalue in attrs.iteritems():
            if getattr(attrvalue, 'is_hook', 0):
                newattrs['__%s__' % attrname] = attrvalue
            else:
                newattrs[attrname] = attrvalue

        return super(MyType, mcls).__new__(mcls, name, bases, newattrs)

    def __init__(self, name, bases, attrs):
        super(MyType, self).__init__(name, bases, attrs)

        # classregistry.register(self, self.interfaces)
        print "Would register class %s now." % self

    def __add__(self, other):
        class AutoClass(self, other):
            pass
        return AutoClass
        # Alternatively, to autogenerate the classname as well as the class:
        # return type(self.__name__ + other.__name__, (self, other), {})

    def unregister(self):
        # classregistry.unregister(self)
        print "Would unregister class %s now." % self

class MyObject:
    __metaclass__ = MyType


class NoneSample(MyObject):
    pass

# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)

class Example(MyObject):
    def __init__(self, value):
        self.value = value
    @make_hook
    def add(self, other):
        return self.__class__(self.value + other.value)

# Will unregister the class
Example.unregister()

inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()

print inst + inst
class Sibling(MyObject):
    pass

ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__
2423
19 сент. '08 в 10:01
источник

Классы как объекты

Прежде чем разбираться в метаклассах, вам нужно освоить классы на Python. И у Python очень своеобразное представление о том, что такое классы, заимствованные из языка Smalltalk.

В большинстве языков классы - это просто фрагменты кода, которые описывают, как создать объект. Это тоже правда в Python:

>>> class ObjectCreator(object):
...       pass
...

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

Но классы больше, чем в Python. Классы тоже объекты.

Да, объекты.

Как только вы используете ключевое слово class, Python выполняет его и создает OBJECT. Инструкция

>>> class ObjectCreator(object):
...       pass
...

создает в памяти объект с именем "ObjectCreator".

Этот объект (класс) сам по себе способен создавать объекты (экземпляры), и именно поэтому он является классом.

Но все же, это объект, и поэтому:

  • Вы можете назначить его переменной
  • Вы можете скопировать это
  • Вы можете добавить атрибуты к нему
  • Вы можете передать его в качестве параметра функции

например:

>>> print(ObjectCreator) # you can print a class because it an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

Создание классов динамически

Так как классы являются объектами, вы можете создавать их на лету, как и любой объект.

Во-первых, вы можете создать класс в функции, используя class:

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

Но это не так динамично, так как вам все равно придется писать весь класс самостоятельно.

Так как классы являются объектами, они должны быть сгенерированы чем-то.

Когда вы используете ключевое слово class, Python создает этот объект автоматически. Но, как и большинство вещей в Python, это дает вам возможность сделать это вручную.

Помните type функции? Старая добрая функция, которая позволяет узнать тип объекта:

>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

Ну, у type есть совершенно другая способность, он также может создавать классы на лету. type может принимать описание класса в качестве параметров и возвращать класс.

(Я знаю, это глупо, что одна и та же функция может иметь два совершенно разных использования в соответствии с параметрами, которые вы передаете ей. Это проблема из-за обратной совместимости в Python)

type работает следующим образом:

type(name of the class,
     tuple of the parent class (for inheritance, can be empty),
     dictionary containing attributes names and values)

например:

>>> class MyShinyClass(object):
...       pass

можно создать вручную таким образом:

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

Вы заметите, что мы используем "MyShinyClass" в качестве имени класса и в качестве переменной для хранения ссылки на класс. Они могут быть разными, но нет причин усложнять вещи.

type принимает словарь для определения атрибутов класса. Так:

>>> class Foo(object):
...       bar = True

Можно перевести на:

>>> Foo = type('Foo', (), {'bar':True})

И используется как обычный класс:

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

И, конечно, вы можете наследовать от него, так что:

>>>   class FooChild(Foo):
...         pass

было бы:

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

В конце концов вы захотите добавить методы в ваш класс. Просто определите функцию с правильной подписью и назначьте ее в качестве атрибута.

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

И вы можете добавить еще больше методов после динамического создания класса, точно так же, как добавление методов в нормально созданный объект класса.

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

Вы видите, куда мы идем: в Python классы являются объектами, и вы можете динамически создавать классы на лету.

Это то, что делает Python, когда вы используете ключевое слово class, и это делается с помощью метакласса.

Что такое метаклассы (наконец)

Метаклассы - это "материал", который создает классы.

Вы определяете классы для создания объектов, верно?

Но мы узнали, что классы Python являются объектами.

Ну, именно метаклассы создают эти объекты. Это классы классов, вы можете изобразить их следующим образом:

MyClass = MetaClass()
my_object = MyClass()

Вы видели, что этот type позволяет вам сделать что-то вроде этого:

MyClass = type('MyClass', (), {})

Это потому, что type функции на самом деле является метаклассом. type - это метакласс, который Python использует для создания всех классов за сценой.

Теперь вы удивляетесь, почему, черт возьми, оно написано строчными буквами, а не Type?

Ну, я думаю, это вопрос совместимости с str, классом, который создает строковые объекты, и int с классом, который создает целочисленные объекты. type это просто класс, который создает объекты класса.

Вы видите это, проверив атрибут __class__.

Все, и я имею в виду все, является объектом в Python. Это включает в себя целые, строки, функции и классы. Все они объекты. И все они были созданы из класса:

>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

Теперь, что такое __class__ любого __class__?

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

Итак, метакласс - это просто материал, который создает объекты класса.

Вы можете назвать это "фабрикой классов", если хотите.

type - это встроенный метакласс, который использует Python, но, конечно, вы можете создать свой собственный метакласс.

__metaclass__

В Python 2 вы можете добавить атрибут __metaclass__ при написании класса (см. Следующий раздел о синтаксисе Python 3):

class Foo(object):
    __metaclass__ = something...
    [...]

Если вы это сделаете, Python будет использовать метакласс для создания класса Foo.

Осторожно, это сложно.

Сначала вы пишете class Foo(object), но объект класса Foo еще не создан в памяти.

Python будет искать __metaclass__ в определении класса. Если он найдет его, он будет использовать его для создания класса объектов Foo. Если этого не произойдет, он будет использовать type для создания класса.

Прочитайте это несколько раз.

Когда вы делаете:

class Foo(Bar):
    pass

Python делает следующее:

Есть ли __metaclass__ атрибут в Foo?

Если да, создайте в памяти объект класса (я сказал объект класса, оставайтесь со мной здесь) с именем Foo, используя то, что находится в __metaclass__.

Если Python не может найти __metaclass__, он будет искать __metaclass__ на уровне MODULE и попытаться сделать то же самое (но только для классов, которые ничего не наследуют, в основном классы старого стиля).

Затем, если он вообще не может найти __metaclass__, он будет использовать собственный метакласс Bar (первый родительский элемент) (который может быть type по умолчанию) для создания объекта класса.

Будьте осторожны, __metaclass__ атрибут __metaclass__ не был унаследован, метакласс родительского (Bar.__class__) будет. Если Bar использовал атрибут __metaclass__ который создал Bar с type() (а не с type.__new__()), подклассы не будут наследовать это поведение.

Теперь большой вопрос, что вы можете поместить в __metaclass__?

Ответ: что-то, что может создать класс.

А что может создать класс? type, или что-нибудь, что подклассы или использует его.

Метаклассы в Python 3

Синтаксис для установки метакласса был изменен в Python 3:

class Foo(object, metaclass=something):
    ...

т.е. атрибут __metaclass__ больше не используется в пользу ключевого аргумента в списке базовых классов.

Поведение метаклассов, однако, остается в основном таким же.

Одна вещь, добавленная к метаклассам в Python 3, заключается в том, что вы также можете передавать атрибуты как аргументы-ключевые слова в метакласс, например, так:

class Foo(object, metaclass=something, kwarg1=value1, kwarg2=value2):
    ...

Прочтите раздел ниже, чтобы узнать, как Python справляется с этим.

Пользовательские метаклассы

Основное назначение метакласса - автоматическое изменение класса при его создании.

Вы обычно делаете это для API, где вы хотите создать классы, соответствующие текущему контексту.

Представьте себе глупый пример, когда вы решаете, что все классы в вашем модуле должны иметь свои атрибуты, написанные в верхнем регистре. Есть несколько способов сделать это, но один из них - установить __metaclass__ на уровне модуля.

Таким образом, все классы этого модуля будут создаваться с использованием этого метакласса, и нам просто нужно указать метаклассу, чтобы все атрибуты были переведены в верхний регистр.

К счастью, __metaclass__ самом деле может быть любым вызываемым, он не должен быть формальным классом (я знаю, что-то с именем 'class' в названии не обязательно должно быть классом, поймите, что... но это полезно).

Итак, начнем с простого примера с использования функции.

# the metaclass will automatically get passed the same argument
# that you usually pass to 'type'
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    """
      Return a class object, with the list of its attribute turned
      into uppercase.
    """

    # pick up any attribute that doesn't start with '__' and uppercase it
    uppercase_attr = {}
    for name, val in future_class_attr.items():
        if not name.startswith('__'):
            uppercase_attr[name.upper()] = val
        else:
            uppercase_attr[name] = val

    # let 'type' do the class creation
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # this will affect all classes in the module

class Foo(): # global __metaclass__ won't work with "object" though
    # but we can define __metaclass__ here instead to affect only this class
    # and this will work with "object" children
    bar = 'bip'

print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True

f = Foo()
print(f.BAR)
# Out: 'bip'

Теперь, давайте сделаем то же самое, но используя реальный класс для метакласса:

# remember that 'type' is actually a class like 'str' and 'int'
# so you can inherit from it
class UpperAttrMetaclass(type):
    # __new__ is the method called before __init__
    # it the method that creates the object and returns it
    # while __init__ just initializes the object passed as parameter
    # you rarely use __new__, except when you want to control how the object
    # is created.
    # here the created object is the class, and we want to customize it
    # so we override __new__
    # you can do some stuff in __init__ too if you wish
    # some advanced use involves overriding __call__ as well, but we won't
    # see this
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type(future_class_name, future_class_parents, uppercase_attr)

Но это не совсем ООП. Мы вызываем type напрямую и не __new__ или не вызываем родительский __new__. Давай сделаем это:

class UpperAttrMetaclass(type):

    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        # reuse the type.__new__ method
        # this is basic OOP, nothing magic in there
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

Возможно, вы заметили дополнительный аргумент upperattr_metaclass. В этом нет ничего особенного: __new__ всегда получает класс, в котором он определен, в качестве первого параметра. Точно так же, как у вас есть self для обычных методов, которые получают экземпляр в качестве первого параметра, или определяющий класс для методов класса.

Конечно, имена, которые я здесь использовал, длинны для ясности, но, как и для self, все аргументы имеют условные имена. Таким образом, настоящий метакласс производства будет выглядеть так:

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type.__new__(cls, clsname, bases, uppercase_attr)

Мы можем сделать его еще чище, используя super, что облегчит наследование (потому что да, вы можете иметь метаклассы, наследуя от метаклассов, наследуя от типа):

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

Да, и в Python 3, если вы делаете этот вызов с аргументами ключевых слов, например:

class Foo(object, metaclass=Thing, kwarg1=value1):
    ...

Это переводит это в метакласс, чтобы использовать это:

class Thing(type):
    def __new__(cls, clsname, bases, dct, kwargs1=default):
        ...

Это. В метаклассах больше ничего нет.

Причиной сложности кода, использующего метаклассы, является не метаклассы, а то, что вы обычно используете метаклассы для скручивания, полагаясь на интроспекцию, манипулирование наследованием, переменные типа __dict__ и т.д.

Действительно, метаклассы особенно полезны для создания чёрной магии и, следовательно, сложных вещей. Но сами по себе они просты

  • перехватить создание класса
  • изменить класс
  • вернуть измененный класс

Почему вы используете классы метаклассов вместо функций?

Так как __metaclass__ может принимать любой вызываемый __metaclass__, зачем вам использовать класс, поскольку он явно более сложный?

Для этого есть несколько причин:

  • Намерение ясно. Когда вы читаете UpperAttrMetaclass(type), вы знаете, что последует
  • Вы можете использовать ООП. Метакласс может наследовать от метакласса, переопределять родительские методы. Метаклассы могут даже использовать метаклассы.
  • Подклассы класса будут экземплярами его метакласса, если вы указали метакласс-класс, но не с метакласс-функцией.
  • Вы можете структурировать свой код лучше. Вы никогда не используете метаклассы для чего-то столь же тривиального, как приведенный выше пример. Это обычно для чего-то сложного. Возможность создавать несколько методов и группировать их в одном классе очень полезна для облегчения чтения кода.
  • Вы можете подключиться к __new__, __init__ и __call__. Что позволит вам делать разные вещи. Даже если обычно вы можете делать все это в __new__, некоторым людям просто удобнее использовать __init__.
  • Это называется метаклассы, черт возьми! Это должно что-то значить!

Почему вы используете метаклассы?

Теперь большой вопрос. Зачем вам использовать некоторые скрытые ошибки?

Ну, обычно вы этого не делаете:

Метаклассы - это более глубокое волшебство, о котором 99% пользователей никогда не должны беспокоиться. Если вам интересно, нужны ли они вам, вам это не нужно (люди, которые действительно нуждаются в них, точно знают, что они им нужны, и не нуждаются в объяснении того, почему).

Питон Гуру Тим Питерс

Основным вариантом использования метакласса является создание API. Типичным примером этого является Django ORM.

Это позволяет вам определить что-то вроде этого:

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

Но если вы сделаете это:

guy = Person(name='bob', age='35')
print(guy.age)

Он не вернет объект IntegerField. Он вернет int и может даже взять его непосредственно из базы данных.

Это возможно, потому что models.Model определяет __metaclass__ и использует магию, которая превратит Person вы только что определили, с помощью простых операторов, в сложный крюк для поля базы данных.

Django делает что-то сложное простым, предоставляя простой API и используя метаклассы, воссоздавая код из этого API для реальной работы за кулисами.

Последнее слово

Во-первых, вы знаете, что классы - это объекты, которые могут создавать экземпляры.

Ну, на самом деле, классы сами по себе являются примерами. Метаклассов.

>>> class Foo(object): pass
>>> id(Foo)
142630324

В Python все является объектом, и все они являются экземплярами классов или экземплярами метаклассов.

За исключением type.

type на самом деле его собственный метакласс. Это не то, что вы могли бы воспроизвести на чистом Python, и это делается путем обмана на уровне реализации.

Во-вторых, метаклассы сложны. Возможно, вы не захотите использовать их для очень простых изменений класса. Вы можете изменить классы, используя два разных метода:

В 99% случаев вам нужно изменить класс, лучше использовать их.

Но в 98% случаев вам вообще не нужно менять класс.

6174
05 июля '11 в 14:29
источник

Обратите внимание, этот ответ для Python 2.x, как он был написан в 2008 году, метаклассы немного отличаются в 3.x, см. комментарии.

Метаклассы - это секретный соус, который делает работу "класса". Метакласс по умолчанию для нового объекта стиля называется "type".

class type(object)
  |  type(object) -> the object type
  |  type(name, bases, dict) -> a new type

Метаклассы принимают 3 аргумента. ' имя', ' базы и dict'

Вот где начинается секрет. Ищите, где в этом примерном определении класса появляются имя, базы и dict.

class ThisIsTheName(Bases, Are, Here):
    All_the_code_here
    def doesIs(create, a):
        dict

Позволяет определить метакласс, который продемонстрирует, как его вызывает класс:.

def test_metaclass(name, bases, dict):
    print 'The Class Name is', name
    print 'The Class Bases are', bases
    print 'The dict has', len(dict), 'elems, the keys are', dict.keys()

    return "yellow"

class TestName(object, None, int, 1):
    __metaclass__ = test_metaclass
    foo = 1
    def baz(self, arr):
        pass

print 'TestName = ', repr(TestName)

# output => 
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName =  'yellow'

И теперь, пример, который на самом деле означает что-то, это автоматически сделает переменные в списке "атрибуты", установленные в классе, и установите значение "Нет".

def init_attributes(name, bases, dict):
    if 'attributes' in dict:
        for attr in dict['attributes']:
            dict[attr] = None

    return type(name, bases, dict)

class Initialised(object):
    __metaclass__ = init_attributes
    attributes = ['foo', 'bar', 'baz']

print 'foo =>', Initialised.foo
# output=>
foo => None

Обратите внимание, что магическое поведение, которое "Initalised" получает с помощью метакласса init_attributes, не передается в подкласс Initalised.

Вот еще более конкретный пример, показывающий, как вы можете подклассифицировать "тип", чтобы создать метакласс, который выполняет действие при создании класса. Это довольно сложно:

class MetaSingleton(type):
    instance = None
    def __call__(cls, *args, **kw):
        if cls.instance is None:
            cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
        return cls.instance

 class Foo(object):
     __metaclass__ = MetaSingleton

 a = Foo()
 b = Foo()
 assert a is b
343
19 сент. '08 в 9:26
источник

Одно использование для метаклассов - это добавление новых свойств и методов в экземпляр автоматически.

Например, если вы посмотрите на модели Django, их определение выглядит немного запутанным. Похоже, что вы определяете свойства класса:

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

Однако во время выполнения объекты Person заполняются всякими полезными методами. См. источник для некоторой удивительной метаклассификации.

141
19 сент. '08 в 9:45
источник

Другие объяснили, как работают метаклассы и как они вписываются в систему типа Python. Вот пример того, к чему их можно использовать. В рамках тестирования, который я написал, я хотел отслеживать порядок, в котором были определены классы, чтобы впоследствии описать их в этом порядке. Мне было проще сделать это, используя метакласс.

class MyMeta(type):

    counter = 0

    def __init__(cls, name, bases, dic):
        type.__init__(cls, name, bases, dic)
        cls._order = MyMeta.counter
        MyMeta.counter += 1

class MyType(object):              # Python 2
    __metaclass__ = MyMeta

class MyType(metaclass=MyMeta):    # Python 3
    pass

Все, что подкласс MyType затем получает атрибут класса _order, который записывает порядок, в котором были определены классы.

139
21 июня '11 в 19:30
источник

Я думаю, что введение ONLamp в программирование метаклассов хорошо написано и дает действительно хорошее введение в тему, хотя ему уже несколько лет.

http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html (архивируется по адресу https://web.archive.org/web/20080206005253/http://www.onlamp. com/pub/a/python/2003/04/17/metaclasses.html)

Вкратце: класс - это план создания экземпляра, метакласс - это план создания класса. Легко видеть, что в классах Python должны быть объекты первого класса, чтобы включить это поведение.

Я никогда не писал сам, но я думаю, что одно из самых хороших применений метаклассов можно увидеть в структуре Django. Классы моделей используют метаклассовый подход, чтобы включить декларативный стиль написания новых моделей или классов форм. Пока метакласс создает класс, все члены получают возможность настраивать сам класс.

Осталось сказать следующее: если вы не знаете, что такое метаклассы, вероятность того, что они вам не понадобятся, составляет 99%.

104
19 сент. '08 в 9:32
источник

Что такое метаклассы? Для чего вы их используете?

TL;DR: метаклас создает экземпляр и определяет поведение для класса точно так же, как экземпляр класса и определяет поведение для экземпляра.

псевдокод:

>>> Class(...)
instance

Вышеприведенное должно выглядеть знакомым. Ну, откуда приходит Class? Это экземпляр метакласса (также псевдокод):

>>> Metaclass(...)
Class

В реальном коде мы можем передать метакласс по умолчанию, type, все, что нам нужно, чтобы создать экземпляр класса, и мы получим класс:

>>> type('Foo', (object,), {}) # requires a name, bases, and a namespace
<class '__main__.Foo'>

Поставить иначе

  • Класс относится к экземпляру, поскольку метакласс относится к классу.

    Когда мы создаем экземпляр объекта, мы получаем экземпляр:

    >>> object()                          # instantiation of class
    <object object at 0x7f9069b4e0b0>     # instance
    

    Аналогично, когда мы определяем класс явно с метаклассом по умолчанию, type, мы его создаем:

    >>> type('Object', (object,), {})     # instantiation of metaclass
    <class '__main__.Object'>             # instance
    
  • Другими словами, класс является экземпляром метакласса:

    >>> isinstance(object, type)
    True
    
  • Положите третий способ, метакласс - класс класса.

    >>> type(object) == type
    True
    >>> object.__class__
    <class 'type'>
    

Когда вы пишете определение класса, и Python выполняет его, он использует метакласс для создания экземпляра объекта класса (который, в свою очередь, будет использоваться для создания экземпляров этого класса).

Так же, как мы можем использовать определения классов для изменения поведения пользовательских объектов, мы можем использовать определение класса метакласса, чтобы изменить способ поведения объекта класса.

Для чего их можно использовать? Из docs:

Потенциальное использование метаклассов безгранично. Некоторые идеи, которые были изучены, включают в себя ведение журнала, проверку интерфейса, автоматическое делегирование, автоматическое создание свойств, прокси, фреймворки и автоматическую блокировку/синхронизацию ресурсов.

Тем не менее, обычно пользователям рекомендуется избегать использования метаклассов, если это абсолютно необходимо.

Вы используете метакласс каждый раз, когда вы создаете класс:

Когда вы пишете определение класса, например, как это,

class Foo(object): 
    'demo'

Вы создаете экземпляр объекта класса.

>>> Foo
<class '__main__.Foo'>
>>> isinstance(Foo, type), isinstance(Foo, object)
(True, True)

Это то же самое, что функциональный вызов type с соответствующими аргументами и присвоение результата переменной этого имени:

name = 'Foo'
bases = (object,)
namespace = {'__doc__': 'demo'}
Foo = type(name, bases, namespace)

Обратите внимание, что некоторые вещи автоматически добавляются в __dict__, то есть в пространство имен:

>>> Foo.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, 
'__module__': '__main__', '__weakref__': <attribute '__weakref__' 
of 'Foo' objects>, '__doc__': 'demo'})

Метакласс объекта, который мы создали, в обоих случаях: type.

(Обратите внимание на содержимое класса __dict__: __module__, потому что классы должны знать, где они определены, и __dict__ и __weakref__ существуют, потому что мы не определяем __slots__ - если мы define __slots__, мы сохраним немного места в экземплярах, так как мы можем запретить __dict__ и __weakref__, исключив их. пример:

>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})
>>> Baz.__dict__
mappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})

... но я отвлекся.)

Мы можем расширить type так же, как и любое другое определение класса:

Здесь по умолчанию __repr__ классов:

>>> Foo
<class '__main__.Foo'>

Одна из самых ценных вещей, которые мы можем сделать по умолчанию при написании объекта Python, - предоставить ему хороший __repr__. Когда мы вызываем help(repr), мы узнаем, что есть хороший тест для __repr__, который также требует проверки равенства - obj == eval(repr(obj)). Следующая простая реализация __repr__ и __eq__ для экземпляров класса нашего класса классов предоставляет нам демонстрацию, которая может улучшить по умолчанию __repr__ классов:

class Type(type):
    def __repr__(cls):
        """
        >>> Baz
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        >>> eval(repr(Baz))
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        """
        metaname = type(cls).__name__
        name = cls.__name__
        parents = ', '.join(b.__name__ for b in cls.__bases__)
        if parents:
            parents += ','
        namespace = ', '.join(': '.join(
          (repr(k), repr(v) if not isinstance(v, type) else v.__name__))
               for k, v in cls.__dict__.items())
        return '{0}(\'{1}\', ({2}), {{{3}}})'.format(metaname, name, parents, namespace)
    def __eq__(cls, other):
        """
        >>> Baz == eval(repr(Baz))
        True            
        """
        return (cls.__name__, cls.__bases__, cls.__dict__) == (
                other.__name__, other.__bases__, other.__dict__)

Итак, теперь, когда мы создаем объект с этим метаклассом, __repr__, отраженный в командной строке, обеспечивает гораздо менее уродливое зрение, чем значение по умолчанию:

>>> class Bar(object): pass
>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})

С хорошим __repr__, определенным для экземпляра класса, у нас есть более сильная способность отлаживать наш код. Тем не менее, дальнейшая проверка с помощью eval(repr(Class)) маловероятна (поскольку функции было бы невозможно предсказать из их значений по умолчанию __repr__).

Ожидаемое использование: __prepare__ пространство имен

Если, например, мы хотим знать, в каком порядке создаются методы класса, мы могли бы предоставить упорядоченный dict как пространство имен класса. Мы будем делать это с помощью __prepare__, который возвращает пространство имен dict для класса, если оно реализовано в Python 3:

from collections import OrderedDict

class OrderedType(Type):
    @classmethod
    def __prepare__(metacls, name, bases, **kwargs):
        return OrderedDict()
    def __new__(cls, name, bases, namespace, **kwargs):
        result = Type.__new__(cls, name, bases, dict(namespace))
        result.members = tuple(namespace)
        return result

И использование:

class OrderedMethodsObject(object, metaclass=OrderedType):
    def method1(self): pass
    def method2(self): pass
    def method3(self): pass
    def method4(self): pass

И теперь у нас есть запись порядка, в котором были созданы эти методы (и другие атрибуты класса):

>>> OrderedMethodsObject.members
('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')

Примечание. Этот пример был адаптирован из документации - нового перечисления в стандартной библиотеке.

Итак, что мы сделали, это создать метакласс, создав класс. Мы также можем рассматривать метакласс как и любой другой класс. Он имеет порядок разрешения метода:

>>> inspect.getmro(OrderedType)
(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)

И он имеет приблизительно правильный repr (который мы больше не можем использовать, если мы не сможем найти способ представления наших функций.):

>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})
>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})
89
11 авг. '15 в 2:28
источник

Обновление Python 3

Есть (в этой точке) два ключевых метода в метаклассе:

  • __prepare__ и
  • __new__

__prepare__ позволяет вам создавать настраиваемое сопоставление (например, OrderedDict), которое будет использоваться в качестве пространства имен во время создания класса. Вы должны вернуть экземпляр любого пространства имен, которое вы выберете. Если вы не реализуете __prepare__, используется обычный dict.

__new__ отвечает за фактическое создание/модификацию окончательного класса.

Голые кости, do-nothing-extra metaclass хотели бы:

class Meta(type):

    def __prepare__(metaclass, cls, bases):
        return dict()

    def __new__(metacls, cls, bases, clsdict):
        return super().__new__(metacls, cls, bases, clsdict)

Простой пример:

Предположим, что для ваших атрибутов нужен какой-то простой код проверки. Как всегда, он должен быть int или str. Без метакласса ваш класс будет выглядеть примерно так:

class Person:
    weight = ValidateType('weight', int)
    age = ValidateType('age', int)
    name = ValidateType('name', str)

Как вы можете видеть, вам нужно дважды повторить имя атрибута. Это делает опечатки возможными наряду с раздражающими ошибками.

Простой метакласс может решить эту проблему:

class Person(metaclass=Validator):
    weight = ValidateType(int)
    age = ValidateType(int)
    name = ValidateType(str)

Это будет выглядеть метакласс (не используя __prepare__, поскольку он не нужен):

class Validator(type):
    def __new__(metacls, cls, bases, clsdict):
        # search clsdict looking for ValidateType descriptors
        for name, attr in clsdict.items():
            if isinstance(attr, ValidateType):
                attr.name = name
                attr.attr = '_' + name
        # create final class and return it
        return super().__new__(metacls, cls, bases, clsdict)

Пример прогона:

p = Person()
p.weight = 9
print(p.weight)
p.weight = '9'

дает:

9
Traceback (most recent call last):
  File "simple_meta.py", line 36, in <module>
    p.weight = '9'
  File "simple_meta.py", line 24, in __set__
    (self.name, self.type, value))
TypeError: weight must be of type(s) <class 'int'> (got '9')

Примечание. Этот пример достаточно прост, он также может быть выполнен с помощью декоратора класса, но, по-видимому, фактический метакласс будет делать гораздо больше.

Класс "ValidateType" для справки:

class ValidateType:
    def __init__(self, type):
        self.name = None  # will be set by metaclass
        self.attr = None  # will be set by metaclass
        self.type = type
    def __get__(self, inst, cls):
        if inst is None:
            return self
        else:
            return inst.__dict__[self.attr]
    def __set__(self, inst, value):
        if not isinstance(value, self.type):
            raise TypeError('%s must be of type(s) %s (got %r)' %
                    (self.name, self.type, value))
        else:
            inst.__dict__[self.attr] = value
66
01 марта '16 в 22:48
источник

Роль метода метакласса __call__() при создании экземпляра класса

Если вы занимались программированием на Python более нескольких месяцев, вы в конечном итоге натолкнетесь на код, который выглядит следующим образом:

# define a class
class SomeClass(object):
    # ...
    # some definition here ...
    # ...

# create an instance of it
instance = SomeClass()

# then call the object as if it a function
result = instance('foo', 'bar')

Последнее возможно, когда вы реализуете магический метод __call__() в классе.

class SomeClass(object):
    # ...
    # some definition here ...
    # ...

    def __call__(self, foo, bar):
        return bar + foo

Метод __call__() вызывается, когда экземпляр класса используется как вызываемый. Но, как мы видели из предыдущих ответов, сам класс является экземпляром метакласса, поэтому, когда мы используем класс в качестве вызываемого (т.е. когда мы создаем его экземпляр), мы фактически вызываем его метакласс __call__(), В этот момент большинство программистов на Python немного запутались, потому что им сказали, что при создании экземпляра, подобного этому instance = SomeClass() вы вызываете его метод __init__(). Некоторые, кто копнул немного глубже, знают, что до __init__() существует __new__(). Что ж, сегодня раскрывается еще один слой правды, перед __new__() появился метакласс ' __call__().

Давайте изучим цепочку вызовов метода с точки зрения создания экземпляра класса.

Это метакласс, который регистрирует ровно тот момент, когда экземпляр создан, и момент, когда он собирается его вернуть.

class Meta_1(type):
    def __call__(cls):
        print "Meta_1.__call__() before creating an instance of ", cls
        instance = super(Meta_1, cls).__call__()
        print "Meta_1.__call__() about to return instance."
        return instance

Это класс, который использует этот метакласс

class Class_1(object):

    __metaclass__ = Meta_1

    def __new__(cls):
        print "Class_1.__new__() before creating an instance."
        instance = super(Class_1, cls).__new__(cls)
        print "Class_1.__new__() about to return instance."
        return instance

    def __init__(self):
        print "entering Class_1.__init__() for instance initialization."
        super(Class_1,self).__init__()
        print "exiting Class_1.__init__()."

А теперь давайте создадим экземпляр Class_1

instance = Class_1()
# Meta_1.__call__() before creating an instance of <class '__main__.Class_1'>.
# Class_1.__new__() before creating an instance.
# Class_1.__new__() about to return instance.
# entering Class_1.__init__() for instance initialization.
# exiting Class_1.__init__().
# Meta_1.__call__() about to return instance.

Обратите внимание, что приведенный выше код на самом деле не делает ничего, кроме регистрации задач. Каждый метод делегирует реальную работу своей родительской реализации, сохраняя поведение по умолчанию. Поскольку type является родительским классом Meta_1 (type является родительским метаклассом по умолчанию) и, учитывая последовательность упорядочения вышеприведенных выходных данных, мы теперь имеем представление о том, что будет являться псевдо-реализацией type.__call__():

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

        # ... maybe a few things done to cls here

        # then we call __new__() on the class to create an instance
        instance = cls.__new__(cls, *args, **kwargs)

        # ... maybe a few things done to the instance here

        # then we initialize the instance with its __init__() method
        instance.__init__(*args, **kwargs)

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

        # then we return it
        return instance

Мы можем видеть, что метод метакласса __call__() - это тот, который вызывается первым. Затем он делегирует создание экземпляра методу класса __new__() и инициализацию экземпляру __init__(). Это также тот, который в конечном итоге возвращает экземпляр.

Из вышесказанного вытекает, что метаклассу __call__() также предоставляется возможность решить, будет ли в конечном итоге выполняться вызов Class_1.__new__() или Class_1.__init__(). За время своего выполнения он мог фактически вернуть объект, который не был затронут ни одним из этих методов. Возьмем для примера такой подход к шаблону синглтона:

class Meta_2(type):
    singletons = {}

    def __call__(cls, *args, **kwargs):
        if cls in Meta_2.singletons:
            # we return the only instance and skip a call to __new__()
            # and __init__()
            print ("{} singleton returning from Meta_2.__call__(), "
                   "skipping creation of new instance.".format(cls))
            return Meta_2.singletons[cls]

        # else if the singleton isn't present we proceed as usual
        print "Meta_2.__call__() before creating an instance."
        instance = super(Meta_2, cls).__call__(*args, **kwargs)
        Meta_2.singletons[cls] = instance
        print "Meta_2.__call__() returning new instance."
        return instance

class Class_2(object):

    __metaclass__ = Meta_2

    def __new__(cls, *args, **kwargs):
        print "Class_2.__new__() before creating instance."
        instance = super(Class_2, cls).__new__(cls)
        print "Class_2.__new__() returning instance."
        return instance

    def __init__(self, *args, **kwargs):
        print "entering Class_2.__init__() for initialization."
        super(Class_2, self).__init__()
        print "exiting Class_2.__init__()."

Давайте посмотрим, что происходит при неоднократных попытках создать объект типа Class_2

a = Class_2()
# Meta_2.__call__() before creating an instance.
# Class_2.__new__() before creating instance.
# Class_2.__new__() returning instance.
# entering Class_2.__init__() for initialization.
# exiting Class_2.__init__().
# Meta_2.__call__() returning new instance.

b = Class_2()
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.

c = Class_2()
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.

a is b is c # True
57
13 окт. '16 в 12:21
источник

Метакласс - это класс, который сообщает, как (какой-то) должен быть создан другой класс.

Это случай, когда я видел метакласс как решение моей проблемы: У меня была действительно сложная проблема, которая, вероятно, могла быть решена по-другому, но я решил решить ее с помощью метакласса. Из-за сложности это один из немногих модулей, которые я написал, когда комментарии в модуле превосходят количество написанного кода. Вот оно...

#!/usr/bin/env python

# Copyright (C) 2013-2014 Craig Phillips.  All rights reserved.

# This requires some explaining.  The point of this metaclass excercise is to
# create a static abstract class that is in one way or another, dormant until
# queried.  I experimented with creating a singlton on import, but that did
# not quite behave how I wanted it to.  See now here, we are creating a class
# called GsyncOptions, that on import, will do nothing except state that its
# class creator is GsyncOptionsType.  This means, docopt doesn't parse any
# of the help document, nor does it start processing command line options.
# So importing this module becomes really efficient.  The complicated bit
# comes from requiring the GsyncOptions class to be static.  By that, I mean
# any property on it, may or may not exist, since they are not statically
# defined; so I can't simply just define the class with a whole bunch of
# properties that are @property @staticmethods.
#
# So here how it works:
#
# Executing 'from libgsync.options import GsyncOptions' does nothing more
# than load up this module, define the Type and the Class and import them
# into the callers namespace.  Simple.
#
# Invoking 'GsyncOptions.debug' for the first time, or any other property
# causes the __metaclass__ __getattr__ method to be called, since the class
# is not instantiated as a class instance yet.  The __getattr__ method on
# the type then initialises the class (GsyncOptions) via the __initialiseClass
# method.  This is the first and only time the class will actually have its
# dictionary statically populated.  The docopt module is invoked to parse the
# usage document and generate command line options from it.  These are then
# paired with their defaults and what in sys.argv.  After all that, we
# setup some dynamic properties that could not be defined by their name in
# the usage, before everything is then transplanted onto the actual class
# object (or static class GsyncOptions).
#
# Another piece of magic, is to allow command line options to be set in
# in their native form and be translated into argparse style properties.
#
# Finally, the GsyncListOptions class is actually where the options are
# stored.  This only acts as a mechanism for storing options as lists, to
# allow aggregation of duplicate options or options that can be specified
# multiple times.  The __getattr__ call hides this by default, returning the
# last item in a property list.  However, if the entire list is required,
# calling the 'list()' method on the GsyncOptions class, returns a reference
# to the GsyncListOptions class, which contains all of the same properties
# but as lists and without the duplication of having them as both lists and
# static singlton values.
#
# So this actually means that GsyncOptions is actually a static proxy class...
#
# ...And all this is neatly hidden within a closure for safe keeping.
def GetGsyncOptionsType():
    class GsyncListOptions(object):
        __initialised = False

    class GsyncOptionsType(type):
        def __initialiseClass(cls):
            if GsyncListOptions._GsyncListOptions__initialised: return

            from docopt import docopt
            from libgsync.options import doc
            from libgsync import __version__

            options = docopt(
                doc.__doc__ % __version__,
                version = __version__,
                options_first = True
            )

            paths = options.pop('<path>', None)
            setattr(cls, "destination_path", paths.pop() if paths else None)
            setattr(cls, "source_paths", paths)
            setattr(cls, "options", options)

            for k, v in options.iteritems():
                setattr(cls, k, v)

            GsyncListOptions._GsyncListOptions__initialised = True

        def list(cls):
            return GsyncListOptions

        def __getattr__(cls, name):
            cls.__initialiseClass()
            return getattr(GsyncListOptions, name)[-1]

        def __setattr__(cls, name, value):
            # Substitut option names: --an-option-name for an_option_name
            import re
            name = re.sub(r'^__', "", re.sub(r'-', "_", name))
            listvalue = []

            # Ensure value is converted to a list type for GsyncListOptions
            if isinstance(value, list):
                if value:
                    listvalue = [] + value
                else:
                    listvalue = [ None ]
            else:
                listvalue = [ value ]

            type.__setattr__(GsyncListOptions, name, listvalue)

    # Cleanup this module to prevent tinkering.
    import sys
    module = sys.modules[__name__]
    del module.__dict__['GetGsyncOptionsType']

    return GsyncOptionsType

# Our singlton abstract proxy class.
class GsyncOptions(object):
    __metaclass__ = GetGsyncOptionsType()
49
25 февр. '14 в 0:20
источник

type на самом деле является metaclass - классом, который создает другие классы. Большинство metaclass являются подклассами type. metaclass получает класс new в качестве первого аргумента и предоставляет доступ к объекту класса с данными, указанными ниже:

>>> class MetaClass(type):
...     def __init__(cls, name, bases, attrs):
...         print ('class name: %s' %name )
...         print ('Defining class %s' %cls)
...         print('Bases %s: ' %bases)
...         print('Attributes')
...         for (name, value) in attrs.items():
...             print ('%s :%r' %(name, value))
... 

>>> class NewClass(object, metaclass=MetaClass):
...    get_choch='dairy'
... 
class name: NewClass
Bases <class 'object'>: 
Defining class <class 'NewClass'>
get_choch :'dairy'
__module__ :'builtins'
__qualname__ :'NewClass'

Note:

Обратите внимание, что класс не был создан в любое время; простой акт создания класса вызвал выполнение metaclass.

36
09 авг. '16 в 21:49
источник

Версия tl; dr

Функция type(obj) предоставляет вам тип объекта.

type() класса - это его метакласс.

Чтобы использовать метакласс:

class Foo(object):
    __metaclass__ = MyMetaClass
32
27 дек. '17 в 5:21
источник

Классы Python сами являются объектами, как, например, их метакласса.

Метаклас по умолчанию, который применяется, когда вы определяете классы как:

class foo:
    ...

meta class используются для применения некоторого правила ко всему набору классов. Например, предположим, что вы создаете ORM для доступа к базе данных и хотите, чтобы записи из каждой таблицы были отображены в эту таблицу (на основе полей, бизнес-правил и т.д.), Возможное использование метакласса это, например, логика пула соединений, которая является общим для всех классов записей из всех таблиц. Другое использование - это логика поддержки внешних ключей, которая включает в себя несколько классов записей.

когда вы определяете метакласс, тип подкласса и можете переопределить следующие магические методы для вставки вашей логики.

class somemeta(type):
    __new__(mcs, name, bases, clsdict):
      """
  mcs: is the base metaclass, in this case type.
  name: name of the new class, as provided by the user.
  bases: tuple of base classes 
  clsdict: a dictionary containing all methods and attributes defined on class

  you must return a class object by invoking the __new__ constructor on the base metaclass. 
 ie: 
    return type.__call__(mcs, name, bases, clsdict).

  in the following case:

  class foo(baseclass):
        __metaclass__ = somemeta

  an_attr = 12

  def bar(self):
      ...

  @classmethod
  def foo(cls):
      ...

      arguments would be : ( somemeta, "foo", (baseclass, baseofbase,..., object), {"an_attr":12, "bar": <function>, "foo": <bound class method>}

      you can modify any of these values before passing on to type
      """
      return type.__call__(mcs, name, bases, clsdict)


    def __init__(self, name, bases, clsdict):
      """ 
      called after type has been created. unlike in standard classes, __init__ method cannot modify the instance (cls) - and should be used for class validaton.
      """
      pass


    def __prepare__():
        """
        returns a dict or something that can be used as a namespace.
        the type will then attach methods and attributes from class definition to it.

        call order :

        somemeta.__new__ ->  type.__new__ -> type.__init__ -> somemeta.__init__ 
        """
        return dict()

    def mymethod(cls):
        """ works like a classmethod, but for class objects. Also, my method will not be visible to instances of cls.
        """
        pass

так или иначе, эти два являются наиболее часто используемыми крючками. метаклассирование является мощным, а выше - нигде и исчерпывающий список применений для метаклассификации.

21
13 июля '17 в 10:58
источник

Функция type() может возвращать тип объекта или создавать новый тип,

например, мы можем создать класс Hi с помощью функции type() и не использовать этот способ с классом Hi (object):

def func(self, name='mike'):
    print('Hi, %s.' % name)

Hi = type('Hi', (object,), dict(hi=func))
h = Hi()
h.hi()
Hi, mike.

type(Hi)
type

type(h)
__main__.Hi

В дополнение к типу() для динамического создания классов вы можете контролировать поведение поведения класса и использовать метакласс.

В соответствии с объектной моделью Python класс является объектом, поэтому класс должен быть экземпляром другого определенного класса. По умолчанию класс Python является экземпляром класса type. То есть, тип - это метакласс большинства встроенных классов и метакласс пользовательских классов.

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

class CustomList(list, metaclass=ListMetaclass):
    pass

lst = CustomList()
lst.add('custom_list_1')
lst.add('custom_list_2')

lst
['custom_list_1', 'custom_list_2']

Магия вступает в силу, когда мы передаем аргументы ключевого слова в метаклассе, это означает, что интерпретатор Python создает CustomList через ListMetaclass. new(), на данный момент мы можем изменить определение класса, например, и добавить новый метод, а затем вернуть исправленное определение.

17
12 янв. '18 в 12:16
источник

В дополнение к опубликованным ответам я могу сказать, что metaclass определяет поведение класса. Таким образом, вы можете явно установить свой метакласс. Всякий раз, когда Python получает class ключевого слова, он начинает поиск metaclass. Если он не найден - тип метакласса по умолчанию используется для создания объекта класса. Используя атрибут __metaclass__, вы можете установить metaclass вашего класса:

class MyClass:
   __metaclass__ = type
   # write here other method
   # write here one more method

print(MyClass.__metaclass__)

Он выдаст вывод примерно так:

class 'type'

И, конечно же, вы можете создать свой собственный metaclass чтобы определить поведение любого класса, созданного с использованием вашего класса.

Для этого ваш класс metaclass умолчанию должен быть унаследован, так как это основной metaclass:

class MyMetaClass(type):
   __metaclass__ = type
   # you can write here any behaviour you want

class MyTestClass:
   __metaclass__ = MyMetaClass

Obj = MyTestClass()
print(Obj.__metaclass__)
print(MyMetaClass.__metaclass__)

Выход будет:

class '__main__.MyMetaClass'
class 'type'
7
15 сент. '18 в 15:41
источник

метаклассов. Я могу это проиллюстрировать. Метакласс - это класс, экземпляры которого являются классами. Подобно "обычным" классам, определяется поведение экземпляров класса, метакласс определяет поведение классов и их экземпляров.

Метаклассы не поддерживаются каждым объектно-ориентированным языком программирования. Те языки программирования, которые поддерживают метаклассы, значительно различаются в зависимости от их реализации. Python поддерживает их.

Некоторые программисты видят метаклассы в Python как "решения, ожидающие или ищущие проблему".

Существует множество вариантов использования метаклассов. Просто чтобы назвать несколько:

logging and profiling
interface checking
registering classes at creation time
automatically adding new methods
automatic property creation
proxies
automatic resource locking/synchronization.

Метаклассы определяются как любой другой класс Python, но они являются классами, которые наследуются от типа. Другое отличие состоит в том, что метаклас вызывается автоматически, когда инструкция класса, использующая метакласс, заканчивается. Другими словами: Если ключевое слово "метакласса" не будет передано после базовых классов (также не может быть базовых классов) заголовка класса, будет вызван тип() (т.е. вызов). Если ключевое слово metaclass используется, с другой стороны, назначенный ему класс будет вызываться вместо типа.

Позвольте мне показать вам, создав очень простой метакласс. Это ничего не значит, за исключением того, что он будет печатать содержимое своих аргументов в новом методе и возвращает результаты этого типа. Новый вызов:

класс LittleMeta (тип):   def new (cls, clsname, суперклассы, атрибут):       print ( "clsname:", clsname)       print ( "суперклассы:", суперклассы)       print ( "attributedict:", attributedict)        new (cls, clsname, суперклассы, атрибут)

Я буду использовать метакласс "LittleMeta" в следующем примере:

класс S:   проходить класс A (S, metaclass= LittleMeta):

clsname: A суперклассы: (,) attributedict: {' module': ' main', ' qualname': 'A'}   проходить a = A()

3
23 нояб. '17 в 9:46
источник

Метакласс определяется как "класс класса". Любой класс, экземпляры которого сами являются классами, является метаклассом. Итак, в соответствии с тем, что мы видели выше, это делает тип метаклассом - на самом деле, наиболее часто используемым метаклассом в Python, поскольку он является метаклассом по умолчанию для всех классов.

Так как метакласс является классом класса, он используется для построения классов (так же, как класс используется для построения объектов). Но подождите секунду, не создаем классы со стандартным определением класса? Определенно, но то, что Python делает под капотом, следующее:

  • Когда он видит определение класса, Python выполняет его для сбора атрибуты (включая методы) в словарь
  • Когда определение класса закончено, Python определяет метакласс из класс. Позвольте назвать Meta​​li >
  • В конце концов, Python выполняет Meta (имя, базы, dct), где:

    -Meta - это метакласс, поэтому этот вызов создает его.

    -name - это имя вновь созданного класса

    -bases - это набор базовых классов класса

    -dct сопоставляет имена атрибутов объектам, перечисляя все атрибуты класса

Как определить метакласс класса? Проще говоря, если какой-либо класс или одна из его баз имеет атрибут метакласс, он воспринимается как метакласс. В противном случае введите метакласс.

Итак, что происходит, когда мы определяем:

class MyKlass(object):
  foo = 2

Это: MyKlass не имеет атрибута метакласса, поэтому вместо него используется тип, а создание класса выполняется как:

MyKlass = type(name, bases, dct)

Это соответствует тому, что мы видели в начале статьи. Если, с другой стороны, у MyKlass есть определенный метакласс:

class MyKlass(object):
  __metaclass__ = MyMeta
  foo = 2

Затем создание класса выполняется как:

MyKlass = MyMeta(name, bases, dct)

Итак, MyMeta должен быть соответствующим образом реализован для поддержки такой формы вызова и возврата нового класса. Это фактически похоже на запись нормального класса с предопределенной сигнатурой конструктора.

o управлять созданием и инициализацией класса в метаклассе, вы можете реализовать метод metaclass __new__ и/или конструктор __init__. Большинство реальных метаклассов, вероятно, переопределит только один из них. __new__ должен быть реализован, если вы хотите управлять созданием нового объекта (класса в нашем случае), а __init__ должен быть реализован, когда вы хотите контролировать инициализацию нового объекта после его создания.

Итак, когда вызов MyMeta выполняется выше, что происходит под капотом, это:

MyKlass = MyMeta.__new__(MyMeta, name, bases, dct)
MyMeta.__init__(MyKlass, name, bases, dct)

Вот более конкретный пример, который должен продемонстрировать, что происходит. Пусть записано это определение для метакласса

class MyMeta(type):
    def __new__(meta, name, bases, dct):
        print '-----------------------------------'
        print "Allocating memory for class", name
        print meta
        print bases
        print dct
        return super(MyMeta, meta).__new__(meta, name, bases, dct)
    def __init__(cls, name, bases, dct):
        print '-----------------------------------'
        print "Initializing class", name
        print cls
        print bases
        print dct
        super(MyMeta, cls).__init__(name, bases, dct)

Выполняется со следующим определением класса:

class MyKlass(object):
    __metaclass__ = MyMeta

    def foo(self, param):
        pass

    barattr = 2
1
11 февр. '18 в 15:10
источник

Метакласс - это класс, экземплярами которого являются классы. Подобно тому, как "обычный" класс определяет поведение экземпляров класса, метакласс определяет поведение классов и их экземпляров.

Метаклассы поддерживаются не всеми объектно-ориентированными языками программирования. Те языки программирования, которые поддерживают метаклассы, значительно различаются по способу их реализации. Python поддерживает их.

Существует множество вариантов использования метаклассов. Просто назвать несколько:

  • регистрация и профилирование
  • проверка интерфейса
  • регистрация классов во время создания
  • автоматическое добавление новых методов
  • автоматическое создание свойств
  • автоматическая блокировка/синхронизация ресурсов.

В принципе, метаклассы определяются как любой другой класс Python, но они являются классами, которые наследуются от "типа". Другое отличие состоит в том, что метакласс вызывается автоматически, когда оператор класса, использующий метакласс, заканчивается. Другими словами: если ключевое слово "metaclass" не передано после базовых классов (может быть и без базовых классов) заголовка класса, будет вызван type() (то есть вызов типа). Если ключевое слово metaclass используется с другой стороны, назначенный ему класс будет вызываться вместо типа.

Теперь мы создаем очень простой метакласс. Это бесполезно, за исключением того, что он напечатает содержимое своих аргументов в новом методе и вернет результаты типа. новый звонок:

class LittleMeta(type):
    def __new__(cls, clsname, superclasses, attributedict):
        print("clsname: ", clsname)
        print("superclasses: ", superclasses)
        print("attributedict: ", attributedict)
        return type.__new__(cls, clsname, superclasses, attributedict)

Мы будем использовать метакласс LittleMeta в следующем примере:

class S:
    pass
class A(S, metaclass=LittleMeta):
    pass
a = A()
clsname:  A
superclasses:  (<class '__main__.S'>,)
attributedict:  {'__module__': '__main__', '__qualname__': 'A'}

Мы можем видеть LittleMeta. новый был назван, а не тип. новый

0
20 дек. '18 в 11:47
источник

Метакласс - это, по сути, абстрактный базовый класс - концепция, преподаваемая в большинстве курсов по компьютерному программированию. Класс связан с метаклассом.

-6
01 июня '17 в 11:01
источник

Посмотрите другие вопросы по меткам или Задайте вопрос