Python 有什么奇技淫巧？ - 知乎

"""
Two magic tricks for classes:
    class X:
        __metaclass__ = extendabletype
        ...
    # in some other file...
    class __extend__(X):
        ...      # and here you can add new methods and class attributes to X
Mostly useful together with the second trick, which lets you build
methods whose 'self' is a pair of objects instead of just one:
    class __extend__(pairtype(X, Y)):
        attribute = 42
        def method((x, y), other, arguments):
            ...
    pair(x, y).attribute
    pair(x, y).method(other, arguments)
This finds methods and class attributes based on the actual
class of both objects that go into the pair(), with the usual
rules of method/attribute overriding in (pairs of) subclasses.
For more information, see test_pairtype.
"""

class extendabletype(type):
    """A type with a syntax trick: 'class __extend__(t)' actually extends
    the definition of 't' instead of creating a new subclass."""
    def __new__(cls, name, bases, dict):
        if name == '__extend__':
            for cls in bases:
                for key, value in dict.items():
                    if key == '__module__':
                        continue
                    # XXX do we need to provide something more for pickling?
                    setattr(cls, key, value)
            return None
        else:
            return super(extendabletype, cls).__new__(cls, name, bases, dict)


def pair(a, b):
    """Return a pair object."""
    tp = pairtype(a.__class__, b.__class__)
    return tp((a, b))   # tp is a subclass of tuple

pairtypecache = {}

def pairtype(cls1, cls2):
    """type(pair(a,b)) is pairtype(a.__class__, b.__class__)."""
    try:
        pair = pairtypecache[cls1, cls2]
    except KeyError:
        name = 'pairtype(%s, %s)' % (cls1.__name__, cls2.__name__)
        bases1 = [pairtype(base1, cls2) for base1 in cls1.__bases__]
        bases2 = [pairtype(cls1, base2) for base2 in cls2.__bases__]
        bases = tuple(bases1 + bases2) or (tuple,)  # 'tuple': ultimate base
        pair = pairtypecache[cls1, cls2] = extendabletype(name, bases, {})
    return pair

class __extend__(pairtype(int, int)):
    def foo((x, y)):
        print 'int-int: %s-%s' % (x, y)

class __extend__(pairtype(bool, bool)):
    def bar((x, y)):
        print 'bool-bool: %s-%s' % (x, y)

pair(False, True).foo()  # prints 'int-int: False, True'
pair(123, True).foo()  # prints 'int-int: 123, True'
pair(False, True).bar()  # prints 'bool-bool: False, True'
pair(123, True).bar()  # Oops, no such method

class GameObjectMeta(type):
    def __new__(mcls, clsname, bases, _dict):
        for k, v in _dict.items():
            if isinstance(v, (list, set)):
                _dict[k] = tuple(v)  # mutable obj not allowed

        cls = type.__new__(mcls, clsname, bases, _dict)
        all_gameobjects.add(cls)
        for b in bases:
            game_objects_hierarchy.add((b, cls))

        return cls

    @staticmethod
    def _dump_gameobject_hierarchy():
        with open('/dev/shm/gomap.dot', 'w') as f:
            f.write('digraph {\nrankdir=LR;\n')
            f.write('\n'.join([
                '"%s" -> "%s";' % (a.__name__, b.__name__)
                for a, b in game_objects_hierarchy
            ]))
            f.write('}')

    def __setattr__(cls, field, v):
        type.__setattr__(cls, field, v)
        if field in ('ui_meta', ):
            return
    
        log.warning('SetAttr: %s.%s = %s' % (cls.__name__, field, repr(v)))

metadata = {}

def gen_metafunc(_for):
    def metafunc(clsname, bases, _dict):
        meta_for = getattr(_for, clsname)
        meta_for.ui_meta = UIMetaDescriptor()
        if meta_for in metadata:
            raise Exception('%s ui_meta redefinition!' % meta_for)

        metadata[meta_for] = _dict

    return metafunc

from gamepack.thb import characters

