Problem Formulation and Solution Overview

In this article, you’ll learn how to multiply List Elements by a Number in Python.

This example multiples the first five (5) Prime Numbers by two (2) and return the result.

Question: How would we write Python code to multiply the list elements?

We can accomplish this task by one of the following options:

• Method 1: Use List Comprehension
• Method 2: Use Pandas tolist()
• Method 3: Use map() and a lambda()
• Method 4: Use NumPy Array()
• Method 5: Use Slicing

Method 1: Use List Comprehension

This method uses List Comprehension to apply a mathematical operation to each element and return the result.

prime_nums = [2, 3, 5, 7, 11]

mult_result = [x * 2 for x in prime_nums]

print(mult_result)

Above declares the first (5) Prime Numbers and saves this List to prime_nums. Next, List Comprehension loops through each element and applies the multiplication operation to each. The output saves to mult_result and is output to the terminal.

Method 2: Use Pandas tolist()

This method requires an additional library to be imported, Pandas, to use the tolist() function.

import pandas as pd prime_nums = [2, 3, 5, 7, 11]

mult_result = pd.Series(prime_nums)

mult_result = (mult_result*2).tolist()

print(mult_result)

Above, imports the Pandas Library. Click here if this requires installation. Then, the first (5) Prime Numbers are declared and saved to prime_nums.

Next, prime_nums is passed as an argument to the pd.Series() function and returns mult_result. The output of mult_result at this point is shown below.

Now, we need to convert this output to a list (tolist()) and apply the multiplication operation to each element. The results save to mult_result and are output to the terminal.

Method 3: Use map and lambda Functions

This method wraps the map(), and lambda functions inside a Python List and calculates the results.

prime_nums = [2, 3, 5, 7, 11]

mult_result = list(map(lambda x: x*2, prime_nums))

print(mult_result)

Above declares the first (5) Prime Numbers and saves them to prime_nums. The next line does the following:

• The map() function is passed the lambda() function as an argument (map(lambda x: x*2, prime_nums)).
• The lambda performs the multiplication operation to each element of prime_nums and saves it to map() as an object similar to below.
  <map object at 0x000001DC99CBBBB0>
• The map() object is then converted to a List.
• The results save to mult_result.

Then, mult_result is output to the terminal.

Method 4: Use Numpy Array()

This method requires an additional library to be imported, NumPy, to use the np.array() function.

import numpy as np prime_nums = [2, 3, 5, 7, 11]

the_result = list(np.array(prime_nums) * 2)

print(the_result)

Above, imports the NumPy Library. Click here if this requires installation. Then the first (5) Prime Numbers are declared and saved to prime_nums.

Next, prime_nums is passed as an argument to np.array() where the multiplication operation is applied to each element. Then, this is converted to a List, saved to the_result and output to the terminal.

Method 5: Use Slicing

This method uses Python’s infamous Slicing! No overhead, and a very pythonic way to resolve the issue.

prime_nums = [2, 3, 5, 7, 11]

prime_nums[:] = [x * 2 for x in prime_nums]

print(prime_nums)

Above declares the first (5) Prime Numbers and saves them to prime_nums.

Then slicing is applied and used in conjunction with List Comprehension to apply the multiplication operation to each element. The results save back to prime_nums and are output to the terminal.

A Finxter Favorite!

Summary

These methods of multiplying list elements by a number should give you enough information to select the best one for your coding requirements.

Good Luck & Happy Coding!

Programmer Humor

Programmer 1: We have a problem
Programmer 2: Let’s use RegEx!
Programmer 1: Now we have two problems

… yet – you can easily reduce the two problems to zero as you polish your “RegEx Superpower in Python“.

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