Python 二叉搜索树的去搜索

我正在为即将到来的采访进行练习，我正在尝试反序列化一个二进制搜索树。我让它工作序列化，但我得到一个参数编号错误，但我不明白为什么

我希望“521#####35187###########30####”能重新变成一棵树

错误：TypeError:_deserialize（）正好接受2个参数（给定3个）

def\uuuuu init\uuuuuuu（self，value=None）：
自我价值=价值
self.left\u child=无
self.right\u child=无
类二进制搜索树：
定义初始化（自）：
self.root=None
def插入（自身，值）：
如果self.root为无：
self.root=节点（值）
其他：
self.\u插入（值，self.root）
定义插入（自身、值、当前节点）：
如果值<当前节点值：
如果当前_node.left_子项为无：
当前\节点。左\子节点=节点（值）
其他：
self.\u insert（值，当前\u节点。左\u子节点）
elif值>当前节点值：
如果当前\u node.right\u子项为无：
当前\u节点。右\u子节点=节点（值）
其他：
self.\u insert（值，当前\u节点。右\u子节点）
其他：
打印（“已插入值！”）
def序列化（自、串行）：
如果self.root不是None：
返回“”。加入（self.\u序列化（self.root，serial））
def_serialize（自身、当前_节点、序列）：#后订单
如果当前_节点不是无：
serial.append（str（当前节点值））
self.\u序列化（当前\u节点。左\u子节点，串行）
self.\u序列化（当前\u节点.右\u子节点，串行）
其他：
序列号。追加（“#”）
返回序列
def反序列化（自、串行）：
VAL=iter（serial.split（））
返回self.\u反序列化（self，vals）
def_反序列化（self，vals）：
值=下一个（VAL）
如果值=“#”：
一无所获
节点=节点（int（值））
node.left\u child=self.\u反序列化（VAL）
node.right\u child=self.\u反序列化（VAL）
返回节点
tree=BinarySearchTree（）
树。插入（5）
树。插入（2）
树。插入（1）
树.插入（35）
树.插入（18）
树.插入（7）
树.插入（30）
根=节点（3）
串行=[]
serial=树。序列化（serial）
打印（串行）
树。反序列化（串行）
正如@Primusa指出的，
返回self.\u反序列化（self，vals）
应该是
返回self.\u反序列化（vals）
正如@Primusa指出的，
返回self.\u反序列化（self，vals）
应该是
返回self.\u反序列化（vals）
返回self.\u反序列化（self，vals）
应该是
返回self.\u反序列化（VAL）
，self由python@Primusa，如果这是答案，请将其作为答案发布。谢谢！它成功了@Kevin我认为这属于“简单印刷错误”类别，因为他在其他地方正确使用了
self
，
return self.\u反序列化（self，vals）
应该是
return self.\u反序列化（vals）
，self会自动通过python@Primusa，如果这是答案，请将其作为答案发布。谢谢！它成功了@Kevin我认为这属于“简单印刷错误”类别，因为他在其他地方正确使用了
self
    def __init__(self,value = None):
        self.value = value
        self.left_child = None
        self.right_child = None


class BinarySearchTree:
    def __init__(self):
        self.root = None


    def insert(self,value):
        if self.root is None:
            self.root = Node(value)
        else:
            self._insert(value, self.root)

    def _insert(self, value, current_node):
        if value < current_node.value:
            if current_node.left_child is None:
                current_node.left_child = Node(value)
            else:
                self._insert(value,current_node.left_child)

        elif value > current_node.value:
            if current_node.right_child is None:
                current_node.right_child = Node(value)
            else:
                self._insert(value,current_node.right_child)
        else:
            print("Value already inserted!")


    def serialize(self,serial):
        if self.root is not None:
             return ' '.join(self._serialize(self.root, serial))


    def _serialize(self, current_node, serial): #Post order
        if current_node is not None:
            serial.append(str(current_node.value))
            self._serialize(current_node.left_child, serial)
            self._serialize(current_node.right_child, serial)
        else:
            serial.append("#")

        return serial


    def deserialize(self, serial):
        vals = iter(serial.split())
        return self._deserialize(self, vals)

    def _deserialize(self, vals):
        value = next(vals)
        if value == "#":
            return None

        node = Node(int(value))
        node.left_child = self._deserialize(vals)
        node.right_child = self._deserialize(vals)
        return node




tree = BinarySearchTree()
tree.insert(5)
tree.insert(2)
tree.insert(1)
tree.insert(35)
tree.insert(18)
tree.insert(7)
tree.insert(30)
root = Node(3)
serial = []
serial = tree.serialize(serial)
print(serial)


tree.deserialize(serial)