问题描述
我正在使用NetworkX绘制图形，当我在NetworkX文档中进行搜索时，发现Antigraph类中的代码令人困惑，并且我无法理解其中的某些代码。请帮助我理解此代码。
我附上了这段代码：
import networkx as nx
from networkx.exception import NetworkXError
import matplotlib.pyplot as plt
class AntiGraph(nx.Graph):
"""
Class for complement graphs.
The main goal is to be able to work with big and dense graphs with
a low memory footprint.
In this class you add the edges that *do not exist* in the dense graph,the report methods of the class return the neighbors,the edges and
the degree as if it was the dense graph. Thus it's possible to use
an instance of this class with some of NetworkX functions.
"""
all_edge_dict = {"weight": 1}
def single_edge_dict(self):
return self.all_edge_dict
edge_attr_dict_factory = single_edge_dict
def __getitem__(self,n):
"""Return a dict of neighbors of node n in the dense graph.
Parameters
----------
n : node
A node in the graph.
Returns
-------
adj_dict : dictionary
The adjacency dictionary for nodes connected to n.
"""
return {
node: self.all_edge_dict for node in set(self.adj) - set(self.adj[n]) - {n}
}
def neighbors(self,n):
"""Return an iterator over all neighbors of node n in the
dense graph.
"""
try:
return iter(set(self.adj) - set(self.adj[n]) - {n})
except KeyError as e:
raise NetworkXError(f"The node {n} is not in the graph.") from e
def degree(self,nbunch=None,weight=None):
"""Return an iterator for (node,degree) in the dense graph.
The node degree is the number of edges adjacent to the node.
Parameters
----------
nbunch : iterable container,optional (default=all nodes)
A container of nodes. The container will be iterated
through once.
weight : string or None,optional (default=None)
The edge attribute that holds the numerical value used
as a weight. If None,then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.
Returns
-------
nd_iter : iterator
The iterator returns two-tuples of (node,degree).
See Also
--------
degree
Examples
--------
>>> G = nx.path_graph(4) # or DiGraph,MultiGraph,MultiDiGraph,etc
>>> list(G.degree(0)) # node 0 with degree 1
[(0,1)]
>>> list(G.degree([0,1]))
[(0,1),(1,2)]
"""
if nbunch is None:
nodes_nbrs = (
(
n,{
v: self.all_edge_dict
for v in set(self.adj) - set(self.adj[n]) - {n}
},)
for n in self.nodes()
)
elif nbunch in self:
nbrs = set(self.nodes()) - set(self.adj[nbunch]) - {nbunch}
return len(nbrs)
else:
nodes_nbrs = (
(
n,{
v: self.all_edge_dict
for v in set(self.nodes()) - set(self.adj[n]) - {n}
},)
for n in self.nbunch_iter(nbunch)
)
if weight is None:
return ((n,len(nbrs)) for n,nbrs in nodes_nbrs)
else:
# AntiGraph is a ThinGraph so all edges have weight 1
return (
(n,sum((nbrs[nbr].get(weight,1)) for nbr in nbrs))
for n,nbrs in nodes_nbrs
)
def adjacency_iter(self):
"""Return an iterator of (node,adjacency set) tuples for all nodes
in the dense graph.
This is the fastest way to look at every edge.
For directed graphs,only outgoing adjacencies are included.
Returns
-------
adj_iter : iterator
An iterator of (node,adjacency set) for all nodes in
the graph.
"""
for n in self.adj:
yield (n,set(self.adj) - set(self.adj[n]) - {n})
# Build several pairs of graphs,a regular graph
# and the AntiGraph of it's complement,which behaves
# as if it were the original graph.
Gnp = nx.gnp_random_graph(20,0.8,seed=42)
Anp = AntiGraph(nx.complement(Gnp))
Gd = nx.davis_southern_women_graph()
Ad = AntiGraph(nx.complement(Gd))
Gk = nx.karate_club_graph()
Ak = AntiGraph(nx.complement(Gk))
pairs = [(Gnp,Anp),(Gd,Ad),(Gk,Ak)]
# test connected components
for G,A in pairs:
gc = [set(c) for c in nx.connected_components(G)]
ac = [set(c) for c in nx.connected_components(A)]
for comp in ac:
assert comp in gc
# test biconnected components
for G,A in pairs:
gc = [set(c) for c in nx.biconnected_components(G)]
ac = [set(c) for c in nx.biconnected_components(A)]
for comp in ac:
assert comp in gc
# test degree
for G,A in pairs:
node = list(G.nodes())[0]
nodes = list(G.nodes())[1:4]
assert G.degree(node) == A.degree(node)
assert sum(d for n,d in G.degree()) == sum(d for n,d in A.degree())
# AntiGraph is a ThinGraph,so all the weights are 1
assert sum(d for n,d in A.degree()) == sum(d for n,d in A.degree(weight="weight"))
assert sum(d for n,d in G.degree(nodes)) == sum(d for n,d in A.degree(nodes))
nx.draw(Gnp)
plt.show()
我不能理解这两行：
（1）for v in set(self.adj) - set(self.adj[n]) - {n}
（2）nbrs = set(self.nodes()) - set(self.adj[nbunch]) - {nbunch}
解决方法
要了解这些内容，请仔细打破每个术语。为了说明的目的，我将创建以下图形：
import networkx as nx
source = [1,2,3,4,3]
dest = [2,6,5,5]
edge_list = [(u,v) for u,v in zip(source,dest)]
G = nx.Graph()
G.add_edges_from(ed_ls)
图形具有以下边缘：
print(G.edges())
# EdgeView([(1,2),(2,3),5),(3,4),(4,6)])
现在让我们了解以上代码中的术语：
设置（self.adj）
如果将其打印出来，我们可以看到它是Graph中的节点集：
print(set(self.adj))
# {1,6}
设置（self.adj [n]）
这是与节点n相邻的节点集：
print(set(G.adj[2]))
# {1,5}
现在让我们看看您在问题中问的第一行
for v in set(self.adj) - set(self.adj[n]) - {n}
这可以翻译如下：
for v in set of all nodes - set of nodes adjacent to node N - node N
因此，此set of all nodes - set of nodes adjacent to node N返回与节点N 不相邻的节点集（其中包括节点N本身）。 （本质上，这将创建图的补图。）
让我们看一个例子：
nodes_nbrs = (
(
n,{
v: {'weight': 1}
for v in set(G.adj) - set(G.adj[n]) - {n}
},)
for n in G.nodes()
)
这将具有以下值：
Node 1: {3: {'weight': 1},4: {'weight': 1},5: {'weight': 1},6: {'weight': 1}}
Node 2: {4: {'weight': 1},6: {'weight': 1}}
Node 3: {1: {'weight': 1},6: {'weight': 1}}
Node 4: {1: {'weight': 1},2: {'weight': 1},5: {'weight': 1}}
Node 6: {1: {'weight': 1},3: {'weight': 1},5: {'weight': 1}}
Node 5: {1: {'weight': 1},6: {'weight': 1}}
因此，如果仔细观察，对于每个节点，我们会得到一个与该节点不相邻的节点的列表。
对于节点2，计算看起来像这样：
{1,6} - {1,5} - {2} = {4,6}
现在让我们进入第二行：
nbrs = set(self.nodes()) - set(self.adj[nbunch]) - {nbunch}
这里set(self.adj[nbunch])基本上是nbunch中与节点相邻的一组节点。 nbunch只是节点的迭代器，因此我们得到的是单个节点的邻居，而不是set（self.adj [n]），这里我们得到的是多个节点的邻居。
因此，表达式可以翻译如下： 所有节点的集合-nbunch中与每个节点相邻的所有节点的集合-nbunch中的节点集合
与您要求的第一个表达式相同，只是该表达式用于多个节点，即这还将返回与nbunch中的节点不相邻的节点列表