Rudimentary BST in Python.

bst.py

class Node(object):
    """A node in BST."""
    def __init__(self, value, left_node=None, right_node=None):
        self.value = value
        self.left_node = left_node
        self.right_node = right_node

    def set_left(self, left_node):
        self.left_node = left_node

    def set_right(self, right_node):
        self.right_node = right_node

    def set_value(self, new_value):
        self.value = new_value


class BST(object):
    """A binary search tree with rudimentary insert and traverse interface."""

    def __init__(self):
        self.root_node = None

    def insert(self, value):
        if self.root_node is None:
            self.root_node = Node(value)
            return

        parent_node = self.root_node
        while parent_node:
            if value <= parent_node.value:
                if parent_node.left_node is None:
                    parent_node.set_left(Node(value))
                    break
                else:
                    parent_node = parent_node.left_node
            else:
                if parent_node.right_node is None:
                    parent_node.set_right(Node(value))
                    break
                else:
                    parent_node = parent_node.right_node

    def inorder(self, node=None):
        if self.root_node is not None:
            self.traverse(self.root_node, TraverseOrder.IN)

    def traverse(self, node, order):
        if node is None:
            return

        if order == TraverseOrder.PRE:
            print node.value

        self.traverse(node.left_node, order)

        if order == TraverseOrder.IN:
            print node.value

        self.traverse(node.right_node, order)

        if order == TraverseOrder.POST:
            print node.value

class TraverseOrder:
    PRE = 0
    IN = 1
    POST = 2

if __name__ == '__main__':
    bst = BST()
    for v in [6, 4, 2, 5, 1, 3, 9, 8, 7, 10]:
        bst.insert(v)

    bst.inorder() # should print 1,2,...,10