自定义Mapping类返回自身作为迭代器时list()返回空列表的修复方案咨询

问题分析 #

你猜的完全没错！问题的核心就是：你的SideDict类把自身作为迭代器（__iter__返回self），这是一个有状态的单例迭代器。当list()调用时，它会先获取这个迭代器（也就是实例本身），然后为了预分配内存去调用__len__，而你的__len__又通过for k in self复用了同一个迭代器，把它彻底耗尽了。等list()再想去遍历的时候，迭代器已经没有元素可以返回了，所以得到空列表。

标准的容器（比如Python内置的dict）都是可迭代对象，但不是迭代器——每次调用__iter__()都会返回一个全新的、独立状态的迭代器实例，这样多个迭代操作之间不会互相干扰。而你的实现把两者混在一起了，就会出现这种状态冲突的问题。

解决方案 #

这里有两个可行的修复方向，你可以根据自己的需求选择：

方案1：重构迭代器，让__iter__返回独立的迭代器实例

最规范的做法是把迭代器逻辑抽成一个独立的内部类，每次调用__iter__都返回这个类的新实例，每个迭代器维护自己的状态，互不干扰。

修改后的代码大概是这样的：

from __future__ import annotations
from collections.abc import MutableMapping

class SideDict(MutableMapping, dict):
    """
    特殊字典类，优先使用自身的键值，自身不存在的键会从side_dict中获取
    """
    def __init__(self, data, side_dict: SideDict | None):
        self._store = dict(data)
        self._side_dict = side_dict
        # 其他初始化逻辑保留

    # 其他方法(__bool__, __contains__, __getitem__等)保留不变

    def __iter__(self):
        # 每次调用__iter__都返回一个新的迭代器实例
        return _SideDictIterator(self._store, self._side_dict)

    # 修复__len__，改成更高效的实现
    def __len__(self):
        count = len(self._store)
        if self._side_dict is not None:
            # 统计side_dict中不在自身的键数
            count += len(set(self._side_dict) - set(self._store))
        return count

# 独立的迭代器类，维护自己的迭代状态
class _SideDictIterator:
    def __init__(self, store, side_dict):
        self._store = store
        self._side_dict = side_dict
        self._iter_keys_seen = []
        self._iter_in_side_dict = False
        self._iter = None

    def __next__(self):
        while True:
            if self._iter is None:
                self._iter = iter(self._store)

            try:
                next_ = next(self._iter)
                if next_ in self._iter_keys_seen:
                    continue
                # 你原来对next_的处理逻辑保留
                self._iter_keys_seen.append(next_)
                return next_
            except StopIteration:
                if self._side_dict is None or self._iter_in_side_dict:
                    raise
                else:
                    self._iter_in_side_dict = True
                    self._iter = iter(self._side_dict)

这样一来，list(sd_0)会获取一个迭代器，__len__里的操作会获取另一个完全独立的迭代器，两者状态互不干扰，就不会出现迭代器被耗尽的问题了。

方案2：直接修改__len__，避免通过迭代计算长度

如果不想重构迭代器，那可以直接计算总长度，而不是通过遍历所有键来统计。这样__len__不会触发迭代，自然就不会干扰外部的迭代器了。

计算逻辑要和你的迭代逻辑一致：自身的键数 + side_dict中不在自身的键数（因为重复的键只迭代一次）。代码如下：

def __len__(self):
    # 自身存储的键数量
    total = len(self._store)
    # 加上side_dict中未在自身出现的键数量
    if self._side_dict is not None:
        # 用集合差集快速计算不重复的键数
        unique_side_keys = set(self._side_dict) - set(self._store)
        total += len(unique_side_keys)
    return total

这个方案的好处是不需要改动迭代器的实现，而且计算长度的效率比遍历迭代高得多（尤其是当字典很大的时候）。

额外提示 #

尽量不要让容器类自身同时作为迭代器（也就是不要让__iter__返回self），这是Python容器设计的一个反模式。标准库中的所有内置容器（list、dict、set等）都遵循“可迭代对象≠迭代器”的原则，每次调用__iter__都会返回新的迭代器实例，这样就能避免各种状态冲突的问题。

备注：内容来源于stack exchange，提问作者fishfin