图类型¶

类别	类型	允许自循环	允许平行边
图	无向	是	否
有向图	有方向的	是	否

请注意graphscope.nx不支持MultiGraph和MultiDiGraph。

Graph¶

带自环的无向图

class graphscope.nx.Graph(incoming_graph_data=None, default_label=None, **attr)[源代码]¶

无向图的基类。

一个包含图元数据的Graph，并提供类似NetworkX的图API接口。

值得注意的是，图实际上是由分析引擎后端存储的。换句话说，Graph对象仅保存图的元数据。

Graph支持带有可选数据或属性的节点和边。

图支持无向边。允许自环但不允许多重（平行）边。

节点可以是任意的整数/字符串/浮点数/布尔值对象，并可带有可选的键/值属性。

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

如果图是从GraphScope图对象创建的，则支持节点标签。节点由(label, id)元组标识。

Parameters:

incoming_graph_data (输入图数据 (可选, 默认: None)) - 用于初始化图的数据。如果为None（默认值）则会创建一个空图。数据可以是to_networkx_graph()函数支持的任何格式，目前包括边列表、字典的字典、列表的字典、NetworkX图、2D NumPy数组、SciPy稀疏矩阵或GraphScope图对象。
default_label (默认节点标签 (可选, 默认值: None)) – 如果incoming_graph_data是GraphScope图对象，default_label表示该标签的节点可以直接通过id识别，其他标签节点需要使用(label, id)来标识。
attr (关键字参数，可选（默认=无属性）) - 以键值对形式添加到图中的属性。

另请参阅

DiGraph

示例

创建一个空的图结构（"空图"），不包含任何节点和边。

>>> G = nx.Graph()

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)

除了整数之外，字符串/浮点数/布尔值也可以用来表示节点。

>>> G.add_node('a node')
>>> G.add_node(3.14)
>>> G.add_node(True)

