企业官网建设流程全解析

1. 从零开始：为什么用Python画图是建模的“第一公里”

搞数学建模或者数据分析的朋友，肯定都遇到过这个场景：拿到一堆数据，脑子里构思了一个用图论模型来描述的方案，比如社交网络分析、交通流模拟、知识图谱构建。方案的核心逻辑理清了，但怎么把它直观地、有说服力地展示出来，尤其是给那些不太懂技术的评委或同事看？这时候，一张清晰、专业的图（Graph）往往比千言万语都管用。很多人卡在了这“第一公里”——知道该用图，但不知道如何快速、准确地把图画出来。

我见过不少队伍，模型建得天花乱坠，论文里却用着从Visio或者PPT里拖出来的、连线歪歪扭扭、节点大小不一的示意图，专业感瞬间掉了一半。更麻烦的是，当需要基于图的结构进行计算（比如最短路径、中心性分析）时，这些绘图工具就完全无能为力了。Python，特别是借助networkx这个库，完美地解决了这个问题。它让你能够“以代码定义图，以代码分析图，最后再用代码画出图”，整个过程可复现、可调整、自动化程度高。

简单来说，networkx是一个用于创建、操作和研究复杂网络结构、动力学和功能的Python包。它内置了数十种经典图的生成算法、丰富的图论算法（路径、连通性、匹配、流等），以及多种布局和绘图功能。我们今天要解决的核心问题，就是如何利用它，针对三种最常见的图类型——非赋权图、赋权图、有向图——画出既美观又信息量充足的示意图。这不仅仅是“画图”，更是将你的数学模型进行第一次可视化验证和沟通的关键步骤。

2. 环境奠基：安装networkx与理解绘图核心依赖

在动手画任何图之前，一个稳定、兼容的环境是基石。很多人，尤其是初学者，容易在这里踩坑。最常见的问题不是networkx本身，而是它的绘图后端。

2.1 安装networkx与matplotlib

安装本身非常简单，一条命令即可。我强烈建议使用虚拟环境来管理项目依赖，避免不同项目间的包版本冲突。

# 使用pip安装，这是最通用的方式 pip install networkx matplotlib # 如果你使用Anaconda，也可以用conda安装，它会自动处理一些底层依赖 conda install networkx matplotlib

这里的关键是matplotlib。networkx的绘图功能主要依赖于matplotlib作为渲染引擎。你可以把networkx想象成设计师，它负责设计图的布局、节点和边的样式；而matplotlib则是印刷厂，负责把设计稿实际打印（渲染）出来。没有matplotlib，networkx的绘图函数就无法工作。

2.2 理解绘图后端与常见“画不出来”的问题

安装好后，一个经典的错误是运行绘图代码后，弹出一个空白窗口或者什么都不显示。这通常不是代码逻辑错误，而是matplotlib的交互模式或后端设置问题。

对于脚本执行环境（如.py文件或Jupyter Notebook之外的命令行）：默认情况下，matplotlib的图形窗口在绘制完成后会立即关闭。为了让图像显示并停留，你需要显式地调用plt.show()。这是最基本，但最容易被遗忘的一步。

import networkx as nx import matplotlib.pyplot as plt # 创建一个简单的图并绘制 G = nx.Graph() G.add_edges_from([(1, 2), (2, 3), (3, 1)]) nx.draw(G, with_labels=True) plt.show() # 必须要有这一行，图像才会显示并阻塞程序直到你关闭窗口

对于Jupyter Notebook/Lab环境：为了让图形内嵌在Notebook单元格中显示，你需要在开头使用一个“魔术命令”来设置matplotlib的内联后端。

%matplotlib inline import networkx as nx import matplotlib.pyplot as plt # 之后你的绘图代码，图像会自动显示在单元格下方 G = nx.Graph([(1, 2), (2, 3)]) nx.draw(G, with_labels=True) # 在Notebook中，通常不需要显式调用 plt.show()

