FAQ: Graphs: Python - Finding a Path II


This community-built FAQ covers the “Finding a Path II” exercise from the lesson “Graphs: Python”.

Paths and Courses
This exercise can be found in the following Codecademy content:

Computer Science

Complex Data Structures

FAQs on the exercise Finding a Path II

There are currently no frequently asked questions associated with this exercise – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this exercise. Ask or answer a question by clicking reply (reply) below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this exercise, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

Join the Discussion. Help a fellow learner on their journey.

Ask or answer a question about this exercise by clicking reply (reply) below!

Agree with a comment or answer? Like (like) to up-vote the contribution!

Need broader help or resources? Head here.

Looking for motivation to keep learning? Join our wider discussions.

Learn more about how to use this guide.

Found a bug? Report it!

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

It says to use the .extend() method in the fourth instruction and I don’t think I’ve been introduced to that before so I had no way to know to use that. I looked through all the code to try to find the .extend() method to no avail, so now i’m here asking what it’s about.



I know its been a while since you asked, but since i stumbled with the lesson today, i’m gonna give an answer.

Python commands and functions are way bigger than Codecademy lessons. You need to use other sources to feed your curiosity. I knew about .extend() because of that, it was my first choice. There is another option += that is also valid, but for some reason i forget that it works with lists too (i use it mostly with counter variables).


I am going to have to grab the solution to move to the next step…as I cannot see what is wrong with the above…you can see the error.

No doubt but that it is something simple…

1 Like

P.S. I can add that by not scrolling I missed adding the return when I tried running the change.

i.e. I went into the error state…but adding the return and re-running failed to clear the matter.

Thank you!

Hello mate, maybe they want you to use .extend() list method instead using +=

TL;DR: They are semantically similar, but not the same for any case.

.extend would do the trick. Remember that it’s an automated checking. Regarding .extend you can read the Python 3 doc https://docs.python.org/3/tutorial/datastructures.html

It’s important to note, that while in this case start += next_vertices would behave equal to start.extend(next_vertices) the fact is that although being “semantically” similar, the += would not work if there were something like a tuple (inmutable) involved, or more precise, if the list were an attribute of a inmutable object, while extend would work (see picture).

I hope it helps…


An excellent point. (the screenshot tells it all) Thank you!

1 Like

Hi there,

It seems to me that in add_edge function within Graph class, the keys for graph_dict are in the format of the string ‘values’ that were assigned upon the creation of Vertex objects. But in the find_path function within Graph class, it looks like the key for graph_dict is actually the vertex itself, not just the ‘value’ of the vertex. Shouldn’t the keys for a dictionary all be the same type of object?

Could anyone help me understand what I may be missing?

Please see line 10 in the first image for the first scenario, and line 21 in the second image, to see what I’m talking about.

Hello. It seems to be that it’s correct. In line 10, you are “setting” edges, in line 21 you are just bringing the vertex to the table, to get its egdes.

It seems that the arguments for find_path function are actually the vertex.values. That would explain a lot.

In the part below while loop. Why I can not use (if, elif and else)? I understand the way in the solution is easier but curious to know.

if it is equal, elif is not equal and else.


while len(start) > 0:
current_vertex = start.pop(0)
print("Visiting " + current_vertex)

  if current_vertex == end_vertex:
    return True

  vertex = self.graph_dict[current_vertex]
  next_vertices = vertex.get_edges()
  start = start.extend(next_vertices)
return False

I had the same question earlier but I have figured it out luckily.

If you go back to script.py, you will notice default callings of .find_path have strings as arguments. This explains why the code is written this way, specifically why we write in line 21:

vertex = self.graph_dict[current_vertex]

since current_vertex is actually a string (the name of the station), which is exactly the same value as what you get you put current_vertex.value like in line 11. Hope this helps.

This confusion keeps me thinking, however, why the exercise doesn’t ask us to use the vertex as arguments in the .find_path function… just as other functions in the exercise

Anws, I tried to revise the code so that .find_path() actually takes vertex objects as arguments but not string, which would make more sense. Here’s my revision:

def find_path(self, start_vertex, end_vertex):
    start = [start_vertex]
    while len(start) > 0:
      current_vertex = start.pop(0)
      if current_vertex == end_vertex:
        return True
      #vertex = self.graph_dict[current_vertex.value]
      next_vertices = current_vertex.get_edges()
      start += next_vertices
    return False

Make sure to change the add.edge() function calling within add_vertex() also, as we want to pass vertex object not the value:

def add_vertex(self, vertex):
    self.graph_dict[vertex.value] = vertex

  def add_edge(self, from_vertex, to_vertex, weight = 0):
    self.graph_dict[from_vertex.value].add_edge(**to_vertex**, weight)
    if not self.directed:
      self.graph_dict[to_vertex.value].add_edge(**from_vertex**, weight)

Last but not least, change the function call in script.py:

print("\n\n\nFinding path from harwick to callan\n")
new_path_exists = directed_railway.find_path(harwick_station, callan_station)

print("\n\nTrying to find path from harwick to ulfstead\n")
no_path_exists = directed_railway.find_path(harwick_station, ulfstead_station)

I find this method a lot more straightforward and won’t cause confusion. Hope this helps too. :slight_smile:

How come when I add edge between harwick_station to ulfstead_station, i.e. harwick_station has 2 edges, the .find_path function still says there’s a path from harwick_station to callan_station?:

(1) harwick_station --> peel_station --> callan_station (as given in script.py)
(2) harwick_station --> ulfstead_station

function call in script.py

directed_railway.add_edge(harwick_station, peel_station)
directed_railway.add_edge(harwick_station, ulfstead_station)
directed_railway.add_edge(peel_station, callan_station)

Printed in terminal:
Finding path from harwick to callan

Visiting harwick
Visiting peel
Visiting ulfstead
Visiting callan


(Someone, @tgrtim)Can you explain for me how these lines of code checks for a path:

if current_vertex == end_vertex:
   return True

Wouldn’t they be not equal because they are not the same. They both use a dictionary.

below is finding path function . since there is only 1 element in list ‘start’ , start will only pop 1st one /only 1 element to current_vertex. how can we find a path since it only print the 1st element ? please help .

 def find_path(self, start_vertex, end_vertex):
    start = [start_vertex]
    while len(start) > 0:
      current_vertex = start.pop(0)
      print("Visiting " + current_vertex)