NetworkX Quick Reference

(last modified: 31 March 2005)

More detailed documentation and listing of options and defaults can be found in the html documentation or by using pydoc (or interactive help) on a function, method or class. For example, for methods of the graph class such as add_node, use

pydoc NX.Graph.add_node 

or

pydoc NX.Graph 

to report all Graph methods.

For multi-class functions such as subgraph or watts_strogatz_graph,

use pydoc NX.subgraph 

or

pydoc NX.watts_strogatz_graph

Terminology

Graph or network structure is encoded in the edges (connections, links, ties, arcs, bonds) between nodes (vertices, sites, actors).

nlist     - a list of nodes.
nbunch    - a bunch of nodes: 
            any iterable container of nodes.
e=(u,v)   - an edge as a python tuple (also written u-v or u->v).
elist     - a list of edges [(v1,w1),(v2,w2),..,(vk,wk)]
ebunch    - a bunch of edges (as 2-tuples):
            any iterable container of edge-tuples (v1,w1),(v2,w2),...

Creation

G=Graph()      - create empty simple graph G.
G=DiGraph()    - create empty simple digraph G.
G=empty_graph(n) - create empty graph with n nodes.
G=empty_graph(n,create_using=DiGraph()) - create empty digraph with  n nodes.
G=create_empty_copy(H) - create new, empty graph of same class as H.

Manipulation

Methods associated with a graph-like object G:

G.add_node(n)                - add single node to G.
G.add_nodes_from(nbunch)     - add each node in nbunch to G.
G.delete_node(n)             - delete node n from G.
G.delete_nodes_from(nbunch)  - delete each node n in nbunch.
G.add_edge(u,v)              - add edge (u,v) to G.
                               if G is a digraph, add directed edge u->v.
G.add_edge(e)                - add edge e=(u,v) *(equivalent to above)*
G.add_edges_from(ebunch)     - add each edge e in ebunch to G.
G.delete_edge(u,v)           - delete edge (u,v)
G.delete_edge(e)             - delete edge e=(u,v)
G.delete_edges_from(ebunch)  - delete each edge in ebunch from G.

G.add_path(nlist)            - add nodes and edges to make ordered path.
G.add_cycle(nlist)           - same as add_path, but end nodes are
                               connected.
G.clear()                    - delete all nodes and edges.
G.copy()                     - return "shallow" copy of the graph 
                               (like dict.copy())
G.subgraph(nbunch)           - return subgraph induced by nodes in nbunch.

New graphs from old

subgraph(G, nbunch)                - subgraph induced by nodes in nbunch.
union(G1,G2)                       - graph union.
disjoint_union(G1,G2)              - graph union, assuming all nodes are different.
cartesian_product(G1,G2)           - Cartesian product graph.
compose(G1,G2)                     - combine graphs, identifying nodes with same names.
complement(G)                      - return graph complement. 
create_empty_copy(G)               - empty copy of the same graph class.
convert_to_undirected(G)           - return an undirected copy of G.
convert_to_directed(G)             - return a directed copy of G.
convert_node_labels_to_integers(G) - return copy with nodes relabed as integers. 

Graph Properties

Methods:

G.order()            - number of nodes in G.
G.size()             - number of edges in G.

G.nodes()            - return copy of all nodes of G in a list.
G.nodes_iter()       - return iterator over all nodes in G. 
G.has_node(n)        - True if n is a node in G.
n in G               - equivalent to G.has_node(n)
G.edges()            - return list of all edges in G.
G.edges(nbunch)      - return list of edges adjacent to some node in nbunch.
G.edges_iter()       - return iterator over all edges in G.
G.edges_iter(nbunch) - return iterator that iterate once over
                       each edge adjacent to some node in nbunch. 
G.has_edge(u,v)      - True if (u,v) is an edge in G.

G.neighbors(n)       - return list of nodes connected to node n.
G[n]                 - equivalent to G.neighbors(n)
G.neighbors_iter(n)  - return iterator over the neighbors of node n.
G.has_neighbor(v,u)  - check if u is a neighbor of v (returns True or False).

G.degree(n)                - return degree of node n
G.degree()                 - return list of degrees of all nodes in G.
G.degree(with_labels=True) - return dict mapping each node in G to
                             its degree.
G.degree(nbunch)           - return list of degrees of all nodes in nbunch.
G.degree(nbunch,with_labels=True) - return dict mapping each n in nbunch to degree(n)

