对 Python set 类进行子类化（添加新的实例变量）的正确（或最佳）方法是什么？

Question

我正在实现一个与集合几乎相同的对象，但需要一个额外的实例变量，因此我对内置集合对象进行子类化。 确保复制我的对象之一时复制此变量的值的最佳方法是什么？

使用旧的 set 模块，以下代码可以完美运行：

import sets
class Fooset(sets.Set):
    def __init__(self, s = []):
        sets.Set.__init__(self, s)
        if isinstance(s, Fooset):
            self.foo = s.foo
        else:
            self.foo = 'default'
f = Fooset([1,2,4])
f.foo = 'bar'
assert( (f | f).foo == 'bar')

但是使用内置的 set 模块则不起作用。

我能看到的唯一解决方案是重写返回复制的集合对象的每个方法...在这种情况下，我可能也不必费心对集合对象进行子类化。 当然有一个标准方法可以做到这一点吗？

（澄清一下，以下代码不起作用（断言失败）

class Fooset(set):
    def __init__(self, s = []):
        set.__init__(self, s)
        if isinstance(s, Fooset):
            self.foo = s.foo
        else:
            self.foo = 'default'

f = Fooset([1,2,4])
f.foo = 'bar'
assert( (f | f).foo == 'bar')

：）

Answer 1

我最喜欢的包装内置集合方法的方法：

class Fooset(set):
    def __init__(self, s=(), foo=None):
        super(Fooset,self).__init__(s)
        if foo is None and hasattr(s, 'foo'):
            foo = s.foo
        self.foo = foo



    @classmethod
    def _wrap_methods(cls, names):
        def wrap_method_closure(name):
            def inner(self, *args):
                result = getattr(super(cls, self), name)(*args)
                if isinstance(result, set) and not hasattr(result, 'foo'):
                    result = cls(result, foo=self.foo)
                return result
            inner.fn_name = name
            setattr(cls, name, inner)
        for name in names:
            wrap_method_closure(name)

Fooset._wrap_methods(['__ror__', 'difference_update', '__isub__', 
    'symmetric_difference', '__rsub__', '__and__', '__rand__', 'intersection',
    'difference', '__iand__', 'union', '__ixor__', 
    'symmetric_difference_update', '__or__', 'copy', '__rxor__',
    'intersection_update', '__xor__', '__ior__', '__sub__',
])

本质上与您在自己的答案中所做的事情相同，但位置较少。 如果您也想对列表和字典执行相同的操作，那么放入元类也很容易。

Answer 2

我认为推荐的方法不是直接从内置 set 子类化，而是使用 抽象基类 Set 位于 collections.abc。

使用 ABC Set 为您提供了一些免费的混合方法，因此您可以通过仅定义 __contains__()、__len__() 和 来获得最小的 Set 类>__iter__()。 如果您想要一些更好的设置方法，例如 intersection() 和 difference()，您可能必须包装它们。

这是我的尝试（这个恰好是类似 freezeset 的，但您可以从 MutableSet 继承来获取可变版本）：

from collections.abc import Set, Hashable

class CustomSet(Set, Hashable):
    """An example of a custom frozenset-like object using
    Abstract Base Classes.
    """
    __hash__ = Set._hash

    wrapped_methods = ('difference',
                       'intersection',
                       'symetric_difference',
                       'union',
                       'copy')

    def __repr__(self):
        return "CustomSet({0})".format(list(self._set))

    def __new__(cls, iterable=None):
        selfobj = super(CustomSet, cls).__new__(CustomSet)
        selfobj._set = frozenset() if iterable is None else frozenset(iterable)
        for method_name in cls.wrapped_methods:
            setattr(selfobj, method_name, cls._wrap_method(method_name, selfobj))
        return selfobj

    @classmethod
    def _wrap_method(cls, method_name, obj):
        def method(*args, **kwargs):
            result = getattr(obj._set, method_name)(*args, **kwargs)
            return CustomSet(result)
        return method

    def __getattr__(self, attr):
        """Make sure that we get things like issuperset() that aren't provided
        by the mix-in, but don't need to return a new set."""
        return getattr(self._set, attr)

    def __contains__(self, item):
        return item in self._set

    def __len__(self):
        return len(self._set)

    def __iter__(self):
        return iter(self._set)

Answer 3

遗憾的是，set 不遵循规则，并且不会调用 __new__ 来创建新的 set 对象，即使它们保留了类型。 这显然是 Python 中的一个错误（问题 #1721812，在 2.x 中不会修复）顺序）。 如果不调用创建 X 对象的 type 对象，则永远无法获取类型 X 的对象！ 如果set.__or__不打算调用__new__，它就必须返回set对象而不是子类对象。

但实际上，注意到上面 nosklo 的帖子，你原来的行为没有任何意义。 Set.__or__ 运算符不应该重用任何一个源对象来构造其结果，它应该创建一个新的对象，在这种情况下，它的 foo 应该是 <代码>“默认”！

