我们如何编写一个 `__getitem__` 方法来接受任何可迭代作为输入，并将这些项目链接在一起？ [关闭]

Answer 1

基本理念

与其制作一个单独的容器类型，不如制作一个看法用于容器。语义是：

• 视图实例跟踪一些可迭代对象（可能是其他可迭代对象的元素）。为简单起见，我们不会检查它是否是正确的容器类型或延迟评估。

• 当视图使用不可迭代类型的值进行索引时，它会使用该值索引到容器中。

• 当视图使用可迭代类型的值进行索引时，它会为该值中的每个元素重复索引。

• 如果索引的结果是可迭代的，则结果是围绕该可迭代的视图。否则，结果就是值本身。

它可以很简单地实现：

class View:
    def __init__(self, data):
        self._data = data

    def __getitem__(self, indices):
        result = self._data
        # We can't easily distinguish a `TypeError` due to `indices`
        # being a non-iterable, from a `TypeError` due to reaching a 
        # leaf in the data prematurely. So we explicitly check first.
        try:
            iter(indices)
        except TypeError:
            result = result[indices]
        else:
            for i in indices:
                result = result[i]
        # Now decide whether to wrap the result
        try:
            iter(result)
        except TypeError:
            return result
        else:
            return View(result)

作为重构，我们可以使用__new__ 而不是__init__，这样如果参数不可迭代，则返回不变。这可以防止显式创建坏视图，还可以简化__getitem__ 逻辑：

class View:
    def __new__(cls, data):
        try:
            iter(data)
            result = object.__new__(cls)
            result._data = data
        except TypeError:
            result = data
        return result

    def __getitem__(self, indices):
        result = self._data
        try:
            iter(indices)
        except TypeError:
            result = result[indices]
        else:
            for i in indices:
                result = result[i]
        return View(result)

特别案例

与规范相比，这个结果有两个问题：

1. slice 对象实际上是不可迭代的。我们想解释myview[3:20:8]，就好像它实际上是用它描述的值索引的一样范围， 按顺序。幸运的是，将slice 转换为具有相同start、stop 和step 的对应range 对象很简单。

   但是，如果 start 或 stop 未指定，我们需要抱怨，否则语义没有任何意义；我们必须记住，范围不接受None 作为步长值（slices 将其视为等同于1）。最后，我们必须接受负值不会从最后开始索引，因为再次解释所有极端情况应该发生的事情太困难了。

2. 字符串（可能还有其他类型）是可迭代，并且元素本身是非空字符串 - 因此它们可以被任意多次索引。我们需要对它们进行特殊处理，以便它们作为叶节点工作。

   我们需要辅助逻辑来处理字符串，就好像它们不可迭代一样。它也应该适用于构造（因为否则我们可以从字符串中创建一个完全无用的View 实例）。我们不希望该逻辑处理切片，因为View(slice(0)) 应该给我们原始的slice，而不是range。

   通过一些重构，我们得到：

   def _make_range(a_slice):
       start, stop, step = a_slice.start, a_slice.stop, a_slice.step
       if start is None or stop is None:
           raise ValueError('start and stop must be defined to convert to range')
       return range(start, stop, 1 if step is None else step)
   
   def _non_string_iterable(obj):
       try:
           iter(data)
           return not isinstance(obj, str)
       except TypeError:
           return False
   
   class View:
       def __new__(cls, data):
           if _non_string_iterable(data):
               result = object.__new__(cls)
               result._data = data
               return result
           return data
   
       def __getitem__(self, indices):
           result = self._data
           if isinstance(indices, slice):
               indices = _make_range(indices)
           if _non_string_iterable(indices):
               for i in indices:
                   result = result[i]
           else:
               result = result[indices]
           return View(result)
   

Answer 2

结合collapse() 和dig() 的Python 版本，以及特殊的slice 处理，重现您输入的示例表：

from more_itertools import collapse  # or implement this yourself
from unittest.mock import MagicMock


def dig(collection, *keys):
    """Dig into nested subscriptable objects, e.g. dict and list, i.e JSON."""
    curr = collection
    for k in keys:
        if curr is None:
            break

        if not hasattr(curr, '__getitem__') or isinstance(curr, str):
            raise TypeError(f'cannot dig into {type(curr)}')

        try:
            curr = curr[k]
        except (KeyError, IndexError):
            curr = None

    return curr


def what_you_wanted(collection, *keys):  # If I understood you correctly
    slic = keys[0] if len(keys) == 1 and isinstance(keys[0], slice) else None
    dig_keys = range(slic.stop)[slic] if slic else collapse(keys)
    return dig(collection, *dig_keys)


def test_getitem_with(*keys):
    mock = MagicMock()
    mock.__getitem__.returns = mock
    what_you_wanted(mock, *keys)
    print(mock.mock_calls)


test_getitem_with((1, 2, 3))
test_getitem_with(('x', 'y'))
test_getitem_with((99,))
test_getitem_with([[[99]]])
test_getitem_with((1, 2), 3)
test_getitem_with(([1, [2]], [3]))
test_getitem_with(1, 2, 3)
test_getitem_with(slice(3, 20, 8))
test_getitem_with(range(3, 20, 8))

印刷：

[call.__getitem__(1),
 call.__getitem__().__getitem__(2),
 call.__getitem__().__getitem__().__getitem__(3)]
[call.__getitem__('x'), call.__getitem__().__getitem__('y')]
[call.__getitem__(99)]
[call.__getitem__(99)]
[call.__getitem__(1),
 call.__getitem__().__getitem__(2),
 call.__getitem__().__getitem__().__getitem__(3)]
[call.__getitem__(1),
 call.__getitem__().__getitem__(2),
 call.__getitem__().__getitem__().__getitem__(3)]
[call.__getitem__(1),
 call.__getitem__().__getitem__(2),
 call.__getitem__().__getitem__().__getitem__(3)]
[call.__getitem__(3),
 call.__getitem__().__getitem__(11),
 call.__getitem__().__getitem__().__getitem__(19)]
[call.__getitem__(3),
 call.__getitem__().__getitem__(11),
 call.__getitem__().__getitem__().__getitem__(19)]

为了完成，可以使用what_you_wanted() 定义一个实现__getitem__() 的集合对象（或视图）。