Python中的树

请帮助我理解Python中的树。这是我在互联网上找到的树实现的一个例子

from collections import deque
class EmptyTree(object):
    """Represents an empty tree."""
    # Supported methods
    def isEmpty(self):
        return True
    def __str__(self):
        return ""
    def __iter__(self):
        """Iterator for the tree."""
        return iter([])
    def preorder(self, lyst):
        return
    def inorder(self, lyst):
        return
    def postorder(self, lyst):
        return

class BinaryTree(object):
    """Represents a nonempty binary tree."""
    # Singleton for all empty tree objects
    THE_EMPTY_TREE = EmptyTree()
    def __init__(self, item):
        """Creates a tree with
        the given item at the root."""
        self._root = item
        self._left = BinaryTree.THE_EMPTY_TREE
        self._right = BinaryTree.THE_EMPTY_TREE
    def isEmpty(self):
        return False
    def getRoot(self):
        return self._root
    def getLeft(self):
        return self._left
    def getRight(self):
        return self._right
    def setRoot(self, item):
        self._root = item
    def setLeft(self, tree):
        self._left = tree
    def setRight(self, tree):
        self._right = tree
    def removeLeft(self):
        left = self._left
        self._left = BinaryTree.THE_EMPTY_TREE
        return left
    def removeRight(self):
        right = self._right
        self._right = BinaryTree.THE_EMPTY_TREE
        return right
    def __str__(self):
        """Returns a string representation of the tree
        rotated 90 degrees to the left."""
        def strHelper(tree, level):
            result = ""
            if not tree.isEmpty():
                result += strHelper(tree.getRight(), level + 1)
                result += "   " * level
                result += str(tree.getRoot()) + "\n"
                result += strHelper(tree.getLeft(), level + 1)
            return result
        return strHelper(self, 0)
    def __iter__(self):
        """Iterator for the tree."""
        lyst = []
        self.inorder(lyst)
        return iter(lyst)
    def preorder(self, lyst):
        """Adds items to lyst during
        a preorder traversal."""
        lyst.append(self.getRoot())
        self.getLeft().preorder(lyst)
        self.getRight().preorder(lyst)
    def inorder(self, lyst):
        """Adds items to lyst during
        an inorder traversal."""
        self.getLeft().inorder(lyst)
        lyst.append(self.getRoot())
        self.getRight().inorder(lyst)
    def postorder(self, lyst):
        """Adds items to lystduring
        a postorder traversal."""
        self.getLeft().postorder(lyst)
        self.getRight().postorder(lyst)
        lyst.append(self.getRoot())
    def levelorder(self, lyst):
        """Adds items to lyst during
        a levelorder traversal."""
        # levelsQueue = LinkedQueue()
        levelsQueue = deque ([])
        levelsQueue.append(self)
        while levelsQueue != deque():
            node = levelsQueue.popleft()
            lyst.append(node.getRoot())
            left = node.getLeft()
            right = node.getRight()
            if not left.isEmpty():
                levelsQueue.append(left)
            if not right.isEmpty():
                levelsQueue.append(right)

这是制作小树的程序

"""
File: testbinarytree.py
Builds a full binary tree with 7 nodes.
"""
from binarytree import BinaryTree
lst = ["5", "+", "2"]
for i in range(len(lst)):
    b = BinaryTree(lst[0])
    d = BinaryTree(lst[1])
    f = BinaryTree(lst[2])
# Build the tree from the bottom up, where
# d is the root node of the entire tree
d.setLeft(b)
d.setRight(f)
def size(tree):
    if tree.isEmpty():
        return 0
    else:
        return 1 + size(tree.getLeft()) + size(tree.getRight())
def frontier(tree):
    """Returns a list containing the leaf nodes
    of tree."""
    if tree.isEmpty():
        return []
    elif tree.getLeft().isEmpty() and tree.getRight().isEmpty():
        return [tree.getRoot()]
    else:
        return frontier(tree.getLeft()) + frontier(tree.getRight())
print ("Size:", size(d))
print ("String:")
print (d)

---

如何创建一个类来计算表达式的值，从而使答案=7（5+2）。我真的想用一个小例子来理解这个概念。

你应该做一个函数，按深度顺序遍历一棵树，计算每个节点的值，或者只取它的值（例如，如果它是“5”），或者进行计算（例如，如果它是“+”）-通过按深度优先顺序遍历树，您可以确保在计算给定节点时将计算该节点的所有子节点（例如，在计算“+”时将计算“5”和“2”）

---

然后，在树的根上，你会得到整棵树的结果。

首先，如果这是家庭作业，我不会给出太多细节，听起来有点像

在树类上需要一个计算树的方法。我假设每个树节点的“根”值是一个数字（当节点是叶子时，即没有子节点时）或操作符的名称（当节点有子节点时）

您的方法将是递归的：具有子节点的树节点的值由（1）其左子树的值、（2）其右子树的值和（3）其“根”中的运算符确定

---

您可能需要一个表——可能存储在一个

dict

——将

“+”

之类的运算符名称映射到

运算符之类的实际函数。添加
（或者，如果您愿意，
lambda x，y:x+y
）。
听起来您的问题不是树，树是一个更一般（更简单）的概念，但是如何正确地填充和/或计算表达式树

如果在修复后的顺序中指定了运算符，那么就容易多了

看。它被称为调车场算法。
“计算表达式的值”。什么意思？是否要创建表达式计算器（可能是计算器），将其用作语法树？哪些部分你懂，哪些部分你不懂？是的，我希望它能像计算器一样工作。我理解上面写的一切。我所有试图编写用于计算表达式的类的尝试都以失败告终。它不是真正的中缀！给定的代码手动“解析”表达式，并建立一个树，树的叶子上有5和2，根上有
“+”
。“我不知道提问者在处理更复杂的表达方面有什么野心……”加雷斯：我把这个问题转移到了一个答案上，因为我意识到这可能会给他所需要的一切。