1. 从零开始:认识NetworkX与你的第一张图
如果你对“图”这个概念还停留在Excel里的柱状图,那今天咱们得刷新一下认知了。在计算机科学和数据分析领域,图指的是一种由节点和连接这些节点的边构成的数据结构。想想你的微信好友关系:你就是节点,你和朋友之间的好友关系就是边。再想想城市地铁线路图:每个站点是节点,轨道是边。这种能清晰表达事物之间复杂关系的模型,就是图论研究的核心。
而NetworkX,就是Python世界里用来玩转这种“关系网络”的瑞士军刀。我用了这么多年,一个最深的体会是:它把那些听起来高深的图论算法,都封装成了几句简单的函数调用,让数据分析师、算法工程师甚至业务运营同学,都能轻松上手分析社交网络、推荐系统、交通规划甚至病毒传播路径。
安装它非常简单,如果你已经配好了Python环境,一行命令就够了:
pip install networkx matplotlib numpy
我强烈建议你同时安装matplotlib,因为可视化是理解图最直观的方式;numpy则会在后续矩阵运算时派上用场。安装好后,让我们在Python里打个招呼,并创建你的第一张图:
import networkx as nx
import matplotlib.pyplot as plt
# 创建一个空的无向图,就像准备一张白纸
G = nx.Graph()
print(f"初始图:{G}")
运行一下,你会看到输出初始图:Graph with 0 nodes and 0 edges。没错,现在它还空空如也。别急,我们马上让它丰富起来。NetworkX的妙处在于它的灵活性,节点可以是任何可哈希的对象:数字、字符串、甚至是一个元组或自定义对象。比如,我们可以模拟一个简单的社交圈:
# 添加节点:你可以把他们想象成不同的人
G.add_node("小明")
G.add_node("小红")
G.add_node("小刚")
# 也可以批量添加
G.add_nodes_from(["小李", "小张"])
# 添加边:代表他们之间认识
G.add_edge("小明", "小红") # 小明和小红是朋友
G.add_edge("小红", "小刚")
G.add_edge("小刚", "小李")
G.add_edge("小明", "小张")
# 现在,让我们看看这张图的样子
nx.draw(G, with_labels=True, node_color='lightblue', edge_color='gray')
plt.show()
执行这段代码,一个简单的网络图就会弹出来。你会看到5个带标签的点和4条线,直观地展示了“谁认识谁”。这就是构建图最基础的两步:加节点和加边。我刚开始学的时候,总觉得图论很抽象,但当你亲手用代码把人际关系、论文引用、网页链接“画”出来时,那种抽象变具体的感觉非常棒。
当然,现实中的数据很少需要我们手动一个个添加。更多时候,数据是以“边列表”的形式存在的,比如一个CSV文件,两列数据分别代表关系的起点和终点。NetworkX处理这种数据非常高效:
import pandas as pd
# 假设我们有一个代表关注关系的DataFrame
data = {'follower': ['小明', '小明', '小红', '小刚', '小李'],
'followed': ['小红', '小张', '小刚', '小李', '小张']}
df = pd.DataFrame(data)
# 直接从边列表创建有向图(因为关注是有方向的)
DG = nx.from_pandas_edgelist(df, source='follower', target='followed', create_using=nx.DiGraph())
print(f"有向图节点数:{DG.number_of_nodes()}, 边数:{DG.number_of_edges()}")
通过这个简单的开始,你已经掌握了NetworkX最核心的创建操作。图不再是一个数学概念,而是你手中可以随意塑造、用于解决实际问题的活工具。记住,节点和边是图的灵魂,而NetworkX给了你创造这个灵魂的最简单工具。
2. 让图说话:高级可视化与美学调校
把图画出来只是第一步,画得好、看得懂才是关键。很多新手(包括当年的我)用默认参数nx.draw()画完图,得到的往往是一团乱麻,节点挤在一起,根本看不出任何结构。这可不是NetworkX的错,而是我们需要学会如何“指挥”它进行可视化布局和美化。
首先,我们必须理解布局算法。布局决定了图中每个节点的坐标。nx.draw()默认使用spring_layout,它是一种力导向布局,想象每个节点间有弹簧,连接的节点相互吸引,不连接的节点相互排斥,经过多次迭代后达到平衡。但有时我们需要更符合业务场景的布局:
G = nx.karate_club_graph() # 网络分析经典数据集:空手道俱乐部成员关系
plt.figure(figsize=(12, 5))
# 1. 弹簧布局(默认,适用于通用网络)
plt.subplot(131)
pos_spring = nx.spring_layout(G, seed=42) # seed保证每次布局一致
nx.draw(G, pos_spring, with_labels=True, node_size=300)
plt.title("Spring Layout")
# 2. 环形布局(适合展示循环或等级不明显的网络)
plt.subplot(132)
pos_circular = nx.circular_layout(G)
nx.draw(G, pos_circular, with_labels=True, node_size=300)
plt.title("Circular Layout")
# 3. 分层布局(特别适合有向图,能清晰展示流程或层级)
plt.subplot(133)
# 需要一个有向图示例
DG = nx.DiGraph([(1,2), (2,3), (3,4), (1,4), (2,4)])
pos_shell = nx.shell_layout(DG)
nx.draw(DG, pos_shell, with_labels=True, node_size=500, arrowsize=20)
plt.title("Shell Layout for Directed Graph")
plt.tight_layout()
plt.show()
对比这三种布局,你会发现同一张图可以讲述不同的故事。弹簧布局能突出紧密的社群;环形布局公平展示所有节点;分层布局则让方向和信息流一目了然。在实际项目中,我通常会根据分析目标来回切换布局,寻找最能揭示问题的那一个。
接下来是美学调校。直接画出来的图可能很“素”,不适合放进报告或论文。NetworkX的绘图函数提供了大量参数,让我们能精细控制:
# 使用空手道俱乐部图进行美化示例
pos = nx.spring_layout(G, seed=42)
plt.figure(figsize=(10, 8))
# 计算每个节点的度(连接数),用于决定节点大小
node_degree = dict(G.degree())
# 将度映射到节点大小范围,比如50到800
node_sizes = [50 + node_degree[n]*50 for n in G.nodes()]
# 计算每个节点的中介中心性,用于决定节点颜色
betweenness = nx.betweenness_centrality(G)
# 使用色谱映射数值
node_colors = list(betweenness.values())
# 开始绘制
nodes = nx.draw_networkx_nodes(
G, pos,
node_size=node_sizes,
node_color=node_colors,
cmap=plt.cm.viridis, # 使用viridis配色方案,更专业
alpha=0.9, # 稍微增加一点透明度
edgecolors='black', # 给节点加黑色边框
linewidths=1.5
)
# 绘制边,可以按权重或类型区分
edges = nx.draw_networkx_edges(
G, pos,
width=1.5,
alpha=0.6,
edge_color='darkgray',
style='solid'
)
# 绘制标签,可以调整字体和位置
labels = nx.draw_networkx_labels(
G, pos,
font_size=10,
font_family='sans-serif',
font_weight='bold'
)
# 添加颜色条,说明节点颜色的意义
plt.colorbar(nodes, label='Betweenness Centrality', shrink=0.8)
plt.axis('off') # 关闭坐标轴
plt.title('Karate Club Network: Node Size = Degree, Color = Betweenness', fontsize=14)
plt.tight_layout()
plt.show()
经过这番美化,你的图立刻就从“技术草图”升级为“分析艺术品”。节点大小反映了受欢迎程度(度),颜色深浅反映了枢纽重要性(中介中心性),信息密度大大增加。我经常用这种多变量编码的方式向非技术同事展示分析结果,他们一眼就能抓住重点。
对于有向图,美化时需要特别注意边的方向。nx.draw()中的arrowstyle和arrowsize参数至关重要:
# 创建一个简单有向图表示信息流
DG = nx.DiGraph()
DG.add_edges_from([('数据源', 'ETL'), ('ETL', '数据仓库'), ('数据仓库', 'BI工具'), ('BI工具', '报表')])
pos = nx.planar_layout(DG) # 平面布局,确保边不交叉
nx.draw_networkx(
DG, pos,
node_color='lightgreen',
node_size=2000,
font_size=12,
arrowsize=25, # 箭头大小
arrowstyle='->', # 箭头样式,'->'是实心三角
width=2,
edge_color='steelblue'
)
plt.axis('off')
plt.title('数据流向图', fontsize=15)
plt.show()
最后分享一个我写论文时常用的高级模板。它通过精细控制每一个图形元素,能产出达到出版级别的图:
def draw_paper_quality(G, pos, centrality_dict, title):
"""
论文级绘图函数
G: 网络图
pos: 布局位置
centrality_dict: 节点中心性字典,用于着色
title: 图标题
"""
fig, ax = plt.subplots(figsize=(10, 8))
# 1. 绘制节点(使用渐变色,并归一化数据)
import matplotlib.colors as mcolors
centrality_values = list(centrality_dict.values())
norm = mcolors.Normalize(vmin=min(centrality_values), vmax=max(centrality_values))
cmap = plt.cm.plasma # 或viridis, inferno等
nodes = nx.draw_networkx_nodes(
G, pos,
node_size=400,
node_color=centrality_values,
cmap=cmap,
norm=norm,
edgecolors='white',
linewidths=1.5,
ax=ax
)
# 2. 绘制边(带透明度渐变,突出结构)
edges = nx.draw_networkx_edges(
G, pos,
width=1.2,
alpha=0.5,
edge_color='#2E2E2E',
style='solid',
ax=ax,
connectionstyle='arc3,rad=0.1' # 边带弧度,避免重叠
)
# 3. 绘制标签(使用背景框增强可读性)
labels = nx.draw_networkx_labels(
G, pos,
font_size=9,
font_weight='medium',
font_family='Arial',
bbox=dict(boxstyle='round,pad=0.3', facecolor='white', edgecolor='none', alpha=0.7),
ax=ax
)
# 4. 添加颜色条和标题
plt.colorbar(nodes, ax=ax, shrink=0.8, label='Centrality Value')
ax.set_title(title, fontsize=16, fontweight='bold', pad=20)
ax.axis('off')
plt.tight_layout()
return fig, ax
# 使用示例
G = nx.florentine_families_graph() # 佛罗伦萨家族联姻图
pos = nx.spring_layout(G, seed=123)
betweenness = nx.betweenness_centrality(G)
fig, _ = draw_paper_quality(G, pos, betweenness, 'Florentine Families Marriage Network')
plt.show()
掌握这些可视化技巧后,你就能让数据自己“讲故事”了。记住,好的可视化不仅是美观,更是为了更有效地传递信息,揭示单看数据难以发现的模式和洞见。
3. 洞察网络:关键节点与中心性指标计算
图画漂亮了,接下来我们就要问一些实质性问题了:在这个关系网里,谁最重要?哪些人是信息传递的关键枢纽?哪些连接一旦断裂,整个网络就会分崩离析?这些问题,都需要通过计算网络的中心性指标来回答。别被这个词吓到,说白了,就是用不同的“尺子”来衡量节点的重要性。
第一把尺子叫度中心性。这是最直观的:朋友多的人,影响力可能就大。在NetworkX里,计算一个节点的度(直接连接数)和度中心性非常简单:
G = nx.karate_club_graph() # 继续用我们的空手道俱乐部图
# 计算单个节点的度
node_id = 0
print(f"节点 {node_id} 的度(直接朋友数): {G.degree(node_id)}")
# 计算所有节点的度
all_degrees = dict(G.degree())
print("前5个节点的度:", dict(list(all_degrees.items())[:5]))
# 度中心性:其实就是归一化后的度(除以最大可能连接数)
degree_centrality = nx.degree_centrality(G)
print(f"节点 {node_id} 的度中心性: {degree_centrality[node_id]:.4f}")
print("度中心性最高的节点:", max(degree_centrality, key=degree_centrality.get))
但度中心性有个局限:它只关心直接朋友。如果一个节点朋友不多,但他的朋友都是“大佬”,那他的影响力可能被低估。这就需要第二把尺子:特征向量中心性。它的思想是“一个人的重要性,取决于他朋友的重要性”。这就像社交网络里的“大佬的朋友也是大佬”效应。
# 计算特征向量中心性
eigenvector_centrality = nx.eigenvector_centrality(G, max_iter=1000)
# 排序查看最重要的节点
sorted_eigen = sorted(eigenvector_centrality.items(), key=lambda x: x[1], reverse=True)
print("特征向量中心性排名前5:")
for node, score in sorted_eigen[:5]:
print(f" 节点 {node}: {score:.4f}")
在实际分析微博或Twitter转发网络时,特征向量中心性特别有用,它能找出那些不仅粉丝多,而且粉丝也很有影响力的“关键意见领袖”。
第三把重要的尺子是中介中心性。想象一下城市里的交通枢纽:它本身可能不是目的地,但很多路线都要经过它。在网络中,如果一个节点出现在许多其他节点之间的最短路径上,那它的中介中心性就高。这类节点往往是信息流、资金流或物流的关键控制点。
betweenness_centrality = nx.betweenness_centrality(G, normalized=True) # normalized=True进行归一化
sorted_betweenness = sorted(betweenness_centrality.items(), key=lambda x: x[1], reverse=True)
print("中介中心性排名前5(网络中的交通枢纽):")
for node, score in sorted_betweenness[:5]:
print(f" 节点 {node}: {score:.4f}")
# 可视化对比:用节点大小表示度中心性,颜色深度表示中介中心性
pos = nx.spring_layout(G, seed=42)
plt.figure(figsize=(12, 5))
plt.subplot(121)
# 节点大小=度中心性*1000
node_size = [degree_centrality[n]*1000 for n in G.nodes()]
nx.draw(G, pos, node_size=node_size, node_color='lightblue', with_labels=True)
plt.title("节点大小代表度中心性")
plt.subplot(122)
# 节点颜色=中介中心性(使用色谱)
node_color = list(betweenness_centrality.values())
nodes = nx.draw_networkx_nodes(G, pos, node_color=node_color, cmap=plt.cm.hot, node_size=300)
nx.draw_networkx_edges(G, pos, alpha=0.5)
nx.draw_networkx_labels(G, pos)
plt.colorbar(nodes, label='Betweenness Centrality')
plt.title("节点颜色代表中介中心性")
plt.axis('off')
plt.tight_layout()
plt.show()
通过对比,你可能会发现一些有趣的现象:度中心性最高的节点(最受欢迎的人)和中介中心性最高的节点(最关键的信息桥梁)不一定是同一个人。这在实际组织管理或舆情监控中非常有价值。
第四把尺子是接近中心性。它衡量的是一个节点到网络中所有其他节点的平均距离有多“近”。一个接近中心性高的节点,能快速接触到网络中的大部分信息。在传染病防控中,识别出接近中心性高的个体(超级传播者)至关重要。
closeness_centrality = nx.closeness_centrality(G)
sorted_closeness = sorted(closeness_centrality.items(), key=lambda x: x[1], reverse=True)
print("接近中心性排名前5(能快速联系全网的人):")
for node, score in sorted_closeness[:5]:
print(f" 节点 {node}: {score:.4f}")
对于有向图(如网页链接、微博关注),PageRank算法是一把经典且强大的尺子。它最初是谷歌用来给网页排名的核心算法,其核心思想是:一个节点的重要性,不仅取决于指向它的链接数量,还取决于那些链接源节点本身的重要性。
# 创建一个有向图示例(简单的网页链接)
DG = nx.DiGraph()
DG.add_edges_from([(1,2), (2,1), (1,3), (3,1), (2,3), (3,2), (4,1), (5,2), (6,3)])
pagerank_scores = nx.pagerank(DG, alpha=0.85) # alpha是阻尼因子,通常0.85
print("PageRank分数:")
for node, score in sorted(pagerank_scores.items(), key=lambda x: x[1], reverse=True):
print(f" 页面 {node}: {score:.4f}")
在实际内容推荐系统中,我经常用PageRank的变种来给商品或内容打分。如果一个商品被很多其他热门商品关联推荐,那它本身的排名也应该更高。
最后,我们把这些中心性指标放在一起做个综合对比,这能帮助我们全面理解网络中的权力结构:
# 创建一个对比表格
import pandas as pd
centrality_df = pd.DataFrame({
'Degree': degree_centrality,
'Eigenvector': eigenvector_centrality,
'Betweenness': betweenness_centrality,
'Closeness': closeness_centrality
})
# 对于有向图,还可以加入PageRank
# centrality_df['PageRank'] = pagerank_scores
print("网络中心性指标综合对比(前10节点):")
print(centrality_df.head(10).round(4))
# 计算各指标的相关性,看它们是否衡量了同一类“重要性”
correlation_matrix = centrality_df.corr()
print("\n各中心性指标间的相关系数矩阵:")
print(correlation_matrix.round(3))
通过这个相关系数矩阵,你会发现有些指标高度相关(比如度和特征向量中心性),有些则相对独立(比如中介中心性)。这意味着,要全面评估一个节点的影响力,你不能只看一个指标。在我做过的一个企业协作网络分析项目中,我们发现技术专家往往有很高的特征向量中心性(被其他专家认可),而项目经理则拥有很高的中介中心性(在不同团队间协调)。这种多维度的分析,为人才识别和团队优化提供了扎实的数据支撑。
4. 深入肌理:社群检测与网络结构剖析
当网络规模变大,成百上千个节点和边交织在一起时,我们很自然会问:这个网络内部有没有“小团体”?哪些人更抱团?这就是社群检测要解决的问题。发现网络中的社群结构,能帮助我们理解系统的模块化组织,比如社交网络中的朋友圈、论文引用网络中的研究领域、互联网中的主题社区。
最直观的社群检测算法之一是标签传播算法。它的思想非常朴素,像一种“口碑传播”:每个节点开始时拥有一个独一无二的标签,然后迭代地,每个节点都采纳其大多数邻居所拥有的标签。最终,联系紧密的节点群会收敛到同一个标签上,形成一个社群。
from networkx.algorithms import community
import warnings
warnings.filterwarnings('ignore')
G = nx.karate_club_graph()
# 使用标签传播算法
communities_lpa = list(community.label_propagation_communities(G))
print(f"标签传播算法检测到 {len(communities_lpa)} 个社群")
for i, com in enumerate(communities_lpa):
print(f" 社群{i+1}: {sorted(com)}")
# 可视化这些社群
pos = nx.spring_layout(G, seed=123)
plt.figure(figsize=(10, 8))
# 为不同社群分配颜色
color_map = []
for node in G:
for i, com in enumerate(communities_lpa):
if node in com:
# 使用一组区分度较好的颜色
colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd']
color_map.append(colors[i % len(colors)])
break
nx.draw(G, pos, node_color=color_map, with_labels=True, node_size=500, edge_color='gray')
plt.title('Label Propagation Community Detection', fontsize=15)
plt.show()
运行后,你会看到节点被染成了不同颜色,同一个颜色的节点属于同一个社群。标签传播算法的优点是速度快,适合大规模网络,且不需要预先指定社群数量。但它的结果可能因为迭代顺序不同而有细微变化。
另一种更经典、在学术论文中更常见的是Louvain算法,它基于模块度优化。模块度是衡量社群划分好坏的一个指标,值越高说明社群内部连接越紧密,社群之间连接越稀疏。Louvain算法通过不断移动节点来最大化整个网络的模块度。
# NetworkX本身未内置Louvain,但我们可以用python-louvain库(community)
# 安装: pip install python-louvain
try:
import community as community_louvain
partition = community_louvain.best_partition(G)
# 查看划分结果
print(f"Louvain算法将网络划分为 {max(partition.values())+1} 个社群")
# 按社群分组节点
communities_dict = {}
for node, comm_id in partition.items():
communities_dict.setdefault(comm_id, []).append(node)
for comm_id, nodes in communities_dict.items():
print(f" 社群{comm_id}: {sorted(nodes)}")
# 计算模块度
modularity = community_louvain.modularity(partition, G)
print(f" 划分的模块度 Q = {modularity:.4f}")
# 可视化
plt.figure(figsize=(10, 8))
nx.draw(G, pos, node_color=list(partition.values()), cmap=plt.cm.tab20,
with_labels=True, node_size=500, edge_color='gray')
plt.title(f'Louvain Community Detection (Modularity Q={modularity:.3f})', fontsize=15)
plt.show()
except ImportError:
print("未安装python-louvain库,请运行: pip install python-louvain")
# 使用NetworkX自带的贪心模块度算法作为备选
communities_greedy = list(community.greedy_modularity_communities(G))
print(f"贪心模块度算法检测到 {len(communities_greedy)} 个社群")
模块度Q值通常在-0.5到1之间,大于0.3一般就认为有明显的社群结构了。在实际的社交网络分析中,高模块度往往意味着网络中存在紧密的小圈子。
除了找社群,我们还需要识别网络中的关键连接和脆弱点。比如,哪些边一旦断开,会立刻让网络分裂?这种边被称为桥。与之相对的是局部聚集系数,它衡量一个节点的邻居之间也互相连接的程度,可以理解为“我的朋友们彼此是不是也是朋友”,高聚集系数意味着小圈子的形成。
# 查找网络中的所有桥
bridges = list(nx.bridges(G))
print(f"网络中共有 {len(bridges)} 条桥边")
if bridges:
print("前5条桥边:", bridges[:5])
# 可视化标记桥边
plt.figure(figsize=(10, 8))
edge_colors = ['red' if edge in bridges or (edge[1], edge[0]) in bridges else 'gray' for edge in G.edges()]
nx.draw(G, pos, edge_color=edge_colors, with_labels=True, node_size=500, width=2)
plt.title('Bridges in the Network (Red Edges)', fontsize=15)
plt.show()
# 计算每个节点的局部聚集系数
clustering = nx.clustering(G)
print("\n局部聚集系数最高的5个节点(朋友圈最紧密):")
for node, coeff in sorted(clustering.items(), key=lambda x: x[1], reverse=True)[:5]:
print(f" 节点 {node}: {coeff:.3f}")
在一个真实的协作网络中,桥边往往连接着不同部门或团队,虽然数量少,但却是信息跨团队流动的生命线。而高聚集系数的节点周围,往往是已经形成默契的小组。
更进一步,我们可以分析网络的连通性。一个网络可能不是完全连通的,而是由几个互不连接的“岛屿”(连通分量)组成。
# 找出所有连通分量
connected_components = list(nx.connected_components(G))
print(f"网络包含 {len(connected_components)} 个连通分量")
if len(connected_components) > 1:
for i, comp in enumerate(connected_components):
print(f" 分量{i+1}: 包含 {len(comp)} 个节点")
else:
print(" 网络是全连通的!")
# 获取最大连通分量(通常我们只分析这个主体部分)
largest_cc = max(nx.connected_components(G), key=len)
G_largest = G.subgraph(largest_cc)
print(f"最大连通分量包含 {G_largest.number_of_nodes()} 个节点和 {G_largest.number_of_edges()} 条边")
对于有向图,我们还需要分析强连通分量(其中任意两点可互相到达)和弱连通分量(忽略方向后连通)。
# 创建一个有向图示例
DG = nx.DiGraph()
DG.add_edges_from([(1,2), (2,3), (3,1), (3,4), (4,5), (5,4), (6,7)])
# 强连通分量
strong_components = list(nx.strongly_connected_components(DG))
print(f"有向图有 {len(strong_components)} 个强连通分量")
for i, comp in enumerate(strong_components):
print(f" 强连通分量{i+1}: {sorted(comp)}")
# 弱连通分量(忽略方向)
weak_components = list(nx.weakly_connected_components(DG))
print(f"\n忽略方向后,有 {len(weak_components)} 个弱连通分量")
最后,让我们把这些结构分析技术整合到一个实际案例中。假设我们拿到了一家公司内部的邮件往来数据(已匿名化),我们可以通过社群检测发现非正式的团队结构,通过中心性分析找出信息枢纽和潜在瓶颈,通过桥边识别跨部门协作的关键人物。
# 模拟一个公司邮件网络分析的简化流程
def analyze_company_network(G):
"""综合网络分析函数"""
print("=== 公司协作网络分析报告 ===")
print(f"网络规模: {G.number_of_nodes()} 人, {G.number_of_edges()} 封邮件往来")
# 1. 连通性
num_components = nx.number_connected_components(G)
if num_components > 1:
print(f"⚠️ 网络不连通,有 {num_components} 个独立群组,可能存在信息孤岛。")
else:
print("✅ 网络全连通,信息流通基础良好。")
# 2. 关键人物(度中心性 + 中介中心性)
degree_cent = nx.degree_centrality(G)
betweenness_cent = nx.betweenness_centrality(G)
top_connector = max(degree_cent, key=degree_cent.get)
top_hub = max(betweenness_cent, key=betweenness_cent.get)
print(f"\n🔗 最活跃的连接者 (度中心性最高): 节点 {top_connector}")
print(f" 他/她与 {G.degree(top_connector)} 人有直接邮件往来。")
print(f"🌉 最关键的信息枢纽 (中介中心性最高): 节点 {top_hub}")
print(f" 许多沟通路径需要经过他/她,可能是团队间的协调员。")
# 3. 社群结构
try:
import community as community_louvain
partition = community_louvain.best_partition(G)
num_communities = max(partition.values()) + 1
modularity = community_louvain.modularity(partition, G)
print(f"\n👥 检测到约 {num_communities} 个自然形成的社群 (模块度 Q={modularity:.3f})")
if modularity > 0.3:
print(" 社群结构明显,可能存在基于项目或部门的自然分组。")
except:
pass
# 4. 脆弱点分析
bridges = list(nx.bridges(G))
if bridges:
print(f"\n⚠️ 发现 {len(bridges)} 条关键桥边")
print(" 这些连接一旦中断,可能导致网络分裂,建议建立备份沟通渠道。")
# 5. 整体紧密程度
avg_clustering = nx.average_clustering(G)
print(f"\n📊 网络平均聚集系数: {avg_clustering:.3f}")
if avg_clustering > 0.5:
print(" 网络整体比较紧密,'朋友的朋友也是朋友'现象普遍。")
return {
'top_connector': top_connector,
'top_hub': top_hub,
'num_communities': num_communities if 'num_communities' in locals() else None,
'modularity': modularity if 'modularity' in locals() else None,
'num_bridges': len(bridges),
'avg_clustering': avg_clustering
}
# 生成一个模拟的公司网络(使用幂律分布模拟真实社交网络)
company_G = nx.barabasi_albert_graph(n=50, m=2, seed=42)
analysis_result = analyze_company_network(company_G)
通过这样一套组合分析,你就能从一团混沌的关系数据中,提炼出关于组织协作效率、信息流健康度的深刻洞察。这些分析不再是炫技的数学工具,而是能直接指导管理决策的实用方法。我在实际项目中,就曾用类似的分析帮助客户识别出了那些未被正式任命、却在团队中实际扮演协调角色的“隐形领袖”,以及那些因为过度依赖单个人而存在风险的沟通链路。
1147



被折叠的 条评论
为什么被折叠?



