I would like to ask you a question about analyzing the example code that implements the Dijkstra algorithm in Python. (Help me!!!))

graph = {}
graph["start"] = {}
graph["start"]["a"] = 6
graph["start"]["b"] = 2
graph["a"] = {"fin": 1} # graph["a"]["fin"] = 1
graph["b"] = {"a": 3, "fin": 5} # graph["b"]["a"] = 3   graph["b"]["fin"] = 5
graph["fin"] = {}

# Hash table that stores the price of a node
In infinity = float("inf") # Python, the infinite representation method uses float('inf').
costs = {}
costs["a"] = 6
costs["b"] = 2
costs["fin"] = infinity

# Hashtables for Parents
parents = {}
parents["a"] = "start"
parents["b"] = "start"
parents["fin"] = None

processed = [] # Each node needs to be processed only once, so a list of nodes that have already been processed is needed.

# Function to find the cheapest node
def find_lowest_cost_node(costs):
    lowest_cost = float("inf")
    lowest_cost_node = None

    For node in costs: # In the cost table, rotate nodes one by one
        cost = costs[node] # cost = {'a' : 6, 'b' : 2, fin : infinity}
        If cost < lowest_cost and node not in process: # The cost of the node being verified is lower than the minimum cost and the node is not processed
            lowest_cost = cost # Renew lowest cost
            lowest_cost_node = node # Update the lowest cost node

    return lowest_cost_node


node = find_lowest_cost_node(costs) # Find the cheapest node that has not yet been processed. # # b
# End of repeat statement after processing all nodes processed
while node is not None: 
    cost = costs[node] #cost = {'a' : 6, 'b' : 2, 'fin' : infinity} #initial cost = costs[b] = 2
    neighbors = graph[node] # neighbors = {'a' : {'fin' : 1}, 'b' : {'a': 3, 'fin': 5}, 'fin' : {} }

    For n in neighbors.keys(): # Repeat for all neighbors [start][a] = 6 [start][b] = 2 [a][fin] = 1 [b][a] = 3 [b][fin] = 5
        new_cost = cost + neighbors[n]

        If costs[n] > new_cost: # If passing through a new node is cheaper,
            costs[n] = new_cost # Update the price of the node to the price of the new node
            parents[n] = node # Set parent to this node new

    Processed.append(node) # Record the fact that the node was processed
    node = find_lowest_cost_node(costs) # Find and repeat the node you want to handle next

print('Parent Table (Route Move):')
print(parents)
print('shortest distance node cost :')
print(costs)

# Output result
# Parent table (path move): 
# # {'a': 'b', 'b': 'start', 'fin': 'a'}
# The shortest distance node cost is: 
# # {'a': 5, 'b': 2, 'fin': 6}