ADT图怎么获得所有边 total_edges()

from Graph_ import Node, LinkedList, Queue

class Vertex:
    def __init__(self, label):
        self.label = label

class Graph:
    def __init__(self):
        self.adjacency_list = {}
        self.edge_weights = {}

    def add_vertex(self, new_vertex):
        self.adjacency_list[new_vertex] = []

    def add_directed_edge(self, from_vertex, to_vertex, weight = 1.0):
        self.edge_weights[(from_vertex, to_vertex)] = weight
        self.adjacency_list[from_vertex].append(to_vertex)

    def add_undirected_edge(self, vertex_a, vertex_b, weight = 1.0):
        self.add_directed_edge(vertex_a, vertex_b, weight)
        self.add_directed_edge(vertex_b, vertex_a, weight)

    def get_vertex(self, vertex_label):
        for vertex in self.adjacency_list:
            if vertex.label == vertex_label:
                return vertex
        return None

    def total_edges(self,vertices):
    #实现total_edges 获得所有边


if __name__ == '__main__':

class Node:
    def __init__(self, initial_data):
        self.data = initial_data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
    def append(self, new_node):
        if self.head == None:
            self.head = new_node
            self.tail = new_node
        else:
            self.tail.next = new_node
            self.tail = new_node
    def remove_after(self, current_node):
        # Special case, remove head
        if (current_node == None) and (self.head != None):
            succeeding_node = self.head.next
            self.head = succeeding_node
            if succeeding_node == None: # Remove last item
                self.tail = None
        elif current_node.next != None:
            succeeding_node = current_node.next.next
            current_node.next = succeeding_node
            if succeeding_node == None: # Remove tail
                self.tail = current_node

class Queue:
    def __init__(self):
        self.list = LinkedList()

    def enqueue(self, new_item):
        # Create a new node to hold the item
        new_node = Node(new_item)

        # Insert as list tail (end of queue)
        self.list.append(new_node)

    def dequeue(self):
        # Copy data from list's head node (queue's front node)
        dequeued_item = self.list.head.data

        # Remove list head
        self.list.remove_after(None)

        # Return the dequeued item
        return dequeued_item

题目中好像没有说明无向边需要输出几次，如果按照代码中的存储形式的话，直接返回edge_weights里的key就可以了

    def total_edges(self,vertices):
         edges = []
         for v in vertices:
              for d in self.adjacency_list[v]:
                   edges.append((v, d))
         return edges

会返回一个包含(起点，终点)的列表

建立边的时候把边都写在self.edge_weights里面了
感觉可以直接扫描该字典，同时对无向边进行去重，或者干脆在初始化边的时候把无向边建立为带无向label的边，即用label区分有向边与无向边。
也可以暴力遍历节点，直接用节点名拼起来去字典里扫描，复杂度会高一点

• 修改代码，以便接受来自用户的整数（n）作为节点数

• 接下来，程序应该允许用户输入 n 个字符串并从中生成一个无向图

• 然后，显示：'要添加边缘吗？ y / n' 除非用户输入n，接受来自用户的两个字符串

• 接下来，找到两个具有相同 node.label 的节点，并在它们之间生成一条边

  • 在这里你需要检查这样的节点是否存在，如果不显示'错误输入！'
  • 如果边已添加，则不要再次添加，显示：'此边已添加！
    • 提示：记住它是一个无向图，所以 (a,b) 与 (b,a) 相同
  • 询问用户是否要输入更多边，通过显示：“您要添加边吗？是/否'
    -继续让用户输入边直到他们输入“n”

• 最后，编写一个函数，计算创建的无向图中的总边数

你需要在if __name__ == '__main__':下面编写功能代码，包括输入输出，然后
可以按照输入的n个字符串调用add_vertex，我理解题目应该是n个字符串是n个节点
之后搜索相同的字符串，然后add_undirected_edge添加边