关于用networkx画图的问题

Question

我正在使用 NetworkX 绘制图形，当我在 NetworkX 文档中搜索时，我看到了来自 Antigraph class 的一段代码，它令人困惑，我无法理解这段代码的某些行。请帮助我理解这段代码。

我附上了这段代码：

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}

Answer 1

要理解这些行，让我们仔细分解每个术语。为了便于解释，我将创建以下图表：

import networkx as nx

source = [1, 2, 3, 4, 2, 3]
dest = [2, 3, 4, 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), (2, 5), (3, 4), (3, 5), (4, 6)])

现在让我们理解上面代码中的术语：

设置(self.adj)
如果我们打印出来，我们可以看到它是图中的节点集：

print(set(self.adj))
# {1, 2, 3, 4, 5, 6}

设置(self.adj[n])
这是与节点 n:

相邻的节点集

print(set(G.adj[2]))
# {1, 3, 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 return 是 与节点 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}, 2: {'weight': 1}, 3: {'weight': 1}, 5: {'weight': 1}}
Node 5: {1: {'weight': 1}, 4: {'weight': 1}, 6: {'weight': 1}}

所以如果你仔细观察，对于每个节点，我们都会得到一个不与该节点相邻的节点列表。

例如，节点 2，计算结果如下所示：

{1, 2, 3, 4, 5, 6} - {1, 3, 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 中的节点集合

这与您询问的第一个表达式相同，只是这个表达式用于多个节点，即 这也将 return 与 nbunch 中的节点不相邻的节点列表

关于用networkx画图的问题

Question about Drawing a graph with networkx

python

graph

matplotlib

networkx