Improved the comments in edge.py and graph.py

Author: davecom

Chapter4/edge.py

@@ -19,8 +19,8 @@
 
 @dataclass
 class Edge:
-    u: int
-    v: int
+    u: int # the "from" vertex
+    v: int # the "to" vertex
 
     def reversed(self) -> Edge:
         return Edge(self.v, self.u)

Chapter4/graph.py

@@ -27,51 +27,60 @@ def __init__(self, vertices: List[V] = []) -> None:
 
     @property
     def vertex_count(self) -> int:
-        return len(self._vertices)
+        return len(self._vertices) # Number of vertices
 
     @property
     def edge_count(self) -> int:
-        return sum(map(len, self._edges))
+        return sum(map(len, self._edges)) # Number of edges
 
     # Add a vertex to the graph and return its index
     def add_vertex(self, vertex: V) -> int:
         self._vertices.append(vertex)
         self._edges.append([]) # add empty list for containing edges
         return self.vertex_count - 1 # return index of added vertex
 
-    # this is an undirected graph,
+    # This is an undirected graph,
     # so we always add edges in both directions
     def add_edge(self, edge: Edge) -> None:
         self._edges[edge.u].append(edge)
         self._edges[edge.v].append(edge.reversed())
 
+    # Add an edge using vertex indices (convenience method)
     def add_edge_by_indices(self, u: int, v: int) -> None:
         edge: Edge = Edge(u, v)
         self.add_edge(edge)
 
+    # Add an edge by looking up vertex indices (convenience method)
     def add_edge_by_vertices(self, first: V, second: V) -> None:
         u: int = self._vertices.index(first)
         v: int = self._vertices.index(second)
         self.add_edge_by_indices(u, v)
 
+    # Find the vertex at a specific index
     def vertex_at(self, index: int) -> V:
         return self._vertices[index]
 
+    # Find the index of a vertex in the graph
     def index_of(self, vertex: V) -> int:
         return self._vertices.index(vertex)
 
+    # Find the vertices that a vertex at some index is connected to
     def neighbors_for_index(self, index: int) -> List[V]:
         return list(map(self.vertex_at, [e.v for e in self._edges[index]]))
 
+    # Lookup a vertice's index and find its neighbors (convenience method)
     def neighbors_for_vertex(self, vertex: V) -> List[V]:
         return self.neighbors_for_index(self.index_of(vertex))
 
+    # Return all of the edges associated with a vertex at some index
     def edges_for_index(self, index: int) -> List[Edge]:
         return self._edges[index]
 
+    # Lookup the index of a vertex and return its edges (convenience method)
     def edges_for_vertex(self, vertex: V) -> List[Edge]:
         return self.edges_for_index(self.index_of(vertex))
 
+    # Make it easy to pretty-print a Graph
     def __str__(self) -> str:
         desc: str = ""
         for i in range(self.vertex_count):
@@ -112,7 +121,7 @@ def __str__(self) -> str:
 
     # Reuse BFS from Chapter 2 on city_graph
     import sys
-    sys.path.insert(0, '..') # so we can access the Chapter2 module in the parent directory
+    sys.path.insert(0, '..') # so we can access the Chapter2 package in the parent directory
     from Chapter2.generic_search import bfs, Node, node_to_path
 
     bfs_result: Optional[Node[V]] = bfs("Boston", lambda x: x == "Miami", city_graph.neighbors_for_vertex)