networkx 添加边权重

说明：我把节点的度放到了第一节（因为它补充的知识太多了，有些啰嗦）

1…可以研究的属性

①节点和边

import networkx as nx
G = nx.graph_atlas(100)
nx.draw(G, with_labels=True)
print('图中所有的节点', G.nodes()) #图中所有的节点 [0, 1, 2, 3, 4, 5]
print('图中节点的个数', G.number_of_nodes())#图中节点的个数 6
print('图中所有的边', G.edges())#图中所有的边 [(0, 1), (0, 2), (0, 3), (3, 4), (3, 5), (4, 5)]
print('图中边的个数', G.number_of_edges())# 图中边的个数 6

②遍历边

#快速遍历每一条边，可以使用邻接迭代器实现，对于无向图，每一条边相当于两条有向边
FG = nx.Graph()
FG.add_weighted_edges_from([(1,2,0.125), (1,3,0.75), (2,4,1.2), (3,4,0.275)])
for n, nbrs in FG.adjacency():
    for nbr, eattr in nbrs.items():
        data = eattr['weight']
        print('(%d, %d, %0.3f)' % (n,nbr,data))

print('***********************************')

#筛选weight小于0.5的边：
FG = nx.Graph()
FG.add_weighted_edges_from([(1,2,0.125), (1,3,0.75), (2,4,1.2), (3,4,0.275)])
for n, nbrs in FG.adjacency():
    for nbr, eattr in nbrs.items():
        data = eattr['weight']
        if data < 0.5:
            print('(%d, %d, %0.3f)' % (n,nbr,data))
print('***********************************')

#一种方便的访问所有边的方法:
for u,v,d in FG.edges(data = 'weight'):
    print((u,v,d))

没有权重的也可以用这个公式：

import networkx as nx
G = nx.graph_atlas(100)
nx.draw(G, with_labels=True)
for u,v,d in G.edges(data="weight"):
    print(u,v,d)

③节点与邻居

import networkx as nx 
G = nx.graph_atlas(100)
nx.draw(G,with_labels=True) 
print(nx.nodes(G))
print(nx.number_of_nodes(G))#返回图中节点的数量
print(list(nx.all_neighbors(G,3)))#返回图中节点的所有邻居。
print(list(nx.non_neighbors(G,3)))#返回图中没有邻居3的节点
print(list(nx.common_neighbors(G, 2, 1)))#返回图中两个节点的公共邻居。
print(nx.edges(G, 0))#返回与0节点相关的边。 print(nx.edges(G))#返回边。
print(nx.number_of_edges(G))#返回边的数目

④平均集聚系数，直径，密度等

import networkx as nx
G = nx.graph_atlas(100)
nx.draw(G, with_labels=True)
print(nx.average_clustering(G))#完成平均群聚系数的计算
print(nx.clustering(G))#可以计算各个节点的集聚系数
print(nx.diameter(G))#返回图G的直径
print(nx.average_shortest_path_length(G))#返回图G所有节点间平均最短路径长度
print(nx.is_directed(G))#如果图是有向的，返回true
print(nx.density(G))#返回图的密度

import networkx as nx
import numpy as np
G = nx.graph_atlas(100)
aa=nx.clustering(G)#aa是字典类型
bb=dict(nx.clustering(G))#bb是字典类型
cc=bb.values()#cc是列表类型
ccc=bb.keys()#ccc是列表类型
cccc=bb.items()#cccc是列表类型
print(aa)
print(bb)
print(cc)
print(ccc)
print(cccc)

dd=np.mean(list(aa))
ee=np.mean(list(bb))
ff=np.mean(list(cc))
print(dd)
print(ee)
print(ff)
只有ff才是平均集聚系数，因为dd和ee是对键的平均（参考第一节的“networkx经常涉及的字典列表知识”），
ff是对值的平均，ff才是平均集聚系数

⑤nx.dijkstra_path(G, source, target, weight=‘weight’) ————求最短路径

nx.dijkstra_path_length(G, source, target, weight=‘weight’) ————求最短距离

import networkx as nx
G = nx.graph_atlas(100)
nx.draw(G, with_labels=True)
print(nx.dijkstra_path(G,4,1, weight='weight'))
print(nx.dijkstra_path_length(G,4,1, weight='weight'))

