使用Python，networkx构造有向图及无向图以及图合并等api

源码

图的构造、节点及边的添加等

'''
networkx绘制图相关api
'''import networkx as nx
from networkx.classes.coreviews import AtlasView
from networkx.classes.reportviews import NodeDataView# 创建一个没有节点和边缘的空图
G = nx.Graph()# 添加节点
G.add_node(1)# 一次性添加多个节点
G.add_nodes_from([2, 3])# 一次性添加多个节点及属性 (node,node_attribute_dict)
G.add_nodes_from([(4, {"color": "red"}), (5, {"color": "green"})])# 一个图中的节点合并到另一个图中
H = nx.path_graph(10)
G.add_nodes_from(H)  # 或者 G.add_node(H)# 添加边
G.add_edge(1, 2)
e = (2, 3)
G.add_edge(*e)  # unpack edge tuple*# 添加边列表
G.add_edges_from([(1, 2), (1, 3)])# 添加H图的一堆边
G.add_edges_from(H.edges)# 删除所有节点和边
G.clear()# 添加节点和边缘
G.add_edges_from([(1, 2), (1, 3)])
G.add_node(1)
G.add_edge(1, 2)
G.add_node("spam")  # adds node "spam"
G.add_nodes_from("spam")  # adds 4 nodes: 's', 'p', 'a', 'm'
G.add_edge(3, 'm')print('num of nodes: ', str(G.number_of_nodes()))
print('num of edges: ', str(G.number_of_edges()))# 输出图的边的顺序
# G.edges 的顺序是邻接的顺序 其中包括节点的顺序和每个 node 的邻接关系。
DG = nx.DiGraph()
DG.add_edge(2, 1)  # adds the nodes in order 2, 1
DG.add_edge(1, 3)
DG.add_edge(2, 4)
DG.add_edge(1, 2)
assert list(DG.successors(2)) == [1, 4]
assert list(DG.edges) == [(2, 1), (2, 4), (1, 3), (1, 2)]# 检查图形的元素：节点、边、邻接关系、度数（点的复杂度，邻接边的个数）
print(list(G.nodes))  # [1, 2, 3, 'spam', 's', 'p', 'a', 'm']
print(list(G.edges))  # [(1, 2), (1, 3), (3, 'm')]
print(list(G.adj[1]))  # or list(G.neighbors(1)) # [2, 3]
print(G.degree[1])  # the number of edges incident to 1# 可以指定报告所有节点子集的边数和度数
print(G.edges([2, 'm']))
# EdgeDataView([(2, 1), ('m', 3)])
print(G.degree([2, 3]))
# DegreeView({2: 1, 3: 2})# 从图形中删除元素、删除边
G.remove_node(2)
G.remove_nodes_from("spam")
print('after del: ', list(G.nodes))  # [1, 3, 'spam']
G.remove_edge(1, 3)
print('after del: ', list(G.edges))# 使用图形构造函数构建图
G.add_edge(1, 2)
H = nx.DiGraph(G)  # create a DiGraph using the connections from G
print(list(H.edges()))  # [(1, 2), (2, 1)]
edgelist = [(0, 1), (1, 2), (2, 3)]
H = nx.Graph(edgelist)  # create a graph from an edge list
print(list(H.edges()))  # [(0, 1), (1, 2), (2, 3)]
adjacency_dict = {0: (1, 2), 1: (0, 2), 2: (0, 1)}
H = nx.Graph(adjacency_dict)  # create a Graph dict mapping nodes to nbrs
print(list(H.edges()))  # [(0, 1), (0, 2), (1, 2)]# 可以使用下标法访问edges和neighbors
G = nx.Graph([(1, 2, {"color": "yellow"})])
print(G[1])  # same as G.adj[1]
AtlasView({2: {'color': 'yellow'}})
print(G[1][2])  # {'color': 'yellow'}
print(G.edges[1, 2])  # {'color': 'yellow'}# 可以使用下标表示法获取/设置边的属性 如果 Edge 已存在。
G.add_edge(1, 3)
G[1][3]['color'] = "blue"
G.edges[1, 2]['color'] = "red"
print(G.edges[1, 2])# 实现对所有（节点、邻接）对的快速检查。 请注意，对于无向图，邻接迭代会将每条边看到两次。G.adjacency()G.adj.items()
FG = nx.Graph()
FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
for n, nbrs in FG.adj.items():for nbr, eattr in nbrs.items():wt = eattr['weight']if wt < 0.5: print(f"({n}, {nbr}, {wt:.3})")# 通过 edges 属性可以方便地访问所有边缘, 相比items进行打印避免了节点的重复打印
for (u, v, wt) in FG.edges.data('weight'):if wt < 0.5:print(f"\t({u}, {v}, {wt:.3})")# 在创建新图表时分配图表属性
G = nx.Graph(day="Friday")
print(G.graph)  # {'day': 'Friday'}
# 或者可以稍后修改属性
G.graph['day'] = "Monday"
print(G.graph)  # {'day': 'Monday'}# 添加节点属性add_node()add_nodes_from()G.nodes
G.add_node(1, time='5pm')
G.add_nodes_from([3], time='2pm')
print(G.nodes[1])  # {'time': '5pm'}
G.nodes[1]['room'] = 714
print(G.nodes.data())
NodeDataView({1: {'time': '5pm', 'room': 714}, 3: {'time': '2pm'}})# 添加/更改边缘属性 或下标表示法。add_edge() add_edges_from()
G.add_edge(1, 2, weight=4.7 )
G.add_edges_from([(3, 4), (4, 5)], color='red')
G.add_edges_from([(1, 2, {'color': 'blue'}), (2, 3, {'weight': 8})])
G[1][2]['weight'] = 4.7
G.edges[3, 4]['weight'] = 4.2
print(G.edges)
print(G.edges.data())

