Python 2 和 Python 3 中的内置类型的子类化

Question

当子类化内置类型时，我注意到Python 2和Python 3之间在内置类型方法的返回类型上有一个相当重要的区别。以下代码说明了集合的这一点：

class MySet(set):

    pass

s1 = MySet([1, 2, 3, 4, 5])

s2 = MySet([1, 2, 3, 6, 7])

print(type(s1.union(s2)))

print(type(s1.intersection(s2)))

print(type(s1.difference(s2)))

在 Python 2 中，所有返回值都是 MySet 类型。对于 Python 3，返回类型为 set。我找不到任何关于结果应该是什么的文档，也找不到任何关于 Python 3 中的更改的文档。

无论如何，我真正关心的是：Python 3 中是否有一种简单的方法来获得 Python 中看到的行为2、无需重新定义内置类型的每一个方法？

Answer 1

从 Python 2.x 迁移到 3.x 时，这并不是内置类型的一般变化 - 例如，list 和 int 具有相同的行为在 2.x 和 3.x 中。仅更改了集合类型以使其与其他类型保持一致，如此错误跟踪器问题中所述。

恐怕没有真正好的方法让它按照旧的方式运行。这是我能够想出的一些代码：

class MySet(set):
    def copy(self):
        return MySet(self)
    def _make_binary_op(in_place_method):
        def bin_op(self, other):
            new = self.copy()
            in_place_method(new, other)
            return new
        return bin_op
    __rand__ = __and__ = _make_binary_op(set.__iand__)
    intersection = _make_binary_op(set.intersection_update)
    __ror__ = __or__ = _make_binary_op(set.__ior__)
    union = _make_binary_op(set.update)
    __sub__ = _make_binary_op(set.__isub__)
    difference = _make_binary_op(set.difference_update)
    __rxor__ = xor__ = _make_binary_op(set.__ixor__)
    symmetric_difference = _make_binary_op(set.symmetric_difference_update)
    del _make_binary_op
    def __rsub__(self, other):
        new = MySet(other)
        new -= self
        return new

这将简单地用返回您自己的类型的版本覆盖所有方法。 （有很多方法！）

也许对于您的应用程序，您可以不用覆盖 copy() 并坚持使用就地方法。

Answer 2

也许一个元类为你完成所有这些单调的包装会让它变得更容易：

class Perpetuate(type):
    def __new__(metacls, cls_name, cls_bases, cls_dict):
        if len(cls_bases) > 1:
            raise TypeError("multiple bases not allowed")
        result_class = type.__new__(metacls, cls_name, cls_bases, cls_dict)
        base_class = cls_bases[0]
        known_attr = set()
        for attr in cls_dict.keys():
            known_attr.add(attr)
        for attr in base_class.__dict__.keys():
            if attr in ('__new__'):
                continue
            code = getattr(base_class, attr)
            if callable(code) and attr not in known_attr:
                setattr(result_class, attr, metacls._wrap(base_class, code))
            elif attr not in known_attr:
                setattr(result_class, attr, code)
        return result_class
    @staticmethod
    def _wrap(base, code):
        def wrapper(*args, **kwargs):
            if args:
                cls = args[0]
            result = code(*args, **kwargs)
            if type(result) == base:
                return cls.__class__(result)
            elif isinstance(result, (tuple, list, set)):
                new_result = []
                for partial in result:
                    if type(partial) == base:
                        new_result.append(cls.__class__(partial))
                    else:
                        new_result.append(partial)
                result = result.__class__(new_result)
            elif isinstance(result, dict):
                for key in result:
                    value = result[key]
                    if type(value) == base:
                        result[key] = cls.__class__(value)
            return result
        wrapper.__name__ = code.__name__
        wrapper.__doc__ = code.__doc__
        return wrapper

class MySet(set, metaclass=Perpetuate):
    pass

s1 = MySet([1, 2, 3, 4, 5])

s2 = MySet([1, 2, 3, 6, 7])

print(s1.union(s2))
print(type(s1.union(s2)))

print(s1.intersection(s2))
print(type(s1.intersection(s2)))

print(s1.difference(s2))
print(type(s1.difference(s2)))

Answer 3

作为 Sven 答案的后续，这里有一个通用包装解决方案，可以处理所有非特殊方法。这个想法是捕获来自方法调用的第一次查找，并安装一个执行类型转换的包装方法。在后续查找时，直接返回包装器。

注意事项：

1）这比我在代码中所希望的更加神奇。

2）我仍然需要手动包装特殊方法（__and__等），因为它们的查找绕过__getattribute__

import types

class MySet(set):

    def __getattribute__(self, name):
        attr = super(MySet, self).__getattribute__(name)
        if isinstance(attr, types.BuiltinMethodType):
            def wrapper(self, *args, **kwargs):
                result = attr(self, *args, **kwargs)
                if isinstance(result, set):
                    return MySet(result)
                else:
                    return result
            setattr(MySet, name, wrapper)
            return wrapper
        return attr