注意：如果你在Jupyter中使用了%matplotlib inline但图仍然不显示，或者显示异常（如图形错位、元素重叠），可以尝试改用%matplotlib notebook。这个命令会提供一些交互功能（如缩放、平移），但在某些复杂布局下可能更稳定。如果问题依旧，检查一下matplotlib的版本是否过旧，或者尝试重启Notebook内核。

后端选择：在极少数情况下，如果你的环境没有图形界面（比如在某些服务器或Docker容器中），你需要将matplotlib的后端设置为“无头”模式，例如Agg，然后将图保存为文件。

import matplotlib matplotlib.use('Agg') # 在导入plt之前设置 import matplotlib.pyplot as plt import networkx as nx G = nx.complete_graph(5) nx.draw(G) plt.savefig('my_graph.png') # 保存到文件 print("图形已保存为 my_graph.png")

确保环境配置正确，我们就有了挥洒创意的画布。接下来，我们从最简单的图开始画起。

3. 绘制非赋权图：基础中的基础，布局定乾坤

非赋权图，也叫无权图，是图论中最基础的模型。它的边只表示节点间“是否存在连接”，而不关心连接的“强度”或“成本”。社交网络中的“是否为好友”、电路板上的“是否连通”，都可以用非赋权图表示。绘制这类图，核心挑战不在于数据本身，而在于如何通过布局算法让图的结构一目了然。

3.1 创建图对象与添加元素

networkx提供了几种图类，最常用的是nx.Graph()（无向图）和nx.DiGraph()（有向图，下一节细说）。创建和添加元素非常直观。

import networkx as nx import matplotlib.pyplot as plt # 方法1：逐步添加 G = nx.Graph() # 创建一个空的无向图 G.add_node(1) # 添加单个节点，节点可以是数字、字符串甚至对象 G.add_nodes_from([2, 3, 4]) # 从列表批量添加节点 G.add_edge(1, 2) # 在节点1和2之间添加一条边 G.add_edges_from([(2, 3), (3, 4), (4, 1)]) # 批量添加边 # 方法2：在创建时直接初始化（更简洁） G = nx.Graph([(1, 2), (2, 3), (3, 4), (4, 1)]) # 边列表会自动创建涉及的节点

3.2 核心绘图函数nx.draw与基础美化

nx.draw()是最基础的绘图函数，它接受图对象G和一系列参数来控制外观。

# 基础绘图 nx.draw(G) plt.show()

这行代码会生成一张图，但很可能杂乱无章，因为节点被随机放置。为了让图有意义，我们必须引入布局算法。

# 使用spring布局（力导向布局）并添加标签 pos = nx.spring_layout(G, seed=42) # seed参数确保每次运行布局一致，便于调试 nx.draw(G, pos, with_labels=True, node_color='lightblue', node_size=500, font_size=10) plt.title("基础非赋权图示例") plt.show()

• pos: 一个字典，键是节点，值是节点的(x, y)坐标。spring_layout模拟了物理中的弹簧模型，连接的边像弹簧，未连接的节点互相排斥，经过迭代后达到一个能量较低的平衡状态，通常能产生比较清晰的布局。seed参数固定随机数种子，保证可复现性。
• with_labels=True: 在节点上显示其标签（即节点标识符）。
• node_color和node_size: 控制节点的颜色和大小。
• font_size: 控制标签字体大小。

3.3 深入理解布局算法：如何让图“自己会说话”

选择正确的布局算法，是让非赋权图传达信息的关键。networkx提供了多种布局，适用于不同结构的图。

1. 环形布局 (circular_layout)：适用于展示循环结构或强调所有节点地位平等。

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

2. 随机布局 (random_layout)：节点完全随机放置。除非用于测试或艺术效果，否则不推荐，因为无法反映任何结构信息。

pos = nx.random_layout(G)

3. 谱布局 (spectral_layout)：利用图的拉普拉斯矩阵的特征向量来定位节点。对于某些具有明显社区结构的图，效果非常好，能将同一社区的节点聚集在一起。

pos = nx.spectral_layout(G)

4. 壳层布局 (shell_layout)：将节点放置在一系列同心圆上。特别适合展示具有层次结构或核心-边缘结构的网络，比如某些社交网络（核心人物在内圈，普通用户在外圈）。

