Base class for undirected graphs.
A Graph stores nodes and edges with optional data, or attributes.
Graphs hold undirected edges. Self loops are allowed but multiple (parallel) edges are not.
Nodes can be arbitrary (hashable) Python objects with optional key/value attributes.
Edges are represented as links between nodes with optional key/value attributes.
Parameters :  data : input graph
attr : keyword arguments, optional (default= no attributes)


See also
Examples
Create an empty graph structure (a “null graph”) with no nodes and no edges.
>>> G = nx.Graph()
G can be grown in several ways.
Nodes:
Add one node at a time:
>>> G.add_node(1)
Add the nodes from any container (a list, dict, set or even the lines from a file or the nodes from another graph).
>>> G.add_nodes_from([2,3])
>>> G.add_nodes_from(range(100,110))
>>> H=nx.Graph()
>>> H.add_path([0,1,2,3,4,5,6,7,8,9])
>>> G.add_nodes_from(H)
In addition to strings and integers any hashable Python object (except None) can represent a node, e.g. a customized node object, or even another Graph.
>>> G.add_node(H)
Edges:
G can also be grown by adding edges.
Add one edge,
>>> G.add_edge(1, 2)
a list of edges,
>>> G.add_edges_from([(1,2),(1,3)])
or a collection of edges,
>>> G.add_edges_from(H.edges())
If some edges connect nodes not yet in the graph, the nodes are added automatically. There are no errors when adding nodes or edges that already exist.
Attributes:
Each graph, node, and edge can hold key/value attribute pairs in an associated attribute dictionary (the keys must be hashable). By default these are empty, but can be added or changed using add_edge, add_node or direct manipulation of the attribute dictionaries named graph, node and edge respectively.
>>> G = nx.Graph(day="Friday")
>>> G.graph
{'day': 'Friday'}
Add node attributes using add_node(), add_nodes_from() or G.node
>>> G.add_node(1, time='5pm')
>>> G.add_nodes_from([3], time='2pm')
>>> G.node[1]
{'time': '5pm'}
>>> G.node[1]['room'] = 714
>>> del G.node[1]['room'] # remove attribute
>>> G.nodes(data=True)
[(1, {'time': '5pm'}), (3, {'time': '2pm'})]
Warning: adding a node to G.node does not add it to the graph.
Add edge attributes using add_edge(), add_edges_from(), subscript notation, or G.edge.
>>> G.add_edge(1, 2, weight=4.7 )
>>> G.add_edges_from([(3,4),(4,5)], color='red')
>>> G.add_edges_from([(1,2,{'color':'blue'}), (2,3,{'weight':8})])
>>> G[1][2]['weight'] = 4.7
>>> G.edge[1][2]['weight'] = 4
Shortcuts:
Many common graph features allow python syntax to speed reporting.
>>> 1 in G # check if node in graph
True
>>> [n for n in G if n<3] # iterate through nodes
[1, 2]
>>> len(G) # number of nodes in graph
5
The fastest way to traverse all edges of a graph is via adjacency_iter(), but the edges() method is often more convenient.
>>> for n,nbrsdict in G.adjacency_iter():
... for nbr,eattr in nbrsdict.items():
... if 'weight' in eattr:
... (n,nbr,eattr['weight'])
(1, 2, 4)
(2, 1, 4)
(2, 3, 8)
(3, 2, 8)
>>> [ (u,v,edata['weight']) for u,v,edata in G.edges(data=True) if 'weight' in edata ]
[(1, 2, 4), (2, 3, 8)]
Reporting:
Simple graph information is obtained using methods. Iterator versions of many reporting methods exist for efficiency. Methods exist for reporting nodes(), edges(), neighbors() and degree() as well as the number of nodes and edges.
For details on these and other miscellaneous methods, see below.
Graph.__init__([data])  Initialize a graph with edges, name, graph attributes. 
Graph.add_node(n[, attr_dict])  Add a single node n and update node attributes. 
Graph.add_nodes_from(nodes, **attr)  Add multiple nodes. 
Graph.remove_node(n)  Remove node n. 
Graph.remove_nodes_from(nodes)  Remove multiple nodes. 
Graph.add_edge(u, v[, attr_dict])  Add an edge between u and v. 
Graph.add_edges_from(ebunch[, attr_dict])  Add all the edges in ebunch. 
Graph.add_weighted_edges_from(ebunch[, weight])  Add all the edges in ebunch as weighted edges with specified weights. 
Graph.remove_edge(u, v)  Remove the edge between u and v. 
Graph.remove_edges_from(ebunch)  Remove all edges specified in ebunch. 
Graph.add_star(nodes, **attr)  Add a star. 
Graph.add_path(nodes, **attr)  Add a path. 
Graph.add_cycle(nodes, **attr)  Add a cycle. 
Graph.clear()  Remove all nodes and edges from the graph. 
Graph.nodes([data])  Return a list of the nodes in the graph. 
Graph.nodes_iter([data])  Return an iterator over the nodes. 
Graph.__iter__()  Iterate over the nodes. 
Graph.edges([nbunch, data])  Return a list of edges. 
Graph.edges_iter([nbunch, data])  Return an iterator over the edges. 
Graph.get_edge_data(u, v[, default])  Return the attribute dictionary associated with edge (u,v). 
Graph.neighbors(n)  Return a list of the nodes connected to the node n. 
Graph.neighbors_iter(n)  Return an iterator over all neighbors of node n. 
Graph.__getitem__(n)  Return a dict of neighbors of node n. 
Graph.adjacency_list()  Return an adjacency list representation of the graph. 
Graph.adjacency_iter()  Return an iterator of (node, adjacency dict) tuples for all nodes. 
Graph.nbunch_iter([nbunch])  Return an iterator of nodes contained in nbunch that are also in the graph. 
Graph.has_node(n)  Return True if the graph contains the node n. 
Graph.__contains__(n)  Return True if n is a node, False otherwise. Use the expression 
Graph.has_edge(u, v)  Return True if the edge (u,v) is in the graph. 
Graph.order()  Return the number of nodes in the graph. 
Graph.number_of_nodes()  Return the number of nodes in the graph. 
Graph.__len__()  Return the number of nodes. 
Graph.degree([nbunch, weight])  Return the degree of a node or nodes. 
Graph.degree_iter([nbunch, weight])  Return an iterator for (node, degree). 
Graph.size([weight])  Return the number of edges. 
Graph.number_of_edges([u, v])  Return the number of edges between two nodes. 
Graph.nodes_with_selfloops()  Return a list of nodes with self loops. 
Graph.selfloop_edges([data])  Return a list of selfloop edges. 
Graph.number_of_selfloops()  Return the number of selfloop edges. 
Graph.copy()  Return a copy of the graph. 
Graph.to_undirected()  Return an undirected copy of the graph. 
Graph.to_directed()  Return a directed representation of the graph. 
Graph.subgraph(nbunch)  Return the subgraph induced on nodes in nbunch. 