有向图及无向图及多重图

'''
有向图及无向图，以及一些公共api
'''
import networkx as nx
from networkx import to_directed, to_undirected, create_empty_copy, subgraph, union, disjoint_union, cartesian_product, \compose, complement# 有向图
DG = nx.DiGraph()
DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])
print(DG.out_degree(1, weight='weight'))  # 0.5
print(DG.degree(1, weight='weight'))  # 1.25
print(list(DG.successors(1)))  # [2]
print(list(DG.neighbors(1)))  # [2]# 有些算法仅适用于有向图，而其他算法则效果不佳 为有向图定义。事实上，将 而无向图在一起是危险的。
H = nx.Graph(DG)  # 从有向图G构建一个无向图# 多重图 NetworkX 为允许多条边的图形提供了类 在任意一对节点之间。允许您添加相同的边两次，可能使用不同的 边缘数据。
MG = nx.MultiGraph()
MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])
print(dict(MG.degree(weight='weight')))  # {1: 1.25, 2: 1.75, 3: 0.5}
GG = nx.Graph()
for n, nbrs in MG.adjacency():for nbr, edict in nbrs.items():minvalue = min([d['weight'] for d in edict.values()])GG.add_edge(n, nbr, weight=minvalue)print(nx.shortest_path(GG, 1, 3))  # [1, 2, 3]print(subgraph(GG, nbunch=2))  # 返回包含nbunch的GG的所有子图
print('subgraph', list(subgraph(GG, nbunch=2)))graph1 = nx.Graph([(8, 9, {"color": "yellow"}), (9, 10, {"color": "red"})])
print(union(graph1, GG))  # 返回俩个图的合集
print('union', union(graph1, GG).edges.data(), '\n')graph1 = nx.Graph([(111, 222, {"color": "yellow"}), (222, 333, {"color": "red"}), (1, 2, {"color": "green"})])
print(disjoint_union(graph1, GG))  # 返回俩个图的合集
print('disjoint_union', disjoint_union(graph1, GG).edges.data(), '\n')graph1 = nx.Graph([(111, 222, {"color": "yellow"})])
print(cartesian_product(graph1, GG))  # 返回G和H的Cartesian
print('cartesian_product', cartesian_product(graph1, GG).edges.data(), '\n')print(compose(graph1, GG))  # 返回G和H合并为一个图后的组合结果
print('compose', compose(graph1, GG).edges.data(), '\n')print(complement(GG))  # 返回G的完整结果
print('complement', complement(GG).edges.data(), '\n')print(to_directed(GG))  # 返回有向图
print('to_directed', to_directed(GG).edges.data(), '\n')print(to_undirected(GG))  # 返回无向图
print('to_undirected', to_undirected(GG).edges.data(), '\n')print(create_empty_copy(GG))  # 构建一个GG图的复制并移除所有的边
print('create_empty_copy', create_empty_copy(GG).nodes)

参考

• https://networkx.org/documentation/latest/tutorial.html#accessing-edges-and-neighbors