# 假设我们有一个核心节点集 [1, 2] 和外圈节点集 [3, 4, 5, 6] G = nx.complete_graph(6) # 创建一个6个节点的完全图举例 core_nodes = [1, 2] other_nodes = [n for n in G.nodes() if n not in core_nodes] pos = nx.shell_layout(G, nlist=[core_nodes, other_nodes]) nx.draw(G, pos, with_labels=True) plt.show()

实战心得：布局选择与调参

• 中小型图（<100节点）：spring_layout是默认且最通用的选择。你可以通过k参数调整节点间的理想距离（默认值约为1/sqrt(n)），iterations参数调整迭代次数（默认50）。对于复杂图，增加迭代次数（如iterations=200）可能得到更稳定的布局。
• 层次清晰的图：优先尝试shell_layout或spectral_layout。
• 大型图（>1000节点）：spring_layout会非常慢。考虑使用nx.draw_networkx_nodes和nx.draw_networkx_edges分别绘制，并可能需要对节点进行采样或使用专门的大图布局工具（如graph-tool或Gephi导出布局后再用networkx画）。
• 固定布局：如果你有一组预设的节点坐标（比如地图上的城市），可以直接构建pos字典传入draw函数。

绘制非赋权图是基本功，核心在于通过布局揭示结构。当图上需要承载更多信息（比如边的权重）时，我们就进入了赋权图的领域。

4. 绘制赋权图：让边的“分量”可视化

赋权图，也叫加权图，它的每条边都有一个数值（权重），可以代表距离、成本、流量、相似度等。在数学建模中，赋权图无处不在，如交通网络（权重为距离或时间）、通信网络（权重为带宽或延迟）。绘制赋权图的关键，是如何将边的权重这个“隐形”信息，通过视觉元素（如边的粗细、颜色、标签）有效地呈现出来。

4.1 为边添加权重属性

在networkx中，权重是作为边的一个属性来存储的。

import networkx as nx # 创建一个赋权图（无向） G = nx.Graph() # 添加带权重的边。权重属性名通常约定俗成叫 'weight' G.add_edge('A', 'B', weight=4) G.add_edge('B', 'C', weight=2) G.add_edge('A', 'C', weight=5) G.add_edge('C', 'D', weight=1) G.add_edge('B', 'D', weight=7) # 也可以批量添加 # edges_with_weight = [('A','B',4), ('B','C',2), ...] # G.add_weighted_edges_from(edges_with_weight)

4.2 基于权重控制边的视觉通道

视觉编码是信息可视化的核心。对于权重，我们主要有三种编码方式：粗细、颜色和标签。通常组合使用以达到最佳效果。

1. 用边的粗细表示权重：这是最直观的方式之一。权重越大，边越粗。

import matplotlib.pyplot as plt pos = nx.spring_layout(G, seed=42) # 提取所有权重，用于后续归一化 weights = nx.get_edge_attributes(G, 'weight').values() # 将权重列表转换为一个与边顺序对应的列表 weight_list = [G[u][v]['weight'] for u, v in G.edges()] # 绘制节点和标签 nx.draw_networkx_nodes(G, pos, node_color='lightblue', node_size=500) nx.draw_networkx_labels(G, pos) # 关键：绘制边，线宽与权重成正比 # 这里对权重进行缩放，避免线宽过大或过小。因子2.0可以调整。 nx.draw_networkx_edges(G, pos, width=[w * 2.0 for w in weight_list]) plt.title("赋权图 - 边粗表示权重") plt.axis('off') # 关闭坐标轴 plt.show()

这里我们使用了draw_networkx_nodes,draw_networkx_edges,draw_networkx_labels这三个函数来分别绘制图的不同部分，从而获得更精细的控制。width参数接受一个标量或一个与边列表顺序对应的宽度列表。

2. 用边的颜色表示权重：颜色可以表示权重的大小（通过颜色深浅/冷暖）或类别（通过不同色相）。这里我们用颜色深浅（colormap）来表示连续权重。

