FAQ: Hash Maps: Python - Handling Collisions in the Setter

This community-built FAQ covers the “Handling Collisions in the Setter” exercise from the lesson “Hash Maps: Python”.

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

Computer Science

Complex Data Structures

FAQs on the exercise Handling Collisions in the Setter

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!

1 Like

Minor point, but we’re asked to check if the key stored at an index is the same as the key argument passed to assign() before being instructed to save both key & value as a list, rather than just the value. I.e. at that point in the development of this class, there is no stored key.


I spent a lot of time at that step, trying to figure out if I was missing something. Thanks for letting me known I was not the only one hehe

1 Like

You are right. We cannot address step.2 before step.3 since we don’t store [key, value] in step.2.


I would say this is a major, not minor, point. I was stuck for a while trying to determine how to check for a key if there was no key saved.


Why having different keys or none should write like this?

 if current_array_value is None:
  self.array[array_index] = [key, value]

if current_array_value[0] == key:
  self.array[array_index] = [key, value]

instead of value only, it saves key as well, but in the arrar_index should be only values. Why should we do that?

1 Like

The value is stored along with its key as a [key, value] pair so that the key is available to be compared against an incoming key to see if there is a collision.

The code you show inserts a given [key, value] pair in the index location if the location is empty, or over-writes the existing [key, value] pair if the key is the same as the incoming key.

If neither condition is true, i.e., if there is a collision between the existing key and the incoming, new key, a new array_index is calculated and used.


So, this is also the reason why the key in the array is in [0], and the value will be in the [1]?

1 Like
if current_array_value is None:
  self.array[array_index] = [key, value]

why aren’t there any end result statement given after return?
what results comes out of this method just by leaving it blank after return?

1 Like

Some functions (and methods) do not need to return anything; they just do something.

In this case, the method inserts a certain key, value pair in a certain location, and then terminates. Technically, it returns the value None, just as if there were no return statement at all. But the way that the method is meant to be used, the calling statement would not be expecting to receive any returned value.

If the control flow is such that there are no further statements or expressions following self.array[array_index] = [key, value], the method would function exactly the same without return.


I was legitimately staring at my screen for 30 minutes until I read the explanation. It makes total sense now it was poorly explained in the description and they could have changed the variable name.


Is it considered good coding practice to end with return even though it is not necessary? I noticed it is used in this way many times in the course.


It is always good coding practice to be aware of what a function is supposed to do. Functions (and class methods) either “do something”, or “return something”.

The former, sometimes called (in parlance dragged in from the non-Python world) void functions, may modify an element passed from a higher namespace - a list, perhaps, or self, in the case of a class method, or they may print() a value to the screen or save it to a file. In this type of function, there is no reason to have a return statement, and I think that most programmers would agree with this.

In the case of so-called fruitful functions, i.e., those that return a value, obviously there is a necessity for a return statement. It is generally accepted that if one path leads to return, then all paths should lead to return. So, in the case where a series of conditionals lead to return x, return y, etc., if those conditionals do not exhaust every possibility, there should be a concluding return None at the end.

From the semi-official style-guide, PEP 8:

Be consistent in return statements. Either all return statements in a function should return an expression, or none of them should. If any return statement returns an expression, any return statements where no value is returned should explicitly state this as return None, and an explicit return statement should be present at the end of the function (if reachable).


Thank you for pinpoint this issue. I agree that the current description of the exercise is misleading.

1 Like

Agree with other posts mentioned: What Step 2 is asking for is impossible to parse out before Step 3 since we are not yet saving the key with the value. I’m glad this discussion thread highlighted that so I could continue the course.


THIS. LOL, I came for the same reasons…I was being ask to compare a newly arrived key to the key that was used to store the value that I found, when I found a value at the computed index.

Whew! It is not me.

Not possible at this juncture! Thank you for taking the time.

Suggested revision:


We’re going to overwrite the functionality for .assign(). After finding the array_index, we want to do a check of the content that’s currently at self.array[array_index].

In order to avoid overwriting the wrong key, check the existing value in the array at self.array[array_index]. Save this into current_array_value.


let create a list in the value so that we can record what key was used to get to this index in the underlying array.

Instead of just assigning value, assign [key, value]

// you can call out the key by current_array_value[0] because we are using a list.


There are three possibilities for current_array_value:

  • It has the same key as key.
  • It has a different key than key.
  • It’s None.

If current_array_value already has contents, check if the saved key is different from the key we are currently processing. If the keys are the same, overwrite the array value.

If the keys are different, we’re going to implement a way to find the next array index where our key should go. We’ll get to handling different keys later.