[已解决]
(步骤1.1)、class MainEngine中的函数add_engine接收的参数为engine_class。函数中有“执行语句” engine: BaseEngine = engine_class(self, self.event_engine)。
(步骤1.2)、然后，在运行add_engine(LogEngine)时，作为参数的LogEngine也就代替了engine_class。上面“执行语句” 变身为：engine: BaseEngine = LogEngine(self, self.event_engine)
(步骤2)、从LogEngine的定义可见：需要接收2个参数：MainEngine、EventEngine。
问题：步骤1.2中LogEngine只有1个参数，少了首个位置的参数MainEngine，代码是如何运行的通的呢？请大师帮助释疑指导，谢谢。

1.2中

LogEngine(self, self.event_engine)

这里第一个self就是MainEngine对象

谢谢！你说的对。如下，我还原到极简状态（copy到单独文件，放在vnpy\trader目录下，可以运行查看），发现无限嵌套竟然可以存在。虽然暂时不理解深层原理。但总算接受了外层的逻辑。

from vnpy.event import Event, EventEngine
class MainEngine:
    def __init__(self) -> None:
        self.engines = {}
        engine = LogEngine(self)   #
        self.engines[engine.engine_name] = engine

class LogEngine():
    def __init__(self, main_engine: MainEngine) -> None:
        self.main_engine: MainEngine = main_engine
        self.engine_name: str = 'log'

if __name__ == "__main__":
    M = MainEngine()
    # 以下都是同一个内存地址（只是记录地址、未参与数据计算）：
    print('最外层实例M：                                                                                          ', M)
    print('实例M中的字典中：                  M.engines字典 -> 键log -> 值实例的一个属性-实例M：main_engine：     ',M.engines['log'].main_engine)
    print('<值实例的一个属性>实例M中的字典中：M.engines字典 -> 键log -> 值实例的一个属性-实例M：main_engine ==》：', M.engines['log'].main_engine.engines['log'].main_engine)

Python对象的成员变量，只是一个对实际对象的引用（类似C++中指针的概念），本来就不存在严格的上下级（或者内外层）概念

上面情况，实际对象的引用 仅仅是一个内存地址。
但我存在怀疑：如果A实例引用了B类实例属性的值、参与计算，B实例内部又存在A实例的该属性（甚至参与计算），会不会引发循环错误。
我缺少这样的案例构造，所以暂时无法彻底理解。仅仅是存疑。

boliboli66 wrote:

上面情况，实际对象的引用 仅仅是一个内存地址。
但我存在怀疑：如果A实例引用了B类实例属性的值、参与计算，B实例内部又存在A实例的该属性（甚至参与计算），会不会引发循环错误。
我缺少这样的案例构造，所以暂时无法彻底理解。仅仅是存疑。

不会，这块可以搜索学习Python语言的【可变对象、不可变对象】的概念基础

赞。谢谢。我试图构造案例：必须两个实例中都是“可变对象”才有可能引发循环。但是一旦都是“可变对象”，在运行时，依据代码行的先后，必然引发 一个错误：类实例尚未定义，无法运行。所以无法形成循环后果。这样理解，也许是正确的吧。