import networkx as nx
import pylab 
import numpy as np
#自定义网络
row=np.array([0,0,0,1,2,3,6])
col=np.array([1,2,3,4,5,6,7])
value=np.array([1,2,1,8,1,3,5])

G=nx.DiGraph()

for i in range(np.size(row)):
    G.add_weighted_edges_from([(row[i],col[i],value[i])])

pos=nx.shell_layout(G)
nx.draw(G,pos,with_labels=True, node_color='white', edge_color='red', node_size=400, alpha=0.5 )
pylab.title('Self_Define Net',fontsize=15)
pylab.show()

path=nx.dijkstra_path(G, source=0, target=7)
print('节点0到7的路径：', path)
distance=nx.dijkstra_path_length(G, source=0, target=7)
print('节点0到7的距离为：', distance) 
#0-3权重是1，3-6权重是3，6-7权重是5

以下这些中心性无一例外都是网络科学导论里面学过的：

import networkx as nx
G = nx.graph_atlas(100)
nx.draw(G, with_labels=True)
print(nx.degree_centrality(G))#计算节点的度中心性
print(nx.closeness_centrality(G))#计算节点的接近中心性
print(nx.betweenness_centrality(G))#计算节点的介数中心性
print(nx.edge_betweenness_centrality(G))#计算边的介数中心性
print(nx.eigenvector_centrality(G))#计算节点的特征向量中心性
print(nx.current_flow_betweenness_centrality(G))#计算节点的流介数中心性
print(nx.edge_current_flow_betweenness_centrality(G))#计算边的流介数中心性

.计算图形的特征向量中心性

import networkx as nx
graph = nx.graph_atlas(100)
centrality = nx.eigenvector_centrality(graph)
print(centrality)
print(sorted((v, f"{c:0.2f}") for v, c in centrality.items()))
 输出：
{0: 0.41711963425636006, 1: 0.18307564367773832, 2: 0.18307564367773832, 3: 0.5842165971953255, 4: 0.45698402360658014, 5: 0.45698402360658014}
[(0, '0.42'), (1, '0.18'), (2, '0.18'), (3, '0.58'), (4, '0.46'), (5, '0.46')]

一种常见的处理办法：

一种常见的处理办法：
我们输出来的每个节点的中心性也好，或者是每个节点的度也罢，他们的格式要么是{0: 0.7000000000000001, 1: 0.0, 2: 0.0, 3: 0.6000000000000001, 4: 0.0, 5: 0.0}如（nx.betweenness centrality(G)），要么是[(0, 3), (1, 1), (2, 1), (3, 3), (4, 2), (5, 2)]（如G.degree()），总是记不清
我们都让他变成字典类型，用dict(nx.betweenness centrality(G))和dict(G.degree()),那么就肯定是{0: 0.7000000000000001, 1: 0.0, 2: 0.0, 3: 0.6000000000000001, 4: 0.0, 5: 0.0}这种字典格式了，然后再提取字典键值对的值dict(G.degree()).values()，对这个可以做平均值等等的处理来求平均度、平均集聚系数等

betweenness centrality中介中心度，计算经过一个点的最短路径的数量。经过一个点的最短路径的数量越多，就说明它的中介中心度越高。很多节点之间的最短路径都经过C这个点，那么就说C有高的中介中心度。这个比例范围从0.0到1.0，0.0表示与任何节点都没有联系（例如一个孤点），1.0表示与每一个节点都有直接联系。

计算匹配性系数
r<0是不匹配的（大度节点和小度节点连接），r>0是匹配的（大和大，小和小），r=0是持平的

import networkx as nx
G = nx.graph_atlas(100)
print(nx.assortativity.degree_assortativity_coefficient(G))

计算连通分量
①无向图

import networkx as nx
G = nx.graph_atlas(100)
nx.draw(G)
print(list(nx.connected_components(G)))#获取连通分量的节点列表(无向图才有)
print(nx.number_connected_components(G))#连通分量数目(无向图才有)

②有向图

import networkx as nx
G = nx.DiGraph()
nx.add_path(G, [0, 1, 2, 3,6,5,8,1,3])
nx.draw(G)
print(nx.number_strongly_connected_components(G))#强连通分量数目（有向图才有）
print(list(nx.strongly_connected_components(G)))#强连通分量（有向图才有）