NetworkX

https://networkx.org/documentation/stable/
Admin
NetworkX is a Python package for creating, manipulating, and studying complex networks, providing...
Tokens:2,701,481
Snippets:15,484
Trust Score:9.6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install extra and example dependencies

Source: https://networkx.org/documentation/stable/developer/contribute.html

Install additional dependencies required for building the example gallery.

```bash
pip install -r requirements/extra.txt
pip install -r requirements/example.txt

```

--------------------------------

### Setup nodes and edges for edge_dfs examples

Source: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.traversal.edgedfs.edge_dfs.html

Defines the nodes and edges used in the subsequent edge_dfs examples.

```python
>>> from pprint import pprint
>>> nodes = [0, 1, 2, 3]
>>> edges = [(0, 1), (1, 0), (1, 0), (2, 1), (3, 1)]
```

--------------------------------

### Setup nodes and edges for edge_bfs examples

Source: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.traversal.edgebfs.edge_bfs.html

Defines the nodes and edges used in the subsequent edge_bfs examples.

```python
>>> from pprint import pprint
>>> nodes = [0, 1, 2, 3]
>>> edges = [(0, 1), (1, 0), (1, 0), (2, 0), (2, 1), (3, 1)]
```

--------------------------------

### Setup: create graph and set capacities

Source: https://networkx.org/documentation/stable/release/api_1.9.html

Sets up an icosahedral graph with unit edge capacities, used as the common input for the flow examples that follow.

```python
>>> import networkx as nx
>>> G = nx.icosahedral_graph()
>>> nx.set_edge_attributes(G, 'capacity', 1)

```

--------------------------------

### Create a new branch for the example

Source: https://networkx.org/documentation/stable/developer/new_contributor_faq.html

Use this command to create a new branch named 'complete-graph-circular-layout-example' before starting work on the example. A descriptive branch name helps remember the purpose of the work.

```bash
git checkout -b complete-graph-circular-layout-example

```

--------------------------------

### BFS order example using nx.bfs_edges

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/traversal/breadth_first_search.html

Shows how to get nodes in breadth-first search order using nx.bfs_edges on a path graph. The example creates a path graph with 3 nodes, starts BFS from node 2, and collects the nodes in BFS order.

```python
>>> G = nx.path_graph(3)
>>> root = 2
>>> edges = nx.bfs_edges(G, root)
>>> nodes = [root] + [v for u, v in edges]
>>> nodes
[2, 1, 0]
```

--------------------------------

### nodes_with_selfloops example

Source: https://networkx.org/documentation/stable/_modules/networkx/classes/function.html

Example for the nodes_with_selfloops function, showing how to get a list of nodes that have self-loops. The example creates a graph with a self-loop on node 1 and returns [1].

```python
>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_edge(1, 1)
>>> G.add_edge(1, 2)
>>> list(nx.nodes_with_selfloops(G))
[1]
```

--------------------------------

### Create Config instance with keyword arguments

Source: https://networkx.org/documentation/stable/reference/configs.html

Shows the alternative way to create a configuration by passing initial values as keyword arguments to the Config constructor.

```python
>>> cfg1 = Config(eggs=1, spam=5)
>>> cfg1
Config(eggs=1, spam=5)
```

--------------------------------

### MultiGraph initialization examples

Source: https://networkx.org/documentation/stable/_modules/networkx/classes/multigraph.html

Demonstrates creating MultiGraph instances with no data, a name, a list of edges, and arbitrary graph attributes. Shows that graph attributes are stored in the graph attribute dictionary.

```python
>>> G = nx.MultiGraph()
>>> G = nx.MultiGraph(name="my graph")
>>> e = [(1, 2), (1, 2), (2, 3), (3, 4)]  # list of edges
>>> G = nx.MultiGraph(e)
```

```python
>>> G = nx.MultiGraph(e, day="Friday")
>>> G.graph
{'day': 'Friday'}
```

--------------------------------

### bfs_edges examples with path_graph

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/traversal/breadth_first_search.html

These examples show how to use nx.bfs_edges to get edges in a breadth-first search, including with a depth limit.

```python
>>> G = nx.path_graph(3)
>>> list(nx.bfs_edges(G, 0))
[(0, 1), (1, 2)]
>>> list(nx.bfs_edges(G, source=0, depth_limit=1))
[(0, 1)]
```

--------------------------------

### nodes view examples: listing nodes

Source: https://networkx.org/documentation/stable/_modules/networkx/classes/graph.html

Doctest examples showing two equivalent ways to get a list of all nodes: using G.nodes and iterating over the graph directly.

```python
>>> G = nx.path_graph(3)
>>> list(G.nodes)
[0, 1, 2]
>>> list(G)
[0, 1, 2]
```

--------------------------------

### Install documentation dependencies

Source: https://networkx.org/documentation/stable/developer/contribute.html

Install the Python packages needed to build the documentation from the root directory.

```bash
pip install -r requirements/doc.txt

```