边：

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.Graph(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  # node must exist already to use G.nodes
>>> 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设为只读的类字典结构来保护图数据结构。不过，您仍可以为属性赋值，例如G.edges[1, 2]。因此，请使用两组方括号来添加/修改数据属性：G.edges[1, 2][‘weight’] = 4

快捷方式：

许多常见的图特征允许使用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

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

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

转换

使用GraphScope图对象创建图。首先我们初始化一个GraphScope图，包含两个节点标签：person和comment`

>>> g = graphscope.g(directed=False).add_vertice("person.csv", label="person").add_vertice("comment.csv", label="comment")

使用g创建一个图，将default_label设置为'person'

>>> G = nx.Graph(g, default_label="person")

person标签节点可以直接通过id识别，而对于comment标签，我们需要使用元组("comment", id)来标识。例如，添加一个person标签节点和一个comment标签节点

>>> G.add_node(0, type="person")
>>> G.add_node(("comment", 0), type="comment")

打印两个节点的属性

>>> G.nodes[0]
{"type", "person"}
>>> G.nodes[("comment", 0)]
{"type", "comment"}

报告：

通过对象属性和方法可以获取简单的图信息。报告功能通常提供视图而非容器，以降低内存消耗。这些视图会随着图的更新而动态更新，类似于字典视图。对象节点、`边和邻接支持通过查找（例如节点[n]、`边[u, v]、邻接[u][v]）和迭代（例如节点.items()、节点.data('颜色')、节点.data('颜色', default='蓝色')，边对象同理）来访问数据属性。视图类型包括节点、边、邻居()/邻接和度。

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

__contains__(n)[源代码]¶

如果n是一个节点则返回True，否则返回False。用法：'n in G'。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> 1 in G
True

__getitem__(n)[源代码]¶

返回节点n的邻居字典。用法：'G[n]'。

Parameters:: n (节点) – 图中的节点。
Returns:: adj_dict – 与节点n相连的邻接字典。
Return type:: 字典

备注

G[n] 等同于 G.adj[n]，类似于 G.neighbors(n) （这是一个遍历 G.adj[n] 的迭代器）

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G[0]
AtlasView({1: {}})

__init__(incoming_graph_data=None, default_label=None, **attr)[源代码]¶

使用图、边、名称或图属性初始化一个图

Parameters:

incoming_graph_data (输入图数据 (可选, 默认: None)) - 用于初始化图的数据。如果为None(默认值)则创建一个空图。数据可以是边列表、任何NetworkX图对象或任何GraphScope图对象。如果安装了相应的可选Python包，数据也可以是2D NumPy数组或SciPy稀疏矩阵
default_label (默认节点标签 (可选, 默认: "_")) – 如果incoming_graph_data是GraphScope图对象，default_label表示可以直接通过id访问该标签的节点，其他标签节点需要使用(label, id)来访问。
attr (关键字参数，可选（默认=无属性）) - 以键值对形式添加到图中的属性。

另请参阅

convert

示例

>>> G = nx.Graph()  # or DiGraph
>>> G = nx.Graph(name='my graph')
>>> e = [(1, 2), (2, 3), (3, 4)]  # list of edges
>>> G = nx.Graph(e)

可以分配任意的图属性键值对（key=value）

>>> G = nx.Graph(e, day="Friday")
>>> G.graph
{'day': 'Friday'}

由GraphScope图对象创建

>>> g = graphscope.g(directed=False)  # if transform to DiGraph, directed=True
>>> g.add_vertices("person.csv", label="person").add_vertices("comment.csv", label="comment").add_edges(...)
>>> G = nx.Graph(g, default_label="person") # or DiGraph

__iter__()[源代码]¶

遍历节点。用法：'for n in G'。

Returns:: niter – 图中所有节点的迭代器。
Return type:: 迭代器

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> [n for n in G]
[0, 1, 2, 3]
>>> list(G)
[0, 1, 2, 3]

__len__()[源代码]¶

返回图中的节点数量。用法：'len(G)'。

Returns:: nnodes – 图中的节点数量。
Return type:: int

另请参阅

number_of_nodes, order

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> len(G)
4

add_edge(u_of_edge, v_of_edge, **attr)[源代码]¶

在u和v之间添加一条边。

如果节点u和v尚未存在于图中，它们将被自动添加。

边的属性可以通过关键字或直接访问边的属性字典来指定。参见以下示例。

Parameters:

u (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如整型/字符串/浮点型/元组/布尔型。
v (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如整型/字符串/浮点型/元组/布尔型。
attr (关键字参数, 可选) – 可以使用关键字参数来分配边数据。

另请参阅

add_edges_from: 添加一组边

备注

添加已存在的边会更新边数据。

许多专为加权图设计的networkx算法会使用边属性(默认为weight)来存储数值。

示例

以下操作均将边 e=(1, 2) 添加到图 G 中：

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> e = (1, 2)
>>> G.add_edge(1, 2)  # explicit two-node form
>>> G.add_edge(*e)  # single edge as tuple of two nodes
>>> G.add_edges_from([(1, 2)])  # add edges from iterable container

使用关键词将数据关联到边:

>>> G.add_edge(1, 2, weight=3)
>>> G.add_edge(1, 3, weight=7, capacity=15, length=342.7)

对于非字符串属性键，请使用下标表示法。

>>> G.add_edge(1, 2)
>>> G[1][2].update({0: 5})
>>> G.edges[1, 2].update({0: 5})

add_edges_from(ebunch_to_add, **attr)[源代码]¶

添加 ebunch_to_add 中的所有边。

Parameters:

ebunch_to_add (container of edges) - 容器中提供的每条边都将被添加到图中。边必须以2元组(u, v)或3元组(u, v, d)的形式给出，其中d是包含边数据的字典。
attr (关键字参数, 可选) – 可以使用关键字参数来分配边数据。

另请参阅

add_edge: 添加一条边
add_weighted_edges_from: 添加加权边的便捷方式

备注

重复添加同一条边不会产生效果，但每次添加重复边时，任何边数据都会被更新。

在边集合中指定的边属性优先级高于通过关键字参数指定的属性。

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
>>> e = zip(range(0, 3), range(1, 4))
>>> G.add_edges_from(e)  # Add the path graph 0-1-2-3

将数据关联到边

>>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
>>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")

add_node(node_for_adding, **attr)[源代码]¶

添加单个节点 node_for_adding 并更新节点属性。

Parameters:

node_for_adding (node) – 节点可以是int、float、str、tuple或bool对象。
attr (关键字参数, 可选) – 使用键值对设置或修改节点属性。

另请参阅

add_nodes_from

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_node(1)
>>> G.add_node(2)
>>> G.number_of_nodes()
2

使用关键词 set/change 设置/修改节点属性：

>>> G.add_node(1, size=10)
>>> G.add_node(3, weight=0.4, type='apple')

备注

nx.Graph 支持节点为 int、float、str、tuple 或 bool 类型的对象。

add_nodes_from(nodes_for_adding, **attr)[源代码]¶

添加多个节点。

Parameters:

nodes_for_adding (可迭代容器) – 包含节点的容器（列表、字典、集合等）。或者包含(节点, 属性字典)元组的容器。节点属性会使用属性字典进行更新。
attr (关键字参数，可选（默认=无属性）) - 为nodes中的所有节点更新属性。以元组形式在nodes中指定的节点属性优先于通过关键字参数指定的属性。

另请参阅

add_node

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_nodes_from("Hello")
>>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
>>> G.add_nodes_from(K3)
>>> sorted(G.nodes(), key=str)
[0, 1, 2, 'H', 'e', 'l', 'o']

使用关键词更新每个节点的特定属性。

>>> G.add_nodes_from([1, 2], size=10)
>>> G.add_nodes_from([3, 4], weight=0.4)

使用 (node, attrdict) 元组来更新特定节点的属性。

>>> G.add_nodes_from([(1, dict(size=11)), (2, {"color": "blue"})])
>>> G.nodes[1]["size"]
11
>>> H = nx.Graph()
>>> H.add_nodes_from(G.nodes(data=True))
>>> H.nodes[1]["size"]
11

add_weighted_edges_from(ebunch_to_add, weight='weight', **attr)[源代码]¶

在ebunch_to_add中添加带权边，并指定权重属性

Parameters:

ebunch_to_add (container of edges) - 列表或容器中提供的每条边都将被添加到图中。边必须以三元组(u, v, w)的形式给出，其中w是一个数字。
weight (string, optional (default= 'weight')) – 要添加的边权重属性名称。
attr (关键字参数，可选（默认=无属性）) - 为所有边添加/更新的边属性。

另请参阅

add_edge: 添加一条边
add_edges_from: 添加多条边

备注

对于Graph/DiGraph重复添加同一条边只会更新边的数据。

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)])

property adj¶

存储每个节点邻居的图邻接对象。

该对象是一个只读的类字典结构，以节点为键，邻接字典为值。邻接字典以相邻节点为键，边数据字典为值。因此G.adj[3][2]['color'] = 'blue'会将边(3, 2)的颜色设置为"blue"。

遍历G.adj的行为类似于字典。常用惯用法包括 for nbr, datadict in G.adj[n].items():。

邻接信息也可以通过图的下标访问提供。因此for nbr, foovalue in G[node].data('foo', default=1): 这样的写法是有效的。

对于有向图，G.adj保存的是出边（后继节点）信息。

adjacency()[源代码]¶

返回一个遍历所有节点的(节点, 邻接字典)元组的迭代器。

对于有向图，仅包含出方向的邻居/邻接节点。

Returns:: adj_iter – 图中所有节点的(节点, 邻接字典)迭代器。
Return type:: 迭代器

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> [(n, nbrdict) for n, nbrdict in G.adjacency()]
[(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})]

adjlist_inner_dict_factory¶: NeighborDict的别名

adjlist_outer_dict_factory¶: AdjListDict的别名

clear()[源代码]¶

从图中移除所有节点和边。

这也会移除名称，以及所有图、节点和边的属性。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.clear()
>>> list(G.nodes)
[]
>>> list(G.edges)
[]

clear_edges()[源代码]¶

移除图中的所有边而不改变节点。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.clear_edges()
>>> list(G.nodes)
[0, 1, 2, 3]
>>> list(G.edges)
[]

copy(as_view=False)[源代码]¶

返回图的副本。

默认情况下，copy方法会返回图及其属性的独立深拷贝。

如果 as_view 为 True，则返回视图而非副本。

备注

所有副本都会复制图结构，但数据属性可能以不同方式处理。人们可能需要的图副本有三种类型。

深度复制（Deepcopy）—— "深度复制"不仅复制图结构，还包括所有数据属性以及它们在引擎后端可能包含的任何对象。整个图对象都是全新的，因此副本中的更改不会影响原始对象。

新数据 - 对于新数据，图结构会被复制，同时创建新的空数据属性字典。生成的图与原始图相互独立，且不包含边、节点或图属性。目前不支持创建全新副本，替代方案是使用：

>>> H = G.__class__()
>>> H.add_nodes_from(G)
>>> H.add_edges_from(G.edges)

视图 - 受字典视图启发，图视图充当原始图的只读版本，提供原始结构的副本而无需为复制信息分配任何内存。

Parameters:: as_view (bool, 可选参数 (默认=False)) - 如果设为True，返回的图视图将提供一个只读视图，无需实际复制原始图的任何数据。
Returns:: G – 图的副本。
Return type:: Graph

另请参阅

to_directed: 返回图的有向副本。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> H = G.copy()

property degree¶

图的度数视图，可通过G.degree或G.degree()访问。

节点度是指与该节点相邻的边数。加权节点度是指与该节点相连的所有边的权重之和。

该对象提供(node, degree)的迭代器功能，同时支持查询单个节点的度数。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅显示与这些节点相关联的边。
weight (string or None, optional (default=None)) – 表示边权重的数值属性名称。如果为None，则每条边的权重默认为1。节点的度数是其相邻边权重的总和。

Returns:

如果请求的是单个节点
deg (int) – 节点的度数
或者如果请求的是多个节点
nd_view (能够迭代(节点, 度数)对的DegreeView对象)

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.degree[0]  # node 0 has degree 1
1
>>> list(G.degree([0, 1, 2]))
[(0, 1), (1, 2), (2, 2)]

edge_attr_dict_factory¶: NeighborAttrDict的别名

edge_subgraph(edges)[源代码]¶

返回由指定边导出的独立深拷贝子图。

诱导子图包含edges中的每条边以及与这些边相关联的每个节点。

Parameters:: edges (可迭代对象) – 该图中边的可迭代集合。
Returns:: G – 该图的一个边诱导子图，具有相同的边属性。
Return type:: Graph

备注

与NetworkX返回视图不同，这里返回一个独立的深拷贝子图。

示例

>>> G = nx.path_graph(5) # or DiGraph
>>> H = G.edge_subgraph([(0, 1), (3, 4)])
>>> list(H.nodes)
[0, 1, 3, 4]
>>> list(H.edges)
[(0, 1), (3, 4)]

property edges¶

图的边视图，可通过 G.edges 或 G.edges() 访问。

edges(self, nbunch=None, data=False, default=None)

EdgeView提供了对边元组的类集合操作以及边属性查询功能。当被调用时，它会返回一个EdgeDataView对象，该对象允许控制对边属性的访问（但不提供类集合操作）。因此，G.edges[u, v]['color']可以获取边(u, v)的颜色属性值，而for (u, v, c) in G.edges.data('color', default='red'):则会遍历所有边并返回颜色属性值，如果不存在颜色属性则默认返回'red'。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
data (string or bool, optional (default=False)) - 在返回的3元组(u, v, ddict[data])中作为边属性返回。如果为True，则返回包含边属性字典的3元组(u, v, ddict)。如果为False，则返回2元组(u, v)。
default (value, optional (default=None)) - 用于没有请求属性的边的默认值。仅当数据不是True或False时相关。

Returns:

edges – 边属性的视图，通常它会遍历边的 (u, v) 或 (u, v, d) 元组，但也可用于属性查询，如 edges[u, v]['foo']。

Return type:

边视图

备注

不在图中的nbunch节点将被（静默）忽略。对于有向图，这将返回出边。

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.add_edge(2, 3, weight=5)
>>> [e for e in G.edges]
[(0, 1), (1, 2), (2, 3)]
>>> G.edges.data()  # default data is {} (empty dict)
EdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
>>> G.edges.data("weight", default=1)
EdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
>>> G.edges([0, 3])  # only edges incident to these nodes
EdgeDataView([(0, 1), (3, 2)])
>>> G.edges(0)  # only edges incident to a single node (use G.adj[0]?)
EdgeDataView([(0, 1)])

get_edge_data(u, v, default=None)[源代码]¶

返回与边(u, v)关联的属性字典。

这与G[u][v]相同，唯一的区别是如果边不存在，将返回默认值而不是抛出异常。

Parameters:

u (节点) –
v (节点) –
default (任意Python对象 (默认=None)) – 如果找不到边(u, v)时返回的值。

Returns:

edge_dict – 边属性字典。

Return type:

字典

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G[0][1]
{}

警告：不允许直接对 G[u][v] 进行赋值操作。但可以安全地为属性 G[u][v]['foo'] 赋值

>>> G[0][1]["weight"] = 7
>>> G[0][1]["weight"]
7
>>> G[1][0]["weight"]
7

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.get_edge_data(0, 1)  # default edge data is {}
{}
>>> e = (0, 1)
>>> G.get_edge_data(*e)  # tuple form
{}
>>> G.get_edge_data("a", "b", default=0)  # edge not in graph, return 0
0

graph_attr_dict_factory¶: dict的别名

graph_cache_factory¶: Cache的别名

property graph_type¶

图对象的类型。

Returns:: 图的类型。
Return type:: 类型 (types_pb2.GraphType)

has_edge(u, v)[源代码]¶

如果边 (u, v) 存在于图中，则返回 True。

这与v in G[u]相同，但不会引发KeyError异常。

Parameters:

u (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如int、str、float、tuple、bool类型。
v (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如整型、字符串、浮点数、元组或布尔值。

Returns:

edge_ind – 如果边存在于图中则为True，否则为False。

Return type:

布尔值

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.has_edge(0, 1)  # using two nodes
True
>>> e = (0, 1)
>>> G.has_edge(*e)  #  e is a 2-tuple (u, v)
True
>>> e = (0, 1, {"weight": 7})
>>> G.has_edge(*e[:2])  # e is a 3-tuple (u, v, data_dictionary)
True

以下语法是等价的：

>>> G.has_edge(0, 1)
True
>>> 1 in G[0]  # though this gives KeyError if 0 not in G
True

has_node(n)[源代码]¶

如果图中包含节点n，则返回True。

与 n in G 相同

Parameters:: n (节点) –

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.has_node(0)
True

它更易读且使用更简单

>>> 0 in G
True

is_directed()[源代码]¶: 如果图是有向的则返回True，否则返回False。

is_multigraph()[源代码]¶: 如果图是多图则返回True，否则返回False。

property key¶: 对应引擎图的关键键值。

property name¶

图的字符串标识符。

该图属性出现在属性字典G.graph中，键名为字符串"name"，同时也作为属性（技术上称为属性）G.name存在。这完全由用户控制。

nbunch_iter(nbunch=None)[源代码]¶

返回一个迭代器，包含同时存在于nbunch和图(graph)中的节点。

检查nbunch中的节点是否属于该图，不属于的节点将被静默忽略。

Parameters:: nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
Returns:: niter – 一个迭代器，用于遍历同时存在于nbunch和图结构中的节点。如果nbunch为None，则遍历图中的所有节点。
Return type:: 迭代器
Raises:: NetworkXError – 如果nbunch不是节点或节点序列。如果nbunch中的某个节点不可哈希。

另请参阅

Graph.__iter__

备注

当nbunch是一个迭代器时，返回的迭代器会直接从nbunch中生成值，当nbunch耗尽时也会随之耗尽。

要测试 nbunch 是否为单个节点，可以使用 "if nbunch in self:"，即使经过此例程处理后也是如此。

如果nbunch不是节点或(可能为空的)序列/迭代器或None，则会引发NetworkXError。此外，如果nbunch中的任何对象不可哈希，也会引发NetworkXError。

neighbors(n)[源代码]¶

返回节点n所有邻居的迭代器。

这与 iter(G[n]) 相同

Parameters:: n (节点) – 图中的节点
Returns:: neighbors – 遍历节点n所有邻居的迭代器
Return type:: 迭代器
Raises:: NetworkXError - 如果节点n不在图中。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> [n for n in G.neighbors(0)]
[1]

备注

访问邻居节点的替代方法是 G.adj[n] 或 G[n]：

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edge("a", "b", weight=7)
>>> G["a"]
AtlasView({'b': {'weight': 7}})
>>> G = nx.path_graph(4)
>>> [n for n in G[0]]
[1]

node_attr_dict_factory¶: NodeAttrDict的别名

node_dict_factory¶: NodeDict的别名

property nodes¶

图的节点视图，如 G.nodes 或 G.nodes()。

可作为G.nodes用于数据查找和类似集合的操作。也可用作G.nodes(data='color', default=None)返回 NodeDataView，该视图报告特定节点数据但不支持集合操作。它提供了类似字典的接口，G.nodes.items() 遍历(node, nodedata)二元组，而G.nodes[3]['foo'] 提供节点3的foo属性值。此外，视图G.nodes.data('foo')为每个节点的 foo属性提供了类似字典的接口。G.nodes.data('foo', default=1) 为没有foo属性的节点提供了默认值。

Parameters:

data (string or bool, optional (default=False)) – 作为2元组(n, ddict[data])返回的节点属性。如果为True，则返回完整的节点属性字典(n, ddict)。如果为False，则仅返回节点n。
default (value, optional (default=None)) - 用于没有请求属性的节点的默认值。仅当data参数不为True或False时相关。

Returns:

允许对节点执行类似集合的操作，同时支持节点属性字典查找和调用以获取NodeDataView。 NodeDataView遍历(n, data)但不支持集合操作。 NodeView遍历n并包含集合操作。

当被调用时，如果data为False，则返回节点迭代器。否则返回2元组迭代器（节点，属性值），其中属性在data中指定。如果data为True，则该属性将成为完整的数据字典。

Return type:

节点视图

备注

如果不需要节点数据，使用表达式 for n in G 或 list(G) 会更简单且等效。

示例

有两种简单的方法可以获取图中所有节点的列表：

>>> G = nx.path_graph(3)
>>> list(G.nodes)
[0, 1, 2]
>>> list(G)
[0, 1, 2]

获取节点数据以及节点：

>>> G.add_node(1, time="5pm")
>>> G.nodes[0]["foo"] = "bar"
>>> list(G.nodes(data=True))
[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
>>> list(G.nodes.data())
[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]

>>> list(G.nodes(data="foo"))
[(0, 'bar'), (1, None), (2, None)]
>>> list(G.nodes.data("foo"))
[(0, 'bar'), (1, None), (2, None)]

>>> list(G.nodes(data="time"))
[(0, None), (1, '5pm'), (2, None)]
>>> list(G.nodes.data("time"))
[(0, None), (1, '5pm'), (2, None)]

>>> list(G.nodes(data="time", default="Not Available"))
[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
>>> list(G.nodes.data("time", default="Not Available"))
[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]

如果某些节点具有属性，而其余节点假定具有默认属性值，您可以使用default关键字参数从节点/属性对创建字典，以确保该值永远不会为None：

>>> G = nx.Graph()
>>> G.add_node(0)
>>> G.add_node(1, weight=2)
>>> G.add_node(2, weight=3)
>>> dict(G.nodes(data="weight", default=1))
{0: 1, 1: 2, 2: 3}

number_of_edges(u=None, v=None)[源代码]¶

返回两个节点之间的边数。

Parameters:

u (节点，可选（默认=所有边）) - 如果指定了u和v，则返回u和v之间的边数。否则返回所有边的总数。
v (nodes, optional (default=all edges)) - 如果指定了u和v，则返回u和v之间的边数。否则返回所有边的总数。

Returns:

nedges – 图中的边数。如果指定了节点u和v，则返回这两个节点之间的边数。如果图是有向的，则仅返回从u到v的边数。

Return type:

int

另请参阅

size

示例

对于无向图，此方法统计图中的总边数：

>>> G = nx.path_graph(4)
>>> G.number_of_edges()
3

如果指定两个节点，这将计算连接这两个节点的总边数：

>>> G.number_of_edges(0, 1)
1

对于有向图，此方法可以统计从u到v的有向边总数：

>>> G = nx.DiGraph()
>>> G.add_edge(0, 1)
>>> G.add_edge(1, 0)
>>> G.number_of_edges(0, 1)
1

number_of_nodes()[源代码]¶

返回图中节点的数量。

Returns:: nnodes – 图中的节点数量。
Return type:: int

另请参阅

order, __len__

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.number_of_nodes()
3

property op¶: 该图的DAG操作。

order()[源代码]¶

返回图中节点的数量。

Returns:: nnodes – 图中的节点数量。
Return type:: int

另请参阅

number_of_nodes, __len__

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.order()
3

remove_edge(u, v)[源代码]¶

移除u和v之间的边。

Parameters:

u (节点) – 移除节点u和v之间的边。
v (节点) – 移除节点u和v之间的边。

Raises:

NetworkXError – 如果节点u和v之间不存在边。

另请参阅

remove_edges_from: 移除一组边

示例

>>> G = nx.path_graph(4)  # or DiGraph, etc
>>> G.remove_edge(0, 1)
>>> e = (1, 2)
>>> G.remove_edge(*e)  # unpacks e from an edge tuple
>>> e = (2, 3, {"weight": 7})  # an edge with attribute data
>>> G.remove_edge(*e[:2])  # select first part of edge tuple

remove_edges_from(ebunch)[源代码]¶

移除 ebunch 中指定的所有边。

Parameters:

ebunch (列表或容器，包含 边元组) –

列表或容器中给出的每条边都将从图中移除。边的格式可以是：

2元组 (u, v) 表示u和v之间的边

3元组 (u, v, k) 其中k会被忽略

另请参阅

remove_edge: 移除单条边

备注

如果ebunch中的某条边不在图中，将静默失败。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> ebunch = [(1, 2), (2, 3)]
>>> G.remove_edges_from(ebunch)

remove_node(n)[源代码]¶

移除节点n。

移除节点n及其所有相邻边。尝试移除不存在的节点将引发异常。

Parameters:: n (节点) – 图中的节点
Raises:: NetworkXError – 如果n不在图中。

另请参阅

remove_nodes_from

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> list(G.edges)
[(0, 1), (1, 2)]
>>> G.remove_node(1)
>>> list(G.edges)
[]

remove_nodes_from(nodes_for_removing)[源代码]¶

移除多个节点。

Parameters:: nodes_for_removing (可迭代容器) – 包含节点的容器（列表、字典、集合等）。如果容器中的节点不在图中，则该节点会被静默忽略。

另请参阅

remove_node

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> e = list(G.nodes)
>>> e
[0, 1, 2]
>>> G.remove_nodes_from(e)
>>> list(G.nodes)
[]

property schema¶

图的模式。

Returns:: 图的模式
Return type:: GraphSchema

property session¶

获取图的会话。

Returns:: 返回该图所属的会话。

property session_id¶

获取图的会话ID。

Returns:: 返回该图所属的会话ID。
Return type:: 字符串

set_edge_data(u, v, data)[源代码]¶

设置边 (u, v) 的边数据。

Parameters:

u (节点) – 节点可以是int、str、float、tuple、bool等可哈希的Python对象。
v (节点) – 节点可以是可哈希的Python对象，包括int、str、float、tuple、bool类型。
data (dict) – 要设置到边(u, v)上的边数据

另请参阅

set_node_data: 设置节点的节点数据

备注

该方法在AdjEdgeAttr中设置items时被调用

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edge(1, 2)
>>> dd = {'foo': 'bar'}
>>> G[1][2] = dd  # call G.set_edge_data(1, 2, dd)
>>> G[1][2]
{'foo': 'bar'}

set_node_data(n, data)[源代码]¶

设置节点的数据。

Parameters:

n (节点) - 节点可以是图中已存在的可哈希Python对象，包括int、str、float、tuple、bool等类型。
data (dict) – 要设置到n的数据

另请参阅

set_edge_data: 设置边的数据

备注

该方法在NodeAttr中设置items时被调用

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_node(1)
>>> dd = {'weight': 3}
>>> G.nodes[1] = dd  # call G.set_node_data(1, dd)
>>> G.nodes[1]
{'weight': 3}

property signature¶: 生成当前图的签名

size(weight=None)[源代码]¶

返回边的数量或所有边权重的总和。

Parameters:

weight (string 或 None, 可选 (默认=None)) – 表示权重的边属性数值。如果为None，则每条边的权重默认为1。

Returns:

size – 边的数量或（如果提供了weight关键字）总权重和。

如果weight为None，则返回int类型。否则返回float类型（如果权重类型更复杂，则返回更通用的数值类型）。

Return type:

数值型

另请参阅

number_of_edges

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.size()
3

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edge("a", "b", weight=2)
>>> G.add_edge("b", "c", weight=4)
>>> G.size()
2
>>> G.size(weight="weight")
6.0

subgraph(nodes)[源代码]¶

返回一个由nodes节点集导出的独立深拷贝子图。

图的诱导子图包含nodes中的节点以及这些节点之间的边。

Parameters:: 节点 (列表, 可迭代对象) - 一个节点容器，将被迭代一次。
Returns:: G – 图的一个子图。
Return type:: Graph

备注

与NetworkX返回视图不同，这里返回一个独立的深拷贝子图。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> H = G.subgraph([0, 1, 2])
>>> list(H.edges)
[(0, 1), (1, 2)]

to_directed(as_view=False)[源代码]¶

返回图的有向表示。

Parameters:: as_view (bool, 可选参数 (默认=False)) – 如果为True，则返回原始有向图的视图。
Returns:: G – 一个具有相同名称、相同节点的有向图，其中每条边(u, v, data)都被替换为两条有向边(u, v, data)和(v, u, data)。
Return type:: DiGraph

备注

默认情况下，这会返回边、节点和图属性的"深拷贝"，尝试完整复制所有数据和引用。

示例

>>> G = nx.Graph()
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]

如果已经定向，返回一个（深度）副本

>>> G = nx.DiGraph()
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1)]

to_undirected(as_view=False)[源代码]¶

返回该图的无向副本。

Parameters:: as_view (bool (可选参数, 默认=False)) – 如果为True则返回原始无向图的视图。
Returns:: G – 图的深度拷贝副本。
Return type:: Graph

另请参阅

Graph, copy, add_edge, add_edges_from

备注

这将返回边、节点和图属性的"深拷贝"，尝试完整复制所有数据和引用。

示例

>>> G = nx.path_graph(2)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]
>>> G2 = H.to_undirected()
>>> list(G2.edges)
[(0, 1)]

to_undirected_class()[源代码]¶

返回用于空无向副本的类。

如果继承基类，请使用此方法来指定to_directed()副本要使用的有向类。

update(edges=None, nodes=None)[源代码]¶

使用节点/边/图作为输入来更新图。

类似于字典的update方法，此方法接收一个图作为输入，将该图的节点和边添加到当前图中。它也可以接收两个输入：边和节点。最后，它还可以单独接收边或节点。若仅指定节点，必须使用关键字nodes。

边和节点的集合处理方式类似于add_edges_from/add_nodes_from方法。当迭代时，它们应该生成2元组(u, v)或3元组(u, v, datadict)。

Parameters:

edges (Graph object, 边的集合, 或 None) – 第一个参数可以是图或一些边。如果它具有 nodes 和 edges 属性，则将其视为类图对象，并使用这些属性作为要添加到图中的节点和边的集合。如果第一个参数没有这些属性，则将其视为边的集合并添加到图中。如果第一个参数是 None，则不会添加任何边。
nodes (节点集合或None) - 第二个参数被视为要添加到图中的节点集合，除非它为None。如果edges是None且nodes是None则会抛出异常。如果第一个参数是Graph，则nodes会被忽略。

示例

>>> G = nx.path_graph(5)
>>> G.update(nx.complete_graph(range(4, 10)))
>>> from itertools import combinations
>>> edges = (
...     (u, v, {"power": u * v})
...     for u, v in combinations(range(10, 20), 2)
...     if u * v < 225
... )
>>> nodes = [1000]  # for singleton, use a container
>>> G.update(edges, nodes)

另请参阅

add_edges_from: 向图中添加多条边
add_nodes_from: 向图中添加多个节点

有向图¶

带自环的有向图

class graphscope.nx.DiGraph(incoming_graph_data=None, default_label=None, **attr)[源代码]¶

有向图的基类。

一个包含图元数据的DiGraph，并提供类似NetworkX的DiGraph API接口。

值得注意的是，图数据实际上是由分析引擎后端存储的。换句话说，Graph对象仅保存图的元数据。

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

有向图支持定向边。允许自循环但不允许多重（平行）边。

节点可以是任意的整数/字符串/浮点数/布尔值对象，并可带有可选的键/值属性。

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

如果DiGraph是从GraphScope图对象创建的，则支持节点标签。节点由(label, id)元组标识。

Parameters:

incoming_graph_data (输入图数据 (可选, 默认: None)) – 用于初始化图的数据。如果为None（默认值）则创建一个空图。数据可以是to_networkx_graph()函数支持的任何格式，目前包括边列表、字典的字典、列表的字典、NetworkX图、NumPy矩阵或二维ndarray、Pandas DataFrame、SciPy稀疏矩阵，或GraphScope图对象。
default_label (默认节点标签 (可选, 默认值: None)) – 如果incoming_graph_data是GraphScope图对象，default_label表示该标签的节点可以直接通过id识别，其他标签节点需要使用(label, id)来标识。
attr (关键字参数，可选（默认=无属性）) - 以键值对形式添加到图中的属性。

另请参阅

Graph

示例

创建一个空的图结构（"空图"），不包含任何节点和边。

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

除了整数，字符串也可以表示一个节点。

>>> G.add_node('a node')

边：

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

转换

使用GraphScope图对象创建图。首先我们初始化一个GraphScope图，包含两个节点标签：person和comment`

>>> g = graphscope.g(directed=True).add_vertice("person.csv", label="person").add_vertice("comment.csv", label="comment")

使用g创建一个图，将default_label设置为'person'

>>> G = nx.DiGraph(g, default_label="person")

person标签节点可以直接通过id识别，而对于comment标签，我们需要使用元组("comment", id)来标识。例如，添加一个person标签节点和一个comment标签节点

>>> G.add_node(0, type="person")
>>> G.add_node(("comment", 0), type="comment")

打印两个节点的属性

>>> G.nodes[0]
{"type", "person"}
>>> G.nodes[("comment", 0)]
{"type", "comment"}

报告：

通过对象属性和方法可以获取简单的图信息。报告功能通常提供视图而非容器，以减少内存使用。这些视图会随着图的更新而动态更新，类似于字典视图。对象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操作。

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

__contains__(n)¶

如果n是一个节点则返回True，否则返回False。用法：'n in G'。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> 1 in G
True

__getitem__(n)¶

返回节点n的邻居字典。用法：'G[n]'。

Parameters:: n (节点) – 图中的节点。
Returns:: adj_dict – 与节点n相连的邻接字典。
Return type:: 字典

备注

G[n] 等同于 G.adj[n]，类似于 G.neighbors(n) （这是一个遍历 G.adj[n] 的迭代器）

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G[0]
AtlasView({1: {}})

__init__(incoming_graph_data=None, default_label=None, **attr)[源代码]¶

使用图、边、名称或图属性初始化一个图

Parameters:

incoming_graph_data (输入图数据 (可选, 默认: None)) - 用于初始化图的数据。如果为None(默认值)则创建一个空图。数据可以是边列表、任何NetworkX图对象或任何GraphScope图对象。如果安装了相应的可选Python包，数据也可以是2D NumPy数组或SciPy稀疏矩阵
default_label (默认节点标签 (可选, 默认: "_")) – 如果incoming_graph_data是GraphScope图对象，default_label表示可以直接通过id访问该标签的节点，其他标签节点需要使用(label, id)来访问。
attr (关键字参数，可选（默认=无属性）) - 以键值对形式添加到图中的属性。

另请参阅

convert

示例

>>> G = nx.Graph()  # or DiGraph
>>> G = nx.Graph(name='my graph')
>>> e = [(1, 2), (2, 3), (3, 4)]  # list of edges
>>> G = nx.Graph(e)

可以分配任意的图属性键值对（key=value）

>>> G = nx.Graph(e, day="Friday")
>>> G.graph
{'day': 'Friday'}

由GraphScope图对象创建

>>> g = graphscope.g(directed=False)  # if transform to DiGraph, directed=True
>>> g.add_vertices("person.csv", label="person").add_vertices("comment.csv", label="comment").add_edges(...)
>>> G = nx.Graph(g, default_label="person") # or DiGraph

__iter__()¶

遍历节点。用法：'for n in G'。

Returns:: niter – 图中所有节点的迭代器。
Return type:: 迭代器

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> [n for n in G]
[0, 1, 2, 3]
>>> list(G)
[0, 1, 2, 3]

__len__()¶

返回图中的节点数量。用法：'len(G)'。

Returns:: nnodes – 图中的节点数量。
Return type:: int

另请参阅

number_of_nodes, order

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> len(G)
4

add_edge(u_of_edge, v_of_edge, **attr)¶

在u和v之间添加一条边。

如果节点u和v尚未存在于图中，它们将被自动添加。

边的属性可以通过关键字或直接访问边的属性字典来指定。参见以下示例。

Parameters:

u (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如整型/字符串/浮点型/元组/布尔型。
v (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如整型/字符串/浮点型/元组/布尔型。
attr (关键字参数, 可选) – 可以使用关键字参数来分配边数据。

另请参阅

add_edges_from: 添加一组边

备注

添加已存在的边会更新边数据。

许多专为加权图设计的networkx算法会使用边属性(默认为weight)来存储数值。

示例

以下操作均将边 e=(1, 2) 添加到图 G 中：

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> e = (1, 2)
>>> G.add_edge(1, 2)  # explicit two-node form
>>> G.add_edge(*e)  # single edge as tuple of two nodes
>>> G.add_edges_from([(1, 2)])  # add edges from iterable container

使用关键词将数据关联到边:

>>> G.add_edge(1, 2, weight=3)
>>> G.add_edge(1, 3, weight=7, capacity=15, length=342.7)

对于非字符串属性键，请使用下标表示法。

>>> G.add_edge(1, 2)
>>> G[1][2].update({0: 5})
>>> G.edges[1, 2].update({0: 5})

add_edges_from(ebunch_to_add, **attr)¶

添加 ebunch_to_add 中的所有边。

Parameters:

ebunch_to_add (container of edges) - 容器中提供的每条边都将被添加到图中。边必须以2元组(u, v)或3元组(u, v, d)的形式给出，其中d是包含边数据的字典。
attr (关键字参数, 可选) – 可以使用关键字参数来分配边数据。

另请参阅

add_edge: 添加一条边
add_weighted_edges_from: 添加加权边的便捷方式

备注

重复添加同一条边不会产生效果，但每次添加重复边时，任何边数据都会被更新。

在边集合中指定的边属性优先级高于通过关键字参数指定的属性。

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
>>> e = zip(range(0, 3), range(1, 4))
>>> G.add_edges_from(e)  # Add the path graph 0-1-2-3

将数据关联到边

>>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
>>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")

add_node(node_for_adding, **attr)¶

添加单个节点 node_for_adding 并更新节点属性。

Parameters:

node_for_adding (node) – 节点可以是int、float、str、tuple或bool对象。
attr (关键字参数, 可选) – 使用键值对设置或修改节点属性。

另请参阅

add_nodes_from

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_node(1)
>>> G.add_node(2)
>>> G.number_of_nodes()
2

使用关键词 set/change 设置/修改节点属性：

>>> G.add_node(1, size=10)
>>> G.add_node(3, weight=0.4, type='apple')

备注

nx.Graph 支持节点为 int、float、str、tuple 或 bool 类型的对象。

add_nodes_from(nodes_for_adding, **attr)¶

添加多个节点。

Parameters:

nodes_for_adding (可迭代容器) – 包含节点的容器（列表、字典、集合等）。或者包含(节点, 属性字典)元组的容器。节点属性会使用属性字典进行更新。
attr (关键字参数，可选（默认=无属性）) - 为nodes中的所有节点更新属性。以元组形式在nodes中指定的节点属性优先于通过关键字参数指定的属性。

另请参阅

add_node

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_nodes_from("Hello")
>>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
>>> G.add_nodes_from(K3)
>>> sorted(G.nodes(), key=str)
[0, 1, 2, 'H', 'e', 'l', 'o']

使用关键词更新每个节点的特定属性。

>>> G.add_nodes_from([1, 2], size=10)
>>> G.add_nodes_from([3, 4], weight=0.4)

使用 (node, attrdict) 元组来更新特定节点的属性。

>>> G.add_nodes_from([(1, dict(size=11)), (2, {"color": "blue"})])
>>> G.nodes[1]["size"]
11
>>> H = nx.Graph()
>>> H.add_nodes_from(G.nodes(data=True))
>>> H.nodes[1]["size"]
11

add_weighted_edges_from(ebunch_to_add, weight='weight', **attr)¶

在ebunch_to_add中添加带权边，并指定权重属性

Parameters:

ebunch_to_add (container of edges) - 列表或容器中提供的每条边都将被添加到图中。边必须以三元组(u, v, w)的形式给出，其中w是一个数字。
weight (string, optional (default= 'weight')) – 要添加的边权重属性名称。
attr (关键字参数，可选（默认=无属性）) - 为所有边添加/更新的边属性。

另请参阅

add_edge: 添加一条边
add_edges_from: 添加多条边

备注

对于Graph/DiGraph重复添加同一条边只会更新边的数据。

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)])

