The TypeError: unhashable type: 'list' usually occurs when you try to use a list object as a set element or dictionary key and Python internally passes the unhashable list into the hash() function. But as lists are mutable objects, they do not have a fixed hash value. The easiest way to fix this error is to use a hashable tuple instead of a non-hashable list as a dictionary key or set element.

We’ll show how this is done in the remaining article. The last method is a unique way to still use lists in sets or dictionary keys that you likely won’t find anywhere else, so keep reading and learn something new!

Problem Formulation and Explanation

Question: How to fix the TypeError: unhashable type: 'list' in your Python script?

There are two common reasons for this error:

• You try to use a list as a dictionary key, or
• You try to use a list as a set element.

This is not a trivial problem because Python lists are mutable and, therefore, not hashable.

Here’s the first example:

my_list = [1, 2, 3]

my_dict = {}

my_dict[my_list] = 'hello Finxters!' '''

Traceback (most recent call last): File "C:\Users\xcent\Desktop\code.py", line 3, in <module> my_dict[my_list] = 'hello Finxters!'

TypeError: unhashable type: 'list' '''

And here’s the second example:

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

my_set = set(my_list) '''

Traceback (most recent call last): File "C:\Users\xcent\Desktop\code.py", line 2, in <module> my_set = set(my_list)

TypeError: unhashable type: 'list' '''

As you’ve seen in the previous two code snippets, the TypeError: unhashable type: 'list' usually occurs when you try to use a list object as a set element or dictionary key.

But let’s dive deeper to find the real reason for the error:

Minimal Reproducible Error Example: Lists are mutable objects so they do not have a fixed hash value. In fact, the error can be reproduced most easily when calling hash(lst) on a list object lst.

This is shown in the following minimal example that causes the error:

hash([1, 2, 3])

The output is the error message:

Traceback (most recent call last): File "C:\Users\xcent\Desktop\code.py", line 1, in <module> hash([1, 2, 3])

TypeError: unhashable type: 'list'

Because you cannot successfully pass a list into the hash() function, you cannot directly use lists as set elements or dictionary keys.

But let’s dive into some solutions to this problem!

Method 1: Use Tuple Instead of List as Dictionary Key

The easiest way to fix the TypeError: unhashable type: 'list' is to use a hashable tuple instead of a non-hashable list as a dictionary key. For example, whereas d[my_list] will raise the error, you can simply use d[tuple(my_list)] to fix the error.

Here’s an example of what you can do instead:

my_list = [1, 2, 3]

my_dict = {}

my_dict[tuple(my_list)] = 'hello Finxters!' print(my_dict)

# {(1, 2, 3): 'hello Finxters!'}

The error may also occur when you try to use a list as a set element. Next, you’ll learn what to do in that case:

Method 2: Use Tuple Instead of List as Set Element

To fix the TypeError: unhashable type: 'list' when trying to use a list as a set element is to use a hashable tuple instead of a non-hashable list. For example, whereas set.add([1, 2]) will raise the error, you can simply use set.add((1, 2)) or set.add(tuple([1, 2])) to fix the error.

Here’s a minimal example:

my_set = set() # Error: my_set.add([1, 2]) # This is how to resolve the error:

my_set.add((1, 2))

# Or: my_set.add(tuple([1, 2])) print(my_set)

# {(1, 2)}

If you want to convert a list of lists to a set, you can check out my detailed tutorial on the Finxter blog:

Related Tutorial: How to convert a list of lists to a set?

Method 3: Use String Representation of List as Set Element or Dict Key

To fix the TypeError: unhashable type: 'list', you can also use a string representation of the list obtained with str(my_list) as a set element or dictionary key. Strings are hashable and immutable, so Python won’t raise the error when using this approach.

Here’s an example:

my_list = [1, 2, 3] # 1. Use str repr of list as dict key:

d = {}

d[str(my_list)] = 'hello Finxters' # 2. Use str repr of list as set element:

s = set()

s.add(str(my_list))

In both cases, we used the string representation of the list instead of the list itself. The string is immutable and hashable and it fixes the error.

But what if you really need a mutable set or dictionary key? Well, you shouldn’t but you can by using this approach:

Method 4: Create Hashable Wrapper List Class

You can still use a mutable list as a dictionary key, set element, or argument of the hash() function by defining a wrapper class, say HackedList, that overrides the __hash__() dunder method.

Python’s built-in hash(object) function takes one object as an argument and returns its hash value as an integer. You can view this hash value as a unique fingerprint of this object.

The Python __hash__() method implements the built-in hash() function.

Here’s the minimal code example that creates a wrapper class HackedList that overrides the __hash__() dunder method so you can use an instance of HackedList as a dictionary key, set element, or just as input to the hash() function:

my_list = [1, 2, 3] class HackedList: def __init__(self, lst): self.lst = lst def __hash__(self): return len(self.lst) my_hacked_list = HackedList(my_list) # 1. Pass hacked list into hash() function:

print(hash(my_hacked_list)) # Output: 3 # 2. Use hacked list as dictionary key:

d = dict()

d[my_hacked_list] = 'hello Finxters' # 3: Use hacked list as set element:

s = set()

s.add(my_hacked_list)

Here’s the content of the dictionary and set defined previously:

{<__main__.HackedList object at 0x0000016CFB0BDFA0>: 'hello Finxters'}

{<__main__.HackedList object at 0x0000016CFB0BDFA0>}

If you want to fix the ugly output, you can additionally define the __str__() and __repr__() magic methods like so:

my_list = [1, 2, 3] class HackedList: def __init__(self, lst): self.lst = lst def __hash__(self): return len(self.lst) def __str__(self): return str(self.lst) def __repr__(self): return str(self.lst) my_hacked_list = HackedList(my_list) # 1. Pass hacked list into hash() function:

print(hash(my_hacked_list)) # Output: 3 # 2. Use hacked list as dictionary key:

d = dict()

d[my_hacked_list] = 'hello Finxters' # 3: Use hacked list as set element:

s = set()

s.add(my_hacked_list) print(d)

print(s)

Beautiful output:

{[1, 2, 3]: 'hello Finxters'}

{[1, 2, 3]}

Summary

The five most Pythonic ways to convert a list of lists to a set in Python are:

• Method 1: Use Tuple Instead of List as Dictionary Key
• Method 2: Use Tuple Instead of List as Set Element
• Method 3: Use String Representation of List as Set Element or Dict Key
• Method 4: Create Hashable Wrapper List Class

Feel free to check out more free tutorials and cheat sheets for learning and improving your Python skills in our free email academy:

Nerd Humor

Full Course: Check out the full beginner course on Forex trading on this Finxter page (5 video lessons).

As a Python beginner, or anything else new that we dive into, everything is fresh and exciting for a while and we have no problem staying motivated to do the work and move ahead.

It’s no wonder you can stay fired up when you are learning the most popular language, in a field that looks promising for years to come, and its innovations will shape the future. That’s exciting!

There’s a book that summarizes the next step in your journey, whether it be Python, Forex, business, freelancing, or anything else. It deals with what most people call, “being at the intermediate level.”

It’s called “The Dip”, by Seth Godin. Like most “self-help” type books, even though this one is only around 100 pages, it could have been done in 10 or 15. In this case though, the author gets an “A+” for the concept.

The idea that after the honeymoon, there will be a period of uncertain struggle on where to go next. Python has the mother of all dips.

To wrap up this beginner’s guide, I want to help you find your way through the dip and come out the other side a success.  That “way” is in the title – “Practical Projects.”

Freelance and Get Some Work that Uses Your Python Skills

Doing a project for someone who doesn’t know how, or have the time to do it themselves, is a great way to put your Python skills to the test.

The great thing about freelancing your skills, is you never know what someone is going to need, and this can give you a great variety of projects.

PRO TIP: Don’t wait until you “feel” ready.  You will never feel ready – what you need is confidence – by doing some real work, learning from your mistakes, and not making them again.

Getting started on a platform like Upwork is simple and you will know which projects you can handle, and which ones you can’t – besides, it’s good for you to take a couple that will push your skills and require you to learn how to complete them.

Here are a few more Ideas for some real-world projects:

Data Analysis Projects with Python and Its Libraries

We went through some simple examples of what you can do with data earlier in the series.  Let’s break down a sample in detail:

• Think about a subject that interests you, and where you can find data collections for that topic.
• Do a search and find some downloadable files from their collections.
• Pick a file that suits your project, download the CSV, (I hope you’re using Anaconda and Jupyter), clean it up and organize it, then see what types of patterns, if any, you can identify.  I grabbed historical data on interest rates from the Fed’s website for my last analysis.  There is so much information out there for free that we will never be able to cover a tiny percentage of it.  So narrow it down to your specific needs.

Projects and Tests for Forex Trading and Python

• Form a hypothesis – “Is there a correlation between the EUR/USD and WTI?”  In light of recent global events, one would be safe in questioning crude oil’s affect on the entire world.
• Do a comparison – Do you remember in a previous lesson when I demonstrated how to overlay one instrument with another on your charts? This is a simple way to look for correlation. Remember, correlation can be positive or negative.
• Look to see if one or the other seems to “lead” its partner.  This can be a great way to see into the future – so to speak.
• If your theory looks promising, question if there is a way to quantify and automate the information using Python.  This would also be a good time to start digging into machine learning.  Use Python to streamline the process and set alerts.

This is a hypothetical situation I created as an example.  Do not trade any theory from anyone without thoroughly testing it yourself.

Sources for Datasets

• Governments collect data and make it available to the public on their websites.  Records of everything from NFP to GDP, and weather events can be found with a little effort.
• Central banks, the IMF, and the World Bank also issue reports and data on a variety of economic indicators and predictions created by their own experts.
• Be wary of “advice” sites that are trying to sell you something – look for facts gleaned from statistics and research instead.

Get on Board with a Broker and Get a Robot

We have already discussed how to choose a broker, and did some analysis together on the subject.  With the regulations in place these days, it’s really easy to find one that is legit.  It will boil down to personal preference in the end.  Make sure you feel comfortable with your choice, and that they have responsive customer service so you can communicate easily.

As a beginner, just like with Python, it’s important to start getting some experience while you’re learning to code your own bots. Using a ready-made bot on a demo account is the best way to get going and see if automated trading is right for you.

REMEMBER: Don’t make it all about the money just yet – the knowledge you’re getting in the process is the real value.  If you have followed the steps in this series, you should already be on your way to safely making money with Python.

Bonus for Finishing the Beginner Series on Forex Bots and Python

For all of you who have stuck it out until the end of our beginner series, I’m going to give you some analysis that will demonstrate the many different ways to go about your trade planning – they’re endless, which is what makes Forex so interesting.  No matter your style, you can find a system that fits.

In the accompanying video, I’m going to give some high-level tips and analysis on the EUR/USD pair that we have been using in the series, and explain what actually makes currency values change.

Check out the video, and it has been a pleasure sharing this information with you.

Here’s to good trading and good luck!