Graph | NetworkX 入门教程
安装
最新稳定版NetworkX支持 Python 3.8, 3.9, or 3.10
pip install networkx[default]创建一个图
创建一个没有边（edge）和节点（node）的空图
根据定义，图形是节点（顶点）以及已识别的节点对（称为边，链接等）的集合。在 NetworkX 中，节点可以是任何可哈希(hashable)对象，例如，文本字符串、图像、XML对象、另一个图、自定义节点对象等。
python 中的 None不能作为节点。
import networkx as nx
G = nx.Graph()节点
图可以以多种形式扩张。NetworkX包括许多图生成函数和工具，用于读取和写入多种格式的图。
作为简单开始，可以每次添加一个节点：
G.add_node(1)
或者从可迭代容器(iterable)（如列表）中添加多个节点
G.add_nodes_from([2, 3])
你也可以同时添加包含节点属性的节点，如果你的容器以(node, node_attribute_dict)2元-元组的形式
G.add_nodes_from([
(4, {"color": "red"}),
(5, {"color": "green"}),
])
节点的属性此处查看
一个图中的节点可以合并到另一个图
H = nx.path_graph(10)
G.add_nodes_from(H)
现在图G中节点包括原H中的节点。相反，你也可以将整个图H作为图G中的一个节点
G.add_node(H)
现在图G 将图H作为其中一个节点。这种灵活性非常强大，因为它允许图形组成的图形，文件组成的图形，函数组成的图形等等。值得考虑如何构建应用程序，以便节点是有用的实体。当然，如果您愿意，您始终可以在G中使用唯一标识符，并按标识符键记节点信息的单独字典。
如果哈希取决于其内容，则不应更改节点对象。
边
图也可以以添加一条边的形式增长
G.add_edge(1, 2)
e = (2, 3)
G.add_edge(*e) # unpack edge tuple*
通过接入边的列表增长
G.add_edges_from([(1, 2), (1, 3)])
或者通过添加任何边的ebunch。
ebunch 是边的元组的任何可迭代容器。边的元组可以是 2 元组节点，也可以是 3 元组：在 2 个节点后跟边的属性字典，如 (2, 3,{'weight':3.1415})。
边的属性此处查看
G.add_edges_from(H.edges)
添加现有节点或边时没有冲突。 例如，在删除所有节点和边之后，
G.clear()
添加新的节点/边时，NetworkX 悄悄地忽略任何已经存在的。
G.add_edges_from([(1, 2), (1, 3)])
G.add_node(1)
G.add_edge(1, 2)
G.add_node("spam") # adds node "spam"
G.add_nodes_from("spam") # adds 4 nodes: 's', 'p', 'a', 'm'
G.add_edge(3, 'm')
此时，图G 包含 8 个节点和 3 条边
>>> G.number_of_nodes()
8
>>> G.number_of_edges()
3
邻接报告(adjacency reporting)的顺序（例如， G.adj、 G.successors、 G.predecessors）是边添加的顺序。 然而，G.edges 的顺序是邻接的顺序，包括节点的顺序和每个节点的邻接。 请参见下面的示例：
==什么意思==
DG = nx.DiGraph()
DG.add_edge(2, 1) # adds the nodes in order 2, 1
DG.add_edge(1, 3)
DG.add_edge(2, 4)
DG.add_edge(1, 2)
assert list(DG.successors(2)) == [1, 4]
assert list(DG.edges) == [(2, 1), (2, 4), (1, 3), (1, 2)]
检查图的元素
我们可以检查节点和边。 四个基本图形属性便于报告：G.nodes、G.edges、G.adj 和 G.degree。 这些是图中节点、边、邻居（邻接）和节点度数的集合视图。 它们为图形结构提供了一个不断更新的只读视图。 它们也类似于 dict，因为您可以通过视图查找节点和边缘数据属性，并使用方法 .items()、.data() 迭代数据属性。 如果你想要一个特定的容器类型而不是一个视图，你可以指定一个。 这里我们使用列表，尽管集合、字典、元组和其他容器在其他情况下可能会更好。
>>> list(G.nodes)
[1, 2, 3, 'spam', 's', 'p', 'a', 'm']
>>> list(G.edges)
[(1, 2), (1, 3), (3, 'm')]
>>> list(G.adj[1]) # or list(G.neighbors(1))
[2, 3]
>>> G.degree[1] # the number of edges incident to 1
2
可以指定使用 nbunch 报告来自所有节点子集的边缘和度数。 nbunch 是以下任何一种：None（表示所有节点），单个节点或节点的可迭代容器，其本身不是图中的节点。
>>> G.edges([2, 'm'])
EdgeDataView([(2, 1), ('m', 3)])
>>> G.degree([2, 3])
DegreeView({2: 1, 3: 2})
从图中删除元素
可以以添加元素相同的风格山下湖边和节点。使用 Graph.remove_node(), Graph.remove_nodes_from(), Graph.remove_edge() 和 Graph.remove_edges_from(), 等方法
>>> G.remove_node(2)
>>> G.remove_nodes_from("spam")
>>> list(G.nodes)
[1, 3, 'spam']
>>> G.remove_edge(1, 3)
使用图构造函数
图形对象不是只能增量构建 - 指定图形结构的数据可以直接传递给各种图形类的构造函数。 通过实例化其中一个图形类来创建图形结构时，您可以指定多种格式的数据。
>>> G.add_edge(1, 2)
>>> H = nx.DiGraph(G) # create a DiGraph using the connections from G
>>> list(H.edges())
[(1, 2), (2, 1)]
>>> edgelist = [(0, 1), (1, 2), (2, 3)]
>>> H = nx.Graph(edgelist) # create a graph from an edge list
>>> list(H.edges())
[(0, 1), (1, 2), (2, 3)]
>>> adjacency_dict = {0: (1, 2), 1: (0, 2), 2: (0, 1)}
>>> H = nx.Graph(adjacency_dict) # create a Graph dict mapping nodes to nbrs
>>> list(H.edges())
[(0, 1), (0, 2), (1, 2)]什么能用作节点和边
您可能会注意到节点和边未被指定为 NetworkX 对象。 这意味着您可以自由地将有意义的对象用作节点和边。 最常见的选择是数字或字符串，但节点可以是任何可散列对象（None 除外），并且可以使用 G.add_edge(n1, n2, object=x) 将边与任何对象 x 关联。
例如，n1 和 n2 可以是来自 RCSB 蛋白质数据库的蛋白质对象，而 x 可以指的是出版物的 XML 记录，详细说明了它们相互作用的实验观察结果。
我们发现这种能力非常有用，但除非熟悉 Python，否则滥用它会导致令人惊讶的行为。 如果有疑问，请考虑使用 convert_node_labels_to_integers() 来获得更传统的带有整数标签的图。
访问边缘和邻居
除了视图 Graph.edges 和 Graph.adj 之外，还可以使用下标表示法访问边和邻居。
>>> G = nx.Graph([(1, 2, {"color": "yellow"})])
>>> G[1] # same as G.adj[1]
AtlasView({2: {'color': 'yellow'}})
>>> G[1][2]
{'color': 'yellow'}
>>> G.edges[1, 2]
如果边缘已经存在，您可以使用下标表示法获取/设置边缘的属性。
>>> G.add_edge(1, 3)
>>> G[1][3]['color'] = "blue"
>>> G.edges[1, 2]['color'] = "red"
>>> G.edges[1, 2]
{'color': 'red'}使用 G.adjacency() 或 G.adj.items() 可以快速检查所有（节点、邻接）对。 请注意，对于无向图，邻接迭代会看到每条边两次。
FG = nx.Graph()
FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
for n, nbrs in FG.adj.items():
for nbr, eattr in nbrs.items():
wt = eattr['weight']
if wt < 0.5: print(f"({n}, {nbr}, {wt:.3})")
使用edges 属性可以方便地访问所有边缘
for (u, v, wt) in FG.edges.data('weight'):
if wt < 0.5:
print(f"({u}, {v}, {wt:.3})")
向图、节点和边添加属性
诸如权重、标签、颜色或任何您喜欢的 Python 对象之类的属性都可以附加到图形、节点或边上。
每个图、节点和边都可以在关联的属性字典中保存键/值属性对（键必须是可散列的）。 默认情况下，这些是空的，但可以使用 add_edge、add_node 或直接操作名为 G.graph、G.nodes 和 G.edges 的属性字典来添加或更改属性。
图属性
创建新图形时分配图形属性
>>> G = nx.Graph(day="Friday")
>>> G.graph
{'day': 'Friday'}
或者您可以稍后修改属性
>>> G.graph['day'] = "Monday"
>>> G.graph
{'day': 'Monday'}节点属性
使用 add_node(), add_nodes_from(), or G.nodes 添加节点属性
>>> G.add_node(1, time='5pm')
>>> G.add_nodes_from([3], time='2pm')
>>> G.nodes[1]
{'time': '5pm'}
>>> G.nodes[1]['room'] = 714
>>> G.nodes.data()
NodeDataView({1: {'time': '5pm', 'room': 714}, 3: {'time': '2pm'}})
请注意，将节点添加到G.nodes不会将其添加到图中，请使用G.add_node()添加新节点。 对于边缘也是如此。
边属性
使用 add_edge()、add_edges_from() 或下标表示法添加/更改边缘属性。
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.edges[3, 4]['weight'] = 4.2
特殊属性权重( weight)应该是数字，因为它被需要加权边缘的算法使用。
有向图
DiGraph 类提供了特定于有向边的附加方法和属性，例如，DiGraph.out_edges、DiGraph.in_degree、DiGraph.predecessors、DiGraph.successors 等。为了让算法轻松地使用这两个类，有向版本的 neighbors等效于 successors ，而 degree 报告 是 in_degree 和 out_degree 的总和，即使有时可能感觉不一致。
>>> DG = nx.DiGraph()
>>> DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])
>>> DG.out_degree(1, weight='weight')
0.5
>>> DG.degree(1, weight='weight')
1.25
>>> list(DG.successors(1))
[2]
>>> list(DG.neighbors(1))
[2]
一些算法仅适用于有向图，而另一些算法对有向图没有很好的定义。 事实上，将有向图和无向图混为一谈的趋势是危险的。 如果您想将有向图视为无向的某些测量，您可能应该使用 Graph.to_undirected() 或使用
H = nx.Graph(G)
获得无向图版本
多图
NetworkX 提供了允许任意一对节点之间存在多条边的图类。 MultiGraph 和 MultiDiGraph 类允许您添加相同的边两次，可能使用不同的边数据。 这对于某些应用程序来说可能很强大，但许多算法在此类图上没有很好地定义。 在结果定义明确的地方，例如 MultiGraph.degree() 我们提供了函数。 否则，您应该以使测量明确定义的方式转换为标准图表。
>>> MG = nx.MultiGraph()
>>> MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])
>>> dict(MG.degree(weight='weight'))
{1: 1.25, 2: 1.75, 3: 0.5}
>>> GG = nx.Graph()
>>> for n, nbrs in MG.adjacency():
... for nbr, edict in nbrs.items():
... minvalue = min([d['weight'] for d in edict.values()])
... GG.add_edge(n, nbr, weight = minvalue)
>>> nx.shortest_path(GG, 1, 3)
[1, 2, 3]
图生成器和图操作
除了逐节点或逐边构造图之外，它们还可以通过以下方式生成
1. 应用经典的图操作，例如：
| 方法 | 介绍 |
|---|---|
| subgraph(G, nbunch) | Returns the subgraph induced on nodes in nbunch. |
| union(G, H[, rename, name]) | Return the union of graphs G and H. |
| disjoint_union(G, H) | Return the disjoint union of graphs G and H. |
| cartesian_product(G, H) | Returns the Cartesian product of G and H. |
| compose(G, H) | Returns a new graph of G composed with H. |
| complement(G) | Returns the graph complement of G. |
| create_empty_copy(G[, with_data]) | Returns a copy of the graph G with all of the edges removed. |
| to_undirected(graph) | Returns an undirected view of the graph graph. |
| to_directed(graph) | Returns a directed view of the graph graph. |
2. 对经典小图进行调用
| 方法 | 介绍 |
|---|---|
| petersen_graph([create_using]) | Returns the Petersen graph. |
| tutte_graph([create_using]) | Returns the Tutte graph. |
| sedgewick_maze_graph([create_using]) | Return a small maze with a cycle. |
| tetrahedral_graph([create_using]) | Returns the 3-regular Platonic Tetrahedral graph. |
3. 为经典图使用（constructive）生成器
| 方法 | 介绍 |
|---|---|
| complete_graph(n[, create_using]) | Return the complete graph K_n with n nodes. |
| complete_bipartite_graph(n1, n2[, create_using]) | Returns the complete bipartite graph K_{n_1,n_2}. |
| barbell_graph(m1, m2[, create_using]) | Returns the Barbell Graph: two complete graphs connected by a path. |
| lollipop_graph(m, n[, create_using]) | Returns the Lollipop Graph; K_m connected to P_n. |
像这样
K_5 = nx.complete_graph(5)
K_3_5 = nx.complete_bipartite_graph(3, 5)
barbell = nx.barbell_graph(10, 10)
lollipop = nx.lollipop_graph(10, 20)
4. 使用随机图生成器，
| 方法 | 介绍 |
|---|---|
| erdos_renyi_graph(n, p[, seed, directed]) | Returns a Gn,p random graph, also known as an Erdős-Rényi graph or a binomial graph. |
| watts_strogatz_graph(n, k, p[, seed]) | Returns a Watts–Strogatz small-world graph. |
| barabasi_albert_graph(n, m[, seed, ...]) | Returns a random graph using Barabási–Albert preferential attachment |
| random_lobster(n, p1, p2[, seed]) | Returns a random lobster graph. |
像这样
er = nx.erdos_renyi_graph(100, 0.15)
ws = nx.watts_strogatz_graph(30, 3, 0.1)
ba = nx.barabasi_albert_graph(100, 5)
red = nx.random_lobster(100, 0.9, 0.9)
5. 使用常用图形格式读取存储在文件中的图形
NetworkX 支持许多流行的格式，例如边缘列表、邻接列表、GML、GraphML、pickle、LEDA 等。
nx.write_gml(red, "path.to.file")
mygraph = nx.read_gml("path.to.file")
有关图形格式的详细信息，请参阅读和写图形；有关图形生成器函数，请参阅图形生成器
分析图
可以使用各种图论函数来分析图G 的结构，例如：
>>> G = nx.Graph()
>>> G.add_edges_from([(1, 2), (1, 3)])
>>> G.add_node("spam") # adds node "spam"
>>> list(nx.connected_components(G))
[{1, 2, 3}, {'spam'}]
>>> sorted(d for n, d in G.degree())
[0, 1, 1, 2]
>>> nx.clustering(G)
{1: 0, 2: 0, 3: 0, 'spam': 0}
一些具有大输出的函数迭代 (node, value) 2 元组。 如果您愿意，这些很容易存储在 dict 结构中。
>>> sp = dict(nx.all_pairs_shortest_path(G))
>>> sp[3]
{3: [3], 1: [3, 1], 2: [3, 1, 2]}
有关支持的图形算法的详细信息，请参阅算法。
绘制图
NetworkX 主要不是一个图形绘图包，而是包含使用 Matplotlib 的基本绘图以及使用开源 Graphviz 软件包的接口。 这些是 networkx.drawing 模块的一部分，如果可能，将被导入。
首先导入 Matplotlib 的绘图接口（pylab 也可以）
import matplotlib.pyplot as plt
要测试 nx_pylab 是否成功导入，请使用以下方法之一绘制图G
G = nx.petersen_graph()
subax1 = plt.subplot(121)
nx.draw(G, with_labels=True, font_weight='bold')
subax2 = plt.subplot(122)
nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')
_images/tutorial-34.png
)
交互式操作时上述图像会自动展示。 请注意如果您没有在交互模式下使用 matplotlib，您可能需要下面命令展示图形
plt.show()
options = {
'node_color': 'black',
'node_size': 100,
'width': 3,
}
subax1 = plt.subplot(221)
nx.draw_random(G, **options)
subax2 = plt.subplot(222)
nx.draw_circular(G, **options)
subax3 = plt.subplot(223)
nx.draw_spectral(G, **options)
subax4 = plt.subplot(224)
nx.draw_shell(G, nlist=[range(5,10), range(5)], **options)
_images/tutorial-35.png
您可以通过 draw_networkx() 找到其他选项，并通过布局模块找到布局。 您可以通过 draw_shell() 使用多个 shell。
G = nx.dodecahedral_graph()
shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7], [9, 10, 11, 12, 13]]
nx.draw_shell(G, nlist=shells, **options)
_images/tutorial-36.png
要将图形保存到文件中，请使用，例如
nx.draw(G)
plt.savefig("path.png")
此函数写入本地目录中的文件 path.png。 如果 Graphviz 和 PyGraphviz 或 pydot 在您的系统上可用，您还可以使用 networkx.drawing.nx_agraph.graphviz_layout 或 networkx.drawing.nx_pydot.graphviz_layout 来获取节点位置，或者以点格式编写图形以进行进一步处理。
networkx官方文档
Tutorial — NetworkX 3.2.1 documentation