property adj¶

存储每个节点邻居的图邻接对象。

遍历G.adj的行为类似于字典。常用惯用法包括 for nbr, datadict in G.adj[n].items():。

邻接信息也可以通过图的下标访问提供。因此for nbr, foovalue in G[node].data('foo', default=1): 这样的写法是有效的。

对于有向图，G.adj保存的是出边（后继节点）信息。

adjacency()¶

返回一个遍历所有节点的(节点, 邻接字典)元组的迭代器。

对于有向图，仅包含出方向的邻居/邻接节点。

Returns:: adj_iter – 图中所有节点的(节点, 邻接字典)迭代器。
Return type:: 迭代器

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> [(n, nbrdict) for n, nbrdict in G.adjacency()]
[(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})]

adjlist_inner_dict_factory¶: NeighborDict的别名

adjlist_outer_dict_factory¶: AdjListDict的别名

clear()¶

从图中移除所有节点和边。

这也会移除名称，以及所有图、节点和边的属性。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.clear()
>>> list(G.nodes)
[]
>>> list(G.edges)
[]

clear_edges()¶

移除图中的所有边而不改变节点。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.clear_edges()
>>> list(G.nodes)
[0, 1, 2, 3]
>>> list(G.edges)
[]

copy(as_view=False)¶

返回图的副本。