Functions

number_of_nodes(G) - number of nodes in G.
order(G)           - equivalent to above.
number_of_edges(G) - number of edges in G.
size(G)            - equivalent to above.

nodes(G)     - return copy of all nodes of G in a list.
node_iter(G) - return iterator over all nodes in G.
edges(G)     - return list of all edges in G.
edge_iter(G) - return iterator over all edges in G.

diameter(G)  - return maximum of all-pairs shortest path.
periphery(G) - return list of nodes with eccentricity equal to diameter.
radius(G)    - return minimum of all-pairs shortest path.
center(G)    - return list of nodes with eccentricity equal to radius.

is_connected(G)                - True if G is a connected graph.
number_connected_components(G) - number of connected components in G.
connected_components(G)        - list of lists of nodes in each component of G.
average_clustering(G)          - clustering coefficient averaged over nodes of G.
transitivity(G)                - fraction of transitive triples that are triangles.
communities(G)                 - list of lists storing binary-tree community dendrogram.
kl_connected_subgraph(G)       - subgraph of G that is kl-connected.
is_kl_connected(G)             - True if G is kl-connected.

amatrix(G)                     - adjacency matrix for G as a Numeric array.
laplacian(G)                   - Graph Laplacian for G as a Numeric array.
fan_chung_laplacian(G)         - Fan Chung generalized graph Laplacian for G as a Numeric array.

Nodal Properties

If n is unspecified, then report properties of all nodes in graph.

neighbors(G,n)                  - neighbors of n in G.
degree(G,n)                     - number of edges for n in G.
eccentricity(G,n)               - maximum of shortest-path lengths from n to anywhere in G. 
triangles(G,n)                  - number of triangles which include n. 
clustering(G,n)                 - clustering coefficient: ratio of triangles to potential.
node_betweenness(G,n)           - number of shortest paths through n.
shortest_path(G,u,v)            - list denoting the shortest path from u to v.
shortest_path_length(G,u,v)     - length of the shortest path from u to v.
node_connected_component(G,n)   - list of nodes in node n's connected component.

Generating Graphs

Variable size graphs

make_small_graph(graph_description,create_using=None,**kwds)
LCF_graph(n,shift_list,repeats)  

balanced_tree(r,h)
barbell_graph(m1,m2)
complete_graph(n)
complete_bipartite_graph(n1,n2)
circular_ladder_graph(n)
cycle_graph(n)
empty_graph(n,create_using=None,**kwds)
grid_graph([m1,m2,...,mk])  
grid_2d_graph(m,n)
hypercube_graph(n)
ladder_graph(n)
lollipop_graph(m,n)
null_graph(create_using=None,**kwds)
path_graph(n)
periodic_grid_2d_graph(m,n)
star_graph(n)
wheel_graph(n)

Small, named graphs of fixed size

bull_graph(), chvatal_graph(), cubical_graph(), desargues_graph(),
diamond_graph(), dodecahedral_graph(), frucht_graph(),
heawood_graph(), house_graph(), house_x_graph(),
icosahedral_graph(), krackhardt_kite_graph(),
moebius_kantor_graph(), octahedral_graph(), pappus_graph(),
petersen_graph(), sedgewick_maze_graph(), tetrahedral_graph(), trivial_graph()
truncated_cube_graph(), truncated_tetrahedron_graph(), tutte_graph()

Random graphs

barabasi_albert_graph(n,m,seed=None)
binomial_graph(n,p,seed=None) 
erdos_renyi_graph(n,m,seed=None)
powerlaw_cluster_graph(n,m,p,seed=None)
random_regular_graph(d,n,seed=None)
random_lobster(n,p1,p2,seed=None)
watts_strogatz_graph(n,k,p,seed=None)

Graphs from degree sequences

configuration_model(deg_sequence,seed=None)
havel_hakimi_graph(deg_sequence,seed=None)
is_valid_degree_sequence(deg_sequence)
create_degree_sequence(n, sfunction=None, max_tries=50, **kwds)

IO:

read_adjlist(path=False, create_using=False)
write_adjlist(G,path=False)
read_edgelist(path=False, create_using=False)
write_edgelist(G,path=False)
read_multiline_adjlist(path=False, create_using=False)
write_multiline_adjlist(G,path=False)
read_gpickle(path=False)
write_gpickle(G,path=False)