Ошибка typeerror dict object is not callable

A more functional approach would be by using dict.get

input_nums = [int(in_str) for in_str in input_str.split())
strikes = list(map(number_map.get, input_nums.split()))

One can observe that the conversion is a little clumsy, better would be to use the abstraction of function composition:

def compose2(f, g):
    return lambda x: f(g(x))

strikes = list(map(compose2(number_map.get, int), input_str.split()))

Example:

list(map(compose2(number_map.get, int), ["1", "2", "7"]))
Out[29]: [-3, -2, None]

Obviously in Python 3 you would avoid the explicit conversion to a list. A more general approach for function composition in Python can be found here.

(Remark: I came here from the Design of Computer Programs Udacity class, to write:)

def word_score(word):
    "The sum of the individual letter point scores for this word."
    return sum(map(POINTS.get, word))

A Python dictionary is a collection of data values stored in key-value pairs. To access items in a dictionary, you must use the indexing syntax of square brackets [] with the index position. If you use parentheses, you will raise the “TypeError: ‘dict’ object is not callable”.

This tutorial will describe the error and why it occurs. We will explore an example scenario of this error and go through how to solve it.

TypeError: ‘dict’ object is not callable

Python dictionary is a mutable data structure, meaning we can change the object’s internal state. Dictionaries are iterable objects, which means you can access items individually from inside the dictionary. Accessing an item from a dictionary follows the syntax of using square brackets with the index position. You must specify the appropriate key to access the value you want. If you use an unhashable type to access a dictionary, for example, a slice, you will raise the TypeError: unhashable type: ‘slice’. Let’s look at an example of accessing a dictionary:

pizzas = {

"name1": "margherita",

"name2": "pepperoni",

"name2": "four cheeses"

}

# Access pizza name

print(pizzas["name1"])

margherita

When we run our code, we print the value associated with the key “key1”.

TypeError tells us that we are trying to perform an illegal operation on a Python data object. Specifically, we cannot use parentheses to access dictionary elements. The part “‘dict’ object is not callable” tells us that we are trying to call a dictionary object as if it were a function or method. In Python, functions and methods are callable objects, they have the __call__ method, and you put parentheses after the callable object name to call it. Python dictionary is not a function or method, making calling a dictionary an illegal operation.

Example: Accessing Elements of a Dictionary

Let’s create a program that prints out the values of a dictionary to the console. The dictionary contains information about a type of fundamental particle, the muon.

We will start by declaring a dictionary for the muon data.

# Declare dictionary for muon particle

muon = {

   "name":"Muon",

   "charge":"-1",

   "mass":"105.7",

   "spin":"1/2"

}

The dictionary has four keys and four values. We can use the print() function to print each value to the console.

# Print values for each key in dictionary

print(f'Particle name is: {muon("name")}')

print(f'Particle charge is: {muon("charge")}')

print(f'Particle mass is : {muon("mass")} MeV')

print(f'Particle spin is: {muon("spin")}')

If we run the code, we get the following output:

TypeError                                 Traceback (most recent call last)
1 print(f'Particle name is: {muon("name")}')

TypeError: 'dict' object is not callable

We raise the error because we are not accessing the items with the correct syntax. In the above code, we used parentheses to access items in the dictionary.

Solution

To solve this error, we must replace the parentheses with square brackets to access the items in the muon dictionary.

# Print values for each key in dictionary

print(f'Particle name is: {muon["name"]}')

print(f'Particle charge is: {muon["charge"]}')

print(f'Particle mass is : {muon["mass"]} MeV')

print(f'Particle spin is: {muon["spin"]}')

When we run the code, we will get the following output:

Particle name is: Muon

Particle charge is: -1

Particle mass is : 105.7 MeV

Particle spin is: 1/2

Our code runs successfully and prints four aspects of the muon particle. Instead of using parentheses (), we used square brackets [].

We can also use items() to iterate over the dictionary as follows:

# Iterate over key-value pairs using items()