默认情况下，copy方法会返回图及其属性的独立深拷贝。

如果 as_view 为 True，则返回视图而非副本。

备注

所有副本都会复制图结构，但数据属性可能以不同方式处理。人们可能需要的图副本有三种类型。

>>> H = G.__class__()
>>> H.add_nodes_from(G)
>>> H.add_edges_from(G.edges)

视图 - 受字典视图启发，图视图充当原始图的只读版本，提供原始结构的副本而无需为复制信息分配任何内存。

Parameters:: as_view (bool, 可选参数 (默认=False)) - 如果设为True，返回的图视图将提供一个只读视图，无需实际复制原始图的任何数据。
Returns:: G – 图的副本。
Return type:: Graph

另请参阅

to_directed: 返回图的有向副本。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> H = G.copy()

property degree¶

图的度数视图，可通过G.degree或G.degree()访问。

节点度是指与该节点相邻的边数。加权节点度是指与该节点相连的所有边的权重之和。

该对象提供(node, degree)的迭代器功能，同时支持查询单个节点的度数。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
weight (string or None, optional (default=None)) – 表示边权重的数值属性名称。如果为None，则每条边的权重默认为1。节点的度数是其相邻边权重的总和。

Returns:

如果请求的是单个节点
deg (int) – 节点的度数
或者如果请求的是多个节点
nd_iter (iterator) – 该迭代器返回(node, degree)形式的二元组。

