JavaScript子类继承转Python遇阻：ChildNode类继承父类属性方法报错

核心矛盾在于Python的super().__init__()必须严格匹配父类构造方法的参数要求，而JavaScript无参调用super()会默认传递undefined给父类构造函数，二者规则不同。以下是几种解决方案：

方案1：给父类构造函数添加默认参数（贴合原JS逻辑） #

修改父类BinarySearchTree的__init__方法，为参数设置默认值，让子类可选择性传参，后续再删除不需要的key属性：

class BinarySearchTree:
    # 为参数设置默认值，支持无参/部分参数调用
    def __init__(self, val: int = None, key: int = None):
        self.val = val
        self.left = None
        self.right = None
        self.key = key

    def insert(self, val):
        currNode = self

        if val == currNode.val:
            return None

        if val < currNode.val:
            if not currNode.left:
                currNode.left = ChildNode(val)
                return self
            else:
                currNode.left.insert(val)

        if val > currNode.val:
            if not currNode.right:
                currNode.right = ChildNode(val)
                return self
            else:
                currNode.right.insert(val)

class ChildNode(BinarySearchTree):
    def __init__(self, val):
        # 仅传递val给父类，key使用默认值None
        super().__init__(val)
        # 删除不需要的key属性，和JS逻辑对齐
        del self.key


root = BinarySearchTree(20, 14)
root.insert(8)
root.insert(22)
root.insert(4)
print(root)

方案2：调用super时传递临时key，再删除 #

如果不想修改父类构造方法，可在子类调用super()时传入临时key值（比如None），之后删除该属性：

class ChildNode(BinarySearchTree):
    def __init__(self, val):
        # 传递val和临时key
        super().__init__(val, None)
        del self.key

更合理的重构建议 #

原JS代码混淆了「二叉搜索树」和「树节点」的职责：BinarySearchTree既是树的整体，也是单个节点类。Python中更清晰的设计是拆分出独立的Node类，BinarySearchTree负责管理根节点和提供核心方法：

class Node:
    def __init__(self, val: int):
        self.val = val
        self.left = None
        self.right = None

class BinarySearchTree:
    def __init__(self, root_val: int, key: int):
        self.root = Node(root_val)
        self.key = key  # key仅属于树本身，与节点无关

    def insert(self, val):
        curr_node = self.root

        while True:
            if val == curr_node.val:
                return None
            if val < curr_node.val:
                if not curr_node.left:
                    curr_node.left = Node(val)
                    return self
                curr_node = curr_node.left
            else:
                if not curr_node.right:
                    curr_node.right = Node(val)
                    return self
                curr_node = curr_node.right

root = BinarySearchTree(20, 14)
root.insert(8)
root.insert(22)
root.insert(4)
print(root.root)

这种设计符合面向对象单一职责原则，避免了继承带来的冗余属性传递问题。

内容的提问来源于stack exchange，提问作者Ronny Fitzgerald