NetworkX（网络图）

MoRanzhi1203

已于 2024-08-17 23:49:55 修改

阅读量485

点赞数 6

文章标签： python

于 2024-08-17 21:55:43 首次发布

本文链接：https://blog.csdn.net/MoRanzhi1203/article/details/141287459

版权

NetworkX（网络图）

NetworkX 是 Python 中一个强大且灵活的库，专用于创建、操作和研究复杂网络（图）。它支持多种图类型，并提供丰富的算法和绘图功能，适用于社会网络分析、交通网络优化、生物网络分析等领域。

1. 安装 NetworkX

在开始使用 NetworkX 之前，请确保已安装该库。你可以使用以下命令安装：

pip install networkx

安装完成后，在代码中导入库：

import networkx as nx

2. 创建和操作图

2.1 图的类型

在 NetworkX 中，有几种主要的图类型：

无向图 (Graph)：节点之间的连接是双向的。
有向图 (DiGraph)：节点之间的连接是有方向的。
多重图 (MultiGraph)：允许节点之间有多条边。
有向多重图 (MultiDiGraph)：允许节点之间有多条有方向的边。

# 创建一个无向图
G = nx.Graph()

# 创建一个有向图
DG = nx.DiGraph()

# 创建一个多重图
MG = nx.MultiGraph()

# 创建一个有向多重图
MDG = nx.MultiDiGraph()

在这里插入图片描述

这些图类型在不同的应用场景下具有独特的用途。无向图通常用于表示双向关系，如社交网络中的好友关系；有向图则适用于表示单向关系，如网页之间的链接结构。

2.2 添加节点

在 NetworkX 中，节点可以是任意可哈希的 Python 对象（如整数、字符串、元组等）。你可以根据需求添加节点并为其设置属性。

# 添加单个节点
G.add_node(1)

# 添加多个节点
G.add_nodes_from([2, 3, 4])

# 添加带属性的节点
G.add_node(5, label='A', color='red')

节点属性是附加到节点上的信息。例如，color 属性可以表示节点的颜色，label 属性可以用于标识节点的标签。

请添加图片描述

查看图中的节点：

# 获取所有节点
nodes = G.nodes()
print(f"所有节点：{nodes}")

# 获取节点的属性
attributes = G.nodes[5]
print(f"节点 5 的属性：{attributes}")

所有节点：[1, 2, 3, 4, 5]
节点 5 的属性：{‘label’: ‘A’, ‘color’: ‘red’}

2.3 添加边

边可以将两个节点连接起来，并可以附带属性（如权重、颜色等）。边的属性可以用于表示连接的强度或其他关联信息。

# 添加单条边
G.add_edge(1, 2)

# 添加带权重的边
G.add_edge(2, 3, weight=4.2)

# 添加多条边
G.add_edges_from([(3, 4), (4, 5)])

# 添加带属性的边
G.add_edge(1, 3, color='blue', weight=1.5)

边的属性可以用于多种用途，例如在社交网络中，边的权重可能表示关系的紧密程度；在交通网络中，边的权重可能表示距离或耗时。

添加边

查看图中的边：

# 获取所有边
edges = G.edges()
print(f"所有边：{edges}")

# 获取边的属性
edge_attrs = G[1][3]
print(f"边 (1, 3) 的属性：{edge_attrs}")

所有边：[(1, 2), (1, 3), (2, 3), (3, 4), (4, 5)]
边 (1, 3) 的属性：{‘color’: ‘blue’, ‘weight’: 1.5}

2.4 访问图的元素

# 获取节点的度数（节点连接的边数）
degree = G.degree(1)
print(f"节点 1 的度数：{degree}")

# 检查节点是否存在
exists = G.has_node(1)
print(f"节点 1 是否存在：{exists}")

# 检查边是否存在
exists = G.has_edge(1, 2)
print(f"边 (1, 2) 是否存在：{exists}")

# 获取某个节点的邻居节点
neighbors = list(G.neighbors(1))
print(f"节点 1 的邻居节点：{neighbors}")