另请参阅

in_degree, out_degree

示例

>>> G = nx.DiGraph()
>>> nx.add_path(G, [0, 1, 2, 3])
>>> G.degree(0) # node 0 with degree 1
1
>>> list(G.degree([0, 1, 2]))
[(0, 1), (1, 2), (2, 2)]

edge_attr_dict_factory¶: NeighborAttrDict的别名

edge_subgraph(edges)¶

返回由指定边导出的独立深拷贝子图。

诱导子图包含edges中的每条边以及与这些边相关联的每个节点。

Parameters:: edges (可迭代对象) – 该图中边的可迭代集合。
Returns:: G – 该图的一个边诱导子图，具有相同的边属性。
Return type:: Graph

备注

与NetworkX返回视图不同，这里返回一个独立的深拷贝子图。

示例

>>> G = nx.path_graph(5) # or DiGraph
>>> H = G.edge_subgraph([(0, 1), (3, 4)])
>>> list(H.nodes)
[0, 1, 3, 4]
>>> list(H.edges)
[(0, 1), (3, 4)]

property edges¶

有向图DiGraph的边视图，可通过G.edges或G.edges()访问。

edges(self, nbunch=None, data=False, default=None)

OutEdgeView提供了对边元组的类似集合操作以及边属性查找功能。当被调用时，它还会提供一个EdgeDataView对象，该对象允许控制对边属性的访问（但不提供类似集合的操作）。因此，G.edges[u, v]['color']提供了边(u, v)的颜色属性值，而for (u, v, c) in G.edges.data('color', default='red'):则会遍历所有边并返回颜色属性值，如果不存在颜色属性则默认返回'red'。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
data (string or bool, optional (default=False)) – 在返回的3元组(u, v, ddict[data])中作为边属性返回。如果为True，则返回包含边属性字典的3元组(u, v, ddict)。如果为False，则返回2元组(u, v)。
default (value, optional (default=None)) - 用于没有请求属性的边的默认值。仅当数据不是True或False时相关。

