How can extract different terms from a symbolic expression?

edit

You can write your own parse tree class. It should be possible to plot the tree as graph.

class Tree(object):

    def __init__(self,item,left=None,right=None):
        self.item = item
        self.left = left
        self.right = right

    def show(self):       
        if self.left: self.left.show()
        print self.item, 
        if self.right: self.right.show()

    def evaluate(self):
        """ 
        if self.item is an operator, it is a callable function,
        so you can call it with left and right sub-tree as arguments
        """
        if self.left==None and self.right==None:  # self.item is a 'leaf'
            return self.item
        elif self.left==None:  # unary operation
            return self.item(self.right.evaluate())
        else:                  # binary operation 
            return self.item(self.left.evaluate(),self.right.evaluate())


def create_tree(expr):
    """
    expr is an expression  or(!)  a tuple containing an operation 
                                  and its list of operands
    """
    if type(expr)==tuple:
        op = expr[0]
        operands = expr[1]
    else:
        try:
           op = expr.operator()
           operands = expr.operands()
        except:
            return Tree(expr)
    if not op:  
       return Tree(expr)
    else:
        if len(operands) > 2:
            return Tree(op,left=create_tree(operands[0]),
                           right=create_tree((op,operands[1:])))
        elif len(operands) == 2:
            return Tree(op,left=create_tree(operands[0]),
                           right=create_tree(operands[1])) 
        else:    
            # unary operation , not testet
            return Tree(op,right=create_tree(operands[0]))


T=create_tree(5+x+x^2)
#T.show()
T.evaluate()

Try ex1.operands(), ex1.operator() , ex1.op

var('a b c x')
ex1 = a*x^2 + b/x - c
ex1.operands()

     [a*x^2, -c, b/x]

UPDATE: To show the parse tree, let us use a recursive function:

def print_tree(expr,k=0):
    op = expr.operator()
    operands = expr.operands()
    if op:
        print k*' ---',op, operands
        k += 1
        for operand in operands:
            print_tree(operand,k)

print_tree(ex1)