DiGraph—Directed graphs with self loops

Overview

class DiGraph(incoming_graph_data=None, **attr)

有向图的基类。

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

DiGraph持有有向边。自环是允许的，但多重（平行）边是不允许的。

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

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

Parameters:

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

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

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

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

See also

Graph

MultiGraph

MultiDiGraph

Examples

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

>>> G = nx.DiGraph()

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也可以通过添加边来增长。

添加一条边，

>>> G.add_edge(1, 2)

添加边列表，

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

或边的集合，

>>> G.add_edges_from(H.edges)

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

Attributes:

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

Shortcuts:

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

>>> 1 in G  # 检查节点是否在图中
True
>>> [n for n in G if n < 3]  # 遍历节点
[1, 2]
>>> len(G)  # 图中节点的数量
5

通常，遍历图中所有边的最佳方式是通过邻居。邻居以邻接字典 G.adj 或 G.adjacency() 的形式报告。

>>> for n, nbrsdict in G.adjacency():
...     for nbr, eattr in nbrsdict.items():
...         if "weight" in eattr:
...             # 对边做一些有用的事情
...             pass

但边报告对象通常更方便：

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

Reporting:

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

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

Subclasses (Advanced):

Graph类使用dict-of-dict-of-dict数据结构。最外层的字典（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）。

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

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()	从图中移除所有边，但不改变节点。

Reporting nodes edges and neighbors

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

Counting nodes edges and neighbors

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

Making copies and subgraphs

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