Returns:

edges – 边属性的视图，通常它会遍历边的 (u, v) 或 (u, v, d) 元组，但也可用于属性查询，如 edges[u, v]['foo']。

Return type:

出边视图

另请参阅

in_edges, out_edges

备注

不在图中的nbunch节点将被（静默）忽略。对于有向图，这将返回出边。

示例

>>> G = nx.DiGraph()
>>> nx.add_path(G, [0, 1, 2])
>>> G.add_edge(2, 3, weight=5)
>>> [e for e in G.edges]
[(0, 1), (1, 2), (2, 3)]
>>> G.edges.data()  # default data is {} (empty dict)
OutEdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
>>> G.edges.data("weight", default=1)
OutEdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
>>> G.edges([0, 2])  # only edges incident to these nodes
OutEdgeDataView([(0, 1), (2, 3)])
>>> G.edges(0)  # only edges incident to a single node (use G.adj[0]?)
OutEdgeDataView([(0, 1)])

get_edge_data(u, v, default=None)¶

返回与边(u, v)关联的属性字典。

这与G[u][v]相同，唯一的区别是如果边不存在，将返回默认值而不是抛出异常。

Parameters:

u (节点) –
v (节点) –
default (任意Python对象 (默认=None)) – 如果找不到边(u, v)时返回的值。

Returns:

edge_dict – 边属性字典。

Return type:

字典

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G[0][1]
{}

警告：不允许直接对 G[u][v] 进行赋值操作。但可以安全地为属性 G[u][v]['foo'] 赋值

>>> G[0][1]["weight"] = 7
>>> G[0][1]["weight"]
7
>>> G[1][0]["weight"]
7

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.get_edge_data(0, 1)  # default edge data is {}
{}
>>> e = (0, 1)
>>> G.get_edge_data(*e)  # tuple form
{}
>>> G.get_edge_data("a", "b", default=0)  # edge not in graph, return 0
0

graph_attr_dict_factory¶: dict的别名

graph_cache_factory¶: Cache的别名

property graph_type¶

图对象的类型。

Returns:: 图的类型。
Return type:: 类型 (types_pb2.GraphType)

has_edge(u, v)¶

如果边 (u, v) 存在于图中，则返回 True。

这与v in G[u]相同，但不会引发KeyError异常。

Parameters:

u (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如int、str、float、tuple、bool类型。
v (节点) – 节点可以是字符串或数字等类型。节点必须是可哈希的Python对象，如整型、字符串、浮点数、元组或布尔值。

Returns:

edge_ind – 如果边存在于图中则为True，否则为False。

Return type:

布尔值

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.has_edge(0, 1)  # using two nodes
True
>>> e = (0, 1)
>>> G.has_edge(*e)  #  e is a 2-tuple (u, v)
True
>>> e = (0, 1, {"weight": 7})
>>> G.has_edge(*e[:2])  # e is a 3-tuple (u, v, data_dictionary)
True

以下语法是等价的：

>>> G.has_edge(0, 1)
True
>>> 1 in G[0]  # though this gives KeyError if 0 not in G
True

has_node(n)¶

如果图中包含节点n，则返回True。

与 n in G 相同

Parameters:: n (节点) –

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.has_node(0)
True

它更易读且使用更简单

>>> 0 in G
True

has_predecessor(u, v)[源代码]¶

如果节点 u 有前驱节点 v 则返回 True。

如果图中存在边 u<-v，则返回 true。

has_successor(u, v)[源代码]¶

如果节点u有前驱节点v，则返回True。

如果图中存在边 u<-v，则返回 true。

property in_degree¶

一个用于查看(节点, 入度)的InDegreeView，或用于查看单个节点入度的视图。

节点的入度是指指向该节点的边的数量。加权节点度数是与该节点相连的所有边的权重之和。

该对象提供对（节点，入度）的迭代遍历，以及查找单个节点的度。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
weight (string or None, optional (default=None)) – 表示边权重的数值属性名称。如果为None，则每条边的权重默认为1。节点的度数是其相邻边权重的总和。

Returns:

如果请求的是单个节点
deg (int) – 节点的入度
或者如果请求的是多个节点
nd_iter (iterator) – 该迭代器返回(node, in-degree)形式的二元组。

另请参阅

degree, out_degree

示例

>>> G = nx.DiGraph()
>>> nx.add_path(G, [0, 1, 2, 3])
>>> G.in_degree(0)  # node 0 with degree 0
0
>>> list(G.in_degree([0, 1, 2]))
[(0, 0), (1, 1), (2, 1)]

property in_edges¶

图的入边视图，表示为 G.in_edges 或 G.in_edges()。

in_edges(self, nbunch=None, data=False, default=None):

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
data (string or bool, optional (default=False)) - 在返回的3元组(u, v, ddict[data])中作为边属性返回。如果为True，则返回包含边属性字典的3元组(u, v, ddict)。如果为False，则返回2元组(u, v)。
default (value, optional (default=None)) - 用于没有请求属性的边的默认值。仅当数据不是True或False时相关。

Returns:

in_edges – 边属性的视图，通常用于遍历边的 (u, v) 或 (u, v, d) 元组，但也可用于属性查询，如 edges[u, v]['foo']。

Return type:

入边视图

另请参阅

edges

is_directed()[源代码]¶: 如果图是有向的则返回True，否则返回False。

is_multigraph()[源代码]¶: 如果图是多图则返回True，否则返回False。

property key¶: 对应引擎图的关键键值。

property name¶

图的字符串标识符。

该图属性出现在属性字典G.graph中，键名为字符串"name"，同时也作为属性（技术上称为属性）G.name存在。这完全由用户控制。

nbunch_iter(nbunch=None)¶

返回一个迭代器，包含同时存在于nbunch和图(graph)中的节点。

检查nbunch中的节点是否属于该图，不属于的节点将被静默忽略。

Parameters:: nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
Returns:: niter – 一个迭代器，用于遍历同时存在于nbunch和图结构中的节点。如果nbunch为None，则遍历图中的所有节点。
Return type:: 迭代器
Raises:: NetworkXError – 如果nbunch不是节点或节点序列。如果nbunch中的某个节点不可哈希。

另请参阅

Graph.__iter__

备注

当nbunch是一个迭代器时，返回的迭代器会直接从nbunch中生成值，当nbunch耗尽时也会随之耗尽。

要测试 nbunch 是否为单个节点，可以使用 "if nbunch in self:"，即使经过此例程处理后也是如此。

如果nbunch不是节点或(可能为空的)序列/迭代器或None，则会引发NetworkXError。此外，如果nbunch中的任何对象不可哈希，也会引发NetworkXError。

neighbors(n)¶

返回节点n的后继节点迭代器。

节点n的后继节点是指存在一条从n指向m的有向边的节点m。

Parameters:: n (节点) – 图中的节点
Raises:: NetworkXError – 如果n不在图中。

另请参阅

predecessors

备注

neighbors() 和 successors() 是相同的。

node_attr_dict_factory¶: NodeAttrDict的别名

node_dict_factory¶: NodeDict的别名

property nodes¶

图的节点视图，如 G.nodes 或 G.nodes()。

Parameters:

data (string or bool, optional (default=False)) – 作为2元组(n, ddict[data])返回的节点属性。如果为True，则返回完整的节点属性字典(n, ddict)。如果为False，则仅返回节点n。
default (value, optional (default=None)) - 用于没有请求属性的节点的默认值。仅当data参数不为True或False时相关。

Returns:

Return type:

节点视图

备注

如果不需要节点数据，使用表达式 for n in G 或 list(G) 会更简单且等效。

示例

有两种简单的方法可以获取图中所有节点的列表：

>>> G = nx.path_graph(3)
>>> list(G.nodes)
[0, 1, 2]
>>> list(G)
[0, 1, 2]

获取节点数据以及节点：

>>> G.add_node(1, time="5pm")
>>> G.nodes[0]["foo"] = "bar"
>>> list(G.nodes(data=True))
[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
>>> list(G.nodes.data())
[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]

>>> list(G.nodes(data="foo"))
[(0, 'bar'), (1, None), (2, None)]
>>> list(G.nodes.data("foo"))
[(0, 'bar'), (1, None), (2, None)]

>>> list(G.nodes(data="time"))
[(0, None), (1, '5pm'), (2, None)]
>>> list(G.nodes.data("time"))
[(0, None), (1, '5pm'), (2, None)]

>>> list(G.nodes(data="time", default="Not Available"))
[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
>>> list(G.nodes.data("time", default="Not Available"))
[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]

如果某些节点具有属性，而其余节点假定具有默认属性值，您可以使用default关键字参数从节点/属性对创建字典，以确保该值永远不会为None：

>>> G = nx.Graph()
>>> G.add_node(0)
>>> G.add_node(1, weight=2)
>>> G.add_node(2, weight=3)
>>> dict(G.nodes(data="weight", default=1))
{0: 1, 1: 2, 2: 3}

number_of_edges(u=None, v=None)¶

返回两个节点之间的边数。

Parameters:

u (节点，可选（默认=所有边）) - 如果指定了u和v，则返回u和v之间的边数。否则返回所有边的总数。
v (nodes, optional (default=all edges)) - 如果指定了u和v，则返回u和v之间的边数。否则返回所有边的总数。

Returns:

nedges – 图中的边数。如果指定了节点u和v，则返回这两个节点之间的边数。如果图是有向的，则仅返回从u到v的边数。

Return type:

int

另请参阅

size

示例

对于无向图，此方法统计图中的总边数：

>>> G = nx.path_graph(4)
>>> G.number_of_edges()
3

如果指定两个节点，这将计算连接这两个节点的总边数：

>>> G.number_of_edges(0, 1)
1

对于有向图，此方法可以统计从u到v的有向边总数：

>>> G = nx.DiGraph()
>>> G.add_edge(0, 1)
>>> G.add_edge(1, 0)
>>> G.number_of_edges(0, 1)
1

number_of_nodes()¶

返回图中节点的数量。

Returns:: nnodes – 图中的节点数量。
Return type:: int

另请参阅

order, __len__

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.number_of_nodes()
3

property op¶: 该图的DAG操作。

order()¶

返回图中节点的数量。

Returns:: nnodes – 图中的节点数量。
Return type:: int

另请参阅

number_of_nodes, __len__

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> G.order()
3

property out_degree¶

针对 (节点, 出度) 的 OutDegreeView

节点的出度(out_degree)是指从该节点指出的边的数量。加权节点度(weighted node degree)是指与该节点相连的所有边的权重之和。

该对象提供遍历 (节点, 出度) 的迭代器功能，同时支持查询单个节点的度数。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
weight (string or None, optional (default=None)) – 表示边权重的数值属性名称。如果为None，则每条边的权重默认为1。节点的度数是其相邻边权重的总和。

Returns:

如果请求的是单个节点
deg (int) – 节点的出度
或者如果请求的是多个节点
nd_iter (iterator) – 该迭代器返回(node, out-degree)形式的二元组。

另请参阅

degree, in_degree

示例

>>> G = nx.DiGraph()
>>> nx.add_path(G, [0, 1, 2, 3])
>>> G.out_degree(0)  # node 0 with degree 1
1
>>> list(G.out_degree([0, 1, 2]))
[(0, 1), (1, 1), (2, 1)]

property out_edges¶

有向图DiGraph的边视图，可通过G.edges或G.edges()访问。

edges(self, nbunch=None, data=False, default=None)

OutEdgeView提供了对边元组的类似集合操作以及边属性查找功能。当被调用时，它还会返回一个EdgeDataView对象，该对象允许控制对边属性的访问（但不提供类似集合的操作）。因此，G.edges[u, v]['color']可以获取边(u, v)的颜色属性值，而for (u, v, c) in G.edges.data('color', default='red'):则会遍历所有边并返回颜色属性值，如果不存在颜色属性则默认返回'red'。

Parameters:

nbunch (单个节点、容器或所有节点（默认=所有节点）) - 该视图仅报告与这些节点相关联的边。
data (string or bool, optional (default=False)) - 在返回的3元组(u, v, ddict[data])中作为边属性返回。如果为True，则返回包含边属性字典的3元组(u, v, ddict)。如果为False，则返回2元组(u, v)。
default (value, optional (default=None)) - 用于没有请求属性的边的默认值。仅当数据不是True或False时相关。

Returns:

edges – 边属性的视图，通常它会遍历边的 (u, v) 或 (u, v, d) 元组，但也可用于属性查询，如 edges[u, v]['foo']。

Return type:

出边视图

另请参阅

in_edges, out_edges

备注

不在图中的nbunch节点将被（静默）忽略。对于有向图，这将返回出边。

示例

>>> G = nx.DiGraph()
>>> nx.add_path(G, [0, 1, 2])
>>> G.add_edge(2, 3, weight=5)
>>> [e for e in G.edges]
[(0, 1), (1, 2), (2, 3)]
>>> G.edges.data()  # default data is {} (empty dict)
OutEdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
>>> G.edges.data("weight", default=1)
OutEdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
>>> G.edges([0, 2])  # only edges incident to these nodes
OutEdgeDataView([(0, 1), (2, 3)])
>>> G.edges(0)  # only edges incident to a single node (use G.adj[0]?)
OutEdgeDataView([(0, 1)])

property pred¶

存储每个节点前驱节点的图邻接对象。

该对象是一个只读的类字典结构，以节点为键，邻接字典为值。邻接字典以相邻节点为键，边数据字典为值。因此G.pred[2][3]['color'] = 'blue'会将边(3, 2)的颜色设置为"blue"。

遍历G.pred的行为类似于字典。常用用法包括 for nbr, datadict in G.pred[n].items():。字典不提供的数据视图也存在： for nbr, foovalue in G.pred[node].data('foo'): 可以通过data方法的default参数设置默认值。

predecessors(n)[源代码]¶

返回节点n的前驱节点迭代器。

节点n的前驱节点是指存在一条从m指向n的有向边的节点m。

Parameters:: n (节点) – 图中的节点
Raises:: NetworkXError – 如果n不在图中。

另请参阅

successors

remove_edge(u, v)¶

移除u和v之间的边。

Parameters:

u (节点) – 移除节点u和v之间的边。
v (节点) – 移除节点u和v之间的边。

Raises:

NetworkXError – 如果节点u和v之间不存在边。

另请参阅

remove_edges_from: 移除一组边

示例

>>> G = nx.path_graph(4)  # or DiGraph, etc
>>> G.remove_edge(0, 1)
>>> e = (1, 2)
>>> G.remove_edge(*e)  # unpacks e from an edge tuple
>>> e = (2, 3, {"weight": 7})  # an edge with attribute data
>>> G.remove_edge(*e[:2])  # select first part of edge tuple

remove_edges_from(ebunch)¶

移除 ebunch 中指定的所有边。

Parameters:

ebunch (列表或容器，包含 边元组) –

列表或容器中给出的每条边都将从图中移除。边的格式可以是：

2元组 (u, v) 表示u和v之间的边

3元组 (u, v, k) 其中k会被忽略

另请参阅

remove_edge: 移除单条边

备注

如果ebunch中的某条边不在图中，将静默失败。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> ebunch = [(1, 2), (2, 3)]
>>> G.remove_edges_from(ebunch)

remove_node(n)¶

移除节点n。

移除节点n及其所有相邻边。尝试移除不存在的节点将引发异常。

Parameters:: n (节点) – 图中的节点
Raises:: NetworkXError – 如果n不在图中。

另请参阅

remove_nodes_from

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> list(G.edges)
[(0, 1), (1, 2)]
>>> G.remove_node(1)
>>> list(G.edges)
[]

remove_nodes_from(nodes_for_removing)¶

移除多个节点。

Parameters:: nodes_for_removing (可迭代容器) – 包含节点的容器（列表、字典、集合等）。如果容器中的节点不在图中，则该节点会被静默忽略。

另请参阅

remove_node

示例

>>> G = nx.path_graph(3)  # or DiGraph
>>> e = list(G.nodes)
>>> e
[0, 1, 2]
>>> G.remove_nodes_from(e)
>>> list(G.nodes)
[]

reverse(copy=True)[源代码]¶

返回图的逆图。

反向图是一个具有相同节点和边的图，但边的方向被反转。

Parameters:: copy (bool 可选参数 (默认值=True)) – 如果为True，则返回一个包含反转边的新有向图。如果为False，则使用原图的视图来创建反转图。

property schema¶

图的模式。

Returns:: 图的模式
Return type:: GraphSchema

property session¶

获取图的会话。

Returns:: 返回该图所属的会话。

property session_id¶

获取图的会话ID。

Returns:: 返回该图所属的会话ID。
Return type:: 字符串

set_edge_data(u, v, data)¶

设置边 (u, v) 的边数据。

Parameters:

u (节点) – 节点可以是int、str、float、tuple、bool等可哈希的Python对象。
v (节点) – 节点可以是可哈希的Python对象，包括int、str、float、tuple、bool类型。
data (dict) – 要设置给边(u, v)的边数据

另请参阅

set_node_data: 设置节点的节点数据

备注

该方法在AdjEdgeAttr中设置items时被调用

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edge(1, 2)
>>> dd = {'foo': 'bar'}
>>> G[1][2] = dd  # call G.set_edge_data(1, 2, dd)
>>> G[1][2]
{'foo': 'bar'}

set_node_data(n, data)¶

设置节点的数据。

Parameters:

n (节点) - 节点可以是整型、字符串、浮点型、元组、布尔型等可哈希的Python对象，且必须存在于图中。
data (dict) – 要设置到n的数据

另请参阅

set_edge_data: 设置边的数据

备注

该方法在NodeAttr中设置items时被调用

示例

>>> G = nx.Graph()  # or DiGraph
>>> G.add_node(1)
>>> dd = {'weight': 3}
>>> G.nodes[1] = dd  # call G.set_node_data(1, dd)
>>> G.nodes[1]
{'weight': 3}

property signature¶: 生成当前图的签名

size(weight=None)¶

返回边的数量或所有边权重的总和。

Parameters:

weight (string 或 None, 可选 (默认=None)) – 表示权重的边属性数值。如果为None，则每条边的权重默认为1。

Returns:

size – 边的数量或（如果提供了weight关键字）总权重和。

如果weight为None，则返回int类型。否则返回float类型（如果权重类型更复杂，则返回更通用的数值类型）。

Return type:

数值型

另请参阅

number_of_edges

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> G.size()
3

>>> G = nx.Graph()  # or DiGraph
>>> G.add_edge("a", "b", weight=2)
>>> G.add_edge("b", "c", weight=4)
>>> G.size()
2
>>> G.size(weight="weight")
6.0

subgraph(nodes)¶

返回一个由nodes节点集导出的独立深拷贝子图。

图的诱导子图包含nodes中的节点以及这些节点之间的边。

Parameters:: 节点 (列表, 可迭代对象) - 一个节点容器，将被迭代一次。
Returns:: G – 图的一个子图。
Return type:: Graph

备注

与NetworkX返回视图不同，这里返回一个独立的深拷贝子图。

示例

>>> G = nx.path_graph(4)  # or DiGraph
>>> H = G.subgraph([0, 1, 2])
>>> list(H.edges)
[(0, 1), (1, 2)]

property succ¶

存储每个节点邻居的图邻接对象。

遍历G.adj的行为类似于字典。常用惯用法包括 for nbr, datadict in G.adj[n].items():。

邻接信息也可以通过图的下标访问提供。因此for nbr, foovalue in G[node].data('foo', default=1): 这样的写法是有效的。

对于有向图，G.adj保存的是出边（后继节点）信息。

successors(n)[源代码]¶

返回节点n的后继节点迭代器。

节点n的后继节点是指存在一条从n指向m的有向边的节点m。

Parameters:: n (节点) – 图中的节点
Raises:: NetworkXError – 如果n不在图中。

另请参阅

predecessors

备注

neighbors() 和 successors() 是相同的。

to_directed(as_view=False)¶

返回图的有向表示。

Parameters:: as_view (bool, 可选参数 (默认=False)) – 如果为True，则返回原始有向图的视图。
Returns:: G – 一个具有相同名称、相同节点的有向图，其中每条边(u, v, data)都被替换为两条有向边(u, v, data)和(v, u, data)。
Return type:: DiGraph

备注

默认情况下，这会返回边、节点和图属性的"深拷贝"，尝试完整复制所有数据和引用。

示例

>>> G = nx.Graph()
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]

如果已经定向，返回一个（深度）副本

>>> G = nx.DiGraph()
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1)]

