思考题：
from typing import Set


class Graph:
    def __init__(self, value, nodes=None):
        self._value = value
        self._nodes: list = [] if nodes is None else nodes

    @property
    def value(self):
        return self._value

    @property
    def nodes(self):
        return self._nodes

    def node_add(self, node):
        self._nodes.append(node)

    def node_adds(self, nodes):
        self._nodes.extend(nodes)

    def node_del(self, node):
        self._nodes.remove(node)

    def __str__(self):
        return "Graph {} nodes {}".format(self._value, [node.value for node in self.nodes])

    def __repr__(self):
        return self.__str__()


def dfs(start: Graph, includes: Set[Graph] = None) -> Set[Graph]:
    if includes is None:
        includes = set()
    if start in includes:
        return includes
    includes.add(start)
    for s in start.nodes:
        includes.update(dfs(s, includes))
    return includes


if __name__ == '__main__':
    A = Graph('A')
    B = Graph('B')
    C = Graph('C')
    D = Graph('D')
    E = Graph('E')
    F = Graph('F')
    has_nodes = {A, B, C, D, E, F}

    # A->B->E
    # ->C->E
    # B->A
    # D->F
    # F->D
    A.node_adds([B, C])
    B.node_adds([A, E])
    C.node_adds([E])
    D.node_adds([F])
    F.node_adds([D])
    graph_nodes = dfs(A, set())
    # OUT: {Graph B nodes ['A', 'E'], Graph E nodes [], Graph C nodes ['E'], Graph A nodes ['B', 'C']}
    print(graph_nodes)
    # OUT: {Graph F nodes ['D'], Graph D nodes ['F']}
    print(has_nodes - graph_nodes)

开头的代码
运行出错：ModuleNotFoundError: No module named 'psutil'
安装出错：
pip install --upgrade psutil
Collecting psutil
  Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'ReadTimeoutError("HTTPSConnectionPool(host='pypi.org', port=443): Read timed out. (read timeout=15)")': /simple/psutil/
  Could not find a version that satisfies the requirement psutil (from versions: )
No matching distribution found for psutil
请问这是什么原因？

简单写了一个有向图的遍历程序，说明：
(1)有向图采用邻接链表存储
(2)有向图采用递归算法进行深度优先遍历
#邻接链表节点定义
class LinkNode:
    def __init__(self,data):
        self.data = data
        self.next = None
    
#邻接链表定义
class AdjoinList:
    def __init__(self):
        self.adjlist = {} #存贮节点间的邻接关系
        self.vistlist = {} #存贮节点是否被访问，初始所有节点都是False
    
    #建立结点x1和x2的连接关系，其中，x1指向x2
    def addNode(self,x1,x2):

        #建立链接
        point = self.adjlist.setdefault(x1, None)
        lnode = LinkNode(x2)
        lnode.next = point
        self.adjlist[x1] = lnode
        self.adjlist.setdefault(x2, None)

        #初始化访问列表
        self.vistlist.setdefault(x1,False)
        self.vistlist.setdefault(x2,False)

    #遍历图中所有结点
    def visitNode(self,nodevalue):
        if nodevalue is not None:
            self.vistlist[nodevalue] = True
            print('visist:', nodevalue)
            nextnode = self.adjlist[nodevalue]
                
            while nextnode is not None:

                if not self.vistlist[nextnode.data]:
                    self.visitNode(nextnode.data)
                
                nextnode = nextnode.next


    #输出未被访问的结点
    def showUnvistedNode(self):
        print('UnvistedNode:', ','.join([x for x in self.vistlist if not self.vistlist[x]]))

#主程序
def main():
#BEGIN

    adlist = AdjoinList()

    #创建有向图，有向图简单示意如下：
    '''
    a-->b-->c
    |
    |
    d-->e-->f

    g-->h-->j
    
    '''
    adlist.addNode('a','b')
    adlist.addNode('a','d')
    adlist.addNode('b','c')
    adlist.addNode('d','e')
    adlist.addNode('e','f')
    adlist.addNode('g','h')
    adlist.addNode('h','j')

    #从a节点开始遍历有向图
    adlist.visitNode('a')

    #输出未访问的节点
    adlist.showUnvistedNode()

#END

if __name__ == '__main__':
    main()

def func():
    show_memory_info('initial')
    a = [i for i in derange(10000000)]
    show_memory_info('after a created')
    return a

a = func()
show_memory_info('finished')

########## 输出 ##########

initial memory used: 47.96484375 MB
after a created memory used: 434.515625 MB
finished memory used: 434.515625 MB

这是本文第四个代码块，for i in range；多了de，变成了derange；

请问一下，老师：
import sys

a= [1]

print(sys.getrefcount(a))

b = a
print(sys.getrefcount(a))

c,d,e,f,g,h = b,b,c,e,d,a
print(g)
print(sys.getrefcount(a))
-------


import sys...
2
3
[1]
6
为什么最后一次是6次？而g的值是正常的呢？