因此，实际上，任何执行此操作的人都应该必须重载这些运算符，以便他们知道使用了 foo 的哪个副本。 如果它不依赖于组合的 Foosets，您可以将其设置为默认类，在这种情况下它将受到尊重，因为新对象认为它是子类类型。

我的意思是，如果你这样做的话，你的例子就会起作用：

class Fooset(set):
  foo = 'default'
  def __init__(self, s = []):
    if isinstance(s, Fooset):
      self.foo = s.foo

f = Fooset([1,2,5])
assert (f|f).foo == 'default'

Answer 4

<代码>设置1 | set2 是一个不会修改现有 set 的操作，而是返回一个新的 set。 新的集被创建并返回。 没有办法让它自动将任意属性从一个或两个 set 复制到新创建的 set，而无需自定义 |通过定义__or__方法自己操作 。

class MySet(set):
    def __init__(self, *args, **kwds):
        super(MySet, self).__init__(*args, **kwds)
        self.foo = 'nothing'
    def __or__(self, other):
        result = super(MySet, self).__or__(other)
        result.foo = self.foo + "|" + other.foo
        return result

r = MySet('abc')
r.foo = 'bar'
s = MySet('cde')
s.foo = 'baz'

t = r | s

print r, s, t
print r.foo, s.foo, t.foo

印刷：

MySet(['a', 'c', 'b']) MySet(['c', 'e', 'd']) MySet(['a', 'c', 'b', 'e', 'd'])
bar baz bar|baz

Answer 5

看起来 set 绕过了 c 代码。 然而，您将结束 Fooset 的实例，它只是没有机会复制该字段。

除了覆盖返回新集合的方法之外，我不确定在这种情况下您可以做太多事情。 Set 显然是为了一定的速度而构建的，c 中的很多工作也是如此。

Answer 6

我试图回答阅读它的问题：“如何使“集合”运算符的返回值成为我的集合子类的类型。忽略给定类的详细信息以及示例是否我从我自己的问题来到这里，如果我的阅读正确的话，

这个答案与其他一些答案不同，如下所示：

• 给定的类（子类）只能通过添加装饰器来更改。
• 因此，它足够通用，无需关心给定类的细节 (hasattr(s, 'foo'))
• 每个类（当它被装饰时）支付一次额外成本，而不是每个实例
• 给定示例的唯一问题，特定于“集合”的是方法列表，可以轻松定义它，
• 假设基类不是抽象的，可以复制构造自身（否则需要实现 __init__ 方法，该方法从 的实例复制。基类）

库代码，可以放在项目或模块中的任何位置：

class Wrapfuncs:
  def __init__(self, *funcs):
    self._funcs = funcs

  def __call__(self, cls):
    def _wrap_method(method_name):
      def method(*args, **kwargs):
          result = getattr(cls.__base__, method_name)(*args, **kwargs)
          return cls(result)
      return method

    for func in self._funcs:
      setattr(cls, func, _wrap_method(func))
    return cls

要将其与集合一起使用，我们需要返回一个新实例的方法列表：

returning_ops_funcs = ['difference', 'symmetric_difference', '__rsub__', '__or__', '__ior__', '__rxor__', '__iand__', '__ror__', '__xor__', '__sub__', 'intersection', 'union', '__ixor__', '__and__', '__isub__', 'copy']

并且我们可以使用它与我们的类：

@Wrapfuncs(*returning_ops_funcs)
class MySet(set):
  pass

我不会详细说明该类的特殊之处。

我已经用以下几行测试了代码：

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

print(s1&s2)
print(s1.intersection(s2))
print(s1 and s2)
print(s1|s2)
print(s1.union(s2))
print(s1|s2|s3)
print(s1.union(s2, s3))
print(s1 or s2)
print(s1-s2)
print(s1.difference(s2))
print(s1^s2)
print(s1.symmetric_difference(s2))

print(s1 & set(s2))
print(set(s1) & s2)

print(s1.copy())

其中 print:

MySet({2, 3})
MySet({2, 3})
MySet({2, 3, 4})
MySet({1, 2, 3, 4})
MySet({1, 2, 3, 4})
MySet({1, 2, 3, 4, 5})
MySet({1, 2, 3, 4, 5})
MySet({1, 2, 3})
MySet({1})
MySet({1})
MySet({1, 4})
MySet({1, 4})
MySet({2, 3})
{2, 3}
MySet({1, 2, 3})

有一种情况，结果不是最佳的。 在这种情况下，运算符与类的实例一起使用作为右侧操作数，并且将内置“集合”的实例作为第一个操作数。 我不喜欢这个，但我相信这个问题对于我见过的所有提议的解决方案都是常见的。

我还考虑过提供一个使用 collections.abc.Set 的示例。
虽然可以这样做：

