Package: print-tree2
print_treeThis package helps you to print your tree structure in a pretty format.Installpip install print-tree2I wish to useprint_treeas the name but the package is already on pypi though it's not working.
To verify your installation, try:git clone https://github.com/liwt31/print_tree.git
cd print_tree/
pytestFeaturesThere is already a pretty print tree lib on GitHubpptree, why reinvent another wheel?
The most important reason is:This package provides an inherit interface that does not require you to modify any of your code, whilepptreeby design requires your node class to have certain methods or properties.Besides, this package:Does not change the order of your children (pptreedoes).Uses Unicode to achieve cross-platform --pptreefails on Windows because of wider space on terminals.Supports colored terminal strings (Only for Linux currently) and full-width characters.Still,pptreeis a wonderful package. The implementation is really beautiful and I borrowed some ideas from the author.DocumentationTheprint*.pyfiles in theexampledirectory provides several examples on how to use the package. And below can be regard as an explanation of these files. The files inexampledirectory enabled coloring to demonstrate the ability of this package to print tree with colors. Because the effect can not be seen in this MD file, corresponding codes are ommited.
Suppose we have theNodeclass:class Node(object):

    def __init__(self, value, parent):
        self.value = value
        self.children = []
        if parent is not None:
            parent.children.append(self)As an example, let's construct a tree as follows:data_structure = Node('Data Stucture', None)

vector = Node('Vector', data_structure)
list_ = Node('List', data_structure)
tree = Node('Tree', data_structure)
graph = Node('Graph', data_structure)

dag = Node('DAG', graph)
avl = Node('AVL', tree)
splay = Node('Splay', tree)
b = Node('B', tree)
quad = Node('Quand', tree)
kd = Node('kd', tree)To print the tree, we have to tellprint_treetwo things:how to transverse the tree from the root node.how to interpret every node as a string.To achieve these goals, we inherentprint_treefrom the package then overrideget_childrenandget_node_str:from print_tree import print_tree

class print_custom_tree(print_tree):

    def get_children(self, node):
        return node.children

    def get_node_str(self, node):
        return str(node.value)get_childrenshould accept aNodeand return a list with element typeNodeorPlaceHolder(see below for more info onPlaceHolder), andget_node_straccept aNodeand return a string. Then we can useprint_custom_treeas if it's a function:>>> print_custom_tree(data_structure)

             ┌Vector
             ├List
Data Stucture┤
             │    ┌AVL
             │    ├Splay
             ├Tree┼B
             │    ├Quand
             │    └kd
             └Graph─DAGIf you feel uncomfortable about the naming of the class, you can importPrintTreethen usePrintTreeinstead.Now let's move on to some more complex examples. In theexampledirectory I have defined a primitive search tree with custom numbers of branch. For brevity only the__init__function of theNodeis shown here. Ifbranch == 2then it's a binary search tree.class Node(object):

    def __init__(self, value, branch):
        self.values = [value]
        self.branch = branch
        self.children = [None] * branchIf we wish to emphasize on thebinarystructure, we can overrideget_childrenandget_node_stras follows:class print_binary(print_tree):
    def get_children(self, node):
        l_child, r_child = node.children
        if r_child is None and l_child is None:
            return []
        else:
            r_child = r_child or PlaceHolder
            l_child = l_child or PlaceHolder
            return [r_child, l_child]

    def get_node_str(self, node):
        return str(node.values[0])In this case it is possible that the return list ofget_childrencontainsPlaceHolder, which can be directly imported byfrom print_tree import PlaceHolder. IfPlaceHolderis in the return list,print_treewill take it as a placeholder: nothing will be shown, but it takes blank space:# Tree (bst) already initialized
>>> print_binary(bst.root)

        ┌19┐
        │  │  ┌18
        │  └17┤
        │     │  ┌16
        │     └15┘
        │       
        │       
     ┌14┤
     │  └13
  ┌12┘
  │ 
  │ 
11┤
  │     ┌10
  │   ┌9┤
  │   │ └8
  │ ┌7┤
  │ │ │   ┌6
  │ │ │ ┌5┤
  │ │ │ │ │ ┌4
  │ │ │ │ └3┘
  │ │ │ │   
  │ │ └2┤
  │ │   └1
  └0┘Because the tree is randomly generated, the result is probably different from what you saw when you test your installation. However, in both cases, you can read the inorder transverse of the tree from bottom to top aslist(range(20))(0 to 19).
The effect ofPlaceHolderbecomes prominent after we delete them (also note on the benefit of inheritance):class print_binary_without_placeholder(print_binary):
    def get_children(self, node):
        l_child, r_child = node.children
        children = []
        if r_child is not None:
            children.append(r_child)
        if l_child is not None:
            children.append(l_child)
        return children

# initialize the tree(bst)
...

print_binary_without_placeholder(bst.root)

              ┌18
        ┌19─17┤
        │     └15─16
  ┌12─14┤
  │     └13
11┤
  │     ┌10
  │   ┌9┤
  │   │ └8
  └0─7┤
      │   ┌6
      │ ┌5┤
      │ │ └3─4
      └2┤
        └1