Aspen与Python联动(5)-aspen.Tree.FindNode().Elements是不是可迭代对象？

编程技术
,
1

先说结论，是

因为它可以被iter()

it = iter(Name_Block_All.Elements)
while True:
    try:
        elem = next(it)
    except StopIteration:
        break
    print(elem.Name)

如果说它不能被iter()，那么它就不是可迭代对象，反过来，它能够被iter()，说明它是可迭代对象

这是 Python 对“可迭代对象”的唯一硬性定义：

只要 iter(x) 不抛 TypeError，x 就是可迭代对象；
只要 iter(x) 抛 TypeError，x 就不是可迭代对象。

那么我们知道

isinstance(obj, collections.abc.Iterable)可以判断是不是可迭代对象，我们试试

isinstance(Name_Block_All,Iterable)
#False

所以这里产生矛盾了，它可以被iter(),但是如果用isinstance来判断是否是可迭代对象的话失败了

魔法方法

为什么？

先给出结论

在 Python 里，“可迭代”≠“继承 abc.Iterable”。
只要类型在 C 级别 实现了 tp_iter（或者 Python 级别实现了 __iter__），解释器就允许 iter()、for…in… 正常工作；
而 collections.abc.Iterable 的 isinstance 判断只认识：

  • 实现了 __iter__ 的 Python 类

  • 或者 注册（register）到 abc.Iterable 的 Python 类

对于 C 扩展模块里直接填充 tp_iter 槽位的类型，如果它没有在 Python 层显式地
collections.abc.Iterable.register(MyType)，
那么 isinstance(MyType(), Iterable) 就是 False，但 iter() 依然能成功。

具体到 aspen 这个例子:

Name_Block_All 的真实类型大概率是 某个 C 扩展里定义的类，它内部长这样（伪代码）：

typedef struct {
    PyObject_HEAD
    ...  // 指向底层树节点数组
} NodeArrayObject;

static PyTypeObject NodeArrayType = {
    ...
    .tp_iter = NodeArray_tp_iter,   // 这里给了迭代器
    ...
};

翻译:

// 定义一个结构体，表示一个 Python 对象（NodeArrayObject）
typedef struct {
    PyObject_HEAD  // 这是 Python 对象的标准头部，包含引用计数和类型指针
    ...            // 这里省略了具体字段，表示它内部有一个指向底层树节点数组的指针
} NodeArrayObject;
// 定义这个 Python 类型的元信息（类型对象）
static PyTypeObject NodeArrayType = {
    ...
    .tp_iter = NodeArray_tp_iter,  // 设置 tp_iter 字段，表示这个类型支持迭代器协议
                                   // NodeArray_tp_iter 是一个函数指针，返回一个迭代器对象
    ...
};

验证办法:

把“缺口”补上，让 isinstance 也返回 True：

import collections.abc as abc
abc.Iterable.register(type(Name_Block_All))   # 注册一下
print(isinstance(Name_Block_All, abc.Iterable))  # 现在就是 True 了

什么是C级别？

“C 级别”就是“用 C 语言直接写死、在解释器源码里固化”的那一层，和“Python 级别”相对。

级别 谁在干活 你能在 .py 文件里直接看到/改到吗？
Python 级别 Python 代码 :white_check_mark: 能，import 进来就能读/改
C 级别 编译好的二进制（.pyd / .so）或 CPython 源码 :cross_mark: 不行，只能看源码或反汇编

1.Python级别

class MyList:
  def iter(self):          # Python 层面的 iter
    yield 1; yield 2

  • 解释器运行到 for x in MyList(): 时，会去调用你写的 Python 函数 __iter__。

  • 因为 collections.abc.Iterable 只检查“有没有 __iter__ 方法”，所以
    isinstance(MyList(), Iterable) 一定是 True。

  1. C 级别（CPython 源码或 C 扩展）
// 在 CPython 源码或第三方 C 扩展里
typedef struct {
    PyObject_HEAD
    ...
} NodeArrayObject;

