有自循环和平行边的多图有向图#

概述#

class MultiDiGraph(incoming_graph_data=None, multigraph_input=None, **attr)[源代码]#

可以存储多边缘的有向图类。

多条边是两个节点之间的多条边。每个边缘可以保存可选的数据或属性。

多图表保存有向边。允许自循环。

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

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

参数

incoming_graph_data输入图形(可选，默认：无): 要初始化图形的数据。如果为None(默认)，则创建一个空图。数据可以是to_networkx_graph()函数支持的任何格式，当前包括边列表、字典的字典、列表的字典、网络X图、2D NumPy数组、SciPy稀疏矩阵或PyGraphviz图。
multigraph_input布尔或无(默认为无): 注：仅在以下情况下使用 incoming_graph_data 是个定论。如果为True， incoming_graph_data 假设是由节点到邻居到边缘关键字到多边的边缘数据为关键字的词典结构。如果不是这样，则会引发NetworkXError。如果为False， to_networkx_graph() 用于尝试将DICT的图形数据结构确定为由节点到邻居到边数据的DICT-OF-DICT，或者由节点到邻居的DICT-OF-迭代DICT。如果没有，则尝试对True的处理，但如果失败，则尝试对False的处理。
attr关键字参数，可选(默认值=无属性): 要以键=值对的形式添加到图表中的属性。

参见

Graph
DiGraph
MultiGraph
OrderedMultiDiGraph

实例

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

>>> G = nx.MultiDiGraph()

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

节点：

一次添加一个节点：

>>> G.add_node(1)

添加任何容器中的节点（列表、dict、set，甚至是文件中的行或另一个图中的节点）。

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

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

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

属性：

每个图、节点和边都可以在关联的属性字典中保存键/值属性对（键必须是可哈希的）。默认情况下，这些值为空，但可以使用添加边、添加节点或直接操作分别命名为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 。

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

子类（高级）：

多图表类使用dict结构的dict的dict。外部dict（节点dict）保存由节点键控的相邻信息。下一个dict（adjlist-dict）表示相邻信息，并保存由邻居键入的边键dict。边键dict保存由边键键入的每个边。内部dict（边缘attr u dict）表示边缘数据，并保存由属性名称键控的边缘属性值。

在dict结构的dict的dict中，这四个dict中的每一个都可以被用户定义的dict-like对象替换。一般来说，应该维护类似dict的功能，但是可以添加额外的功能。要替换其中一个dict，请通过更改类（！）创建一个新的graph类。变量为该dict-like结构保留工厂。变量名为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）: 工厂函数，用于创建包含节点属性的dict，由节点ID键控。它不需要参数，并返回类似dict的对象
节点u attr_dict_factory:函数，（默认值：dict）: 用于创建节点属性dict的factory函数，其中保存由属性名键入的属性值。它不需要参数，并返回类似dict的对象
adjlist_outer_dict_factory函数（默认值：dict）: factory函数用于在数据结构中创建最外部的dict，其中保存由节点键控的相邻信息。它不需要参数，并返回类似dict的对象。
adjlist_inner_dict_factory函数（默认值：dict）: factory函数用于创建邻接列表dict，其中保存邻居键控的多边缘密钥dict。它不需要参数，并返回类似dict的对象。
edge_key_dict_factory函数（默认值：dict）: 用于创建边键dict的工厂函数，它保存由边键键入的边数据。它不需要参数，并返回类似dict的对象。
edge_attr_dict_factory函数（默认值：dict）: 用于创建边缘属性dict的工厂函数，它保存由属性名键入的属性值。它不需要参数，并返回类似dict的对象。
graph_attr_dict_factory函数（默认值：dict）: 用于创建图形属性dict的factory函数，其中保存由属性名键入的属性值。它不需要参数，并返回类似dict的对象。

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

to_directed_class可调用（默认：有向图或多图）: 类以在 to_directed 方法。如果 None ，使用networkx类（有向图或多图）。
to_undirected_class可调用（默认：图形或多图形）: 类以在 to_undirected 方法。如果 None ，使用networkx类（图形或多图形）。

请看 ordered 例如，通过重写基类来创建图子类 dict 像字典一样的东西。

方法#

添加和删除节点和边#

`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_中的所有边添加到_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`()	从图形中移除所有边，而不改变节点。

报告节点边缘和邻居#

`MultiDiGraph.nodes`	图形的节点视图，如g.nodes或g.nodes（）。
`MultiDiGraph.__iter__`()	循环访问节点。
`MultiDiGraph.has_node`(n)	如果图表包含节点n，则返回true。
`MultiDiGraph.__contains__`(n)	如果n是节点，则返回true，否则返回false。
`MultiDiGraph.edges`	作为g.edges或g.edges（）的图的outmultipedgeview。
`MultiDiGraph.out_edges`	作为g.edges或g.edges（）的图的outmultipedgeview。
`MultiDiGraph.in_edges`	图形的inmultiegeview，如g.in_edges或g.in_edges（）。
`MultiDiGraph.has_edge`(u, v[, key])	如果图在节点u和v之间有边，则返回true。
`MultiDiGraph.get_edge_data`(u, v[, key, default])	返回与edge(u，v，key)关联的属性字典。
`MultiDiGraph.neighbors`(n)	返回N的后续节点上的迭代器。
`MultiDiGraph.adj`	图形邻接对象，包含每个节点的邻居。
`MultiDiGraph.__getitem__`(n)	返回节点n的邻居的dict。
`MultiDiGraph.successors`(n)	返回N的后续节点上的迭代器。
`MultiDiGraph.succ`	包含每个节点的后续节点的图邻接对象。
`MultiDiGraph.predecessors`(n)	返回n的前置节点上的迭代器。
`MultiDiGraph.succ`	包含每个节点的后续节点的图邻接对象。
`MultiDiGraph.adjacency`()	返回所有节点的（node，adjacency dict）元组的迭代器。
`MultiDiGraph.nbunch_iter`([nbunch])	返回包含在nbunch中的节点上的迭代器，该节点也在图中。

计算节点边缘和邻居#

`MultiDiGraph.order`()	返回图表中的节点数。
`MultiDiGraph.number_of_nodes`()	返回图表中的节点数。
`MultiDiGraph.__len__`()	返回图表中的节点数。
`MultiDiGraph.degree`	图形的degreeview，如g.degree或g.degree（）。
`MultiDiGraph.in_degree`	（节点，以度表示）或（单个节点，以度表示）的度视图。
`MultiDiGraph.out_degree`	为单个节点返回（node，out degree）或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` .
`MultiDiGraph.edge_subgraph`(edges)	返回由指定边诱导的子图。
`MultiDiGraph.reverse`([copy])	返回图形的相反方向。