MultiGraph—Undirected graphs with self loops and parallel edges

Overview

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

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

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

MultiGraph 持有无向边。允许自环。

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

边表示为节点之间的链接，带有可选的键/值属性，在 MultiGraph 中，每条边都有一个键来区分具有相同源节点和目标节点的多条边。

Parameters:

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

用于初始化图的数据。如果为 None（默认），则创建一个空图。数据可以是 to_networkx_graph() 函数支持的任何格式，目前包括边列表、字典的字典、字典的列表、NetworkX 图、二维 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

MultiDiGraph

Examples

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

>>> G = nx.MultiGraph()

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, {"route": 28}), (4, 5, {"route": 37})])
>>> G[4]
AdjacencyView({3: {0: {}}, 5: {0: {}, 1: {'route': 28}, 2: {'route': 37}}})

Attributes:

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

>>> G = nx.MultiGraph(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 。

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

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

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

Reporting nodes edges and neighbors

MultiGraph.nodes	图的节点视图，表示为 G.nodes 或 G.nodes()。
MultiGraph.__iter__()	遍历节点。使用：'for n in G'。
MultiGraph.has_node(n)	返回 True 如果图包含节点 n。
MultiGraph.__contains__(n)	返回 True 如果 n 是一个节点，否则返回 False。使用方法：'n in G'。
MultiGraph.edges	返回一个边迭代器。
MultiGraph.has_edge(u, v[, key])	如果图中节点 u 和 v 之间存在边，则返回 True。
MultiGraph.get_edge_data(u, v[, key, default])	返回与边 (u, v, key) 相关联的属性字典。
MultiGraph.neighbors(n)	返回节点 n 的所有邻居的迭代器。
MultiGraph.adj	图邻接对象，存储每个节点的邻居信息。
MultiGraph.__getitem__(n)	返回节点 n 的邻居字典。使用方法：'G[n]'。
MultiGraph.adjacency()	返回一个迭代器，遍历所有节点的 (节点, 邻接字典) 元组。
MultiGraph.nbunch_iter([nbunch])	返回一个迭代器，遍历包含在nbunch中且也在图中的节点。

Counting nodes edges and neighbors

MultiGraph.order()	返回图中的节点数量。
MultiGraph.number_of_nodes()	返回图中的节点数量。
MultiGraph.__len__()	返回图中的节点数量。使用方法：'len(G)'。
MultiGraph.degree	图的度视图，如 G.degree 或 G.degree()。
MultiGraph.size([weight])	返回边的数量或所有边权重的总和。
MultiGraph.number_of_edges([u, v])	返回两个节点之间的边数。

Making copies and subgraphs

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