Python 学习笔记之 networkx 使用_networkx怎么使用

介绍 networkx

networkx 支持创建简单无向图、有向图和多重图；内置许多标准的图论算法，节点可为任意数据；支持任意的边值维度，功能丰富，简单易用

networkx 中的 Graph

Graph 的定义

Graph 是用点和线来刻画离散事物集合中的每对事物间以某种方式相联系的数学模型

网络作为图的一个重要领域，包含的概念与定义更多，如有向图网络、无向图网络等

Graph 在现实世界中随处可见，如交通运输图、旅游图、流程图等。此处我们只考虑由点和线所组成的图

Graph 的结构

一个 Graph 包含一个节点集合和一个边集

在 networkx 中，一个节点可以是任意 hash 对象（除了 None 对象），一条边也可以关联任意的对象,像一个文本字符串，一幅图像，一个 XML 对象，甚至是另一个图或任意定制的节点对象

总结 ：

1. Python 中的 None 对象是不可以作为节点的类型的
2. 在 networkx 中，节点与边能够存储任意类型字典的属性和任意其他丰富类型的数据

Graph 的分类

• Graph：指无向图（undirected Graph），即忽略了两个节点间连边的方向
• DiGraph：指有向图（directed Graph），即考虑了两个节点之间连边的有向性
• MultiGraph：指多重无向图，即两个结点之间的边数多于一条，又允许顶点通过同一条边和自己关联（即允许重边和自环）
• MultiDiGraph：多重有向图

g = nx.Graph()  # 无向图
dg = nx.DiGraph()  # 有向图
mg = nx.MultiGraph()  # 多重无向图
mdg = nx.MultiDiGraph()  # 多重有向图
g.clear()  # 清空图
1
2
3
4
5

networkx 语法

节点操作

添加节点

如果添加的节点和边是已经存在的，是不会报错的， networkx 会自动忽略掉已经存在的边和节点的添加

import networkx as nx
import matplotlib.pyplot as plt
 
G = nx.Graph()                 # 建立一个空的无向图G
G.add_node('a')                  # 添加一个节点a
G.add_nodes_from(['b','c','d','e'])    # 从一个列表中添加节点
H = nx.path_graph(10)          # 返回由10个节点挨个连接的无向图，有9条边
G.add_nodes_from(H)            # 创建一个子图H加入G
G.add_node(H)                  # 直接将图作为节点

nx.draw(G, with_labels=True)
plt.show()

print('图中所有的节点', G.nodes())
print('图中节点的个数', G.number_of_nodes())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

删除节点

# 删除节点
G.remove_node(1)    # 删除指定节点
G.remove_nodes_from(['b','c','d','e'])   # 删除列表中的节点
nx.draw(G, with_labels=True)
plt.show()
1
2
3
4
5

边操作

添加边

# 添加边
F = nx.Graph()      # 创建无向图
F.add_edge(11,12)   # 指定节点之间添加一条边
# 等价于
e=(13,14)        # e 是一个元组
F.add_edge(*e)   # python 中解包的过程

F.add_edges_from([(1,2),(1,3)])     # 通过 list 来添加多条边

# 通过一个图的边来添加边
H = nx.path_graph(10)          # 返回由10个节点挨个连接的无向图，有9条边
F.add_edges_from(H.edges()) # 不能写作F.add_edges_from(H)

nx.draw(F, with_labels=True)
plt.show()

print('图中所有的边', F.edges())
print('图中边的个数', F.number_of_edges()) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

遍历边

# 快速遍历每一条边，可以使用邻接迭代器实现，对于无向图，每一条边相当于两条有向边
G1 = nx.Graph()
G1.add_weighted_edges_from([(1,2,0.125), (1,3,0.75), (2,4,1.2), (3,4,0.275)])
for n, nbrs in G1.adjacency():
    for nbr, eattr in nbrs.items():
        data = eattr['weight']
        print('(%d, %d, %0.3f)' % (n,nbr,data))

print('***********************************')

# 筛选 weight 小于0.5的边：
G2 = nx.Graph()
G2.add_weighted_edges_from([(1,2,0.125), (1,3,0.75), (2,4,1.2), (3,4,0.275)])
for n, nbrs in G2.adjacency():
    for nbr, eattr in nbrs.items():
        data = eattr['weight']
        if data < 0.5:
            print('(%d, %d, %0.3f)' % (n,nbr,data))
print('***********************************')

# 一种方便的访问所有边的方法:
for u,v,d in G2.edges(data = 'weight'):
    print((u,v,d))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出：

