How To Draw Tree In Python

Set Up Tree with igraph¶

Install igraph with pip install python-igraph.

In [1]:

                                    !pip install python-igraph

Requirement already satisfied: python-igraph in /home/circleci/project/doc/venv/lib/python3.7/site-packages (0.9.8) Requirement already satisfied: igraph==0.9.8 in /home/circleci/project/doc/venv/lib/python3.7/site-packages (from python-igraph) (0.9.8) Requirement already satisfied: texttable>=1.6.2 in /home/circleci/project/doc/venv/lib/python3.7/site-packages (from igraph==0.9.8->python-igraph) (1.6.4)

In [2]:

                                import                igraph                from                igraph                import                Graph                ,                EdgeSeq                nr_vertices                =                25                v_label                =                list                (                map                (                str                ,                range                (                nr_vertices                )))                G                =                Graph                .                Tree                (                nr_vertices                ,                2                )                # 2 stands for children number                lay                =                G                .                layout                (                'rt'                )                position                =                {                k                :                lay                [                k                ]                for                k                in                range                (                nr_vertices                )}                Y                =                [                lay                [                k                ][                1                ]                for                k                in                range                (                nr_vertices                )]                M                =                max                (                Y                )                es                =                EdgeSeq                (                G                )                # sequence of edges                E                =                [                e                .                tuple                for                e                in                G                .                es                ]                # list of edges                L                =                len                (                position                )                Xn                =                [                position                [                k                ][                0                ]                for                k                in                range                (                L                )]                Yn                =                [                2                *                M                -                position                [                k                ][                1                ]                for                k                in                range                (                L                )]                Xe                =                []                Ye                =                []                for                edge                in                E                :                Xe                +=                [                position                [                edge                [                0                ]][                0                ],                position                [                edge                [                1                ]][                0                ],                None                ]                Ye                +=                [                2                *                M                -                position                [                edge                [                0                ]][                1                ],                2                *                M                -                position                [                edge                [                1                ]][                1                ],                None                ]                labels                =                v_label

Create Plotly Traces¶

In [3]:

                                import                plotly.graph_objects                as                go                fig                =                go                .                Figure                ()                fig                .                add_trace                (                go                .                Scatter                (                x                =                Xe                ,                y                =                Ye                ,                mode                =                'lines'                ,                line                =                dict                (                color                =                'rgb(210,210,210)'                ,                width                =                1                ),                hoverinfo                =                'none'                ))                fig                .                add_trace                (                go                .                Scatter                (                x                =                Xn                ,                y                =                Yn                ,                mode                =                'markers'                ,                name                =                'bla'                ,                marker                =                dict                (                symbol                =                'circle-dot'                ,                size                =                18                ,                color                =                '#6175c1'                ,                #'#DB4551',                line                =                dict                (                color                =                'rgb(50,50,50)'                ,                width                =                1                )                ),                text                =                labels                ,                hoverinfo                =                'text'                ,                opacity                =                0.8                ))

Create Text Inside the Circle via Annotations¶

In [4]:

                                def                make_annotations                (                pos                ,                text                ,                font_size                =                10                ,                font_color                =                'rgb(250,250,250)'                ):                L                =                len                (                pos                )                if                len                (                text                )                !=                L                :                raise                ValueError                (                'The lists pos and text must have the same len'                )                annotations                =                []                for                k                in                range                (                L                ):                annotations                .                append                (                dict                (                text                =                labels                [                k                ],                # or replace labels with a different list for the text within the circle                x                =                pos                [                k                ][                0                ],                y                =                2                *                M                -                position                [                k                ][                1                ],                xref                =                'x1'                ,                yref                =                'y1'                ,                font                =                dict                (                color                =                font_color                ,                size                =                font_size                ),                showarrow                =                False                )                )                return                annotations

Add Axis Specifications and Create the Layout¶

In [5]:

                                axis                =                dict                (                showline                =                False                ,                # hide axis line, grid, ticklabels and  title                zeroline                =                False                ,                showgrid                =                False                ,                showticklabels                =                False                ,                )                fig                .                update_layout                (                title                =                'Tree with Reingold-Tilford Layout'                ,                annotations                =                make_annotations                (                position                ,                v_label                ),                font_size                =                12                ,                showlegend                =                False                ,                xaxis                =                axis                ,                yaxis                =                axis                ,                margin                =                dict                (                l                =                40                ,                r                =                40                ,                b                =                85                ,                t                =                100                ),                hovermode                =                'closest'                ,                plot_bgcolor                =                'rgb(248,248,248)'                )                fig                .                show                ()

What About Dash?¶

Dash is an open-source framework for building analytical applications, with no Javascript required, and it is tightly integrated with the Plotly graphing library.

Learn about how to install Dash at https://dash.plot.ly/installation.

Everywhere in this page that you see fig.show(), you can display the same figure in a Dash application by passing it to the figure argument of the Graph component from the built-in dash_core_components package like this:

                                import                plotly.graph_objects                as                go                # or plotly.express as px                fig                =                go                .                Figure                ()                # or any Plotly Express function e.g. px.bar(...)                # fig.add_trace( ... )                # fig.update_layout( ... )                import                dash                import                dash_core_components                as                dcc                import                dash_html_components                as                html                app                =                dash                .                Dash                ()                app                .                layout                =                html                .                Div                ([                dcc                .                Graph                (                figure                =                fig                )                ])                app                .                run_server                (                debug                =                True                ,                use_reloader                =                False                )                # Turn off reloader if inside Jupyter