132

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

到目前为止，我有这段代码，我相信它会正确实现切片，但是每当我调用v[4]where v is a vector 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]
4

5 回答 5

137

当对象被切片时，该__getitem__()方法将接收一个对象。slice只需查看对象的start、stop和step成员，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')
于 2010-05-29T22:56:39.900 回答
75

我有一个“合成”列表（其中的数据比你想在内存中创建的要大），我的__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."

切片不返回相同的类型，这是一个禁忌，但它对我有用。

于 2012-03-30T23:43:03.150 回答
27

如何定义 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 中消失了。

于 2015-12-19T15:06:28.623 回答
7

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

看：

http://docs.python.org/library/functions.html#slice

http://docs.python.org/reference/datamodel.html#object.__getitem__

于 2010-05-29T22:58:10.323 回答
7

为了扩展 Aaron 的答案，对于诸如 之类的事情，您可以通过检查是否为 anumpy来进行多维切片：giventuple

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)))
于 2017-05-25T01:35:09.760 回答