MultiDiGraph—带有自环和并行边的有向图

概述

class MultiDiGraph(incoming_graph_data=None, multigraph_input=None, **attr)

一个可以存储多重边的有向图类。

多重边是连接两个节点的多个边。每个边都可以存储可选数据或属性。

MultiDiGraph 存储有向边。允许自环。

节点可以是任意（可哈希）Python 对象，带有可选的键/值属性。按照惯例，None 不用作节点。

边表示为节点之间的链接，带有可选的键/值属性。

参数:

incoming_graph_data输入图（可选，默认值: None）

用于初始化图的数据。如果为 None（默认值），则创建一个空图。数据可以是 to_networkx_graph() 函数支持的任何格式，当前包括边列表、字典的字典、列表的字典、NetworkX 图、二维 NumPy 数组、SciPy 稀疏矩阵或 PyGraphviz 图。

multigraph_input布尔值或 None（默认值: None）

注意：仅当 incoming_graph_data 是字典时使用。如果为 True，则假定 incoming_graph_data 是一个字典嵌套结构，按节点到邻居到边键再到多重边边数据的字典结构。如果不是这种情况，则会引发 NetworkXError。如果为 False，则使用 to_networkx_graph() 尝试确定字典的图数据结构，可以是按节点到邻居到边数据的字典嵌套结构，或者按节点到邻居的可迭代对象字典结构。如果为 None，则先尝试 True 的处理方式，如果失败，则尝试 False 的处理方式。

attr关键字参数，可选（默认值= 无属性）

作为键=值对添加到图的属性。

另请参阅

Graph

DiGraph

MultiGraph

示例

创建一个不含节点和边的空图结构（“空图”）。

>>> G = nx.MultiDiGraph()

图 G 可以通过几种方式增长。

节点

一次添加一个节点

>>> G.add_node(1)

从任何容器（列表、字典、集合，甚至文件中的行或其他图中的节点）添加节点。

>>> G.add_nodes_from([2, 3])
>>> G.add_nodes_from(range(100, 110))
>>> H = nx.path_graph(10)
>>> G.add_nodes_from(H)

除了字符串和整数之外，任何可哈希的 Python 对象（None 除外）都可以表示节点，例如自定义节点对象，甚至另一个图。

>>> G.add_node(H)

边

图 G 也可以通过添加边来增长。

添加一条边，

>>> key = G.add_edge(1, 2)

一个边列表，

>>> keys = G.add_edges_from([(1, 2), (1, 3)])

或一个边集合，

>>> keys = G.add_edges_from(H.edges)

如果某些边连接到图中尚不存在的节点，则会自动添加这些节点。如果边已经存在，则会创建并存储额外的边，使用键来标识该边。默认情况下，键是最低的未使用整数。

>>> keys = G.add_edges_from([(4, 5, dict(route=282)), (4, 5, dict(route=37))])
>>> G[4]
AdjacencyView({5: {0: {}, 1: {'route': 282}, 2: {'route': 37}}})

属性

每个图、节点和边都可以在关联的属性字典中保存键/值属性对（键必须是可哈希的）。默认情况下这些是空的，但可以通过 add_edge、add_node 或直接操作分别命名为 graph、node 和 edge 的属性字典来添加或更改。

>>> G = nx.MultiDiGraph(day="Friday")
>>> G.graph
{'day': 'Friday'}

使用 add_node()、add_nodes_from() 或 G.nodes 添加节点属性

>>> G.add_node(1, time="5pm")
>>> G.add_nodes_from([3], time="2pm")
>>> G.nodes[1]
{'time': '5pm'}
>>> G.nodes[1]["room"] = 714
>>> del G.nodes[1]["room"]  # remove attribute
>>> list(G.nodes(data=True))
[(1, {'time': '5pm'}), (3, {'time': '2pm'})]

使用 add_edge()、add_edges_from()、下标表示法或 G.edges 添加边属性。

>>> key = G.add_edge(1, 2, weight=4.7)
>>> keys = G.add_edges_from([(3, 4), (4, 5)], color="red")
>>> keys = G.add_edges_from([(1, 2, {"color": "blue"}), (2, 3, {"weight": 8})])
>>> G[1][2][0]["weight"] = 4.7
>>> G.edges[1, 2, 0]["weight"] = 4

警告：我们通过将 G.edges[1, 2, 0] 设为只读的类似字典的结构来保护图数据结构。但是，您可以为例如 G.edges[1, 2, 0] 中的属性赋值。因此，使用两组方括号来添加/更改数据属性：G.edges[1, 2, 0]['weight'] = 4 （对于多重图，边键是必需的：MG.edges[u, v, key][name] = value）。

快捷方式

许多常见的图特性允许使用 Python 语法来加快报告速度。