import matplotlib.cm as cm pos = nx.spring_layout(G, seed=42) weights = nx.get_edge_attributes(G, 'weight') weight_list = [weights[(u, v)] for u, v in G.edges()] # 选择一个颜色映射，如 'viridis' (深到浅)，'plasma', 'YlOrRd' (黄橙红) cmap = cm.get_cmap('YlOrRd') # 将权重归一化到 [0, 1] 区间，用于映射颜色 norm_weights = [(w - min(weight_list)) / (max(weight_list) - min(weight_list)) for w in weight_list] edge_colors = [cmap(w) for w in norm_weights] # 得到RGBA颜色列表 nx.draw_networkx_nodes(G, pos, node_color='lightgray', node_size=500) nx.draw_networkx_labels(G, pos) # 用颜色列表绘制边 nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=2) plt.title("赋权图 - 边色表示权重 (YlOrRd)") plt.axis('off') plt.show()

3. 为边添加权重标签：最精确的方式，直接将权重数字标在边上。

pos = nx.spring_layout(G, seed=42) nx.draw(G, pos, with_labels=True, node_color='w', edge_color='gray', width=2, font_weight='bold') # 单独绘制边的权重标签 edge_labels = nx.get_edge_attributes(G, 'weight') nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red') plt.title("赋权图 - 标签显示权重") plt.axis('off') plt.show()

draw_networkx_edge_labels函数专门用于在边旁边绘制标签。一个常见问题是标签位置可能不理想或与边重叠，可以通过调整label_pos参数（默认为0.5，表示边的中点）或font_size来改善。

4.3 综合应用：粗细、颜色、标签三合一

在实际的建模报告或论文中，为了达到最佳的沟通效果，我们常常需要综合运用多种视觉编码。

pos = nx.spring_layout(G, seed=42) weights = nx.get_edge_attributes(G, 'weight') weight_list = [weights[(u, v)] for u, v in G.edges()] # 1. 颜色和粗细都基于权重 cmap = cm.get_cmap('Blues') norm_weights = [(w - min(weight_list)) / (max(weight_list) - min(weight_list)) for w in weight_list] edge_colors = [cmap(w) for w in norm_weights] # 线宽在基础值上根据权重增加 base_width = 2 edge_widths = [base_width + w * 0.5 for w in weight_list] # 绘制 nx.draw_networkx_nodes(G, pos, node_color='lightyellow', node_size=700, edgecolors='black') nx.draw_networkx_labels(G, pos, font_size=12, font_weight='bold') nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=edge_widths) # 2. 添加权重标签，使用一个对比色 edge_labels = nx.get_edge_attributes(G, 'weight') nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=9, font_color='darkred', bbox=dict(facecolor='white', edgecolor='none', alpha=0.7)) plt.title("综合可视化：粗细、颜色、标签表示边权重") plt.axis('off') plt.tight_layout() # 自动调整子图参数，使之填充整个图像区域。 plt.show()

注意：视觉编码并非越多越好。如果权重差异不大，过度使用粗细和颜色可能造成视觉混乱，此时仅使用标签可能是最清晰的选择。始终要考虑读者的认知负荷，目标是“一目了然”，而不是“炫技”。

掌握了赋权图的画法，你就能将模型中的量化关系直观呈现。接下来，我们处理另一种常见且重要的图类型——有向图。

5. 绘制有向图：明确流动与依赖关系

有向图（Digraph）的边具有方向，从源节点（u）指向目标节点（v）。它用于建模具有明确方向性的关系，如网页链接（A链接到B）、任务依赖（A完成后B才能开始）、资金流向等。绘制有向图的核心，是如何清晰无误地表达出边的方向。

5.1 创建有向图对象

使用nx.DiGraph()来创建有向图，其节点和边的添加方式与无向图类似。

import networkx as nx # 创建有向图 DG = nx.DiGraph() DG.add_edges_from([(1, 2), (2, 3), (3, 1), (3, 4), (4, 2)]) # 也可以添加带权重的有向边 # DG.add_weighted_edges_from([(1, 2, 0.5), (2, 3, 0.8)])