__metaclass__ = gen_metafunc(characters.sakuya)


class Sakuya:
    # 于是这个就不是类了， 而是作为数据存到了metadata这个dict里
    char_name = u'十六夜咲夜'
    port_image = 'thb-portrait-sakuya'
    figure_image = 'thb-figure-sakuya'
    miss_sound_effect = 'thb-cv-sakuya_miss'
    description = (
        u'|DB完全潇洒的PAD长 十六夜咲夜 体力：4|r\n\n'
        u'|G月时计|r：|B锁定技|r，准备阶段开始时，你执行一个额外的出牌阶段。\n\n'
        u'|G飞刀|r：你可以将一张装备牌当【弹幕】使用或打出。按此法使用的【弹幕】无距离限制。\n\n'
        u'|DB（画师：小D@星の妄想乡，CV：VV）|r'
    )

# -*- coding: utf-8 -*-

# -- stdlib --
import imp
import sys

# -- third party --
# -- own --
from clr import UnityEngine, WarpGateController

# -- code --

class UnityResourceImporter(object):
    known_builtin = (
        'sys',
        'imp',
        'cStringIO',
        'gevent_core',
        'gevent_ares',
        'gevent_util',
        'gevent_semaphore',
        'msgpack_packer',
        'msgpack_unpacker',
        'UnityEngine',
    )

    def __init__(self, bases, unity_loader):
        self.bases = bases
        self.last_fullname = ''
        self.last_text = ''
        self.last_ispkg = False
        self.unity_load = unity_loader

    def find_module(self, fullname, path=None):
        if fullname in sys.modules:
            return self

        head = fullname.split('.')[0]
        if head in self.known_builtin:
            return None

        rst = self.do_load_module(fullname)
        if rst:
            self.last_text, self.last_ispkg = rst
            self.last_fullname = fullname
            return self
        else:
            return None

    def load_module(self, fullname):
        if fullname in sys.modules:
            return sys.modules[fullname]

        if fullname != self.last_fullname:
            self.find_module(fullname)

        try:
            code = self.last_text
            ispkg = self.last_ispkg

            mod = sys.modules.setdefault(fullname, imp.new_module(fullname))
            mod.__file__ = "%s>" % fullname
            mod.__loader__ = self

            if ispkg:
                mod.__path__ = []
                mod.__package__ = fullname
            else:
                mod.__package__ = fullname.rpartition('.')[0]

            co = compile(code, mod.__file__, 'exec')
            exec(co, mod.__dict__)

            return mod
        except Exception as e:
            UnityEngine.Debug.LogError('Error importing %s%s' % (fullname, e))
            raise ImportError(e)

    def do_load_module(self, fullname):
        fn = fullname.replace('.', '/')

        asset = self.try_load(fn + '.py')
        if asset is not None:
            return asset, False

        asset = self.try_load(fn + '/__init__.py')
        if asset is not None:
            return asset, True

    def try_load(self, filename):
        for b in self.bases:
            asset = self.unity_load(b + filename)
            if asset is not None:
                return asset

        return None


sys.meta_path.append(UnityResourceImporter([
    'Python/THBattle/',
    'Python/Site/',
    'Python/Stdlib/',
], WarpGateController.GetTextAsset))

class BatchList(list):
    def __getattribute__(self, name):
        try:
            list_attr = list.__getattribute__(self, name)
            return list_attr
        except AttributeError:
            pass

        return list.__getattribute__(self, '__class__')(
            getattr(i, name) for i in self
        )

    def __call__(self, *a, **k):
        return list.__getattribute__(self, '__class__')(
            f(*a, **k) for f in self
        )

class Foo(object):
    def __init__(self, v):
        self.value = v

    def foo(self):
        print 'Foo!', self.value

foo = Foo(1)
foo.foo()  # Foo! 1

foos = BatchList(Foo(i) for i in xrange(10))
foos.value  # BatchList([0, 1, 2, 3, ..., 9])
foos.foo()  # 你能猜到的