============================
**NetworkX Quick Reference**
============================

*(last modified: 17 June 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 networkx.Graph.add_node 

or

::

  pydoc networkx.Graph 

to report all Graph methods. 

For multi-class functions such
as subgraph or watts_strogatz_graph, 

::

  use pydoc networkx.subgraph 

or 

::

   pydoc networkx.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 directed graph G.
  G=XGraph()     - create empty graph G with edge data.
  G=XDiGraph()   - create empty directed graph G with edge data.
  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)

Directed Graphs Only
--------------------
::

  G.in_degree()         - like degree but only inward edges count
  G.out_degree()        - like degree but only outward edges count
  G.predecessors()      - like neighbors but only inward edges count
  G.successors()        - like neighbors but only outward edges count
  G.predecessors_iter() - like neighbors_iter but only inward edges count
  G.successors_iter()   - like neighbors_iter but only outward edges count
                                                                                        

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.
  density(G)         - fraction of possible edges which exist.

  nodes(G)     - return copy of all nodes of G in a list.
  nodes_iter(G) - return iterator over all nodes in G.
  edges(G)     - return list of all edges in G.
  edges_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_directed(G)                 - True if G is a directed graph.
  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.
  
  adj_matrix(G)                  - adjacency matrix for G as a Numeric array.
  laplacian(G)                   - Graph Laplacian for G as a Numeric array.
  generalized_laplacian(G)       - generalized graph Laplacian for G as a Numeric array.

  is_directed_acyclic_graph(G)   - True if DAG
  topological_sort(G)            - list of nodes in directed graph such that every edge goes from left to right.

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.
  betweenness_centrality(G,n)   - fraction of shortest paths that go through n.
  degree_centrality(G,n)        - frction of possible nodes connected to n.
  closeness_centrality(G,n)     - 1/(average distance to all nodes from 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.
  dijkstra(G,u)                 - dicts for shortest weighted paths and path length from u.
  dijkstra_shortest_path(G,u)   - dict of paths from u keyed by target node.
  dijkstra_path_length(G,u)     - dict of path lengths from u keyed by target node.


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)
   pareto_sequence(n,exponent=1.0)    - return a sequence with pareto distribution of length n.
   powerlaw_sequence(n,exponent=2.0)  - return a sequence with powerlaw distribution of length n.
   uniform_sequence(n)                - return a sequence with uniform distribution of length n.
   discrete_sequence(n,distribution)  - return a sequence with distribution matching given distribution.

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)


.. _html documentation: Reference/index.html