5.2 使用箭头表达方向

networkx的draw函数族通过arrow相关参数来控制箭头的绘制。最常用的是nx.draw_networkx_edges中的arrows,arrowstyle, 和arrowsize 参数。

import matplotlib.pyplot as plt pos = nx.spring_layout(DG, seed=42) nx.draw_networkx_nodes(DG, pos, node_color='lightcoral', node_size=500) nx.draw_networkx_labels(DG, pos) # 关键：绘制带箭头的边 # arrows=True 是默认的，但为了清晰我们显式写出 # arrowstyle='->' 指定箭头样式，'->' 是简单的三角箭头 # arrowsize=15 控制箭头的大小 nx.draw_networkx_edges(DG, pos, edge_color='gray', width=2, arrows=True, arrowstyle='->', arrowsize=15) plt.title("基础有向图") plt.axis('off') plt.show()

5.3 有向图布局的挑战与技巧

有向图的布局比无向图更具挑战性，因为布局算法需要同时考虑节点位置和边的指向，以避免箭头交叉和指向不清。spring_layout虽然也能用，但并非为有向图优化。networkx提供了一些专门用于有向图的布局，或者我们可以通过一些技巧来改善。

1. 分层布局 (multipartite_layout或自定义层级)：对于具有明显层次或流程的有向图（如工作流、依赖图），分层布局是最清晰的。我们需要为每个节点指定一个“层”。

# 假设我们有一个简单的AOV网（Activity On Vertex） DG = nx.DiGraph() DG.add_edges_from([('需求', '设计'), ('设计', '开发'), ('开发', '测试'), ('测试', '发布'), ('设计', '测试')]) # 一个快速路径 # 手动定义层级（在实际中，可能需要用拓扑排序算法自动计算） layers = {'需求': 0, '设计': 1, '开发': 2, '测试': 3, '发布': 4} # 使用 multipartite_layout，它根据节点在 `subset_key` 属性中的值进行分层 for node, layer in layers.items(): DG.nodes[node]['layer'] = layer pos = nx.multipartite_layout(DG, subset_key='layer') nx.draw(DG, pos, with_labels=True, node_color='lightgreen', arrows=True) plt.title("分层布局有向图 (工作流示例)") plt.axis('off') plt.show()

2. 改进的力导向布局：对于没有明显层次的有向图，可以尝试使用nx.spring_layout，但通过调整参数使其更适合有向图。一个技巧是让边的“引力”不对称，但这需要更底层的定制。一个更简单实用的方法是使用nx.kamada_kawai_layout，它基于节点间的理想距离，有时对有向图能产生不错的效果。

pos = nx.kamada_kawai_layout(DG) nx.draw(DG, pos, with_labels=True, node_color='lightblue', arrows=True, connectionstyle='arc3,rad=0.1') # 使用弧形边减少交叉 plt.title("Kamada-Kawai 布局有向图") plt.axis('off') plt.show()

这里connectionstyle='arc3,rad=0.1'将边画成轻微的弧线，这在边比较密集时有助于减少视觉上的交叉，让箭头方向更易追踪。

3. 有向赋权图的综合绘制：结合有向和赋权，是建模中的高级需求，例如带流量的管道网络、带消耗的生产线。

# 创建一个有向赋权图 DG = nx.DiGraph() DG.add_weighted_edges_from([('Src', 'A', 5), ('Src', 'B', 3), ('A', 'C', 2), ('B', 'C', 4), ('C', 'Dst', 6)]) pos = nx.spring_layout(DG, seed=42) weights = nx.get_edge_attributes(DG, 'weight') weight_list = [weights[(u, v)] for u, v in DG.edges()] # 绘制节点和标签 nx.draw_networkx_nodes(DG, pos, node_color='gold', node_size=700) nx.draw_networkx_labels(DG, pos, font_size=11, font_weight='bold') # 绘制边：宽度代表权重，箭头代表方向 edge_widths = [w * 0.8 for w in weight_list] nx.draw_networkx_edges(DG, pos, width=edge_widths, edge_color='steelblue', arrows=True, arrowsize=20, connectionstyle='arc3,rad=0.1') # 添加权重标签 edge_labels = nx.get_edge_attributes(DG, 'weight') nx.draw_networkx_edge_labels(DG, pos, edge_labels, font_size=9) plt.title("有向赋权图 (流量/成本网络示例)") plt.axis('off') plt.tight_layout() plt.show()

