用于索引从 1 开始的 python 列表的自定义包装器

Question

我想为 python list 类型编写一个简单的包装器，强制它从 1 而不是 0 开始索引。我有一个相当复杂的程序，基于持续时间数据的一些离散概率分布，具有整数长度的存储桶，但我没有任何小于 1 的持续时间。无论如何，它将大大简化我的代码的一些重要部分能够从 1 开始无缝索引。我一开始使用的是 dict，但我发现它们的几个属性太麻烦了。

我以前从未为 Python 类编写过包装器，更不用说内置类型了，但我觉得我想做的事情相当简单。至少，我应该能够做这样的事情：

>>> p = one_list([1,2,3,4,5])
>>> for i in range(1,6):
    print i, p[i]

1 1
2 2
3 3
4 4
5 5
>>> len(p)
5

但是，如果我也可以覆盖 list 类的其他一些相关内置方法，例如 <代码>索引。

>>> len(p)
5
>>> p.index(p[-1])
5

请分享您关于我如何去做这样的事情的建议。我正在考虑是否只使用自定义类来完成它，但这似乎可能有点矫枉过正。我也欢迎任何关于有用的覆盖方法的建议。

编辑：后记

我只是想指出，这样做并不值得，我接受下面答案的原因并不是因为我试图以他的方式实现它描述，而是因为他帮助我意识到列表本身就足够好了。

Answer 1

这是一个完整的（我认为）基于 1 的列表的实现，正确处理切片（包括扩展切片）、索引、弹出等。正确处理这个问题比您想象的要稍微棘手一些，尤其是切片和负索引。事实上，我仍然不能 100% 确定它完全按照应有的方式工作，因此请注意编码器。

class list1(list):
    """One-based version of list."""

    def _zerobased(self, i):
        if type(i) is slice:
            return slice(self._zerobased(i.start),
                         self._zerobased(i.stop), i.step)
        else:
            if i is None or i < 0:
                return i
            elif not i:
                raise IndexError("element 0 does not exist in 1-based list")
            return i - 1

    def __getitem__(self, i):
        return list.__getitem__(self, self._zerobased(i))

    def __setitem__(self, i, value):
        list.__setitem__(self, self._zerobased(i), value)

    def __delitem__(self, i):
        list.__delitem__(self, self._zerobased(i))

    def __getslice__(self, i, j):
        print i,j
        return list.__getslice__(self, self._zerobased(i or 1),
                                 self._zerobased(j))

    def __setslice__(self, i, j, value):
        list.__setslice__(self, self._zerobased(i or 1),
                          self._zerobased(j), value)

    def index(self, value, start=1, stop=-1):
        return list.index(self, value, self._zerobased(start),
                          self._zerobased(stop)) + 1

    def pop(self, i):
        return list.pop(self, self._zerobased(i))

senderle 的 ExtraItemList 将会有更好的性能，因为它不'不需要不断调整索引，也不需要在您和数据之间有额外的（非 C！）方法调用层。希望我能想到这种方法；也许我可以将它与我的结合起来获利......

Answer 2

好吧，看来你很有决心。正如我上面所说，你必须重写 __getitem__、__setitem__ 和 __delitem__。实际上，您还必须覆盖 __getslice__、__setslice__、__delslice__ （否则切片像往常一样从 0 开始）。然后 __add__、__mul__、__iadd__、__imul__ 也返回 WonkyList（否则串联将无法按照您想要的方式工作）。您必须覆盖 index 因为它会返回错误的值（我测试过）。还有插入、删除和弹出。这里有一些可以帮助您开始的东西：

class WonkyList(list):
    def __getitem__(self, index):
        return super(WonkyList, self).__getitem__(index - 1)
    def __setitem__(self, index, val):
        super(WonkyList, self).__setitem__(index - 1, val)
    def __delitem__(self, index):
        super(WonkyList, self).__delitem__(index - 1)

已测试：

>>> w = WonkyList(range(10))
>>> w[1]
0
>>> del w[5]
>>> w
[0, 1, 2, 3, 5, 6, 7, 8, 9]
>>> w[1] = 10
>>> w
[10, 1, 2, 3, 5, 6, 7, 8, 9]

以下是一些方法，除非您覆盖所有必要的方法，否则它会失败：

>>> w
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> w[5]
4
>>> w.pop(5)
5
>>> w.insert(5, 5)
>>> w
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del w[2:4]
>>> w
[0, 1, 4, 5, 6, 7, 8, 9]
>>> 
>>> w.index(1)
1

---

或者您可以尝试其他方法。例如，您是否考虑过...

def ExtraItemList(list):
    def __init__(self, seq):
        self[0] = 0
        self[1:] = seq
    def n_items(self):
        return len(self) - 1

这似乎可以解决您列出的问题，并且它仍然以基本上类似列表的方式运行，即使初始化程序有点奇怪。虽然说实话，看看你给出的例子，我开始觉得这甚至是一个丑陋的解决方案——你给出的函数都没有显示出从 1 开始索引的优点，它们只是显示了添加的坏影响列表开头的额外项目。根据这些示例，您应该只使用常规列表。

也许最好的方法是编写使用所需偏移量的自定义 get 和 set 方法。这样列表就会正常运行，但在需要时您将有一个替代界面。

Answer 3

这是一个可以帮助您入门的基本实现。我认为概括它会很好，这样您就可以拥有索引从您喜欢的任何整数开始的列表。这让我发现 __slots__，所以谢谢为了问这个问题！

class OffsetList(list):
    __slots__ = 'offset'
    def __init__(self, init=[], offset=-1):
        super(OffsetList, self).__init__(init)
        self.offset = offset
    def __getitem__(self, key):
        return super(OffsetList, self).__getitem__(key + self.offset)
    def __setitem__(self, key, value):
        return super(OffsetList, self).__setitem__(key + self.offset, value)
    def __delitem__(self, key):
        return super(OffsetList, self).__delitem__(key + self.offset)
    def index(self, *args):
        return super(OffsetList, self).index(*args) - self.offset

>>> a = OffsetList([1,2,3])
>>> a
[1, 2, 3]
>>> a[1]
1
>>> a.index(2)
2

您可能会发现您也想实现 __getslice__、__setslice__、__delslice__，更不用说 pop 和 插入。