1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
============================
**NetworkX Quick Reference**
============================
**NetworkX Quick Reference**
============================
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 functions associated with multiple graph classes, 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) - a Graph or DiGraph edge as a Python tuple (also written u-v or u->v).
e=(u,v,x) - an XGraph or XGraph edge as a Python tuple, x is an arbitrary object.
elist - a list of edges.
ebunch - a bunch of edges:
any iterable container of edge-tuples.
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.out_edges() - like edges, but only outward pointing edges.
G.in_edges() - like edges, but only inward pointing edges.
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.
G[n] - same as above.
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, p, seed=None)
gnm_random_graph(n, m, seed=None)
gnp_random_graph(n, p, 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, comments='#', delimiter=' ', create_using=None, nodetype=None)
write_adjlist(G, path, comments='#', delimiter=' ')
read_edgelist(path, comments="#", delimiter=' ', create_using=None, nodetype=None, edgetype=None)
write_edgelist(G, path, comments="#", delimiter=' ')
read_multiline_adjlist(path, comments='#', delimiter=' ', create_using=None, nodetype=None, edgetype=None )
write_multiline_adjlist(G, path, comments='#', delimiter=' ')
read_gpickle(path)
write_gpickle(G, path)
read_yaml(path)
write_yaml(G, path, default_flow_style=False)
.. _html documentation: https://networkx.lanl.gov/Reference/
|