--------------------------------

### Create example directed graph with supported and unsupported nodes

Source: https://networkx.org/documentation/stable/_downloads/538f38325dbb659c6ead9fd27aaef906/plot_subgraphs.ipynb

Creates the example directed graph G_ex with an input node 'In' (blue), output node 'Out' (magenta), four supported nodes (green), and two unsupported nodes (red), connected by eight edges. This graph is used to demonstrate the partitioning function.

```python
G_ex = nx.DiGraph()
G_ex.add_nodes_from(["In"], node_type="input", node_color="b")
G_ex.add_nodes_from(["A", "C", "E", "F"], node_type="supported", node_color="g")
G_ex.add_nodes_from(["B", "D"], node_type="unsupported", node_color="r")
G_ex.add_nodes_from(["Out"], node_type="output", node_color="m")
G_ex.add_edges_from(
    [
        ("In", "A"),
        ("A", "B"),
        ("B", "C"),
        ("B", "D"),
        ("D", "E"),
        ("C", "F"),
        ("E", "F"),
        ("F", "Out"),
    ]
)
```

--------------------------------

### Example: bipartite.degrees on a complete bipartite graph

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/bipartite/basic.html

Shows how to get the degrees of the two bipartite sets using nx.bipartite.degrees. The example prints the degree dictionary for the top set.

```python
>>> G = nx.complete_bipartite_graph(3, 2)
>>> degX, degY = nx.bipartite.degrees(G, nodes={3, 4})
>>> dict(degX)
{0: 2, 1: 2, 2: 2}
```

--------------------------------

### k_crust example: havel_hakimi_graph and k_crust

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/core.html

Shows how to create a graph with a given degree sequence and compute its k-crust. The example uses nx.havel_hakimi_graph and nx.k_crust with k=1, displaying the degree view and the resulting crust nodes.

```python
>>> degrees = [0, 1, 2, 2, 2, 2, 3]
>>> H = nx.havel_hakimi_graph(degrees)
>>> H.degree
DegreeView({0: 1, 1: 2, 2: 2, 3: 2, 4: 2, 5: 3, 6: 0})
>>> nx.k_crust(H, k=1).nodes
NodeView((0, 4, 6))
```

--------------------------------

### Get first k tuples of communities with itertools.islice

Source: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.community.centrality.girvan_newman.html

Uses itertools.islice to get only the first k tuples of communities from the girvan_newman iterator. The example prints each tuple of sorted communities.

```python
>>> import itertools
>>> G = nx.path_graph(8)
>>> k = 2
>>> comp = nx.community.girvan_newman(G)
>>> for communities in itertools.islice(comp, k):
...     print(tuple(sorted(c) for c in communities))
...
([0, 1, 2, 3], [4, 5, 6, 7])
([0, 1], [2, 3], [4, 5, 6, 7])
```

--------------------------------

### k_core example: havel_hakimi_graph and k_core

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/core.html

Shows how to create a graph with a given degree sequence and compute its k-core. The example uses nx.havel_hakimi_graph and nx.k_core, displaying the degree view and the resulting core nodes.

```python
>>> degrees = [0, 1, 2, 2, 2, 2, 3]
>>> H = nx.havel_hakimi_graph(degrees)
>>> H.degree
DegreeView({0: 1, 1: 2, 2: 2, 3: 2, 4: 2, 5: 3, 6: 0})
>>> nx.k_core(H).nodes
NodeView((1, 2, 3, 5))
```

--------------------------------

### Example: Multigraph with parallel_edges=True (incomplete)

Source: https://networkx.org/documentation/stable/_modules/networkx/convert_matrix.html

This example is incomplete in the source; it shows the setup for treating integer entries as the number of parallel edges, but the code and output are truncated. It is included as displayed.

```python
>>> A = np.array([[1, 1], [1, 2]])
>>> G = nx.from_numpy_array(A, create_using=nx.MultiGraph, parallel_edges=True)
>>> G[1][1]
```

--------------------------------

### Example: blockmodeling with partition as dict of block sets

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/minors/contraction.html

Same blockmodeling example but using a dictionary where keys are block labels and values are sets of nodes. Produces the same quotient graph edges.

```python
>>> G = nx.path_graph(6)
>>> partition = {0: {0, 1}, 2: {2, 3}, 4: {4, 5}}
>>> M = nx.quotient_graph(G, partition, relabel=True)
>>> list(M.edges())
[(0, 1), (1, 2)]
```

--------------------------------

### Example: Using k_edge_components with k=3

Source: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.connectivity.edge_kcomponents.k_edge_components.html

This example creates a graph from paths and finds k-edge-connected components with k=3. It demonstrates that the result includes {1, 4} as a component, unlike k_edge_subgraphs.