节点 1 的度数：2
节点 1 是否存在：True
边 (1, 2) 是否存在：True
节点 1 的邻居节点：[2, 3]

2.5 移除节点和边

当你不再需要某些节点或边时，可以将它们移除。

# 移除节点
G.remove_node(5)

# 移除多个节点
G.remove_nodes_from([3, 4])

# 移除边
G.remove_edge(1, 2)

# 移除多条边
G.remove_edges_from([(2, 3), (3, 4)])

这些操作可以动态地调整图的结构，以适应不同的分析需求。

3. 图的属性和元数据

import networkx as nx

G = nx.Graph()
G.add_nodes_from([1, 2, 3, 4, 5, 6])
G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1), (1, 3), (2, 4), (5, 6)])

3.1 为节点和边设置属性

在 NetworkX 中，你可以为节点和边设置属性，以存储与节点或边相关的信息（例如标签、颜色、权重等）。

# 设置节点属性
G.nodes[1]['color'] = 'red'
G.nodes[2]['size'] = 10

# 设置边属性
G[1][2]['weight'] = 4.5
G[1][2]['label'] = 'A to B'

这些属性在许多场景下非常有用，例如在社交网络中，你可以使用颜色属性标识不同类别的节点，或使用权重属性表示连接的强度。

3.2 获取节点和边的属性

你可以方便地获取节点和边的属性，默认值在属性不存在时会返回。

# 获取节点的颜色属性
color = G.nodes[1].get('color', 'blue')  # 如果不存在属性，则返回默认值 'blue'
print(f"节点 1 的颜色：{color}")

# 获取边的权重属性
weight = G[1][2].get('weight', 1.0)
print(f"边 (1, 2) 的权重：{weight}")

节点 1 的颜色：red
边 (1, 2) 的权重：4.5

3.3 设置和获取图的元数据

你还可以为整个图设置一些元数据，如图的名称、创建时间等信息。

# 设置图的名称
G.graph['name'] = 'My Graph'

# 获取图的名称
graph_name = G.graph.get('name', 'Unnamed')
print(f"图的名称：{graph_name}")

图的名称：My Graph

4. 图的分析和算法

NetworkX 提供了多种用于分析图结构的算法，这些算法可以用于寻找最短路径、分析连通性、计算中心性等。

4.1 最短路径

NetworkX 提供了多种寻找最短路径的方法，最常用的是 shortest_path()。

# 查找最短路径
path = nx.shortest_path(G, source=1, target=4, weight='weight')
print(f"节点 1 到节点 4 的最短路径：{path}")

# 查找最短路径长度
path_length = nx.shortest_path_length(G, source=1, target=4,
                                      weight='weight')
print(f"节点 1 到节点 4 的最短路径长度：{path_length}")

节点 1 到节点 4 的最短路径：[1, 4]
节点 1 到节点 4 的最短路径长度：1

4.2 连通性分析

连通性分析用于检测图中节点之间的连通情况，可以帮助识别孤立节点或连通分量。

# 查找所有连通分量
components = list(nx.connected_components(G))
print(f"所有连通分量：{components}")

# 查找某个节点的连通分量
component = nx.node_connected_component(G, 1)
print(f"包含节点 1 的连通分量：{component}")

所有连通分量：[{1, 2, 3, 4}, {5, 6}]
包含节点 1 的连通分量：{1, 2, 3, 4}

4.3 聚类系数

聚类系数衡量节点邻居之间的连通程度，通常用于分析网络的团簇结构。

# 计算单个节点的聚类系数
clustering_coefficient = nx.clustering(G, 1)
print(f"节点 1 的聚类系数：{clustering_coefficient}")

# 计算所有节点的聚类系数
all_clustering = nx.clustering(G)
print(f"所有节点的聚类系数：{all_clustering}")

节点 1 的聚类系数：1.0
所有节点的聚类系数：{1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 0, 6: 0}

4.4 图的中心性

中心性是衡量图中节点重要性的指标。常见的中心性包括度中心性、接近中心性和介数中心性。

# 计算度中心性
degree_centrality = nx.degree_centrality(G)
print(f"度中心性：{degree_centrality}")

# 计算接近中心性
closeness_centrality = nx.closeness_centrality(G)
print(f"接近中心性：{closeness_centrality}")

# 计算介数中心性
betweenness_centrality = nx.betweenness_centrality(G)
print(f"介数中心性：{betweenness_centrality}")

度中心性：{1: 0.6000000000000001, 2: 0.6000000000000001, 3: 0.6000000000000001, 4: 0.6000000000000001, 5: 0.2, 6: 0.2}
接近中心性：{1: 0.6, 2: 0.6, 3: 0.6, 4: 0.6, 5: 0.2, 6: 0.2}
介数中心性：{1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0, 6: 0.0}

5. 图的绘制与可视化

NetworkX 提供了丰富的绘图功能，可以轻松地将图结构可视化。你可以自定义节点和边的颜色、形状、大小等属性。

5.1 基本绘图

你可以使用 nx.draw() 方法来绘制图，并添加节点标签。

import matplotlib.pyplot as plt

# 绘制图
nx.draw(G, with_labels=True)

# 显示图
plt.show()

请添加图片描述

5.2 自定义绘图

你可以自定义节点和边的颜色、大小和布局。

# 设置布局
pos = nx.spring_layout(G)

# 自定义节点颜色和大小
nx.draw(G, pos, with_labels=True, node_color='skyblue', node_size=1500, font_size=12)

# 自定义边的颜色和宽度
nx.draw_networkx_edges(G, pos, edgelist=G.edges(), edge_color='black', width=2)

# 显示图
plt.show()

请添加图片描述

5.3 根据属性进行可视化

你可以根据节点和边的属性进行可视化，例如根据边的权重调整边的宽度。

# 根据边的权重调整边的宽度
edges = G.edges()
weights = [G[u][v].get('weight', 1.0) for u, v in edges]  # 如果没有 'weight' 属性，使用默认值 1.0

# 绘制图，边的宽度与权重相关
nx.draw(G, pos, with_labels=True, edgelist=edges, width=weights)

# 显示图
plt.show()

请添加图片描述

6. 图文件的导入与导出

6.1 导出图

你可以将图导出为多种格式，如 GraphML、GML、Adjacency List 等。

# 导出为GraphML格式
nx.write_graphml(G, 'my_graph.graphml')

# 导出为GML格式
nx.write_gml(G, 'my_graph.gml')

# 导出为邻接表格式
nx.write_adjlist(G, 'my_graph.adjlist')

6.2 导入图

你可以从文件中导入图，以便进行分析和可视化。

# 从GraphML文件导入图
G = nx.read_graphml('my_graph.graphml')

# 从GML文件导入图
G = nx.read_gml('my_graph.gml')

# 从邻接表文件导入图
G = nx.read_adjlist('my_graph.adjlist')

7. 高级图分析

NetworkX 还支持许多高级图分析功能，如社区发现、最小生成树、最大流最小割等。这些功能通常用于复杂网络的深入分析。

7.1 社区发现

社区发现用于识别图中节点的群体结构。NetworkX 提供了一些基本的社区发现算法。

import networkx.algorithms.community as nx_comm

# 使用Girvan-Newman算法进行社区发现
communities = nx_comm.girvan_newman(G)

# 获取前两个社区划分
next_level_communities = next(communities)
print(f"第一个级别的社区：{next_level_communities}")

第一个级别的社区：({1}, {2, 3, 4}, {5, 6})

7.2 最小生成树

最小生成树用于找到一棵包含所有节点的最小加权树。

# 计算最小生成树
mst = nx.minimum_spanning_tree(G)

# 绘制最小生成树
nx.draw(mst, with_labels=True)
plt.show()

请添加图片描述

7.3 最大流最小割

NetworkX 提供了计算最大流和最小割的功能，通常用于网络流分析。

# 定义一个有向图
flow_G = nx.DiGraph()

# 添加带容量的边
flow_G.add_edge('A', 'B', capacity=15)
flow_G.add_edge('A', 'C', capacity=10)
flow_G.add_edge('B', 'D', capacity=10)
flow_G.add_edge('C', 'D', capacity=15)

# 计算最大流
flow_value, flow_dict = nx.maximum_flow(flow_G, 'A', 'D')
print(f"最大流量值：{flow_value}")
print(f"流量分配：{flow_dict}")

最大流量值：20
流量分配：{‘A’: {‘B’: 10, ‘C’: 10}, ‘B’: {‘D’: 10}, ‘C’: {‘D’: 10}, ‘D’: {}}

请添加图片描述

8. 实际应用案例

8.1 社会网络分析

你可以使用 NetworkX 分析社交网络，例如通过节点代表个体，边代表他们之间的关系。你可以识别网络中的关键人物、分析信息传播路径等。

8.1.1 社会网络分析案例：识别社交网络中的关键影响者

在社交网络中，识别关键影响者（influencers）对于营销策略、信息传播、病毒营销等应用至关重要。这些影响者通常是具有高中心性（centrality）的节点，意味着他们在网络中占据重要位置，能够影响其他节点。

在本案例中，我们将使用 NetworkX 对一个模拟的社交网络进行分析，找出其中的关键影响者。通过计算不同类型的中心性指标，我们可以确定哪些节点在网络中最具影响力。

import networkx as nx
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']

# 定义角色
nodes = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸']

# 创建一个模拟的社交网络图
G = nx.Graph()

# 添加节点（用户）
G.add_nodes_from(nodes)

# 添加边（用户之间的社交关系）并标注关系类型
edges = [
    ('甲', '乙', '朋友'), ('甲', '丙', '同事'), ('甲', '丁', '亲戚'), 
    ('乙', '戊', '同学'), ('乙', '己', '朋友'), 
    ('丙', '庚', '合作伙伴'), 
    ('丁', '辛', '朋友'), ('丁', '壬', '同事'), 
    ('戊', '癸', '朋友'),
    ('己', '癸', '朋友'), ('庚', '癸', '合作伙伴'), ('辛', '癸', '同事'), ('壬', '癸', '朋友')
]
G.add_edges_from([(edge[0], edge[1]) for edge in edges])

# 定义边的标签
edge_labels = {(edge[0], edge[1]): edge[2] for edge in edges}

# 可视化社交网络
plt.figure(figsize=(10, 10))
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_color="skyblue", node_size=700, font_size=15)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red')
plt.title("社交网络图")
plt.show()

在这里插入图片描述

度中心性（Degree Centrality）
```
degree_centrality = nx.degree_centrality(G)
print(f"度中心性：{degree_centrality}")
```
度中心性：{‘甲’: 0.3333333333333333, ‘乙’: 0.3333333333333333, ‘丙’: 0.2222222222222222, ‘丁’: 0.3333333333333333, ‘戊’: 0.2222222222222222, ‘己’: 0.2222222222222222, ‘庚’: 0.2222222222222222, ‘辛’: 0.2222222222222222, ‘壬’: 0.2222222222222222, ‘癸’: 0.5555555555555556}
接近中心性（Closeness Centrality）
```
closeness_centrality = nx.closeness_centrality(G)
print(f"接近中心性：{closeness_centrality}")
```
接近中心性：{‘甲’: 0.5625, ‘乙’: 0.5, ‘丙’: 0.45, ‘丁’: 0.5, ‘戊’: 0.5, ‘己’: 0.5, ‘庚’: 0.5, ‘辛’: 0.5, ‘壬’: 0.5, ‘癸’: 0.6428571428571429}
介数中心性（Betweenness Centrality）
```
betweenness_centrality = nx.betweenness_centrality(G)
print(f"介数中心性：{betweenness_centrality}")
```
介数中心性：{‘甲’: 0.19444444444444445, ‘乙’: 0.12685185185185183, ‘丙’: 0.05185185185185185, ‘丁’: 0.12685185185185183, ‘戊’: 0.04722222222222223, ‘己’: 0.04722222222222223, ‘庚’: 0.08888888888888889, ‘辛’: 0.04722222222222223, ‘壬’: 0.04722222222222223, ‘癸’: 0.4166666666666665}
特征向量中心性（Eigenvector Centrality）
```
eigenvector_centrality = nx.eigenvector_centrality(G)
print(f"特征向量中心性：{eigenvector_centrality}")
```
特征向量中心性：{‘甲’: 0.2954139030491517, ‘乙’: 0.31622869702249273, ‘丙’: 0.19544142166982692, ‘丁’: 0.31622869702249273, ‘戊’: 0.29541056362310775, ‘己’: 0.29541056362310775, ‘庚’: 0.25231134941594746, ‘辛’: 0.29541056362310775, ‘壬’: 0.29541056362310775, ‘癸’: 0.5116653960307177}