(1, 2, 0.125)
(1, 3, 0.750)
(2, 1, 0.125)
(2, 4, 1.200)
(3, 1, 0.750)
(3, 4, 0.275)
(4, 2, 1.200)
(4, 3, 0.275)
***********************************
(1, 2, 0.125)
(2, 1, 0.125)
(3, 4, 0.275)
(4, 3, 0.275)
***********************************
(1, 2, 0.125)
(1, 3, 0.75)
(2, 4, 1.2)
(3, 4, 0.275)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

删除边

# 删除边
F.remove_edge(1,2)
F.remove_edges_from([(11,12), (13,14)])

nx.draw(F, with_labels=True)
plt.show()
1
2
3
4
5
6

属性操作

属性诸如 weight, labels, colors, 或者任何对象，你都可以附加到图、节点或边上。

对于每一个图、节点和边都可以在关联的属性字典中保存一个（多个）键-值对。

默认情况下这些是一个空的字典，但是我们可以增加或者是改变这些属性

# 图的属性
G = nx.Graph(day='Monday')    # 可以在创建图时分配图的属性
print(G.graph)
G.graph['day'] = 'Friday'     # 也可以修改已有的属性
print(G.graph)
G.graph['name'] = 'time'      # 可以随时添加新的属性到图中
print(G.graph)
1
2
3
4
5
6
7

输出：

{'day': 'Monday'}
{'day': 'Friday'}
{'day': 'Friday', 'name': 'time'}
1
2
3

# 节点的属性
G = nx.Graph(day='Monday')
G.add_node(1, index='1th')             # 在添加节点时分配节点属性
print(G.nodes(data=True))
G.nodes[1]['index'] = '0th'             # 通过G.nodes[][]来添加或修改属性
print(G.nodes(data=True))
G.add_nodes_from([2,3], index='2/3th')  # 从列表中添加节点时分配属性
print(G.nodes(data=True))
1
2
3
4
5
6
7
8

输出：

[(1, {'index': '1th'})]
[(1, {'index': '0th'})]
[(1, {'index': '0th'}), (2, {'index': '2/3th'}), (3, {'index': '2/3th'})]
1
2
3

# 边的属性
G = nx.Graph(day='manday')
G.add_edge(1,2,weight=10)                    # 在添加边时分配属性
print(G.edges(data=True))
G.add_edges_from([(1,3), (4,5)], len=22)     # 从集合中添加边时分配属性
print(G.edges(data='len'))
G.add_edges_from([(3,4,{'hight':10}),(1,4,{'high':'unknow'})])
print(G.edges(data=True))
G[1][2]['weight'] = 100000                   # 通过G[][][]来添加或修改属性
print(G.edges(data=True))
1
2
3
4
5
6
7
8
9
10

输出：

[(1, 2, {'weight': 10})]
[(1, 2, None), (1, 3, 22), (4, 5, 22)]
[(1, 2, {'weight': 10}), (1, 3, {'len': 22}), (1, 4, {'high': 'unknow'}), (3, 4, {'hight': 10}), (4, 5, {'len': 22})]
[(1, 2, {'weight': 100000}), (1, 3, {'len': 22}), (1, 4, {'high': 'unknow'}), (3, 4, {'hight': 10}), (4, 5, {'len': 22})]
1
2
3
4

图转化

# 有向图转化成无向图
H = DG.to_undirected()
# 或者
H = nx.Graph(DG)

# 无向图转化成有向图
F = H.to_directed()
# 或者
F = nx.DiGraph(H)
1
2
3
4
5
6
7
8
9

其他操作

图

degree(G[, nbunch, weight])：返回单个节点或nbunch节点的度数视图。

degree_histogram(G)：返回每个度值的频率列表。

density(G)：返回图的密度。

info(G[, n])：打印图G或节点n的简短信息摘要。

create_empty_copy(G[, with_data])：返回图G删除所有的边的拷贝。

is_directed(G)：如果图是有向的，返回true。

add_star(G_to_add_to, nodes_for_star, **attr)：在图形G_to_add_to上添加一个星形。

add_path(G_to_add_to, nodes_for_path, **attr)：在图G_to_add_to中添加一条路径。

add_cycle(G_to_add_to, nodes_for_cycle, **attr)：向图形G_to_add_to添加一个循环。

节点

nodes(G)：在图节点上返回一个迭代器。

number_of_nodes(G)：返回图中节点的数量。

all_neighbors(graph, node)：返回图中节点的所有邻居。

non_neighbors(graph, node)：返回图中没有邻居的节点。

common_neighbors(G, u, v)：返回图中两个节点的公共邻居。

边

edges(G[, nbunch])：返回与nbunch中的节点相关的边的视图。

number_of_edges(G)：返回图中边的数目。

non_edges(graph)：返回图中不存在的边。