实操心得：箭头与标签的清晰度

• 箭头大小：根据图的大小和边的密度动态调整arrowsize。图大边多，箭头要调大（如20-30）；图小边少，可以调小（如10-15）。
• 标签避让：边的权重标签 (edge_labels) 很容易和箭头或节点重叠。可以尝试：
  • 使用bbox参数给标签添加一个半透明的白色背景，如bbox=dict(facecolor='white', edgecolor='none', alpha=0.7)。
  • 微调label_pos（例如0.7，让标签更靠近目标节点），但这需要针对每条边单独设置，比较繁琐。
  • 如果重叠严重，考虑是否必须显示所有权重，或者能否用颜色/粗细替代部分标签。
• 循环（自环）：networkx可以处理自环（add_edge(1,1)），但默认绘制可能不美观。对于有自环的图，可能需要使用nx.draw_networkx_edges并配合connectionstyle进行更精细的控制。

掌握了非赋权、赋权、有向这三种基本图的绘制，你已经能应对数学建模中80%的可视化需求。但要想让你的图从“能用”变得“出色”，还需要一些进阶的美学和实用技巧。

6. 进阶技巧与实战排坑：从“能画”到“画得好”

当你掌握了基本画法后，下一个层次是让图形不仅正确，而且专业、美观、易于解读。这部分分享的是一些教科书里不常讲，但在实际项目中至关重要的经验和技巧。

6.1 节点与边的深度定制

networkx的绘图函数高度可定制，几乎所有视觉元素都可以按节点或边进行个性化设置。

按节点属性着色/调整大小：假设你的节点代表城市，有一个‘人口’属性，你想用节点大小来反映人口。

import networkx as nx import matplotlib.pyplot as plt G = nx.Graph() G.add_node('北京', population=2154) # 单位：万 G.add_node('上海', population=2428) G.add_node('广州', population=1881) G.add_node('深圳', population=1768) G.add_edges_from([('北京','上海'), ('北京','广州'), ('上海','深圳'), ('广州','深圳')]) pos = nx.spring_layout(G, seed=42) # 提取节点属性 populations = nx.get_node_attributes(G, 'population') # 将人口数据映射为节点大小，这里进行缩放，避免图形过大 node_sizes = [populations[node] * 0.1 for node in G.nodes()] # 可以按其他属性着色，这里简单用颜色区分 node_colors = ['red', 'blue', 'green', 'orange'] nx.draw(G, pos, nodelist=list(G.nodes()), # 确保顺序一致 node_size=node_sizes, node_color=node_colors, with_labels=True, font_size=10, font_weight='bold') plt.title("按节点属性定制 (节点大小代表人口)") plt.axis('off') plt.show()

为不同类型的边使用不同样式：例如，在一个交通网络中，用实线表示高速公路，虚线表示国道。

G = nx.Graph() G.add_edges_from([('A','B'), ('A','C'), ('B','D'), ('C','D')]) # 假设边(A,B)和(C,D)是高速公路，其他是国道 edge_style_map = {('A','B'): 'solid', ('C','D'): 'solid', ('A','C'): 'dashed', ('B','D'): 'dashed'} pos = nx.circular_layout(G) nx.draw_networkx_nodes(G, pos, node_color='lightgray') nx.draw_networkx_labels(G, pos) # 分别绘制不同样式的边 solid_edges = [e for e, style in edge_style_map.items() if style == 'solid'] dashed_edges = [e for e, style in edge_style_map.items() if style == 'dashed'] nx.draw_networkx_edges(G, pos, edgelist=solid_edges, width=2, style='solid') nx.draw_networkx_edges(G, pos, edgelist=dashed_edges, width=1.5, style='dashed') plt.title("混合边样式") plt.axis('off') plt.show()