>>> 1 in G  # check if node in graph
True
>>> [n for n in G if n < 3]  # iterate through nodes
[1, 2]
>>> len(G)  # number of nodes in graph
5
>>> G[1]  # adjacency dict-like view mapping neighbor -> edge key -> edge attributes
AdjacencyView({2: {0: {'weight': 4}, 1: {'color': 'blue'}}})

遍历图中所有边的最佳方法通常是通过邻居。邻居作为邻接视图 G.adj 对象或通过方法 G.adjacency() 可用。

>>> for n, nbrsdict in G.adjacency():
...     for nbr, keydict in nbrsdict.items():
...         for key, eattr in keydict.items():
...             if "weight" in eattr:
...                 # Do something useful with the edges
...                 pass

但 edges() 方法通常更方便

>>> for u, v, keys, weight in G.edges(data="weight", keys=True):
...     if weight is not None:
...         # Do something useful with the edges
...         pass

报告

简单的图信息可以通过方法和对象属性获得。报告通常提供视图而非容器，以减少内存使用。这些视图会随着图的更新而更新，类似于字典视图。对象 nodes、edges 和 adj 通过查找（例如 nodes[n]、edges[u, v, k]、adj[u][v]）和迭代（例如 nodes.items()、nodes.data('color')、nodes.data('color', default='blue')，edges 类似）提供对数据属性的访问。对于 nodes、edges、neighbors()/adj 和 degree 都存在视图。

有关这些和其他杂项方法的详细信息，请参见下方。

子类（高级）

MultiDiGraph 类使用一种字典嵌套结构（dict-of-dict-of-dict-of-dict）。外层字典 (node_dict) 保存按节点键入的邻接信息。下一层字典 (adjlist_dict) 表示邻接信息，并保存按邻居键入的边键字典。边键字典 (edge_key dict) 保存按边键键入的每个边属性字典。内层字典 (edge_attr_dict) 表示边数据，并保存按属性名称键入的边属性值。

这种字典嵌套结构中的每个字典都可以替换为用户自定义的类似字典的对象。通常，应保留类似字典的特性，但可以添加额外的特性。要替换其中一个字典，请通过更改类变量（！）来创建一个新的图类，该变量持有用于创建该类似字典结构的工厂函数。这些变量名称是 node_dict_factory、node_attr_dict_factory、adjlist_inner_dict_factory、adjlist_outer_dict_factory、edge_key_dict_factory、edge_attr_dict_factory 和 graph_attr_dict_factory。

node_dict_factory函数，（默认值: dict）

用于创建包含节点属性的字典的工厂函数，按节点 ID 键入。它应该不需要参数并返回一个类似字典的对象

node_attr_dict_factory: function, (default: dict)

用于创建节点属性字典的工厂函数，该字典按属性名称保存属性值。它应该不需要参数并返回一个类似字典的对象

adjlist_outer_dict_factory函数，（默认值: dict）

用于创建数据结构中最外层字典的工厂函数，该字典保存按节点键入的邻接信息。它应该不需要参数并返回一个类似字典的对象。

adjlist_inner_dict_factory函数，（默认值: dict）

用于创建邻接列表字典的工厂函数，该字典保存按邻居键入的多重边键字典。它应该不需要参数并返回一个类似字典的对象。

edge_key_dict_factory函数，（默认值: dict）

用于创建边键字典的工厂函数，该字典按边键保存边数据。它应该不需要参数并返回一个类似字典的对象。

edge_attr_dict_factory函数，（默认值: dict）

用于创建边属性字典的工厂函数，该字典按属性名称保存属性值。它应该不需要参数并返回一个类似字典的对象。

graph_attr_dict_factory函数，（默认值: dict）

用于创建图属性字典的工厂函数，该字典按属性名称保存属性值。它应该不需要参数并返回一个类似字典的对象。

通常，如果您的扩展不影响数据结构，则所有方法都将无问题地继承，除了：to_directed/to_undirected。默认情况下，这些方法会创建一个 DiGraph/Graph 类，而您可能希望它们创建您扩展的 DiGraph/Graph 类。为了方便这一点，我们定义了两个类变量，您可以在子类中设置它们。

to_directed_class可调用对象，（默认值: DiGraph 或 MultiDiGraph）

在 to_directed 方法中用于创建新图结构的类。如果为 None，则使用 NetworkX 类（DiGraph 或 MultiDiGraph）。

to_undirected_class可调用对象，（默认值: Graph 或 MultiGraph）

在 to_undirected 方法中用于创建新图结构的类。如果为 None，则使用 NetworkX 类（Graph 或 MultiGraph）。

子类示例

创建一个低内存图类，通过对所有边使用单个属性字典来有效地阻止边属性。这减少了内存使用，但您会丢失边属性。

