Question

代码是：

class MyClass:
    ...
    def __getitem__(self, index):
        ...
    def __setitem__(self, index, value):
        ...
    def __delitem__(self, index):
        ...

    if sys.version_info < (2, 0):
        # They won't be defined if version is at least 2.0 final

        def __getslice__(self, i, j):
            return self[max(0, i):max(0, j):]
        def __setslice__(self, i, j, seq):
            self[max(0, i):max(0, j):] = seq
        def __delslice__(self, i, j):
            del self[max(0, i):max(0, j):]

我只是没有得到__getslice__(self,i,j)，__setslice__(self,i,j,seq)和__delslice__(self,i,j)返回的内容。

他们在这里退回一份清单吗？如果没有，请向我解释一下？

Answer 1

顺便说一句， __getslice__ 已弃用，但仍使用http://bugs.python.org/issue2041

您粘贴的代码仅为Python解释器的非常旧版本定义了这些函数。

无论如何，如果你想实现这些功能，请遵循任何内置类型，例如： list确实：

__setslice__ 不会返回任何内容，但会替换内容为(i, j)的自己的范围seq

In [3]: l = list()

In [4]: l.__setslice__(1, 3, [1,2,3])

In [5]: l
Out[5]: [1, 2, 3]

__delslice__ 不会返回任何内容，删除自己的范围(i, j)

__getslice__ 会返回范围(i, j)

中的自有元素

In [10]: l = range(5)

In [11]: l.__getslice__(1,3)
Out[11]: [1, 2]

In [12]: l[1:2]
Out[12]: [1]

In [13]: l[1:2+1]
Out[13]: [1, 2]

当然，您可以自由地实现这些方法来做任何您喜欢的事情并返回您喜欢的任何内容，但最好还是保持预期的语义。

最后，Python有一个 slice内置，它是索引i, j, step的容器，例如：

In [18]: l[s]
Out[18]: [1, 3]

In [19]: l = range(100)

In [20]: s = slice(1, 10, 2)

In [21]: l[s]
Out[21]: [1, 3, 5, 7, 9]

In [22]: l[1:10:2]
Out[22]: [1, 3, 5, 7, 9]

Answer 2

与大多数python的钩子方法一样，__getslice__可以返回你想要的任何东西。 __setslice__和__delslice__不应返回任何内容。

请注意，这些方法的用法是deprecated - 你实际上不需要使用它们除非你实际上是继承了仍然实现该方法的python内置的（或者另一个用户定义的类，它实现了我想的那些方法。

Answer 3

在2.0之前的Python版本中，切片与索引分开处理。 seq[i]会调用seq.__getitem__(i)，而seq[i:j]会调用seq.__getslice__(i,j)。但是，从2.0开始，__getitem__通过接收单个切片对象作为其参数来处理这两种情况，即seq[i:j]调用seq.__getitem__(slice(i,j))。它们基本上是不必要的，除非您在使用CPython实现继承内置类型时需要覆盖它们。

在您的代码中，__getslice__会返回__getitem__次返回的内容，而__setslice__和__delslice__都会返回None。

Answer 4

__getslice__是yourobj [a：b：c]的实现，虽然它已被弃用，但你仍然可以实现它。 {@ 1}}和__setslice__也已弃用，并且是__delslice__的设置者和删除者。

该方法返回什么？请参阅您的代码：__getslice__仅实现了python＆lt; 2.0（即仅当他们的实施需要不被弃用时）。

__getslice__返回self [max（i，0），max（j，0）]，它将在python＆lt;中再次调用__getslice__ 2.0。我认为它会给你一个Stack Overflow（你在__getslice__上调用它，然后再调用相同的方法）。

让我们看看（python＆lt; 2.0）：
self（ - 4,2）将返回self [0,2]，它将在__getslice__（0,2）中转换，这将返回self [0,2]，这将成为一个以无限的方式调用__getslice__（0,2），或直到你的内存堆爆炸为止。

在python中列出混淆

4 个答案: