Python图论可视化实战：NetworkX与Matplotlib绘制非赋权、赋权与有向图

1. 项目概述：从数据到洞察，图论可视化的核心价值

在数据科学和算法研究的日常工作中，我们常常会遇到各种关系型数据。比如，社交网络中的好友关系、交通网络中的站点连接、知识图谱中的概念关联，甚至是代码模块之间的依赖关系。这些关系用传统的表格或列表来呈现，往往显得杂乱无章，难以洞察其内在结构和模式。这时，“图”这种数据结构就成为了我们手中最有力的武器。它用“节点”和“边”直观地描绘了实体与关系，而将图可视化出来，则是将抽象数据转化为直观洞察的关键一步。

这个项目的核心，就是使用Python这一强大的工具，来绘制三种基础但至关重要的图类型：非赋权图、赋权图和有向图。听起来可能有些学术，但其实它们对应着非常实际的应用场景。一个简单的社交网络（谁认识谁）就是一个典型的非赋权图，我们只关心连接是否存在。一个城市间的交通网络，每条公路有距离或通行时间，这就是一个赋权图，边的权重代表了关系的强度或成本。而微博上的关注关系（我关注你，但你可能没关注我），则清晰地构成了一个有向图，关系有了明确的方向性。

掌握用Python绘制这些图，意味着你能将任何关系数据快速、美观地呈现出来，无论是用于算法演示、数据分析报告，还是学术论文插图。本文将手把手带你，基于最流行的networkx和matplotlib库，从零开始构建和美化这些图表。我会分享我多年实践中总结的布局技巧、美化心得和那些官方文档里不会写的“坑”，目标是让你看完就能上手，做出既专业又清晰的可视化作品。

2. 工具选型与环境搭建：为什么是NetworkX + Matplotlib？

工欲善其事，必先利其器。在Python的图可视化生态中，选择众多，但networkx+matplotlib的组合无疑是平衡了功能、易用性和灵活性的黄金标准。

NetworkX是一个专门用于创建、操作和研究复杂网络结构、动态和功能的Python包。它内置了海量的图论算法，从最短路径、聚类系数到社区发现，几乎无所不包。但对我们可视化而言，它最重要的价值在于提供了一个高度抽象且统一的图数据结构。无论你处理的是哪种图，在networkx中，你都可以用几乎相同的API来添加节点、添加边、设置属性，这极大地简化了代码逻辑。

Matplotlib则是Python科学计算领域的绘图基石。它可能不是最炫酷的，但绝对是最稳定、可控性最强的2D绘图库。networkx本身并不直接绘图，它负责计算图中每个节点的位置（布局），然后将这些坐标和连接信息交给matplotlib来渲染。这种分工明确的架构，让我们既能享受networkx在图算法上的便利，又能利用matplotlib无限的定制化能力来调整每一个视觉细节。

提示：有些朋友可能会提到pyvis、plotly等交互式库，它们能生成可缩放、可拖拽的网页图，非常适合演示。但对于需要嵌入论文、报告或需要精确控制样式、批量生成的场景，静态、高质量的matplotlib输出仍然是不可替代的。本教程聚焦于打好静态可视化的基础，这是进阶到任何交互式库的必经之路。

环境搭建步骤：

1. 确保你已安装Python（3.7及以上版本推荐）。

2. 打开终端或命令提示符，使用pip安装必备库：

   pip install networkx matplotlib

   如果你使用Anaconda，也可以使用conda install networkx matplotlib。

3. 验证安装。新建一个Python文件，输入以下代码，运行无误即说明环境就绪。

   import networkx as nx import matplotlib.pyplot as plt print(“NetworkX version:”, nx.__version__) print(“Matplotlib version:”, plt.__version__)

实操心得：

• 版本管理：对于正式项目，强烈建议使用虚拟环境（如venv或conda env）来管理依赖，避免不同项目间的库版本冲突。一个简单的命令python -m venv graph_env就能创建一个独立环境。
• IDE选择：Jupyter Notebook非常适合做交互式的探索和快速可视化，你可以边写代码边看图。PyCharm或VS Code则更适合大型项目开发。根据你的工作流选择即可。

3. 核心一：非赋权图（简单图）的绘制与美化

非赋权图，也称为简单图，是图论中最基础的模型。它只关心节点之间是否有连接，而不关心连接的强度或属性。我们从一个最简单的例子开始：绘制一个包含5个节点和若干条边的无向图。

3.1 基础绘制：五步创建你的第一张图

让我们先画一个“五角星”形状的图。

import networkx as nx import matplotlib.pyplot as plt # 1. 创建一个空的无向图 G = nx.Graph() # 2. 添加节点。可以一次加一个，也可以加一个列表。 G.add_nodes_from([1, 2, 3, 4, 5]) # 3. 添加边。边定义了节点之间的关系。 edges = [(1, 2), (1, 3), (2, 4), (3, 5), (4, 5)] G.add_edges_from(edges) # 4. 绘制图形 # `nx.draw` 是networkx最基础的绘图函数，`with_labels=True`表示显示节点标签。 nx.draw(G, with_labels=True, node_color=‘lightblue’, edge_color=‘gray’) # 5. 显示图形 plt.show()

运行这段代码，你会看到一个由5个浅蓝色节点和5条灰色边构成的图。节点1、2、3、4、5按照我们添加边的顺序被连接起来。nx.draw函数自动为我们选择了一种布局（默认是spring_layout，一种模拟弹簧引力和斥力的算法），让节点不至于重叠。

3.2 布局算法详解：让图形结构一目了然

自动布局的结果可能并不总是最优。networkx提供了多种布局算法，理解它们的特点至关重要。

• spring_layout(Fruchterman-Reingold 力导向布局)：默认且最常用。模拟物理系统，连接的节点相互吸引，所有节点相互排斥，经过迭代达到平衡。优点是对大多数图都能产生清晰、美观的效果，能自然展现图的簇状结构。

  pos = nx.spring_layout(G, seed=42) # seed参数确保每次运行布局一致 nx.draw(G, pos, with_labels=True) plt.show()

• circular_layout：将所有节点均匀放置在一个圆环上。非常适合展示环状结构或需要强调节点平等性的图，比如循环链表。

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

• shell_layout：将节点放置在一系列同心圆上。常用于显示具有层次结构或核心-边缘结构的网络，比如将中心度高的节点放在内圈。

  # 假设节点1是中心，其他节点在外围 shells = [[1], [2, 3, 4, 5]] pos = nx.shell_layout(G, shells) nx.draw(G, pos, with_labels=True) plt.show()

• kamada_kawai_layout：另一种力导向算法，旨在最小化全局“能量”。它通常比spring_layout计算量更大，但对于中小型图，有时能产生更优的、边长更均匀的布局。

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

注意事项：

• 布局一致性：在比较同一张图的不同状态（如添加/删除边前后）时，务必使用相同的节点位置字典pos。否则，节点到处乱跳，会严重干扰对比分析。
• 大图慎用力导向：对于节点数超过几百个的大型图，spring_layout和kamada_kawai_layout的计算会非常缓慢。此时应考虑更简单的布局（如circular_layout），或使用专门处理大图的库（如netwulf进行Web渲染，或使用graph-tool等高性能库）。

3.3 深度美化：从“能看”到“专业”

基础的黑色线条和圆点显然不够。我们需要通过颜色、大小、形状和标签来传递更多信息。

# 计算每个节点的度（连接数），用于决定节点大小 node_degree = dict(G.degree()) # 将度映射到节点大小，例如 (度 * 100 + 200) node_size = [node_degree[n] * 100 + 200 for n in G.nodes()] # 为边和节点设置不同的颜色 node_color = [‘red’ if n == 1 else ‘lightblue’ for n in G.nodes()] # 突出节点1 edge_color = [‘green’ if (u, v) == (1, 2) else ‘gray’ for u, v in G.edges()] # 突出边(1,2) # 使用更高级的绘制函数 nx.draw_networkx，它提供更多参数控制 pos = nx.spring_layout(G, seed=42) nx.draw_networkx_nodes(G, pos, node_size=node_size, node_color=node_color, alpha=0.9) # alpha控制透明度 nx.draw_networkx_edges(G, pos, width=2, alpha=0.7, edge_color=edge_color, style=‘solid’) # width控制边粗 nx.draw_networkx_labels(G, pos, font_size=12, font_family=‘sans-serif’) # 美化坐标轴 plt.title(“一个美化后的非赋权图示例”, fontsize=14) plt.axis(‘off’) # 关闭坐标轴，让图更干净 plt.tight_layout() # 自动调整子图参数，使之填充整个图像区域 plt.show()

这段代码展示了如何精细化控制图的每一个视觉元素。通过将节点度映射为大小，我们一眼就能看出哪些是“枢纽”节点。通过高亮特定节点和边，可以引导观众的注意力。

实操心得：颜色映射（Colormap）当需要用一个连续变量（如节点中心性分数）来给节点着色时，不要手动计算RGB值。使用matplotlib的Colormap（色彩映射）是更专业的方法。

import matplotlib.cm as cm # 假设我们有一个中心性字典 centrality = nx.degree_centrality(G) # 将中心性值归一化到0-1之间，用于映射颜色 values = [centrality[node] for node in G.nodes()] # 选择色彩映射，如‘viridis’, ‘plasma’, ‘coolwarm’ cmap = cm.plasma # 绘制节点，c参数接收数值列表，cmap指定色彩映射 nx.draw_networkx_nodes(G, pos, node_size=300, node_color=values, cmap=cmap, alpha=0.8) # 添加一个颜色条以说明 sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=min(values), vmax=max(values))) sm.set_array([]) plt.colorbar(sm, label=‘Degree Centrality’)

这样生成的图，颜色不仅美观，而且包含了精确的数值信息。

4. 核心二：赋权图（加权图）的可视化表达

赋权图在边（有时是节点）上附加了数值权重，用以表示距离、成本、流量、相似度等。可视化赋权图的关键在于：如何将权重信息有效地编码到视觉通道中。最直接的方式是通过边的粗细和颜色。

4.1 创建与绘制加权边

我们创建一个模拟城市间航班网络的赋权图，权重代表飞行时间（小时）。

import networkx as nx import matplotlib.pyplot as plt # 创建一个空的无向加权图 G_weighted = nx.Graph() # 添加带权重的边。格式：(节点1, 节点2, 权重) flights = [ (‘北京’, ‘上海’, 2), (‘北京’, ‘广州’, 3.5), (‘上海’, ‘广州’, 2.2), (‘上海’, ‘成都’, 2.8), (‘广州’, ‘成都’, 2.5), (‘广州’, ‘深圳’, 0.8), (‘成都’, ‘西安’, 1.5) ] G_weighted.add_weighted_edges_from(flights) # 计算布局 pos = nx.spring_layout(G_weighted, seed=42) # 提取所有权重，用于后续映射 weights = nx.get_edge_attributes(G_weighted, ‘weight’).values() weights_list = list(weights) # 将权重映射到边的宽度和颜色。这里使用线性映射。 # 边宽：例如，最小权重对应宽度1，最大权重对应宽度5 min_w, max_w = min(weights_list), max(weights_list) edge_widths = [1 + 4 * (w - min_w) / (max_w - min_w) for w in weights_list] # 边颜色：使用色彩映射，权重越大颜色越“热”（如红色） edge_colors = weights_list # 绘制 plt.figure(figsize=(10, 8)) # 设置画布大小 nx.draw_networkx_nodes(G_weighted, pos, node_size=800, node_color=‘lightgreen’, alpha=0.9) # 关键：绘制边时，传入宽度和颜色列表 nx.draw_networkx_edges(G_weighted, pos, width=edge_widths, edge_color=edge_colors, edge_cmap=plt.cm.Reds, alpha=0.7) nx.draw_networkx_labels(G_weighted, pos, font_size=12, font_weight=‘bold’) # 绘制边的权重标签 nx.draw_networkx_edge_labels(G_weighted, pos, edge_labels=nx.get_edge_attributes(G_weighted, ‘weight’), font_size=10) plt.title(“城市间航班时间（加权图）”, fontsize=16) plt.axis(‘off’) plt.tight_layout() plt.show()

在这张图中，连接“广州”和“深圳”的边最细、颜色最浅（因为飞行时间最短，0.8小时），而“北京”到“广州”的边最粗、颜色最深（飞行时间最长，3.5小时）。边的标签直接显示了具体数值。这种“粗细+颜色+标签”的三重编码，确保了权重信息被清晰、冗余地传达，即使黑白打印，粗细也能区分。

4.2 权重映射策略与视觉编码原理

将数据映射到视觉属性时，需要遵循一些基本原则：

1. 有序性：权重是有序数值，应映射到有序的视觉通道，如大小（宽度）、饱和度、亮度或顺序色板。避免映射到无序通道，如形状或分类色板。
2. 可辨性：确保映射后的视觉差异足以被人眼区分。如果权重差异很小，线性映射可能导致所有边看起来都一样粗。此时可以考虑非线性映射（如对数缩放）来放大小差异。

   # 对数缩放示例，适用于权重跨度大的情况 import numpy as np weights_log = np.log1p(weights_list) # log(1+x) 避免对0取对数 edge_widths = [1 + 4 * (w - min(weights_log)) / (max(weights_log) - min(weights_log)) for w in weights_log]

3. 语义一致性：尽量让视觉编码符合直觉。例如，用更粗、更“热”（红）的边表示更高的权重（如距离、成本），这符合“更多/更强=更突出”的认知。如果权重表示的是“相似度”（值越大越相似），那么用更粗、更“冷”（蓝）的边表示高相似度可能更合适。

注意事项：

• 避免过度编码：同时使用宽度、颜色、标签可能会使图形过于杂乱，尤其是边很多的时候。对于稠密图，可以考虑只使用颜色这一种通道，并通过颜色条（colorbar）来图例，或者干脆在交互式可视化中悬停显示权重。
• 权重标准化：在绘制前，思考权重是否需要进行标准化或归一化。例如，如果你的权重是“距离”和“相似度”两种不同量纲和意义的混合，直接放在一起映射宽度是没有意义的。需要分别处理或转换为统一的度量。

5. 核心三：有向图（Digraph）与方向可视化

有向图中的边具有方向，从源节点（u）指向目标节点（v）。在Python中，我们使用nx.DiGraph()来创建。方向的可视化通常通过箭头来实现。

5.1 绘制带箭头的有向图

我们模拟一个简单的任务依赖关系图：任务A必须在任务B和C之前完成，任务D依赖于任务B。

import networkx as nx import matplotlib.pyplot as plt # 创建一个空的有向图 G_directed = nx.DiGraph() # 添加有向边 dependencies = [(‘A’, ‘B’), (‘A’, ‘C’), (‘B’, ‘D’)] G_directed.add_edges_from(dependencies) # 计算布局。有向图通常使用层次布局来强调流向。 pos = nx.spring_layout(G_directed, seed=42) # 仍然可以使用力导向 # 或者使用专门为有向图设计的层级布局 # pos = nx.planar_layout(G_directed) # 如果图是平面的 # pos = nx.shell_layout(G_directed, [[‘A’], [‘B’, ‘C’], [‘D’]]) # 自定义层级 # 绘制 plt.figure(figsize=(8, 6)) # `nx.draw_networkx_edges` 的 `arrows`, `arrowstyle`, `arrowsize` 参数控制箭头 nx.draw_networkx_nodes(G_directed, pos, node_size=800, node_color=‘gold’, alpha=0.9) nx.draw_networkx_edges(G_directed, pos, edgelist=G_directed.edges(), arrowstyle=‘->’, arrowsize=20, width=2, edge_color=‘darkblue’, connectionstyle=“arc3,rad=0.1”) # connectionstyle使边弯曲，避免重叠 nx.draw_networkx_labels(G_directed, pos, font_size=14, font_weight=‘bold’) plt.title(“任务依赖关系有向图”, fontsize=16) plt.axis(‘off’) plt.tight_layout() plt.show()

关键参数解析：

• arrowstyle：箭头样式。‘->’是实心三角箭头，‘-|>’是填充箭头，‘-’是无箭头（直线）。‘fancy’等样式可提供更多控制。
• arrowsize：箭头大小。需要根据节点大小和图形尺寸调整，太小看不清，太大会遮盖节点。
• connectionstyle：这是解决有向图边重叠问题的神器。“arc3,rad=0.1”表示边绘制为曲率半径为0.1的圆弧，这样从同一节点出发指向不同目标的边就会自然分开，大大提升了可读性。你可以调整rad值来控制弯曲程度。

5.2 复杂有向图布局：层次结构与循环处理

对于工作流、依赖关系、食物链等具有明确方向性的图，spring_layout可能不是最佳选择，因为它不强制方向一致性。networkx提供了nx.drawing.layout中的一些方法，但更强大的层次布局需要借助graphviz的dot布局引擎。

使用PyGraphviz/Agraph获得更优层次布局（推荐）：

# 首先需要安装pygraphviz或agraph (通常通过系统包管理器或conda安装更易成功) # pip install pygraphviz # 可能较难安装，需要Graphviz开发库 # 替代方案：使用 networkx 的 `nx.nx_agraph.graphviz_layout` try: import pygraphviz # 使用 dot 布局（自上而下的层次布局） pos = nx.nx_agraph.graphviz_layout(G_directed, prog=‘dot’) print(“使用Graphviz dot布局成功”) except ImportError: # 回退方案：使用networkx自带的 multipartite_layout (如果图是分层级的) # 需要手动指定层级，例如 {‘A’: 0, ‘B’: 1, ‘C’: 1, ‘D’: 2} layers = {‘A’: 0, ‘B’: 1, ‘C’: 1, ‘D’: 2} pos = nx.multipartite_layout(G_directed, subset_key=layers) print(“使用multipartite_layout作为替代”)

dot布局会自动根据边的方向，将节点排列成清晰的层级，源头任务在上，下游任务在下，视觉效果非常专业。

处理有向环（循环依赖）：如果图中存在环（例如A->B, B->C, C->A），力导向布局可能仍能工作，但层次布局（如dot）会失败，因为它要求图是无环的（DAG）。对于含环的有向图，spring_layout或circular_layout通常是更安全的选择，同时需要确保箭头清晰可辨。

实操心得：

• 箭头重叠：当多个边连接同一对节点（双向或多条平行边）时，箭头会完全重叠。解决方法：1) 使用connectionstyle制造弧度差；2) 使用curved参数（如果后端支持）；3) 对于平行边，可以考虑使用nx.draw_networkx_edges分别绘制每条边，并手动偏移它们的位置。
• 大图箭头：在具有成百上千条边的大规模有向图中，绘制所有箭头会严重拖慢渲染速度并造成视觉混乱。此时，可以考虑不绘制箭头，而通过颜色或渐变来暗示方向（例如，从源节点的颜色渐变到目标节点的颜色），或者仅在用户交互（如悬停）时显示方向。

6. 综合实战：一个社交网络分析与可视化案例

现在，我们将所有知识融合，完成一个接近真实场景的案例：分析并可视化一个小型社交网络。我们拥有“用户”（节点）和“关注”关系（有向边），以及互动频率（边的权重）。

6.1 数据构建与图创建

假设我们有7个用户，他们之间的关注关系和上周的互动消息数如下：

import networkx as nx import matplotlib.pyplot as plt import matplotlib.cm as cm import numpy as np # 创建有向加权图 G_social = nx.DiGraph() # 添加带权有向边: (关注者, 被关注者, 互动数) interactions = [ (‘Alice’, ‘Bob’, 15), (‘Alice’, ‘Charlie’, 8), (‘Bob’, ‘Alice’, 3), (‘Bob’, ‘David’, 20), (‘Charlie’, ‘Alice’, 5), (‘Charlie’, ‘David’, 12), (‘David’, ‘Eva’, 7), (‘Eva’, ‘Frank’, 4), (‘Frank’, ‘Grace’, 9), (‘Grace’, ‘David’, 6), # 添加一些弱连接，使网络更真实 (‘Alice’, ‘Eva’, 2), (‘Frank’, ‘Charlie’, 1), ] G_social.add_weighted_edges_from(interactions) print(“网络基本信息：”) print(f” 节点数: {G_social.number_of_nodes()}”) print(f” 边数: {G_social.number_of_edges()}”) print(f” 平均度: {2*G_social.number_of_edges()/G_social.number_of_nodes():.2f}”)

6.2 多维度计算与属性绑定

为了进行丰富的可视化编码，我们计算几个关键的图指标，并将它们作为属性绑定到节点和边上。

# 1. 计算节点中心性（这里用入度中心性，表示受欢迎程度） in_degree_centrality = nx.in_degree_centrality(G_social) # 计算PageRank，另一种衡量节点重要性的指标 pagerank = nx.pagerank(G_social, weight=‘weight’) # 考虑权重 # 2. 计算聚类系数（对于有向图，networkx会忽略方向计算局部聚类系数） clustering = nx.clustering(G_social.to_undirected()) # 转换为无向图计算 # 3. 将计算出的属性设置为节点属性 nx.set_node_attributes(G_social, in_degree_centrality, ‘in_centrality’) nx.set_node_attributes(G_social, pagerank, ‘pagerank’) nx.set_node_attributes(G_social, clustering, ‘clustering’) # 4. 为边设置一个颜色属性，例如根据权重分段 edge_weights = nx.get_edge_attributes(G_social, ‘weight’) # 定义权重分段函数 def weight_category(w): if w > 15: return ‘very_high’ elif w > 10: return ‘high’ elif w > 5: return ‘medium’ else: return ‘low’ edge_color_map = {e: weight_category(w) for e, w in edge_weights.items()} nx.set_edge_attributes(G_social, edge_color_map, ‘weight_category’) print(“\n节点属性示例 (Alice):”) print(f” 入度中心性: {G_social.nodes[‘Alice’][‘in_centrality’]:.3f}”) print(f” PageRank: {G_social.nodes[‘Alice’][‘pagerank’]:.3f}”) print(f” 聚类系数: {G_social.nodes[‘Alice’][‘clustering’]:.3f}”)

6.3 高级可视化：集成多重视觉编码

现在，我们绘制一张信息丰富的图：

• 节点大小：由PageRank值决定，重要性越高，节点越大。
• 节点颜色：由入度中心性决定，使用viridis色彩映射，越受欢迎颜色越亮。
• 边宽度：由互动次数（权重）决定，互动越多，边越粗。
• 边颜色/样式：根据我们定义的权重类别，用不同颜色和线型区分。
• 箭头：清晰显示关注方向。
• 标签：显示节点名称。

# 准备可视化数据 pos = nx.spring_layout(G_social, seed=42, k=1.5) # k参数增加节点间距 # 节点属性 node_sizes = [G_social.nodes[n][‘pagerank’] * 8000 + 500 for n in G_social.nodes()] # 缩放PageRank node_colors = [G_social.nodes[n][‘in_centrality’] for n in G_social.nodes()] # 入度中心性值 # 边属性：按类别分组 edge_groups = {‘very_high’: [], ‘high’: [], ‘medium’: [], ‘low’: []} for u, v, data in G_social.edges(data=True): edge_groups[data[‘weight_category’]].append((u, v)) # 定义每类边的样式 edge_style_map = { ‘very_high’: {‘color’: ‘darkred’, ‘width’: 4.0, ‘style’: ‘solid’}, ‘high’: {‘color’: ‘red’, ‘width’: 3.0, ‘style’: ‘solid’}, ‘medium’: {‘color’: ‘orange’, ‘width’: 2.0, ‘style’: ‘solid’}, ‘low’: {‘color’: ‘lightgray’, ‘width’: 1.0, ‘style’: ‘dashed’}, # 弱连接用虚线 } # 开始绘图 plt.figure(figsize=(14, 10)) # 1. 绘制节点（使用色彩映射） nodes = nx.draw_networkx_nodes(G_social, pos, node_size=node_sizes, node_color=node_colors, cmap=plt.cm.viridis, alpha=0.85, edgecolors=‘black’, linewidths=1) # 给节点加黑色边框 # 2. 分批次绘制边 for category, edges in edge_groups.items(): if edges: # 如果该类别有边 style = edge_style_map[category] nx.draw_networkx_edges(G_social, pos, edgelist=edges, edge_color=style[‘color’], width=style[‘width’], style=style[‘style’], arrowstyle=‘->’, arrowsize=15, connectionstyle=“arc3,rad=0.1”, alpha=0.7) # 3. 绘制节点标签 nx.draw_networkx_labels(G_social, pos, font_size=11, font_weight=‘bold’) # 4. 添加颜色条和图例 # 节点颜色条 sm = plt.cm.ScalarMappable(cmap=plt.cm.viridis, norm=plt.Normalize(vmin=min(node_colors), vmax=max(node_colors))) sm.set_array([]) cbar = plt.colorbar(sm, ax=plt.gca(), shrink=0.8, label=‘In-Degree Centrality (Popularity)’) # 边图例（手动创建） import matplotlib.patches as mpatches legend_patches = [] for cat, style in edge_style_map.items(): patch = mpatches.Patch(color=style[‘color’], label=f’{cat} interaction’, linestyle=style[‘style’], linewidth=style[‘width’]) legend_patches.append(patch) plt.legend(handles=legend_patches, loc=‘upper left’, bbox_to_anchor=(1.05, 1), title=‘Edge Weight Category’) plt.title(“社交网络分析：关注关系与互动强度\n(节点大小: PageRank, 节点颜色: 入度中心性, 边宽/色/型: 互动频率)”, fontsize=14, pad=20) plt.axis(‘off’) plt.tight_layout() plt.show()

这张图现在包含了大量的信息：一眼望去，我们可以看到David和Alice可能是网络中的核心人物（节点大且颜色亮）。Bob对David的关注互动非常频繁（粗红色实线），而Alice对Eva的关注则很弱（灰色虚线）。整个网络的结构、关键人物和关系强度一目了然。

7. 常见问题、性能优化与输出技巧

即使掌握了基本绘制方法，在实际项目中你仍会遇到各种挑战。以下是我总结的一些典型问题及其解决方案。

7.1 可视化常见问题排查表

7.2 高级输出与集成

1. 高质量保存：用于论文或报告的图片需要矢量格式（无限放大不模糊）和高分辨率。

# 保存为SVG（矢量图，适合论文） plt.savefig(‘social_network.svg’, format=‘svg’, bbox_inches=‘tight’) # 保存为高分辨率PNG plt.savefig(‘social_network.png’, dpi=300, bbox_inches=‘tight’) # 保存为PDF（也是矢量图） plt.savefig(‘social_network.pdf’, bbox_inches=‘tight’)

2. 与Jupyter Notebook深度集成：在Notebook中，可以使用%matplotlib inline魔法命令内嵌显示。为了更好的交互体验，可以结合ipywidgets创建控件来动态调整参数。

%matplotlib inline from ipywidgets import interact, FloatSlider, Dropdown def plot_network(k=1.0, node_scale=1000): pos = nx.spring_layout(G_social, seed=42, k=k) node_sizes = [G_social.nodes[n][‘pagerank’] * node_scale + 300 for n in G_social.nodes()] plt.figure(figsize=(10, 8)) nx.draw_networkx(G_social, pos, node_size=node_sizes, with_labels=True, width=2, alpha=0.7) plt.axis(‘off’) plt.show() interact(plot_network, k=FloatSlider(min=0.5, max=3.0, step=0.1, value=1.5, description=‘间距(k)’), node_scale=FloatSlider(min=500, max=5000, step=500, value=3000, description=‘大小缩放’))

3. 导出到其他工具：networkx可以轻松将图导出，供更强大的可视化工具（如Gephi）处理。

# 导出为GEXF格式 (Gephi) nx.write_gexf(G_social, ‘social_network.gexf’) # 导出为GraphML格式 nx.write_graphml(G_social, ‘social_network.graphml’)

在Gephi中，你可以使用其丰富的布局算法、过滤器和渲染引擎，制作出出版级别的网络可视化图。

踩过几次坑之后，我最大的体会是：图可视化从来不是一步到位的事情。它是一个探索-调整-再探索的循环。你需要先快速画出一张草图，然后根据你想强调的故事（是突出核心节点？还是展示社区结构？或是揭示特定关系？），不断地调整布局、颜色、大小和标签。不要害怕尝试奇怪的参数组合，很多时候，一点小小的调整（比如把spring_layout的seed换一下，或者把边的曲率rad从0.1调到0.2）就能让整个图形豁然开朗。最后，记住你的受众，一张在学术论文里的图和一张在商业报告里的图，其设计语言和细节密度应该是完全不同的。