static PyObject *
NodeArray_tp_iter(NodeArrayObject *self)
{
    return ...;   // 返回一个迭代器
}

static PyTypeObject NodeArrayType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "aspen.NodeArray",
    .tp_iter = NodeArray_tp_iter,   // ← 这里直接塞了函数指针
    ...
};

  • 编译后变成二进制，Python 里只能看到“黑盒子”对象。

  • 解释器照样会走 tp_iter 拿到迭代器，所以 iter(obj)、for…in… 都能用。

  • 但 没有 在 Python 层写 __iter__，也 没有 abc.Iterable.register(...)，
    于是 isinstance(obj, Iterable) 返回 False。

提示:

list、dict、str 这些内置类型全是 C 级别 实现的：
它们的迭代能力来自 tp_iter，而不是 Python 里的 __iter__ 方法；
但因为 CPython 在启动时把 list、dict、str 都 注册 到了 abc.Iterable，
所以 isinstance([], Iterable) 仍然是 True。

而你的 aspen.Tree.FindNode(...).Elements 那个类型，作者只写了 C 的 tp_iter，
忘了（或故意没） 在 Python 层注册，于是出现了
“能 iter()，但 isinstance(..., Iterable) 为 False” 的现象。

现在回到这个问题:这个Name_Block_All，本质是可迭代对象吗？

是。
只要一个对象能被 iter() 成功调用、并返回一个迭代器，它就是可迭代对象——这是 Python 语言层面的唯一判定标准。

isinstance(obj, collections.abc.Iterable) 只是对“Python 层有没有 __iter__ 或是否注册到 abc”做的辅助检查，返回 False 并不能推翻“它确实可迭代”这一事实。

那么它为什么会是这样的？他的本质为什么是C语言编写的而不是Python编写的?

这算是win32com.client还是Aspen本身就有的？

是 Aspen 本身（它的 COM 服务器，也就是那个 Aspen Plus / HYSYS 的进程外 DLL）用 C/C++ 实现的；
win32com.client 只是 Python 这边的“交通员”，负责把 COM 请求打包成 IDispatch 调用、再把返回的 COM 对象包成 PyIDispatch 给你。
它没有也不想去实现那些 tp_iter 槽——那个“能 iter() 却 isinstance(..., Iterable) == False”的对象，完全是 Aspen 的 C++ 代码自己注册到 COM 的类型。

组件 语言 作用
Aspen Plus / HYSYS COM DLL C++ 真正提供 Tree、Node、Elements 等 COM 类；在 C++ 里实现 IEnumVARIANT 或自定义迭代器，因此 Python 端能 for x in collection:
win32com.client (pywin32) Python/C 把 COM 对象包装成 PyIDispatch，让 Python 像操作普通对象一样调用方法和属性；不负责迭代协议，只要 COM 对象返回 IEnumVARIANT，它就原样转发

为什么能看到“C 级别”的 tp_iter？

win32com.client 在拿到一个 COM 集合 时，会生成一个 轻量的 Python 包装类（内部叫 PyIIDEnumVARIANT 或类似），这个包装类是用 C 写的扩展模块，它把自己的 tp_iter 指向 IEnumVARIANT_Next 的封装函数——于是

iter(my_elements)      # 成功

但 win32com 没有把这类动态生成的包装类注册到 collections.abc.Iterable，所以

isinstance(my_elements, Iterable)  # False

“能迭代”是 Aspen 的 C++ COM 对象 + win32com 的 C 扩展包装 共同提供的；
“isinstance 返回 False”是因为 win32com 没给这些临时包装类注册 abc.Iterable——跟 Aspen 本身无关，也跟 Python 代码无关。

再说一下,容器

class BlackBox:
    """能装、能取，就是不能 for"""
    def __init__(self):
        self._data = [1, 2, 3]
    
    def get(self, idx):
        return self._data[idx]

box = BlackBox()
print(box.get(0))      # 1
iter(box)              # TypeError: 'BlackBox' object is not iterable
2 个赞