title: How to write parentheses for binary tree?
body: <p>Here I am trying to combine the binary tree into expression. For instance </p>
  
  <p>b1 = BinaryTree(3.0)</p>
  
  <p>print(parenthesize(b1))</p>
  
  <p>3.0</p>
  
  <p>b2 = BinaryTree(4.0)</p>
  
  <p>b3 = BinaryTree(7.0)</p>
  
  <p>b4 = BinaryTree("*", b1, b2)</p>
  
  <p>b5 = BinaryTree("+", b4, b3)</p>
  
  <p>print(parenthesize(b5))`</p>
  
  <p>((3.0 * 4.0) + 7.0)</p>
  
  <p>The code I write for <code>parenthesize()</code> is at the bottom and the above are the Binary tree base code. But my code, instead of returning "somenumber", it returns 
  ("somenumber"). When I delete the  "(", the parenthesizes totally disappeared. Could someone help fill the code? </p>
  
  <pre><code>class BinaryTree:
  """
  A Binary Tree, i.e. arity 2.
  
  === Attributes ===
  @param object data: data for this binary tree node
  @param BinaryTree|None left: left child of this binary tree node
  @param BinaryTree|None right: right child of this binary tree node
  """
  
  def __init__(self, data, left=None, right=None):
      """
      Create BinaryTree self with data and children left and right.
  
      @param BinaryTree self: this binary tree
      @param object data: data of this node
      @param BinaryTree|None left: left child
      @param BinaryTree|None right: right child
      @rtype: None
      """
      self.data, self.left, self.right = data, left, right
  
  def __eq__(self, other):
      """
      Return whether BinaryTree self is equivalent to other.
  
      @param BinaryTree self: this binary tree
      @param Any other: object to check equivalence to self
      @rtype: bool
  
      &gt;&gt;&gt; BinaryTree(7).__eq__("seven")
      False
      &gt;&gt;&gt; b1 = BinaryTree(7, BinaryTree(5))
      &gt;&gt;&gt; b1.__eq__(BinaryTree(7, BinaryTree(5), None))
      True
      """
      return (type(self) == type(other) and
              self.data == other.data and
              (self.left, self.right) == (other.left, other.right))
  
  def __repr__(self):
      """
      Represent BinaryTree (self) as a string that can be evaluated to
      produce an equivalent BinaryTree.
  
      @param BinaryTree self: this binary tree
      @rtype: str
  
      &gt;&gt;&gt; BinaryTree(1, BinaryTree(2), BinaryTree(3))
      BinaryTree(1, BinaryTree(2, None, None), BinaryTree(3, None, None))
      """
      return "BinaryTree({}, {}, {})".format(repr(self.data),
                                             repr(self.left),
                                             repr(self.right))
  
  def __str__(self, indent=""):
      """
      Return a user-friendly string representing BinaryTree (self)
      inorder.  Indent by indent.
  
      &gt;&gt;&gt; b = BinaryTree(1, BinaryTree(2, BinaryTree(3)), BinaryTree(4))
      &gt;&gt;&gt; print(b)
          4
      1
          2
              3
      &lt;BLANKLINE&gt;
      """
      right_tree = (self.right.__str__(
          indent + "    ") if self.right else "")
      left_tree = self.left.__str__(indent + "    ") if self.left else ""
      return (right_tree + "{}{}\n".format(indent, str(self.data)) +
              left_tree)
  
  def __contains__(self, value):
      """
      Return whether tree rooted at node contains value.
  
      @param BinaryTree self: binary tree to search for value
      @param object value: value to search for
      @rtype: bool
  
      &gt;&gt;&gt; BinaryTree(5, BinaryTree(7), BinaryTree(9)).__contains__(7)
      True
      """
      return (self.data == value or
              (self.left and value in self.left) or
              (self.right and value in self.right))
  
  def parenthesize(b):
  """
  Return a parenthesized expression equivalent to the arithmetic
  expression tree rooted at b.
  
  Assume:  -- b is a binary tree
           -- interior nodes contain data in {'+', '-', '*', '/'}
           -- interior nodes always have two children
           -- leaves contain float data
  
  @param BinaryTree b: arithmetic expression tree
  @rtype: str
  
  &gt;&gt;&gt; b1 = BinaryTree(3.0)
  &gt;&gt;&gt; print(parenthesize(b1))
  3.0
  &gt;&gt;&gt; b2 = BinaryTree(4.0)
  &gt;&gt;&gt; b3 = BinaryTree(7.0)
  &gt;&gt;&gt; b4 = BinaryTree("*", b1, b2)
  &gt;&gt;&gt; b5 = BinaryTree("+", b4, b3)
  &gt;&gt;&gt; print(parenthesize(b5))
  ((3.0 * 4.0) + 7.0)
  """
  if b is None:
      return ''
  else:
      return "("+parenthesize(b.left)+str(b.data)+parenthesize(b.right)+")"
  </code></pre>