DiGraph—带自环的有向图

概述

class DiGraph(incoming_graph_data=None, **attr)

有向图的基类。

DiGraph 存储节点和边，并带有可选数据或属性。

DiGraph 包含有向边。允许自环，但不允许有多条（并行）边。

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

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

参数:

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

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

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

以键=值对的形式添加到图的属性。

另请参阅

Graph

MultiGraph

MultiDiGraph

示例

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

>>> G = nx.DiGraph()

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）都可以表示一个节点，例如自定义节点对象，甚至是另一个 Graph。

>>> G.add_node(H)

边

G 也可以通过添加边来扩展。

添加一条边，

>>> G.add_edge(1, 2)

一个边列表，

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

或一个边集合，

>>> G.add_edges_from(H.edges)

如果某些边连接了图中尚不存在的节点，则这些节点会自动添加。添加已存在的节点或边不会出错。

属性

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

>>> G = nx.DiGraph(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 添加边属性。

>>> 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[1, 2]["weight"] = 4

警告：我们通过将 G.edges[1, 2] 设为只读的类似字典的结构来保护图数据结构。但是，您可以为 G.edges[1, 2] 中的属性赋值。因此，使用两对括号来添加/更改数据属性：G.edges[1, 2]['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.adj 或 G.adjacency() 的形式报告

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

但边报告对象通常更方便

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

报告

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

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

子类（高级）

Graph 类使用一种字典的字典的字典数据结构。外层字典 (node_dict) 按节点键存储邻接信息。下一层字典 (adjlist_dict) 表示邻接信息，按邻居键存储边数据。内层字典 (edge_attr_dict) 表示边数据，按属性名键存储边属性值。

这三个字典中的每一个都可以在子类中被用户定义的类似字典的对象替换。通常，应保留类似字典的特性，但可以添加额外功能。要替换其中一个字典，可以通过更改保存该类似字典结构工厂的类(!)变量来创建一个新的图类。变量名称是 node_dict_factory、node_attr_dict_factory、adjlist_inner_dict_factory、adjlist_outer_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_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

方法

添加和移除节点与边

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

报告节点、边和邻居

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

统计节点、边和邻居

DiGraph.order()	返回图中的节点数量。
DiGraph.number_of_nodes()	返回图中的节点数量。
DiGraph.__len__()	返回图中的节点数量。
DiGraph.degree	作为 G.degree 或 G.degree() 的 Graph 的 DegreeView。
DiGraph.in_degree	用于 (节点, 入度) 或单个节点入度的 InDegreeView。
DiGraph.out_degree	用于 (节点, 出度) 的 OutDegreeView。
DiGraph.size([weight])	返回边的数量或所有边权重的总和。
DiGraph.number_of_edges([u, v])	返回两个节点之间的边数量。

创建副本和子图

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