for key, value in muon.items():

   print(muon[key])

In the above code, we are iterating key-value pairs using items() and printing the value associated with each key. When we run the code, we will get the following output:

Muon

-1

105.7

1/2

Summary

Congratulations on reading to the end of this tutorial. The Python error “TypeError: ‘dict’ object is not callable” occurs when we try to call a dictionary like a function, and the Python dictionary is not a callable object. This error happens when we try to use parentheses instead of square brackets to access items inside a dictionary. You must use square brackets with the key name to access a dictionary item to solve this error.

For further reading on the “not callable” Python TypeError, you can read the following articles:

• How to Solve Python TypeError: ‘nonetype’ object is not callable
• How to Solve TypeError: ‘str’ object is not callable

To learn more about using dictionaries go to the article: Python How to Add to Dictionary.

Go to the Python online courses page to learn more about coding in Python for data science and machine learning.

Have fun and happy researching!

Items in a Python dictionary must be called using the indexing syntax. This means you must follow a dictionary with square brackets and the key of the item you want to access. If you try to use curly brackets, Python will return a “TypeError: ‘dict’ object is not callable” error.

In this guide, we talk about this error and why it is raised. We walk through an example of this error in action so you can learn how to solve it in your code.

TypeError: ‘dict’ object is not callable

Dictionaries are iterable objects. This means that you can access items individually from inside a dictionary.

To access an item in a dictionary, you need to use indexing syntax. Here’s an example of indexing syntax in Python:

dictionary = {"key1": "value1"}
print(dictionary["key1"])

Run our code. “value” is returned. The value associated with the key “key1” is “value1”.

If we try to access an item from our dictionary using curly brackets, we encounter an error. This is because curly brackets are used to denote function calls in Python.

When Python sees a pair or curly brackets, it thinks you are trying to execute a function.

An Example Scenario

Here, we create a program that prints out all the values in a dictionary to the console. This dictionary contains information about a type of bird, the Starling.

Start by declaring a dictionary:

starling = {
	"name": "Starling",
	"Scientific_name": "Sturnus Vulgaris",
	"conservation_status_uk": "Red",
	"food": "Invertebrates and fruit"
}

This dictionary has four keys and four values. Let’s use print() statements to print each value from our dictionary to the console:

print("Name: " + starling("name"))
print("Scientific Name: " + starling("scientific_name"))
print("UK Conservation Status: " + starling("conservation_status_uk"))
print("What They Eat: " + starling("food")) 

This code should print out the values of “name”, “scientific_name”, “conservation_status_uk”, and “food” to the console. Run our code and see what happens:

Traceback (most recent call last):
  File "main.py", line 8, in <module>
	print("Name: " + starling("name"))
TypeError: 'dict' object is not callable

Our code returns an error.

This is because we are incorrectly accessing items from our dictionary. Dictionary items must be accessed using indexing syntax. In our code above, we’ve tried to use curly brackets to access items in our dictionary.

The Solution

To solve this error, we need to make sure we use square brackets to access items in our dictionary. Every time we access an item from the ‘starling” dictionary, we should use this syntax:

Use this syntax in our main program:

print("Name: " + starling["name"])
print("Scientific Name: " + starling["scientific_name"])
print("UK Conservation Status: " + starling["conservation_status_uk"])
print("What They Eat: " + starling["food"])

Our code now functions successfully:

Name: Starling
Scientific Name: Sturnus Vulgaris
UK Conservation Status: Red
What They Eat: Invertebrates and fruit

Instead of using curly brackets to access items in our dictionary, we have used square brackets. Square brackets indicate to Python that we want to access items from an iterable object. Curly brackets, on the other hand, indicate a function call.

Conclusion

The “TypeError: ‘dict’ object is not callable” error is raised when you try to use curly brackets to access items from inside a dictionary. To solve this error, make sure you use the proper square bracket syntax when you try to access a dictionary item.

Now you have all the knowledge you need to fix this error in your Python code!