Methods defined in closures for fast local performance.

gistfile1.py

class Closer(object):
    def __init__(self):
        methods = self.fixup_methods()
        for name, method in methods.iteritems():
            setattr(self, name, method)

    def _inner__(self):
        return locals()

    def fixup_methods(self):
        closure_methods = {}
        for cls in reversed(self.__class__.mro()):
            if hasattr(cls, '_inner__'):
                closure_methods.update(cls._inner__(self))
        return closure_methods

class CloserBetween(Closer):
    def _inner__(self):
        def bub():
            return self.f1()
        return locals()

class CloserBetween2(Closer):
    def _inner__(self):
        def fub():
            return self.bub()
        return locals()

class ClosingOver(CloserBetween, CloserBetween2):
    def _inner__(self):
        def f1():
            return 1

        def f2():
            return f1() + 2

        def f3():
            return f2() + 3

        def f4():
            return f3() + 4

        def f5():
            return f4() + 5

        def f6():
            return f5() + 6

        def f7():
            return f6() + 7

        def f8():
            return f7() + 8

        def f9():
            return f8() + 9

        def f10():
            return f9() + 10

        def f11():
            return f10() + 11

        def f12():
            return f11() + 12

        def f13():
            return f12() + 13

        def f14():
            return f13() + 14

        def mixer():
            x = 1000000
            while x > 0:
                x -= f14()
            return x

        def rub():
            return self.fub()
        return locals()


class NoClosing(object):
    def __init__(self):
        pass

    def f1(self):
        return 1

    def f2(self):
        return self.f1() + 2

    def f3(self):
        return self.f2() + 3

    def f4(self):
        return self.f3() + 4

    def f5(self):
        return self.f4() + 5

    def f6(self):
        return self.f5() + 6

    def f7(self):
        return self.f6() + 7

    def f8(self):
        return self.f7() + 8

    def f9(self):
        return self.f8() + 9

    def f10(self):
        return self.f9() + 10

    def f11(self):
        return self.f10() + 11

    def f12(self):
        return self.f11() + 12

    def f13(self):
        return self.f12() + 13

    def f14(self):
        return self.f13() + 14

    def mixer(self):
        x = 1000000
        while x > 0:
            x -= self.f14()
        return x


if __name__ == '__main__':
    from timeit import Timer

    no_close = NoClosing()
    t = Timer(no_close.mixer)
    print 'no close time:', t.timeit(200)
    t = Timer(no_close.f11)
    print 'single function time', t.timeit(20000)

    closing_over = ClosingOver()
    t = Timer(closing_over.mixer)
    print 'closing time:', t.timeit(200)
    t = Timer(closing_over.f11)
    print 'single function time', t.timeit(20000)

    print 'Multiple inheritence?', closing_over.rub()