找出关键影响者（度中心性最高的节点）

key_influencers = sorted(degree_centrality, key=degree_centrality.get, reverse=True)[:3]
print(f"关键影响者（度中心性最高）：{key_influencers}")

关键影响者（度中心性最高）：[‘癸’, ‘甲’, ‘乙’]

8.2 交通网络优化

在交通网络中，节点可以表示交叉路口，边表示道路。通过 NetworkX，你可以分析最优路径、交通流量，甚至进行交通拥堵模拟。

8.2.1 交通网络优化案例：提升城市交通效率的路径优化

假设我们有一个城市的交通网络，由多个路口（节点）和道路（边）组成。我们的目标是从城市的某个起点（A点）到达终点（B点），并且我们希望：

找到最短路径：从A到B的最短路径。
找到最大流路径：在交通高峰期间，如何最大化从A到B的车辆通过量。
避免拥堵：找到一条尽量避开拥堵区域的路径。

import networkx as nx
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']

# 创建一个有向图来表示交通网络
G = nx.DiGraph()

# 添加节点（路口）
nodes = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
G.add_nodes_from(nodes)

# 添加带权重的边（道路）及其通行能力
edges = [
    ('A', 'B', {'weight': 2, 'capacity': 100}),
    ('A', 'C', {'weight': 5, 'capacity': 50}),
    ('B', 'C', {'weight': 2, 'capacity': 100}),
    ('B', 'D', {'weight': 4, 'capacity': 70}),
    ('C', 'E', {'weight': 1, 'capacity': 120}),
    ('D', 'F', {'weight': 3, 'capacity': 80}),
    ('E', 'F', {'weight': 1, 'capacity': 150}),
    ('F', 'G', {'weight': 2, 'capacity': 90}),
    ('E', 'H', {'weight': 3, 'capacity': 60}),
    ('H', 'G', {'weight': 2, 'capacity': 70}),
]

G.add_edges_from([(u, v, data) for u, v, data in edges])

# 可视化交通网络
pos = nx.spring_layout(G)
plt.figure(figsize=(10, 8))
nx.draw(G, pos, with_labels=True, node_size=700, node_color='lightblue', font_size=15)
nx.draw_networkx_edge_labels(
    G, pos,
    edge_labels={
        (u, v): f"w:{d['weight']},c:{d['capacity']}" for u, v, d in G.edges(data=True)
    })
G.edges(data=True)})
plt.title("城市交通网络图")
plt.show()

在这里插入图片描述

找到最短路径（基于权重，即时间最短）

shortest_path = nx.shortest_path(G, source='A', target='G', weight='weight')
shortest_path_length = nx.shortest_path_length(G, source='A', target='G', weight='weight')
print(f"从A到G的最短路径为：{shortest_path}，总时间为：{shortest_path_length}")

从A到G的最短路径为：[‘A’, ‘B’, ‘D’, ‘F’, ‘G’]，总时间为：11

