pptree: Pretty print trees

3.1 · maintenance · verified Thu Apr 16

pptree is a Python library (current version 3.1) designed to pretty-print tree-like data structures in a console-friendly, hierarchical format. It provides a default `Node` implementation and a `print_tree` function that can work with both its own `Node` objects and custom object structures. The library has an infrequent release cadence, with the last update in April 2020.

Common errors

```
ModuleNotFoundError: No module named 'pptree'
```
cause The `pptree` package has not been installed in the current Python environment.

fix Run `pip install pptree` to install the library.
```
NameError: name 'Node' is not defined
```
cause You likely used `import pptree` and then tried to directly access `Node` or `print_tree` without the `pptree.` prefix.

fix Either change your import statement to `from pptree import Node, print_tree` or access the symbols using `pptree.Node` and `pptree.print_tree`.
```
AttributeError: 'YourCustomNode' object has no attribute 'children'
```
cause When using `print_tree` with a custom node class, the default `childattr='children'` was used, but your custom node class does not have an attribute named `children` to store its child nodes.

fix Specify the correct attribute name for children in your custom node using the `childattr` parameter (e.g., `print_tree(my_root, childattr='my_custom_children_attribute')`).

Warnings

deprecated The `pptree` library appears to be in maintenance mode, with its last release in April 2020. Consider actively maintained alternatives like `treelib` or `PrettyPrintTree` for more features and ongoing support.
Fix: Evaluate newer, actively developed tree visualization libraries for long-term projects.
gotcha Some users have reported potential display issues with Unicode characters or inconsistent spacing in certain terminal environments, particularly on Windows, when using `pptree` or similar console-based tree printers.
Fix: Test `pptree` output in your target environment. For critical applications, consider alternative libraries or rendering methods, or explore `print-tree2` which claims better cross-platform Unicode support.
gotcha The `print_tree` function may reorder the children nodes from their original insertion order during display. If the order of children is semantically significant for your tree structure, this behavior can be misleading or incorrect.
Fix: Do not rely on `pptree` to preserve the exact order of children in the printed output if order is critical. Verify if an alternative library respects child order.
gotcha When using custom node objects with `print_tree`, the `childattr` and `nameattr` parameters must accurately reflect the attribute names in your custom class for its children list and displayable name, respectively. Incorrect values will lead to `AttributeError` or unexpected tree structures.
Fix: Always explicitly define `childattr` and `nameattr` (e.g., `print_tree(root, childattr='my_children', nameattr='my_name')`) when using custom node classes.

Install

pip install pptree Install latest version

Imports

Node
wrong:
```
import pptree.Node
```
correct:
```
from pptree import Node
```
The Node class is directly exposed at the top level of the pptree module when using `from pptree import ...`.
print_tree
wrong:
```
import pptree.print_tree
```
correct:
```
from pptree import print_tree
```
The print_tree function is directly exposed at the top level of the pptree module when using `from pptree import ...`.

Quickstart

This quickstart demonstrates how to create and pretty-print a tree using `pptree`'s default `Node` class and how to adapt `print_tree` for custom node implementations by specifying `childattr` and `nameattr`.

from pptree import Node, print_tree

# Create a tree using the default Node class
root = Node("Root")
child1 = Node("Child 1", root)
child2 = Node("Child 2", root)
grandchild1 = Node("Grandchild 1", child1)

print("--- Default Node Tree ---")
print_tree(root)

# Example with custom node class
class CustomNode:
    def __init__(self, name, parent=None):
        self.custom_name = name
        self.children_list = []
        if parent:
            parent.children_list.append(self)

    def __str__(self):
        return self.custom_name

custom_root = CustomNode("Custom Root")
custom_child1 = CustomNode("Custom Child 1", custom_root)
custom_child2 = CustomNode("Custom Child 2", custom_root)

print("\n--- Custom Node Tree ---")
# For custom nodes, specify 'childattr' and 'nameattr'
print_tree(custom_root, childattr='children_list', nameattr='custom_name')

view raw JSON →