>>> class ThinGraph(nx.Graph):
...     all_edge_dict = {"weight": 1}
...
...     def single_edge_dict(self):
...         return self.all_edge_dict
...
...     edge_attr_dict_factory = single_edge_dict
>>> G = ThinGraph()
>>> G.add_edge(2, 1)
>>> G[2][1]
{'weight': 1}
>>> G.add_edge(2, 2)
>>> G[2][1] is G[2][2]
True

方法

添加和删除节点及边

MultiDiGraph.__init__([incoming_graph_data, ...])	使用边、名称或图属性初始化图。
MultiDiGraph.add_node(node_for_adding, **attr)	添加单个节点 node_for_adding 并更新节点属性。
MultiDiGraph.add_nodes_from(...)	添加多个节点。
MultiDiGraph.remove_node(n)	移除节点 n。
MultiDiGraph.remove_nodes_from(nodes)	移除多个节点。
MultiDiGraph.add_edge(u_for_edge, v_for_edge)	在 u 和 v 之间添加一条边。
MultiDiGraph.add_edges_from(ebunch_to_add, ...)	添加 ebunch_to_add 中的所有边。
MultiDiGraph.add_weighted_edges_from(...[, ...])	添加 ebunch_to_add 中的加权边，带有指定的 weight 属性
MultiDiGraph.new_edge_key(u, v)	返回节点 u 和 v 之间边的未使用键。
MultiDiGraph.remove_edge(u, v[, key])	移除 u 和 v 之间的一条边。
MultiDiGraph.remove_edges_from(ebunch)	移除 ebunch 中指定的所有边。
MultiDiGraph.update([edges, nodes])	使用节点/边/图作为输入更新图。
MultiDiGraph.clear()	从图中移除所有节点和边。
MultiDiGraph.clear_edges()	从图中移除所有边，但不更改节点。

报告节点、边和邻居

MultiDiGraph.nodes	图的节点视图，如 G.nodes 或 G.nodes()。
MultiDiGraph.__iter__()	遍历节点。
MultiDiGraph.has_node(n)	如果图包含节点 n，则返回 True。
MultiDiGraph.__contains__(n)	如果 n 是节点，则返回 True，否则返回 False。
MultiDiGraph.edges	图的 OutMultiEdgeView，如 G.edges 或 G.edges()。
MultiDiGraph.out_edges	图的 OutMultiEdgeView，如 G.edges 或 G.edges()。
MultiDiGraph.in_edges	图的入边视图，如 G.in_edges 或 G.in_edges()。
MultiDiGraph.has_edge(u, v[, key])	如果图在节点 u 和 v 之间有一条边，则返回 True。
MultiDiGraph.get_edge_data(u, v[, key, default])	返回与边 (u, v, key) 关联的属性字典。
MultiDiGraph.neighbors(n)	返回节点 n 的后继节点的迭代器。
MultiDiGraph.adj	保存每个节点邻居的图邻接对象。
MultiDiGraph.__getitem__(n)	返回节点 n 的邻居字典。
MultiDiGraph.successors(n)	返回节点 n 的后继节点的迭代器。
MultiDiGraph.succ	保存每个节点后继者的图邻接对象。
MultiDiGraph.predecessors(n)	返回节点 n 的前驱节点的迭代器。
MultiDiGraph.pred	保存每个节点前驱者的图邻接对象。
MultiDiGraph.adjacency()	返回所有节点的 (节点, 邻接字典) 元组的迭代器。
MultiDiGraph.nbunch_iter([nbunch])	返回 nbunch 中包含的且也在图中的节点的迭代器。

计数节点、边和邻居

MultiDiGraph.order()	返回图中节点的数量。
MultiDiGraph.number_of_nodes()	返回图中节点的数量。
MultiDiGraph.__len__()	返回图中节点的数量。
MultiDiGraph.degree	图的度数视图，如 G.degree 或 G.degree()。
MultiDiGraph.in_degree	用于 (节点, 入度) 或单个节点入度的度数视图。
MultiDiGraph.out_degree	返回用于 (节点, 出度) 或单个节点出度的迭代器。
MultiDiGraph.size([weight])	返回边的数量或所有边权重的总和。
MultiDiGraph.number_of_edges([u, v])	返回两个节点之间的边数。

复制和子图

MultiDiGraph.copy([as_view])	返回图的副本。
MultiDiGraph.to_undirected([reciprocal, as_view])	返回有向图的无向表示。
MultiDiGraph.to_directed([as_view])	返回图的有向表示。
MultiDiGraph.subgraph(nodes)	返回在 nodes 上诱导的子图的 SubGraph 视图。
MultiDiGraph.edge_subgraph(edges)	返回由指定边诱导的子图。
MultiDiGraph.reverse([copy])	返回图的反向图。