找到最大流量路径
```
max_flow_value, max_flow_dict = nx.maximum_flow(G, 'A', 'G',    capacity='capacity')
print(f"从A到G的最大流量为：{max_flow_value}")
print(f"最大流路径分配为：{max_flow_dict}")
```
从A到G的最大流量为：150
最大流路径分配为：{‘A’: {‘B’: 100, ‘C’: 50}, ‘B’: {‘C’: 30, ‘D’: 70}, ‘C’: {‘E’: 80}, ‘D’: {‘F’: 70}, ‘E’: {‘F’: 20, ‘H’: 60}, ‘F’: {‘G’: 90}, ‘G’: {}, ‘H’: {‘G’: 60}}

避免拥堵的路径（可以通过增加某些边的权重来模拟拥堵）

# 我们假设边 ('B', 'C') 和 ('E', 'F') 在高峰期很拥堵，因此增加它们的权重
G['B']['C']['weight'] += 10
G['E']['F']['weight'] += 10

# 重新计算最短路径
congestion_avoidance_path = nx.shortest_path(G, source='A', target='G', weight='weight')
congestion_avoidance_path_length = nx.shortest_path_length(G, source='A', target='G',
                                                           weight='weight')
print(f"避开拥堵后从A到G的路径为：{congestion_avoidance_path}", 
      f"总时间为：{congestion_avoidance_path_length}", sep='，')

避开拥堵后从A到G的路径为：[‘A’, ‘B’, ‘D’, ‘F’, ‘G’]，总时间为：11

8.3 生物网络分析

在生物学中，节点可以代表基因或蛋白质，边代表它们的相互作用。你可以使用 NetworkX 分析生物网络中的关键节点、识别功能模块等。

8.3.1 生物网络分析案例：识别基因调控网络中的关键基因

在生物学中，基因调控网络是描述基因之间调控关系的图结构。每个节点代表一个基因，边表示一个基因对另一个基因的调控作用。通过分析基因调控网络，研究人员可以识别出在某些生物过程或疾病中起关键作用的基因，这对于理解生物学机制和开发治疗策略至关重要。

在这个示例中，我们将构建一个简单的基因调控网络，其中节点表示基因，边表示调控关系。我们使用 NetworkX 库来构建并分析该网络。

import networkx as nx
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']

# 创建一个有向图来表示基因调控网络
G = nx.DiGraph()

# 添加节点（基因）
genes = ["GeneA", "GeneB", "GeneC", "GeneD", "GeneE", "GeneF"]
G.add_nodes_from(genes)

# 添加边（调控关系）
G.add_edges_from([
    ("GeneA", "GeneB"), # GeneA 调控 GeneB
    ("GeneB", "GeneC"), # GeneB 调控 GeneC
    ("GeneA", "GeneD"), # GeneA 调控 GeneD
    ("GeneD", "GeneE"), # GeneD 调控 GeneE
    ("GeneE", "GeneF"), # GeneE 调控 GeneF
    ("GeneC", "GeneF")  # GeneC 调控 GeneF
])

# 可视化基因调控网络
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_color='lightgreen', node_size=2000,
        font_size=12, font_color='black')
        
# 为每条边添加标签（调控关系）
edge_labels = {("GeneA", "GeneB"): "activation",
               ("GeneB", "GeneC"): "repression",
               ("GeneA", "GeneD"): "activation",
               ("GeneD", "GeneE"): "activation",
               ("GeneE", "GeneF"): "activation",
               ("GeneC", "GeneF"): "repression"}

nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red')

plt.title("基因调控网络")
plt.show()

在这里插入图片描述

MoRanzhi1203

关注

6
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
NetworkX（网络图）

NetworkX 是 Python 中一个强大且灵活的库，专用于创建、操作和研究复杂网络（图）。它支持多种图类型，并提供丰富的算法和绘图功能，适用于社会网络分析、交通网络优化、生物网络分析等领域。
复制链接

扫一扫