Python 隐藏的超能力：掌握编码魔法的元对象协议

class mymeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['custom_attribute'] = 'i was added by the metaclass'
        return super().__new__(cls, name, bases, attrs)

class myclass(metaclass=mymeta):
    pass

print(myclass.custom_attribute)  # output: i was added by the metaclass

class loggingclass:
    def __getattr__(self, name):
        print(f"accessing attribute: {name}")
        return super().__getattribute__(name)

obj = loggingclass()
obj.some_attribute  # output: accessing attribute: some_attribute

class proxy:
    def __init__(self, obj):
        self._obj = obj

    def __getattr__(self, name):
        print(f"accessing {name} through proxy")
        return getattr(self._obj, name)

class realclass:
    def method(self):
        return "i'm the real method"

real = realclass()
proxy = proxy(real)
print(proxy.method())  # output: accessing method through proxy \n i'm the real method

class positivenumber:
    def __init__(self):
        self._value = 0

    def __get__(self, obj, objtype):
        return self._value

    def __set__(self, obj, value):
        if value < 0:
            raise valueerror("must be positive")
        self._value = value

class myclass:
    number = positivenumber()

obj = myclass()
obj.number = 10  # this works
obj.number = -5  # this raises a valueerror

class lazyproperty:
    def __init__(self, function):
        self.function = function
        self.name = function.__name__

    def __get__(self, obj, type=none):
        if obj is none:
            return self
        value = self.function(obj)
        setattr(obj, self.name, value)
        return value

class expensiveobject:
    @lazyproperty
    def expensive_attribute(self):
        print("computing expensive attribute...")
        return sum(range(1000000))

obj = expensiveobject()
print("object created")
print(obj.expensive_attribute)  # only now is the attribute computed
print(obj.expensive_attribute)  # second access is instant

class vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"vector({self.x}, {self.y})"

v1 = vector(1, 2)
v2 = vector(3, 4)
print(v1 + v2)  # output: vector(4, 6)

from abc import abc, abstractmethod

class drawable(abc):
    @classmethod
    def __subclasshook__(cls, c):
        if cls is drawable:
            if any("draw" in b.__dict__ for b in c.__mro__):
                return true
        return notimplemented

    @abstractmethod
    def draw(self): pass

class square:
    def draw(self):
        print("drawing a square")

print(issubclass(square, drawable))  # output: true

import functools

def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(100))  # this computes quickly despite the recursive nature

class Point:
    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

# This Point class uses less memory than a normal class would