如何编写一个算法，在保留NetworkX网络的同时剪切节点？

假设我有一个简单的网络，如下所示，我想删除小写节点，同时保留整体结构。我该怎么做？下面是一些示例代码：

import networkx as nx
G = nx.DiGraph();
G.add_edge("A","b")
G.add_edge("b","C")
G.add_edge("b","D")
G.add_edge("D","e")
G.add_edge("e","F")


def printHackyDot(x):
    for n in x.nodes():
        for pre in x.predecessors(n):
            print(pre + " -> " + n)

printHackyDot(G)
badNodes = [n for n in G.nodes if str.islower(n)]

运行此操作将产生：

A -> b
b -> C
b -> D
D -> e
e -> F

i、 e

如何编写f（G）以获得类似的简化图，无需小写节点：

A -> C
A -> D
D -> F

我尝试了以下方法，但如果连续使用两个小写，则失败：

for badNode in [x for x  in list(G.nodes) if str.islower(x)]:
    R.remove_node(badNode)
    for predNode in G.predecessors(badNode):
        for succNode in G.successors(badNode):
            R.add_edge(predNode,succNode)

---

我假设

R

以

G

的副本开始

如果你换个新的就行了

for badNode in [x for x  in list(G.nodes) if str.islower(x)]:
    R.remove_node(badNode)
    for predNode in G.predecessors(badNode):
        for succNode in G.successors(badNode):
            R.add_edge(predNode,succNode)

使用（编辑以删除错误

badNode

过快）

---

问题是，当处理行中两个小写节点中的第一个节点时，它会删除该节点。但是当你处理另一个节点时，它会看到在

G

中，该节点有一个小写的邻居，它会将边缘放回原处。如果你在

R

中查看它的邻域，你会正确地处理它。

如果图形是DAG，这就成功了。聪明的人可以解决这个问题

def isBadNode(x):
    return str.islower(x)

def goodPreds(X,node):
    return [n for n in X.predecessors(node) if not isBadNode(n)]+[gn for n in X.predecessors(node) for gn in goodPreds(X,n) if isBadNode(n)]

def goodSuccs(X,node):
    return [n for n in X.successors(node) if not isBadNode(n)]+[gn for n in X.successors(node) for gn in goodSuccs(X,n) if isBadNode(n)]

R= G.copy()
for badNode in [x for x  in list(R.nodes) if isBadNode(x)]:
    for predNode in goodPreds(G,badNode):
        for succNode in goodSuccs(G,badNode):
            R.add_edge(predNode,succNode)
    R.remove_node(badNode)

---

不，在重新连接之前删除节点G.add_edge（“A”，“b”）G.add_edge（“b”，“C”）G.add_edge（“b”，“D”）G.add_edge（“D”，“e”）G.add_edge（“e”，“f”）G.add_edge（“f”，“G”）

def isBadNode(x):
    return str.islower(x)

def goodPreds(X,node):
    return [n for n in X.predecessors(node) if not isBadNode(n)]+[gn for n in X.predecessors(node) for gn in goodPreds(X,n) if isBadNode(n)]

def goodSuccs(X,node):
    return [n for n in X.successors(node) if not isBadNode(n)]+[gn for n in X.successors(node) for gn in goodSuccs(X,n) if isBadNode(n)]

R= G.copy()
for badNode in [x for x  in list(R.nodes) if isBadNode(x)]:
    for predNode in goodPreds(G,badNode):
        for succNode in goodSuccs(G,badNode):
            R.add_edge(predNode,succNode)
    R.remove_node(badNode)