问题描述：

我正在尝试为正在创建的创建矢量表示的类实现切片功能。

到目前为止，我有这段代码，我相信它将正确实现切片，但每当我执行诸如向量在v[4]哪里之类的操作时v，python 都会引发参数不足的错误。因此，我试图弄清楚如何__getitem__在我的类中定义特殊方法来处理普通索引和切片。

def __getitem__(self, start, stop, step):
    index = start
    if stop == None:
        end = start + 1
    else:
        end = stop
    if step == None:
        stride = 1
    else:
        stride = step
    return self.__data[index:end:stride]

解决方案 1：

该方法将在对象被切片时__getitem__()接收一个对象。只需查看对象的、和成员即可获取切片的组件。slice`startstopstep`slice

>>> class C(object):
...   def __getitem__(self, val):
...     print val
... 
>>> c = C()
>>> c[3]
3
>>> c[3:4]
slice(3, 4, None)
>>> c[3:4:-2]
slice(3, 4, -2)
>>> c[():1j:'a']
slice((), 1j, 'a')

解决方案 2：

我有一个“合成”列表（其中的数据比您想要在内存中创建的要大），它__getitem__看起来像这样：

def __getitem__(self, key):
    if isinstance(key, slice):
        # Get the start, stop, and step from the slice
        return [self[ii] for ii in xrange(*key.indices(len(self)))]
    elif isinstance(key, int):
        if key < 0: # Handle negative indices
            key += len(self)
        if key < 0 or key >= len(self):
            raise IndexError, "The index (%d) is out of range." % key
        return self.getData(key) # Get the data from elsewhere
    else:
        raise TypeError, "Invalid argument type."

切片不会返回相同的类型，这是不行的，但对我来说却有效。

解决方案 3：

如何定义 getitem 类来处理普通索引和切片？

在下标符号中使用冒号时，会自动创建切片对象 -这就是传递给 的内容__getitem__。用于isinstance检查您是否有切片对象：

from __future__ import print_function

class Sliceable(object):
    def __getitem__(self, subscript):
        if isinstance(subscript, slice):
            # do your handling for a slice object:
            print(subscript.start, subscript.stop, subscript.step)
        else:
            # Do your handling for a plain index
            print(subscript)

假设我们正在使用一个范围对象，但我们希望切片返回列表而不是新的范围对象（就像它那样）：

>>> range(1,100, 4)[::-1]
range(97, -3, -4)

由于内部限制，我们无法对范围进行子类化，但我们可以委托给它：

class Range:
    """like builtin range, but when sliced gives a list"""
    __slots__ = "_range"
    def __init__(self, *args):
        self._range = range(*args) # takes no keyword arguments.
    def __getattr__(self, name):
        return getattr(self._range, name)
    def __getitem__(self, subscript):
        result = self._range.__getitem__(subscript)
        if isinstance(subscript, slice):
            return list(result)
        else:
            return result

r = Range(100)

我们没有一个完全可替换的 Range 对象，但是它相当接近：

>>> r[1:3]
[1, 2]
>>> r[1]
1
>>> 2 in r
True
>>> r.count(3)
1

为了更好地理解切片符号，这里是 Sliceable 的示例用法：

>>> sliceme = Sliceable()
>>> sliceme[1]
1
>>> sliceme[2]
2
>>> sliceme[:]
None None None
>>> sliceme[1:]
1 None None
>>> sliceme[1:2]
1 2 None
>>> sliceme[1:2:3]
1 2 3
>>> sliceme[:2:3]
None 2 3
>>> sliceme[::3]
None None 3
>>> sliceme[::]
None None None
>>> sliceme[:]
None None None

Python 2，请注意：

在 Python 2 中，有一个已弃用的方法，在对某些内置类型进行子类化时可能需要重写该方法。

来自数据模型文档：

object.__getslice__(self, i, j)

自 2.0 版起已弃用:支持将切片对象作为__getitem__()方法的参数。（但是，CPython 中的内置类型目前仍实现__getslice__()。因此，在实现切片时必须在派生类中重写它。）

这在 Python 3 中已经消失了。

解决方案 4：

为了扩展Aaron的回答，对于诸如 之类的事情，你可以通过检查 是否来numpy进行多维切片：given`tuple`

class Sliceable(object):
    def __getitem__(self, given):
        if isinstance(given, slice):
            # do your handling for a slice object:
            print("slice", given.start, given.stop, given.step)
        elif isinstance(given, tuple):
            print("multidim", given)
        else:
            # Do your handling for a plain index
            print("plain", given)

sliceme = Sliceable()
sliceme[1]
sliceme[::]
sliceme[1:, ::2]

输出：

('plain', 1)
('slice', None, None, None)
('multidim', (slice(1, None, None), slice(None, None, 2)))

## 解决方案 5：

 
正确的方法是采用`__getitem__`一个参数，它可以是数字或切片对象。