from collections.abc import Set, Hashable
@Wrapfuncs(*returning_ops_funcs)
class MySet(set, Set):
  pass

我不确定它是否具有 @bjmc 所想到的好处，或者它“免费”为您提供的“一些方法”是什么。
该解决方案的目标是使用基类来完成工作并返回子类的实例。 使用成员对象来完成工作的解决方案可能会以类似的方式生成。

Answer 7

使用装饰器概括 Matthew Marshall 响应而不添加运行时检查，这会影响性能：

>>>from functools import wraps
>>>
>>> def builtinSubclass( *methods ):
...    def decorator( cls ):
...       for m in methods:
...          if cls.__dict__.get(m):
...             continue
...          def closure():
...             wrapped = getattr(set, m)
...             @wraps( wrapped )
...             def wrapper(self, *args, **kwargs):
...                print(wrapped, m)
...                return cls( wrapped( self, *args, **kwargs ) )
...             return wrapper
...          print(f"replacing {m}")
...          setattr( cls, m, closure() )
...       return cls
...    return decorator
...
>>>
>>> setSubclass = builtinSubclass('__ror__', 'difference_update', '__isub__',
...    'symmetric_difference', '__rsub__', '__and__', '__rand__', 'intersection',
...    'difference', '__iand__', 'union', '__ixor__', 'symmetric_difference_update',
...    '__or__', 'copy', '__rxor__', 'intersection_update', '__xor__', '__ior__',
...    '__sub__')
>>>
>>> @setSubclass
... class S(set):
...    pass
...
replacing __and__
replacing __or__
replacing intersection
>>> type(S([1]) | S([2]))
intersection
<class '__main__.S'>

干净的代码：

from functools import wraps

def builtinSubclass( *methods ):
   def decorator( cls ):
      for m in methods:
         if cls.__dict__.get(m):
            continue
         def makeWrapper():
            wrapped = getattr(set, m)
            @wraps( wrapped )
            def wrapper(self, *args, **kwargs):
               return cls(wrapped(self, *args, **kwargs))
            return wrapper
         setattr( cls, m, makeWrapper() )
      return cls
   return decorator

setSubclass = builtinSubclass('__ror__', 'difference_update', '__isub__',
                              'symmetric_difference', '__rsub__', '__and__',
                              '__rand__', 'intersection', 'difference',
                              '__iand__', 'union', '__ixor__',
                              'symmetric_difference_update', '__or__', 'copy',
                              '__rxor__', 'intersection_update', '__xor__',
                              '__ior__', '__sub__')

Answer 8

假设其他答案是正确的，并且重写所有方法是执行此操作的唯一方法，这是我尝试采用一种适度优雅的方法来执行此操作。 如果添加更多的实例变量，只需要改变一段代码。 不幸的是，如果将新的二元运算符添加到集合对象中，则此代码将中断，但我认为没有办法避免这种情况。 欢迎评论！

def foocopy(f):
    def cf(self, new):
        r = f(self, new)
        r.foo = self.foo
        return r
    return cf

class Fooset(set):
    def __init__(self, s = []):
        set.__init__(self, s)
        if isinstance(s, Fooset):
            self.foo = s.foo
        else:
            self.foo = 'default'

    def copy(self):
        x = set.copy(self)
        x.foo = self.foo
        return x

    @foocopy
    def __and__(self, x):
        return set.__and__(self, x)

    @foocopy
    def __or__(self, x):
        return set.__or__(self, x)

    @foocopy
    def __rand__(self, x):
        return set.__rand__(self, x)

    @foocopy
    def __ror__(self, x):
        return set.__ror__(self, x)

    @foocopy
    def __rsub__(self, x):
        return set.__rsub__(self, x)

    @foocopy
    def __rxor__(self, x):
        return set.__rxor__(self, x)

    @foocopy
    def __sub__(self, x):
        return set.__sub__(self, x)

    @foocopy
    def __xor__(self, x):
        return set.__xor__(self, x)

    @foocopy
    def difference(self, x):
        return set.difference(self, x)

    @foocopy
    def intersection(self, x):
        return set.intersection(self, x)

    @foocopy
    def symmetric_difference(self, x):
        return set.symmetric_difference(self, x)

    @foocopy
    def union(self, x):
        return set.union(self, x)


f = Fooset([1,2,4])
f.foo = 'bar'
assert( (f | f).foo == 'bar')

Answer 9

对我来说，在 Win32 上使用 Python 2.5.2 可以完美地工作。 使用您的类定义和以下测试：

f = Fooset([1,2,4])
s = sets.Set((5,6,7))
print f, f.foo
f.foo = 'bar'
print f, f.foo
g = f | s
print g, g.foo
assert( (f | f).foo == 'bar')

我得到这个输出，这是我所期望的：

Fooset([1, 2, 4]) default
Fooset([1, 2, 4]) bar
Fooset([1, 2, 4, 5, 6, 7]) bar