from functools import wraps, partial
import logging
def debug(func=None, prefix=''):
    if func is None:
        return partial(debug, prefix=prefix)
    log = logging.getLogger(func.__module__)
    msg = prefix + func.__name__
    @wraps(func)
    def wrapper(*args, **kwargs):
        log.debug(msg)
        print(msg)
        return func(*args, **kwargs)
    return wrapper

@debug(prefix='***')
def add(x, y):
    return x + y

add(1,3)

***add





4

def debugmethods(cls):
    for name, val in vars(cls).items():
        if callable(val):
            print name, val
            setattr(cls, name, debug(val))

    return cls

@debugmethods
class Spam:
    def grok(self):
        pass

    def bar(self):
        pass

    def foo(self):
        pass

    @classmethod
    def gun(cls):
        pass

    @staticmethod
    def fire():
        pass

grok <function grok at 0x1026c2758>
bar <function bar at 0x1026c2140>
foo <function foo at 0x1026c2668>

vars(Spam).items() # Spam.__dict__.items()

[('grok', <function __main__.grok>),
 ('__module__', '__main__'),
 ('bar', <function __main__.bar>),
 ('fire', <staticmethod at 0x10ece4b78>),
 ('gun', <classmethod at 0x10ece4980>),
 ('foo', <function __main__.foo>),
 ('__doc__', None)]

def debugattr(cls):
    orig_getattribute = cls.__getattribute__ 
    def __getattribute__(self, name):
        print('Get:', name)
        return orig_getattribute(self, name)

    cls.__getattribute__ = __getattribute__

    return cls

@debugattr
class Point(object):#Python2.7中一定要继承object，否则没有object的一些属性
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __getattr__(self, e):
        return self.__dict__[e]


p = Point(2,3)
p.x
dir(Point)

('Get:', 'x')





['__class__',
 '__delattr__',
 '__dict__',
 '__doc__',
 '__format__',
 '__getattr__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__module__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']

class debugmeta(type):
    def __new__(cls, clsname, bases, clsdict):
        clsobj = super(debugmeta, cls).__new__(cls, clsname, bases, clsdict)
        clsobj = debugmethods(clsobj)
        return clsobj

'''
# python 3 syntax
class Base(metaclass=debugmeta):
    pass
'''
class Base(object):
    __metaclass__ = debugmeta

__metaclass__ <class '__main__.debugmeta'>

isinstance(Point, type)
dir(debugmeta)

['__abstractmethods__',
 '__base__',
 '__bases__',
 '__basicsize__',
 '__call__',
 '__class__',
 '__delattr__',
 '__dict__',
 '__dictoffset__',
 '__doc__',
 '__eq__',
 '__flags__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__instancecheck__',
 '__itemsize__',
 '__le__',
 '__lt__',
 '__module__',
 '__mro__',
 '__name__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasscheck__',
 '__subclasses__',
 '__subclasshook__',
 '__weakrefoffset__',
 'mro']

class Spam(Base):
    def __init__(self, name):
        self.name = name
    def bar(self):
        print "I'm Spam.bar"

bar <function bar at 0x1026c2c08>
__init__ <function __init__ at 0x1026c2c80>

dir(Spam)

['__class__',
 '__delattr__',
 '__dict__',
 '__doc__',
 '__format__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__metaclass__',
 '__module__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'bar']

body = '''
    def __init__(self, name):
        self.name = name
    def bar(self):
        print "I'm Spam.bar"
'''

clsdict = type.__prepare__('Spam', (Base,))

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-14-cf797e00aba3> in <module>()
----> 1 clsdict = type.__prepare__('Spam', (Base,))


AttributeError: type object 'type' has no attribute '__prepare__'

def prepare_class(name, *bases, metaclass=None, **kwargs):
    if metaclass is None:
        metaclass = compute_default_metaclass(bases)
    prepare = getattr(metaclass, '__prepare__', None)
    if prepare is not None:
        return prepare(name, bases, **kwargs)
    else:
        return dict()

class MyInt(int):
    def __add__(self, other):
        print "I am a new int:)"
        return super(MyInt, self).__add__(other)

i = MyInt(2)
print i+3

I am a new int:)
5

type(i), type(MyInt),type(tuple), type(list), type(dict), type(int), type(type)

(__main__.MyInt, type, type, type, type, type, type)

dir(type)

['__abstractmethods__',
 '__base__',
 '__bases__',
 '__basicsize__',
 '__call__',
 '__class__',
 '__delattr__',
 '__dict__',
 '__dictoffset__',
 '__doc__',
 '__eq__',
 '__flags__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__instancecheck__',
 '__itemsize__',
 '__le__',
 '__lt__',
 '__module__',
 '__mro__',
 '__name__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasscheck__',
 '__subclasses__',
 '__subclasshook__',
 '__weakrefoffset__',
 'mro']

class InterfaceMeta(type):
    def __new__(cls, name, parents, dct):
        # create a class_id if it's not specified
        if 'class_id' not in dct:
            dct['class_id'] = name.lower()

        # open the specified file for writing
        if 'file' in dct:
            filename = dct['file']
            dct['file'] = open(filename, 'w')

        # we need to call type.__new__ to complete the initialization
        return super(InterfaceMeta, cls).__new__(cls, name, parents, dct)

Interface = InterfaceMeta('Interface', (), dict(file='tmp.txt'))

print(Interface.class_id)
print(Interface.file)

interface
<open file 'tmp.txt', mode 'w' at 0x10277c030>

