1. Add the building util of Python

for the markdown docs.
2. Update the deploy.sh

docs/chapter_tree/binary_search_tree.md

@@ -78,21 +78,7 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
-    """ 查找结点 """
-    def search(self, num: int) -> Optional[TreeNode]:
-        cur = self.root
-        # 循环查找，越过叶结点后跳出
-        while cur is not None:
-            # 目标结点在 cur 的右子树中
-            if cur.val < num:
-                cur = cur.right
-            # 目标结点在 cur 的左子树中
-            elif cur.val > num:
-                cur = cur.left
-            # 找到目标结点，跳出循环
-            else:
-                break
-        return cur
+    [class]{BinarySearchTree}-[func]{search}
     ```
 
 === "Go"
@@ -286,36 +272,7 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
-    """ 插入结点 """
-    def insert(self, num: int) -> Optional[TreeNode]:
-        root = self.root
-        # 若树为空，直接提前返回
-        if root is None:
-            return None
-    
-        cur = root
-        pre = None
-    
-        # 循环查找，越过叶结点后跳出
-        while cur is not None:
-            # 找到重复结点，直接返回
-            if cur.val == num:
-                return None
-            pre = cur
-            # 插入位置在 cur 的右子树中
-            if cur.val < num:
-                cur = cur.right
-            # 插入位置在 cur 的左子树中
-            else:
-                cur = cur.left
-    
-        # 插入结点 val
-        node = TreeNode(num)
-        if pre.val < num:
-            pre.right = node
-        else:
-            pre.left = node
-        return node
+    [class]{BinarySearchTree}-[func]{insert}
     ```
 
 === "Go"
@@ -640,59 +597,9 @@ comments: true
 === "Python"
 
     ```python title="binary_search_tree.py"
-    """ 删除结点 """
-    def remove(self, num: int) -> Optional[TreeNode]:
-        root = self.root
-        # 若树为空，直接提前返回
-        if root is None:
-            return None
-    
-        cur = root
-        pre = None
-    
-        # 循环查找，越过叶结点后跳出
-        while cur is not None:
-            # 找到待删除结点，跳出循环
-            if cur.val == num:
-                break
-            pre = cur
-            if cur.val < num:  # 待删除结点在 cur 的右子树中
-                cur = cur.right
-            else:  # 待删除结点在 cur 的左子树中
-                cur = cur.left
-    
-        # 若无待删除结点，则直接返回
-        if cur is None:
-            return None
-    
-        # 子结点数量 = 0 or 1
-        if cur.left is None or cur.right is None:
-            # 当子结点数量 = 0 / 1 时， child = null / 该子结点
-            child = cur.left or cur.right
-            # 删除结点 cur
-            if pre.left == cur:
-                pre.left = child
-            else:
-                pre.right = child
-        # 子结点数量 = 2
-        else:
-            # 获取中序遍历中 cur 的下一个结点
-            nex = self.get_inorder_next(cur.right)
-            tmp = nex.val
-            # 递归删除结点 nex
-            self.remove(nex.val)
-            # 将 nex 的值复制给 cur
-            cur.val = tmp
-        return cur
+    [class]{BinarySearchTree}-[func]{remove}
 
-    """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
-    def get_inorder_next(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
-        if root is None:
-            return root
-        # 循环访问左子结点，直到叶结点时为最小结点，跳出
-        while root.left is not None:
-            root = root.left
-        return root
+    [class]{BinarySearchTree}-[func]{get_inorder_next}
     ```
 
 === "Go"