MultiDiGraph—Directed graphs with self loops and parallel edges

Overview

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

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

多重边是指两个节点之间的多条边。每条边可以持有可选的数据或属性。

一个MultiDiGraph持有有向边。允许自环。

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

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

Parameters:

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

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

multigraph_inputbool或None（默认None）

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

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

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

See also

Graph

DiGraph

MultiGraph

Examples

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

>>> G = nx.MultiDiGraph()

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

Nodes:

一次添加一个节点：

>>> 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)

Edges:

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}}})

Attributes:

每个图、节点和边都可以持有键/值属性对，在关联的属性字典中（键必须是可哈希的）。默认情况下这些是空的，但可以使用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"]  # 移除属性
>>> 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 ）。

Shortcuts:

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

>>> 1 in G  # 检查节点是否在图中
True
>>> [n for n in G if n < 3]  # 遍历节点
[1, 2]
>>> len(G)  # 图中节点的数量
5
>>> G[1]  # 邻接字典式视图，映射邻居 -> 边键 -> 边属性
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:
...                 # 对边做一些有用的事情
...                 pass

但edges()方法通常更方便：

>>> for u, v, keys, weight in G.edges(data="weight", keys=True):
...     if weight is not None:
...         # 对边做一些有用的事情
...         pass

Reporting:

使用方法和对象属性可以获得简单的图信息。报告通常提供视图而不是容器，以减少内存使用。视图在图更新时更新，类似于字典视图。对象 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 。

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

Subclasses (Advanced):

MultiDiGraph类使用一个字典的字典的字典的字典结构。最外层的字典（node_dict）按节点键入邻接信息。下一个字典（adjlist_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: 函数，（默认：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）。

Subclassing Example

创建一个低内存图类，通过使用单个属性字典来有效地禁止边属性。这减少了内存使用，但你失去了边属性。

>>> 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

Methods

Adding and Removing Nodes and Edges

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 中添加指定权重属性的加权边
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()	从图中移除所有边，但不改变节点。

Reporting nodes edges and neighbors

MultiDiGraph.nodes	图的节点视图，表示为 G.nodes 或 G.nodes()。
MultiDiGraph.__iter__()	遍历节点。使用：'for n in G'。
MultiDiGraph.has_node(n)	返回 True 如果图包含节点 n。
MultiDiGraph.__contains__(n)	返回 True 如果 n 是一个节点，否则返回 False。使用方法：'n in G'。
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 的邻居字典。使用方法：'G[n]'。
MultiDiGraph.successors(n)	返回节点 n 的后继节点的迭代器。
MultiDiGraph.succ	图邻接对象，存储每个节点的后继节点。
MultiDiGraph.predecessors(n)	返回节点 n 的前驱节点的迭代器。
MultiDiGraph.pred	图邻接对象，存储每个节点的前驱节点。
MultiDiGraph.adjacency()	返回一个迭代器，遍历所有节点的 (节点, 邻接字典) 元组。
MultiDiGraph.nbunch_iter([nbunch])	返回一个迭代器，遍历包含在nbunch中且也在图中的节点。

Counting nodes edges and neighbors

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

Making copies and subgraphs

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