class Interface(object):
    __metaclass__ = InterfaceMeta
    file = 'tmp.txt'

print(Interface.class_id)
print(Interface.file)

interface
<open file 'tmp.txt', mode 'w' at 0x10277c0c0>

class UserInterface(Interface):
    file = 'foo.txt'

print(UserInterface.file)
print(UserInterface.class_id)

<open file 'foo.txt', mode 'w' at 0x10ed490c0>
userinterface

from abc import ABCMeta

class MyABC():
    __metaclass__ = ABCMeta
    pass

MyABC.register(tuple)

assert issubclass(tuple, MyABC)
assert isinstance((), MyABC)

class ABCMeta(type):

    def __instancecheck__(cls, inst):
        """Implement isinstance(inst, cls)."""
        return any(cls.__subclasscheck__(c)
                   for c in {type(inst), inst.__class__})

    def __subclasscheck__(cls, sub):
        """Implement issubclass(sub, cls)."""
        candidates = cls.__dict__.get("__subclass__", set()) | {cls}
        return any(c in candidates for c in sub.mro())

@add_metaclass(Meta)
class MyClass(object):
    pass
That code produces a class equivalent to

class MyClass(object, metaclass=Meta):
    pass
on Python 3 or

class MyClass(object):
    __metaclass__ = MyMeta
on Python 2.

Note that class decorators require Python 2.6. 

However, the effect of the decorator can be emulated on Python 2.5 like so:

class MyClass(object):
    pass
MyClass = add_metaclass(Meta)(MyClass)

import json
json.dumps({'li': None})

'{"li": null}'

l = ['fucl']*256
l[ord('a')]

'fucl'

import datetime
datetime.datetime.fromtimestamp(1516877655)

datetime.datetime(2018, 1, 25, 18, 54, 15)

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
    bar = 2

-----------------------------------
Allocating memory for class MyKlass
<class '__main__.MyMeta'>
(<type 'object'>,)
{'bar': 2, '__module__': '__main__', 'foo': <function foo at 0x10276ce60>, '__metaclass__': <class '__main__.MyMeta'>}
-----------------------------------
Initializing class MyKlass
<class '__main__.MyKlass'>
(<type 'object'>,)
{'bar': 2, '__module__': '__main__', 'foo': <function foo at 0x10276ce60>, '__metaclass__': <class '__main__.MyMeta'>}

class MyMeta(type):
    def __call__(cls, *args, **kwds):
        print '__call__ of ', str(cls)
        print '__call__ *args=', str(args)
        return type.__call__(cls, *args, **kwds)

class MyKlass(object):
    __metaclass__ = MyMeta

    def __init__(self, a, b):
        print 'MyKlass object with a=%s, b=%s' % (a, b)

print 'gonna create foo now...'
foo = MyKlass(1, 2)
bar = MyKlass(3,4)

gonna create foo now...
__call__ of  <class '__main__.MyKlass'>
__call__ *args= (1, 2)
MyKlass object with a=1, b=2
__call__ of  <class '__main__.MyKlass'>
__call__ *args= (3, 4)
MyKlass object with a=3, b=4

from string import Template
Template("$name is $value").substitute(name="hacker", value=10)

class _TemplateMetaclass(type):
    pattern = r"""
    %(delim)s(?:
      (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters
      (?P<named>%(id)s)      |   # delimiter and a Python identifier
      {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier
      (?P<invalid>)              # Other ill-formed delimiter exprs
    )
    """

    def __init__(cls, name, bases, dct):
        super(_TemplateMetaclass, cls).__init__(name, bases, dct)
        if 'pattern' in dct:
            pattern = cls.pattern
        else:
            pattern = _TemplateMetaclass.pattern % {
                'delim' : _re.escape(cls.delimiter),
                'id'    : cls.idpattern,
                }
        cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)


class Template:
    """A string class for supporting $-substitutions."""
    __metaclass__ = _TemplateMetaclass

    delimiter = '$'
    idpattern = r'[_a-z][_a-z0-9]*'

    def __init__(self, template):
        self.template = template

    # Search for $$, $identifier, ${identifier}, and any bare $'s

    def _invalid(self, mo):
        i = mo.start('invalid')
        lines = self.template[:i].splitlines(True)
        if not lines:
            colno = 1
            lineno = 1
        else:
            colno = i - len(''.join(lines[:-1]))
            lineno = len(lines)
        raise ValueError('Invalid placeholder in string: line %d, col %d' %
                         (lineno, colno))

    def substitute(*args, **kws):
        if not args:
            raise TypeError("descriptor 'substitute' of 'Template' object "
                            "needs an argument")
        self, args = args[0], args[1:]  # allow the "self" keyword be passed
        if len(args) > 1:
            raise TypeError('Too many positional arguments')
        if not args:
            mapping = kws
        elif kws:
            mapping = _multimap(kws, args[0])
        else:
            mapping = args[0]
        # Helper function for .sub()
        def convert(mo):
            # Check the most common path first.
            named = mo.group('named') or mo.group('braced')
            if named is not None:
                val = mapping[named]
                # We use this idiom instead of str() because the latter will
                # fail if val is a Unicode containing non-ASCII characters.
                return '%s' % (val,)
            if mo.group('escaped') is not None:
                return self.delimiter
            if mo.group('invalid') is not None:
                self._invalid(mo)
            raise ValueError('Unrecognized named group in pattern',
                             self.pattern)
        return self.pattern.sub(convert, self.template)

'hacker is 10'