Co to są metaklasy w Pythonie?

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

>>> print(my_object)

<__main__.ObjectCreator object at 0x8974f2c>

class

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

• możesz przypisać go do zmiennej
• możesz to skopiować [*]możesz dodać do niego atrybuty
• możesz przekazać go jako parametr funkcji
na przykład: [/*]

>>> print(ObjectCreator) # you can print a class because it's 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

type

>>> print(type(1))

<type 'int'>

>>> print(type("1"))

<type 'str'>

>>> print(type(ObjectCreator))

<type 'type'>

>>> print(type(ObjectCreator()))

<class '__main__.ObjectCreator'>

type

type

type

type(name, bases, attrs)

• name

  : Nazwa klasy

• bases

  : krotka klasy nadrzędnej (może być pusta do dziedziczenia)

• attrs

  : słownik zawierający nazwy i wartości atrybutów np .:

>>> 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>

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

class

MyClass = MetaClass()

my_object = MyClass()

type

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

type

type

Type

str

int

type

__class__

>>> 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

__metaclass__

__metaclass__

class Foo(object):

 __metaclass__ = something...

 [...]

Foo

class Foo (object)

Foo

__metaclass__

Foo

type

class Foo(Bar):

 pass

__metaclass__

Foo

Foo

__metaclass__

__metaclass__

__metaclass__

__metaclass__

Bar

__metaclass__

Bar .__ class__

Bar

__metaclass__

Bar

type ()

type .__ new__ ()

__metaclass__

type

class Foo(object, metaclass=something):

 ...

__metaclass__

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

 ...

__metaclass__

__metaclass__

# 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_attrs):

 """

 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_attrs = {

 attr if attr.startswith("__") else attr.upper(): v

 for attr, v in future_class_attrs.items()

 } # let `type` do the class creation

 return type(future_class_name, future_class_parents, uppercase_attrs)__metaclass__ = upper_attr # this will affect all classes in the moduleclass 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'

>>> hasattr(Foo, 'bar')

False

>>> hasattr(Foo, 'BAR')

True

>>> Foo.BAR

'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's 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_attrs):

 uppercase_attrs = {

 attr if attr.startswith("__") else attr.upper(): v

 for attr, v in future_class_attrs.items()

 }

 return type(future_class_name, future_class_parents, uppercase_attrs)

class UpperAttrMetaclass(type):

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

 uppercase_attrs = {

 attr if attr.startswith("__") else attr.upper(): v

 for attr, v in attrs.items()

 }

 return type(clsname, bases, uppercase_attrs)

cls

__new__

self

type

__new__

class UpperAttrMetaclass(type):

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

 uppercase_attrs = {

 attr if attr.startswith("__") else attr.upper(): v

 for attr, v in attrs.items()

 }

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

super

class UpperAttrMetaclass(type):

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

 uppercase_attrs = {

 attr if attr.startswith("__") else attr.upper(): v

 for attr, v in attrs.items()

 }

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

class Foo(object, metaclass=MyMetaclass, kwarg1=value1):

 ...

class MyMetaclass(type):

 def __new__(cls, clsname, bases, dct, kwargs1=default):

 ...

__dict__

• tworzenie klasy przechwytywania
• zmień klasę
• zwróć zmienioną klasę

__metaclass__

• Zamiar jest jasny. Kiedy czytasz

  UpperAttrMetaclass (type)

  , wiesz co nastąpi
• Możesz użyć OOP. Metaklasa może dziedziczyć z metaklasy, zastępować metody macierzyste. Metaklasy mogą nawet używać metaklas.
• Podklasy klasy będą instancjami jej metaklasy, jeśli określisz klasę metaklasy, ale nie użyjesz funkcji metaklasy.
• Możesz lepiej zorganizować swój kod. Nigdy nie używasz metaklas do czegoś takiego jak trywialne jak w powyższym przykładzie. Zwykle jest to trudne. Dostępność bardzo przydatna jest możliwość tworzenia wielu metod i grupowania ich w jedną klasę aby kod był łatwiejszy do odczytania.
• Możesz dać się wciągnąć w

  __new__

  ,

  __init__

  i

  __call__

  . Co pozwoli robić różne rzeczy. Chociaż zwykle możesz to wszystko zrobić w

  __new__

  , niektórzy ludzie czują się po prostu bardziej komfortowo używając

  __init__

  .
• Nazywają się metaklasami, do cholery! To musi coś znaczyć!

class Person(models.Model):

 name = models.CharField(max_length=30)

 age = models.IntegerField()

person = Person(name='bob', age='35')

print(person.age)

IntegerField

int

models.Model

__metaclass__

osobę

>>> class Foo(object): pass

>>> id(Foo)

142630324

type

type

• łatanie małpy http://en.wikipedia.org/wiki/Monkey_patch
• klasa dekoratora

type

type

type

type

__init__

__new__

class

class

__metaclass__

__metaclass__

type

__add__

__iter__

__getattr__

def make_hook(f):

 """Decorator to turn 'foo' method into '__foo__'"""

 f.is_hook = 1

 return fclass 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." % selfclass 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):

 passExampleSibling = Example + Sibling

# ExampleSibling is now a subclass of both Example and Sibling (with no

# content of its own) although it will believe it's called 'AutoClass'

print ExampleSibling

print ExampleSibling.__mro__

class type(object)

 | type(object) -> the object's type

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

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):

 passprint '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

Initialised

init_attributes

Initialised

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.instanceclass Foo(object):

 __metaclass__ = MetaSingletona = Foo()

b = Foo()

assert a is b

class MyMeta(type): counter = 0 def __init__(cls, name, bases, dic):

 type.__init__(cls, name, bases, dic)

 cls._order = MyMeta.counter

 MyMeta.counter += 1class MyType(object): # Python 2

 __metaclass__ = MyMetaclass MyType(metaclass=MyMeta): # Python 3

 pass

MyType

_order

class Person(models.Model):

 first_name = models.CharField(max_length=30)

 last_name = models.CharField(max_length=30)

• Tworzenie nowego modelu http://docs.djangoproject.com/ ... 23id3
• Metaklasa, która na to pozwala http://code.djangoproject.com/ ... 23L25do zrobienia

>>> Class(...)

instance

Class

>>> Metaclass(...)

Class

typ

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

<class '__main__.Foo'>

• Klasa jest powiązana z instancją w taki sam sposób, w jaki metaklasa jest z klasą. Kiedy tworzymy instancję obiektu, otrzymujemy instancję:

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

  Podobnie, kiedy jawnie definiujemy klasę z domyślną metaklasą,

  type

  , tworzymy jej instancję:

  >>> type('Object', (object,), {}) # instantiation of metaclass<class '__main__.Object'> # instance

• Innymi słowy, klasa jest instancją metaklasy:

  >>> isinstance(object, type)True

• Po trzecie, metaklasa jest klasą klasy.

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

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__

__slots__

__dict__

__weakref__

>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})

>>> Baz.__dict__

mappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})

type

__repr__

>>> Foo

<class '__main__.Foo'>

__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__

__prepare__

from collections import OrderedDictclass 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>})

• __prepare__

  i

• __new__

__prepare__

OrderedDict

__prepare__

dict

__new__

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')

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

__call __ ()

# define a class

class SomeClass(object):

 # ...

 # some definition here ...

 # ...# create an instance of it

instance = SomeClass()# then call the object as if it's a function

result = instance('foo', 'bar')

__call __ ()

class SomeClass(object):

 # ...

 # some definition here ...

 # ... def __call__(self, foo, bar):

 return bar + foo

__call __ ()

__call __ ()

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

.__ 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 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 instanceclass 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

#!/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's 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's 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's 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()

type (obj)

type ()

class Foo(object):

 __metaclass__ = MyMetaClass

type

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

class foo:

 ...

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

def func(self, name='mike'):

 print('Hi, %s.' % name)Hi = type('Hi', (object,), dict(hi=func))

h = Hi()

h.hi()

Hi, mike.type(Hi)

typetype(h)

__main__.Hi

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):

 passlst = CustomList()

lst.add('custom_list_1')

lst.add('custom_list_2')lst

['custom_list_1', 'custom_list_2']

metaclass

class

metaclass

__metaclass__

metaclass

class MyClass:

 __metaclass__ = type

 # write here other method

 # write here one more methodprint(MyClass.__metaclass__)

class 'type'

metaclass

metaclass

metaclass

class MyMetaClass(type):

 __metaclass__ = type

 # you can write here any behaviour you wantclass MyTestClass:

 __metaclass__ = MyMetaClassObj = MyTestClass()

print(Obj.__metaclass__)

print(MyMetaClass.__metaclass__)

class '__main__.MyMetaClass'

class 'type'

• Możesz użyć

  metaclass

  , aby zmienić funkcję swojej instancji (klasy).

class MetaMemberControl(type):

 __slots__ = () @classmethod

 def __prepare__(mcs, f_cls_name, f_cls_parents, # f_cls means: future class

 meta_args=None, meta_options=None): # meta_args and meta_options is not necessarily needed, just so you know.

 f_cls_attr = dict()

 if not "do something or if you want to define your cool stuff of dict...":

 return dict(make_your_special_dict=None)

 else:

 return f_cls_attr def __new__(mcs, f_cls_name, f_cls_parents, f_cls_attr,

 meta_args=None, meta_options=None): original_getattr = f_cls_attr.get('__getattribute__')

 original_setattr = f_cls_attr.get('__setattr__') def init_getattr(self, item):

 if not item.startswith('_'): # you can set break points at here

 alias_name = '_' + item

 if alias_name in f_cls_attr['__slots__']:

 item = alias_name

 if original_getattr is not None:

 return original_getattr(self, item)

 else:

 return super(eval(f_cls_name), self).__getattribute__(item) def init_setattr(self, key, value):

 if not key.startswith('_') and ('_' + key) in f_cls_attr['__slots__']:

 raise AttributeError(f"you can't modify private members:_{key}")

 if original_setattr is not None:

 original_setattr(self, key, value)

 else:

 super(eval(f_cls_name), self).__setattr__(key, value) f_cls_attr['__getattribute__'] = init_getattr

 f_cls_attr['__setattr__'] = init_setattr cls = super().__new__(mcs, f_cls_name, f_cls_parents, f_cls_attr)

 return cls

class Human(metaclass=MetaMemberControl):

 __slots__ = ('_age', '_name') def __init__(self, name, age):

 self._name = name

 self._age = age def __getattribute__(self, item):

 """

 is just for IDE recognize.

 """

 return super().__getattribute__(item) """ with MetaMemberControl then you don't have to write as following

 @property

 def name(self):

 return self._name @property

 def age(self):

 return self._age

 """

def test_demo():

 human = Human('Carson', 27)

 # human.age = 18 # you can't modify private members:_age <-- this is defined by yourself.

 # human.k = 18 # 'Human' object has no attribute 'k' <-- system error.

 age1 = human._age # It's OK, although the IDE will show some warnings. (Access to a protected member _age of a class) age2 = human.age # It's OK! see below:

 """

 if you do not define `__getattribute__` at the class of Human,

 the IDE will show you: Unresolved attribute reference 'age' for class 'Human'

 but it's ok on running since the MetaMemberControl will help you.

 """

if __name__ == '__main__':

 test_demo()

metaclass

__init_subclass __ (cls, ** kwargs)

• Nazwa klasy
• Krotka mająca klasy bazowe dziedziczone z klasy
• Słownik zawierający wszystkie metody klas i zmienne klas

• kiedy określony efekt należy zastosować do wszystkich podklas
• Wymaga automatycznej zmiany klasy (po utworzeniu)
• Przez programistów API

logging and profiling

interface checking

registering classes at creation time

automatically adding new methods

automatic property creation

proxies

automatic resource locking/synchronization.

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)

class S:

 pass 

class A(S, metaclass=LittleMeta):

 pass 

a = A()

clsname: A

superclasses: (<class '__main__.S'>,)

attributedict: {'__module__': '__main__', '__qualname__': 'A'}

metaclass

metaclass

metaclass

class MyMeta(type):

 passclass MyClass(metaclass=MyMeta):

 passclass MySubclass(MyClass):

 pass

MyMeta

type

MyClass

MySubClass

MyMeta

print(type(MyMeta))

print(type(MyClass))

print(type(MySubclass))<class 'type'>

<class '__main__.MyMeta'>

<class '__main__.MyMeta'>

metaclass

metaclass

metaclass

type ()

metaclass