to_undirected(as_view=False)¶

返回该图的无向副本。

Parameters:: as_view (bool (可选参数, 默认=False)) – 如果为True则返回原始无向图的视图。
Returns:: G – 图的深度拷贝副本。
Return type:: Graph

另请参阅

Graph, copy, add_edge, add_edges_from

备注

这将返回边、节点和图属性的"深拷贝"，尝试完整复制所有数据和引用。

示例

>>> G = nx.path_graph(2)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]
>>> G2 = H.to_undirected()
>>> list(G2.edges)
[(0, 1)]

to_undirected_class()¶

返回用于空无向副本的类。

如果继承基类，请使用此方法来指定to_directed()副本要使用的有向类。

update(edges=None, nodes=None)¶

使用节点/边/图作为输入来更新图。

边和节点的集合处理方式类似于add_edges_from/add_nodes_from方法。当迭代时，它们应该生成2元组(u, v)或3元组(u, v, datadict)。

Parameters:

edges (Graph object, 边的集合, 或 None) - 第一个参数可以是图或一些边。如果它具有 nodes和edges属性，则将其视为类似图的对象，并使用这些属性作为要添加到图中的节点和边的集合。如果第一个参数没有这些属性，则将其视为边的集合并添加到图中。如果第一个参数是None，则不添加任何边。
nodes (collection of nodes, or None) - 第二个参数被视为要添加到图中的节点集合，除非它为None。如果edges是None且nodes是None，则会引发异常。如果第一个参数是Graph，则nodes将被忽略。

示例

>>> G = nx.path_graph(5)
>>> G.update(nx.complete_graph(range(4, 10)))
>>> from itertools import combinations
>>> edges = (
...     (u, v, {"power": u * v})
...     for u, v in combinations(range(10, 20), 2)
...     if u * v < 225
... )
>>> nodes = [1000]  # for singleton, use a container
>>> G.update(edges, nodes)

另请参阅

add_edges_from: 向图中添加多条边
add_nodes_from: 向图中添加多个节点