import networkx as nx
import matplotlib.pyplot as plt
G_w = nx.DiGraph()
edges_list = [
(1,2,1),
(1,3,2),
(1,4,3),
(4,3,4)
]
G_w.add_weighted_edges_from(edges_list)
nx.draw_networkx(G = G_w)
list(G_w.edges(data=True))
[(1, 2, {'weight': 1}),
(1, 3, {'weight': 2}),
(1, 4, {'weight': 3}),
(4, 3, {'weight': 4})]
#自定义可视化，在边上展示权重
edge_labels = nx.get_edge_attributes(G_w, "weight")
print('edge_labels:',edge_labels)
pos = nx.spring_layout(G_w)
nx.draw_networkx_edge_labels(G_w, pos, edge_labels=edge_labels) # 绘制图中边的权重
nx.draw_networkx(G_w, pos)
edge_labels: {(1, 2): 1, (1, 3): 2, (1, 4): 3, (4, 3): 4}
1.度
1.1 度
# 度
G = G_w.copy()
G.degree()
DiDegreeView({1: 3, 2: 1, 3: 2, 4: 2})
1.2 入度
# 入度
G.in_degree()
InDegreeView({1: 0, 2: 1, 3: 2, 4: 1})
1.3 出度
# 出度
G.out_degree()
OutDegreeView({1: 3, 2: 0, 3: 0, 4: 1})
1.4 加权度
加权度
# 计算节点的加权度
G.degree(weight='weight')
DiDegreeView({1: 6, 2: 1, 3: 6, 4: 7})
1.5 邻居节点
与一个给定节点通过一条边直接相连的所有节点。
邻居节点
出度邻居
入度邻居
1.5.1 邻居节点计算
# 查找某个节点的邻居节点 （因为上面是有向图，G.neighbors()计算的是出度节点）
neighbors_of_1 = list(G.neighbors(1))
print("Neighbors of node 1:", neighbors_of_1)
Neighbors of node 1: [2, 3, 4]
# 计算并打印所有节点的邻居节点
for node in G.nodes():
neighbors = list(G.neighbors(node))
print(f"Neighbors of node {node}: {neighbors}")
Neighbors of node 1: [2, 3, 4]
Neighbors of node 2: []
Neighbors of node 3: []
Neighbors of node 4: [3]
1.5.2 出度邻居节点
# 找到节点1的出度邻居
out_neighbors_of_1 = list(G.successors(1))
print("Out-neighbors of node 1:", out_neighbors_of_1)
Out-neighbors of node 1: [2, 3, 4]
# 计算并打印所有节点的邻居节点
for node in G.nodes():
neighbors = list(G.successors(node))
print(f"Out-neighbors of node {node}: {neighbors}")
Out-neighbors of node 1: [2, 3, 4]
Out-neighbors of node 2: []
Out-neighbors of node 3: []
Out-neighbors of node 4: [3]
1.5.3 入度邻居节点
# 计算并打印所有节点的邻居节点
for node in G.nodes():
neighbors = list(G.predecessors(node))
print(f"In-neighbors of node {node}: {neighbors}")
In-neighbors of node 1: []
In-neighbors of node 2: [1]
In-neighbors of node 3: [1, 4]
In-neighbors of node 4: [1]
2.节点数、边数
# 节点的数量
nx.number_of_nodes(G=G)
4
# or
len(G)
4
nx.number_of_edges(G=G)
4
3.最短路径
shortest_path()
# 创建一个带权图
G = nx.Graph()
G.add_nodes_from([1, 2, 3, 4])
## 添加带权边
G.add_edge(1, 2, weight=0.5)
G.add_edge(2, 3, weight=0.3)
G.add_edge(3, 1, weight=0.1)
G.add_edge(4, 1, weight=0.1)
G.add_edge(4, 1, weight=0.2)
# 绘制图形
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_color='lightblue', node_size=500, font_size=16, font_weight='bold')
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels, font_size=12, font_color='red')
plt.show()
# nx.to_numpy_matrix(G=G)
3.1 最短路径(不带权重)
定义：两个节点之间的最短路径上的边数
source :起始节点
target :终止节点
weight : 边属性
G.edges(data=True)
EdgeDataView([(1, 2, {'weight': 0.5}), (1, 3, {'weight': 0.1}), (1, 4, {'weight': 0.2}), (2, 3, {'weight': 0.3})])
# 最短路径(不带权重)
nx.shortest_path(G=G,source=4,target=2,weight=None)
[4, 1, 2]
# 最短路径长度
nx.shortest_path_length(G=G,source=4,target=2,weight=None)
2
3.2 最短路径(带权重)
# 最短路径(带权重)
nx.shortest_path(G=G,source=4,target=2,weight='weight')
[4, 1, 3, 2]
nx.shortest_path_length(G=G,source=4,target=2,weight='weight')
0.6000000000000001
加权时的最短路径是4-1-2，从加权、非加权的最短路径可以看出，不路径长度为2;加权时为4-1-3-2，路径长度为：0.6
4.计算图中所有的最短路径
nx.shortest_path(G=G) # 无加权，所有节点之间的最短路径
{1: {1: [1], 2: [1, 2], 3: [1, 3], 4: [1, 4]},
2: {2: [2], 1: [2, 1], 3: [2, 3], 4: [2, 1, 4]},
3: {3: [3], 2: [3, 2], 1: [3, 1], 4: [3, 1, 4]},
4: {4: [4], 1: [4, 1], 2: [4, 1, 2], 3: [4, 1, 3]}}
# 点-点对之间的最短路径
dict(nx.all_pairs_dijkstra_path(G=G,weight='weight'))
{1: {1: [1], 2: [1, 3, 2], 3: [1, 3], 4: [1, 4]},
2: {2: [2], 1: [2, 3, 1], 3: [2, 3], 4: [2, 3, 1, 4]},
3: {3: [3], 2: [3, 2], 1: [3, 1], 4: [3, 1, 4]},
4: {4: [4], 1: [4, 1], 2: [4, 1, 3, 2], 3: [4, 1, 3]}}
# 点-点对之间的最短路径长度
dict(nx.all_pairs_dijkstra_path_length(G=G,weight='weight'))
{1: {1: 0, 3: 0.1, 4: 0.2, 2: 0.4},
2: {2: 0, 3: 0.3, 1: 0.4, 4: 0.6000000000000001},
3: {3: 0, 1: 0.1, 2: 0.3, 4: 0.30000000000000004},
4: {4: 0, 1: 0.2, 3: 0.30000000000000004, 2: 0.6000000000000001}}
# 计算点-点对之间的最短路径和最短路径长度
dict(nx.all_pairs_dijkstra(G=G,weight='weight'))
{1: ({1: 0, 3: 0.1, 4: 0.2, 2: 0.4},
{1: [1], 2: [1, 3, 2], 3: [1, 3], 4: [1, 4]}),
2: ({2: 0, 3: 0.3, 1: 0.4, 4: 0.6000000000000001},
{2: [2], 1: [2, 3, 1], 3: [2, 3], 4: [2, 3, 1, 4]}),
3: ({3: 0, 1: 0.1, 2: 0.3, 4: 0.30000000000000004},
{3: [3], 2: [3, 2], 1: [3, 1], 4: [3, 1, 4]}),
4: ({4: 0, 1: 0.2, 3: 0.30000000000000004, 2: 0.6000000000000001},
{4: [4], 1: [4, 1], 2: [4, 1, 3, 2], 3: [4, 1, 3]})}
发表评论