6.2 处理大型图与性能优化

当节点和边数量成百上千时，直接使用nx.draw会非常缓慢，且生成的图可能是一团无法辨认的“毛球”。这时需要策略调整。

1. 简化绘制，关闭非必要元素：

# 对于大型图，关闭标签、调整节点和边的大小为固定小值 nx.draw(G, pos, with_labels=False, node_size=20, edge_color='gray', width=0.5)

2. 使用更高效的布局算法：对于超大图（>10000节点），spring_layout基本不可用。可以考虑：

• 使用nx.random_layout快速得到一个随机布局（虽然乱，但快）。
• 使用nx.spiral_layout或nx.shell_layout这类计算简单的布局。
• 使用专业的大规模图可视化工具（如Gephi,Cytoscape）计算好布局，然后将节点坐标导出，再用networkx读取并绘制。networkx可以读取Gephi的.gexf格式文件，其中包含布局信息。

# 假设已有从Gephi导出的节点坐标文件 ‘coords.json’ import json with open('coords.json', 'r') as f: pos = json.load(f) # pos 现在是一个 {node_id: [x, y]} 的字典，可以直接用于nx.draw

3. 采样或聚合：如果图太大，考虑是否真的需要可视化全部数据。可以对图进行社区检测，然后将每个社区聚合为一个“超级节点”进行可视化，或者随机采样一个子图。

6.3 输出高质量图片用于论文或报告

在建模比赛中，最终提交的图表需要满足印刷或高清展示的要求。

plt.figure(figsize=(10, 8)) # 设置画布大小，单位是英寸。更大的画布容纳更多细节。 pos = nx.spring_layout(G, seed=42, k=0.15) # 调整k值，让节点间距更合适 nx.draw(G, pos, with_labels=True, node_size=800, font_size=12, node_color='skyblue', edge_color='darkgray', width=2, font_weight='bold') plt.axis('off') plt.tight_layout(pad=0.5) # 调整子图参数，使图形紧凑且不切边 # 保存为高DPI的矢量或位图格式 plt.savefig('high_quality_graph.png', dpi=300, bbox_inches='tight') # PNG格式，300DPI，裁剪空白 # plt.savefig('high_quality_graph.pdf', format='pdf', bbox_inches='tight') # PDF矢量格式，无限缩放不失真 plt.show()

• dpi(每英寸点数)：用于位图格式（如PNG, JPG）。论文通常要求300 DPI以上。DPI越高，图片越清晰，文件也越大。
• bbox_inches='tight'：自动裁剪图片周围的空白区域，让图形充满画布。
• 矢量格式 (PDF, SVG)：这是最高质量的选择。矢量图由数学公式定义，放大缩小不会失真，非常适合论文印刷。用format='pdf'或format='svg'保存。

6.4 常见“坑”与解决方案

1. 节点或边标签重叠：这是最常见的问题。除了调整font_size，可以尝试不同的布局算法。对于小图，可以手动微调pos字典中的坐标。
2. 图形显示为空白：99%的原因是忘了plt.show()（在脚本中）或没设置%matplotlib inline（在Jupyter中）。另外检查一下绘图代码是否在plt.savefig()之后，savefig会清空当前图形。
3. 颜色映射 (Colormap) 不连续或不符合直觉：确保用于映射的数据（如权重列表）是数值型且范围合理。对于分类数据，使用ListedColormap创建离散的颜色映射。
4. 有向图箭头太小或看不见：检查arrowsize参数，并确保arrows=True。在nx.draw()中，需要设置arrows=True；在nx.draw_networkx_edges()中，默认就是True。
5. 图太大，布局永远算不完：如前所述，换用简单布局或对图进行简化。对于超大规模图，可视化本身可能就不是最佳分析手段，应考虑其他统计摘要方法。

通过将这些进阶技巧融入你的绘图流程，你产出的将不再仅仅是“示意图”，而是能够有效辅助分析、支撑结论、提升作品专业度的“数据可视化作品”。在数学建模中，一张精心绘制的图，其价值有时不亚于一个复杂的算法。