```python
>>> import itertools as it
>>> from networkx.utils import pairwise
>>> paths = [
...     (1, 2, 4, 3, 1, 4),
...     (5, 6, 7, 8, 5, 7, 8, 6),
... ]
>>> G = nx.Graph()
>>> G.add_nodes_from(it.chain(*paths))
>>> G.add_edges_from(it.chain(*[pairwise(path) for path in paths]))
>>> # note this returns {1, 4} unlike k_edge_subgraphs
>>> sorted(map(sorted, nx.k_edge_components(G, k=3)))
[[1, 4], [2], [3], [5, 6, 7, 8]]
```

--------------------------------

### all_triangles function with example

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/cluster.html

Public function that yields all unique triangles in an undirected graph. The example shows creating a complete graph with 4 nodes and sorting the triangles to get a list of node triples.

```python
@not_implemented_for("directed")
@nx._dispatchable
def all_triangles(G, nbunch=None):
    """
    Yields all unique triangles in an undirected graph.

    A triangle is a set of three distinct nodes where each node is connected to
    the other two.

    Parameters
    ----------
    G : NetworkX graph
        An undirected graph.

    nbunch : node, iterable of nodes, or None (default=None)
        If a node or iterable of nodes, only triangles involving at least one
        node in `nbunch` are yielded.
        If ``None``, yields all unique triangles in the graph.

    Yields
    ------
    tuple
        A tuple of three nodes forming a triangle ``(u, v, w)``.

    Examples
    --------
    >>> G = nx.complete_graph(4)
    >>> sorted([sorted(t) for t in all_triangles(G)])
    [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]]
```

--------------------------------

### Set up development environment with venv

Source: https://networkx.org/documentation/stable/developer/contribute.html

Creates a virtual environment, installs dependencies, and installs NetworkX in editable mode. Includes optional pygraphviz and pydot installation.

```bash
# Create a virtualenv named ``networkx-dev`` that lives in the directory of
# the same name
python -m venv networkx-dev
# Activate it
source networkx-dev/bin/activate
# Install main development and runtime dependencies of networkx
pip install -r requirements/default.txt -r requirements/test.txt -r requirements/developer.txt
#
# (Optional) Install pygraphviz and pydot packages
# These packages require that you have your system properly configured
# and what that involves differs on various systems.
# pip install -r requirements/extra.txt
#
# Build and install networkx from source
pip install -e .
# Test your installation
pytest --pyargs networkx

```

--------------------------------

### topological_sort example with reversed order

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/dag.html

Shows how to get the reverse order of a topological sort using the built-in reversed() function on the generator. The example uses a simple chain graph and prints [3, 2, 1].

```python
>>> DG = nx.DiGraph([(1, 2), (2, 3)])
>>> list(reversed(list(nx.topological_sort(DG))))
[3, 2, 1]
```

--------------------------------

### Example: blockmodeling with partition as list of sets

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/minors/contraction.html

Creates a quotient graph from a path graph using a partition given as a list of sets. The resulting graph has edges between consecutive blocks.

```python
>>> G = nx.path_graph(6)
>>> partition = [{0, 1}, {2, 3}, {4, 5}]
>>> M = nx.quotient_graph(G, partition, relabel=True)
>>> list(M.edges())
[(0, 1), (1, 2)]
```

--------------------------------

### Example: Finding the largest biconnected component with max

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/components/biconnected.html

Demonstrates how to use max to get the largest biconnected component more efficiently than sorting. The example uses max with key=len to find the largest component and then checks its length.

```python
>>> Gc = max(nx.biconnected_components(G), key=len)
>>> len(Gc)
5
```

--------------------------------

### Creating a graph and edge tuple for add_edge example

Source: https://networkx.org/documentation/stable/release/api_0.99.html

Sets up a graph and an edge tuple to demonstrate the new add_edge syntax. The tuple must be unpacked when calling add_edge.

```python
>>> import networkx as nx
>>> u='a'
>>> v='b'
>>> e=(u,v)
>>> G=nx.Graph()

```

--------------------------------

### Get list of isolates with nx.isolates

Source: https://networkx.org/documentation/stable/_modules/networkx/algorithms/isolate.html

Demonstrates how to get a list of all isolates in a graph using the list constructor and nx.isolates. The example creates a graph with an edge (1,2) and an isolated node 3, and shows that the list of isolates is [3].

```python
G = nx.Graph()
G.add_edge(1, 2)
G.add_node(3)
list(nx.isolates(G))
[3]
```

--------------------------------

### Example: Access neighbors with G[0]

Source: https://networkx.org/documentation/stable/reference/classes/generated/networkx.DiGraph.__getitem__.html

Shows how to use G[n] to get the adjacency dictionary for a node. The example creates a path graph with nx.path_graph(4) and accesses node 0, returning AtlasView({1: {}}).

```python
>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G[0]
AtlasView({1: {}})
```

--------------------------------

### Build HTML documentation without figures

Source: https://networkx.org/documentation/stable/developer/contribute.html

Build the HTML documentation without generating figures when extra and example dependencies are not installed.

```bash
make html-noplot

```
Tokens:
Raw