Typeerror function object is not subscriptable ошибка

In Python, a function is a block of code that only runs when called. You can pass data, known as parameters or arguments, to a function, and a function can return data as a result. To call a function, you must use the function name followed by parentheses () and pass the arguments inside the parentheses separated by commas. If you try to call a function using square brackets [] instead of parentheses, you will raise the error: “TypeError: ‘function’ object is not subscriptable”.

This tutorial will go through the error in detail. We will go through two example scenarios of this error and learn to solve it.

TypeError: ‘function’ object is not subscriptable

What is a TypeError?

A TypeError occurs when you perform an illegal operation for a specific data type.

What Does Subscriptable Mean?

The subscript operator, which is square brackets [], retrieves items from subscriptable objects like lists or tuples. The operator in fact calls the __getitem__ method, for example, a[i] is equivalent to a.__getitem__(i).

All subscriptable objects have a __getitem__ method. Functions do not contain items and do not have a __getitem__ method. We can verify that functions objects do not have the __getitem__ method by defining a function and passing it to the dir() method:

def add(a, b):
   result = a + b
   return result

print(type(add))

print(dir(add))

<class 'function'>

['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

Let’s look at an example of accessing an item from a list:

numbers = [0, 1, 2, 3, 4]

print(numbers[2])

2

The value at the index position 2 is 2. Therefore, the code returns 2.

Functions are not subscriptable. Therefore, you cannot use square syntax to access the items in a function or to call a function, and functions can only return a subscriptable object if we call them.

The error “TypeError: ‘function’ object is not subscriptable” occurs when you try to access a function as if it were a subscriptable object. There are two common mistakes made in code that can raise this error.

• Calling a function using square brackets
• Assigning a function the same name as a subscriptable object

Example #1: Calling a Function Using Square Brackets

You can call a function using parentheses after the function name, and indexing uses square brackets after the list, tuple, or string name. If we put the indexing syntax after a function name, the Python interpreter will try to perform the indexing operation on the function. Function objects do not support the indexing operation, and therefore the interpreter will throw the error.

Let’s look at an example of creating a function that takes two integers as arguments and raises the first integer to the power of the second integer using the exponentiation operator **. First, you define the exponent function, then define two integer values to pass to the function. Then you will print the result of the exponent function.

# Exponent function

def exponent(a, b):

    return a ** b

a = 4

b = 3

print(f'{a} raised to the power of {b} is: {exponent[a, b]}')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [2], in <cell line: 11>()
      7 a = 4
      9 b = 3
---> 11 print(f'{a} raised to the power of {b} is: {exponent[a, b]}')

TypeError: 'function' object is not subscriptable

The code did not run because you tried to call the exponent function using square brackets.

Solution

You need to replace the square brackets after the exponent name with parentheses to solve the problem.

# Exponent function

def exponent(a, b):

    return a ** b

a = 4

b = 3

print(f'{a} raised to the power of {b} is: {exponent(a, b)}')

4 raised to the power of 3 is: 64

The code runs successfully with the correct syntax to call a function in place.

Example #2: Function has the Same Name as a Subscriptable object

You may encounter this TypeError if you define a subscriptable object with the same name as a function. Let’s look at an example where we define a dictionary containing information about the fundamental physical particle, the muon.

particle = {

   "name":"Muon",

   "charge":-1,

   "spin":1/2,

   "mass":105.7

}

Next, we are going to define a function that prints out the values of the dictionary to the console:

def particle(p):
   
   print(f'Particle Name: {p["name"]}')
   
   print(f'Particle Charge: {p["charge"]}')
   
   print(f'Particle Spin: {p["spin"]}')
   
   print(f'Particle Mass: {p["mass"]}')

Next, we will call the particle function and pass the particle dictionary as a parameter:

particle(particle)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [5], in <cell line: 1>()
----> 1 particle(particle)

Input In [4], in particle(p)
      1 def particle(p):
----> 3    print(f'Particle Name: {p["name"]}')
      5    print(f'Particle Charge: {p["charge"]}')
      7    print(f'Particle Spin: {p["spin"]}')

TypeError: 'function' object is not subscriptable

We raise this error because we have a function and a subscriptable object with the same name. We first declare “particle” as a dictionary, and then we define a function with the same name, which makes “particle” a function rather than a dictionary. Therefore, when we pass “particle” as a parameter to the particle() function, we are passing the function with the name “particle“. Square brackets are used within the code block to access items in the dictionary, but this is done on the function instead.

Solution

To solve this problem, we can change the name of the function. It is good to change the function name to describe what the function does. In this case, we will rename the function to show_particle_details().

particle = {

   "name":"Muon",

   "charge":-1,

   "spin":1/2,

   "mass":105.7

}

def show_particle_details(p):
   
   print(f'Particle Name: {p["name"]}')
   
   print(f'Particle Charge: {p["charge"]}')
   
   print(f'Particle Spin: {p["spin"]}')
   
   print(f'Particle Mass: {p["mass"]}')

Let’s see what happens when we try to run the code:

show_particle_details(particle)

Particle Name: Muon

Particle Charge: -1

Particle Spin: 0.5

Particle Mass: 105.7

The code runs successfully and prints out the particle information to the console.

Summary

Congratulations on reading to the end of this tutorial. The error “TypeError: ‘function’ object is not subscriptable” occurs when you try to access an item from a function. Functions cannot be indexed using square brackets.

To solve this error, ensure functions have different names to variables. Always call a function before attempting to access the functions. When you call a function using parentheses and not square brackets, the function returns.

For further reading on TypeErrors, go to the articles:

• How to Solve Python TypeError: ‘NoneType’ object is not subscriptable
• How to Solve Python TypeError: ‘map’ object is not subscriptable

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

Have fun and happy researching!

Unlike iterable objects, you cannot access a value from a function using indexing syntax.

Even if a function returns an iterable, you must assign the response from a function to a variable before accessing its values. Otherwise, you encounter an “TypeError: ‘function’ object is not subscriptable” error.

In this guide, we talk about what this error means. We walk through two examples of this error so you can figure out how to solve it in your code.

TypeError: ‘function’ object is not subscriptable

Iterable objects such as lists and strings can be accessed using indexing notation. This lets you access an individual item, or range of items, from an iterable.

Consider the following code:

grades = ["A", "A", "B"]
print(grades[0])

The value at the index position 0 is A. Thus, our code returns “A”. This syntax does not work on a function. This is because a function is not an iterable object. Functions are only capable of returning an iterable object if they are called.

The “TypeError: ‘function’ object is not subscriptable” error occurs when you try to access a function as if it were an iterable object.

This error is common in two scenarios:

• When you assign a function the same name as an iterable
• When you try to access the values from a function as if the function were iterable

Let’s analyze both of these scenarios.

Scenario #1: Function with Same Name as an Iterable

Create a program that prints out information about a student at a school. We start by defining a dictionary with information on a student and their latest test score:

student = { "name": "Holly", "latest_test_score": "B", "class": "Sixth Grade" }

Our dictionary contains three keys and three values. One key represents the name of a student; one key represents the score a student earned on their latest test; one key represents the class a student is in.

Next, we’re going to define a function that prints out these values to the console:

def student(pupil):
	print("Name: " + pupil["name"])
	print("Latest Test Score: " + pupil["latest_test_score"])
	print("Class: " + pupil["class"])

Our code prints out the three values in the “pupil” dictionary to the console. The “pupil” dictionary is passed as an argument into the student() function.

Let’s call our function and pass the “student” dictionary as a parameter:

Our Python code throws an error:

Traceback (most recent call last):
  File "main.py", line 8, in <module>
	student(student)
  File "main.py", line 4, in student
	print("Name: " + pupil["name"])
TypeError: 'function' object is not subscriptable

This error is caused because we have a function and an iterable with the same name. “student” is first declared as a dictionary. We then define a function with the same name. This makes “student” a function rather than a dictionary.

When we pass “student” as a parameter into the student() function, we are passing the function with the name “student”.

We solve this problem by renaming our student function:

def show_student_details(pupil):
	print("Name: " + pupil["name"])
	print("Latest Test Score: " + pupil["latest_test_score"])
	print("Class: " + pupil["class"])

show_student_details(student)

We have renamed our function to “show_student_details”. Let’s run our code and see what happens:

Name: Holly
Latest Test Score: B
Class: Sixth Grade

Our code successfully prints out information about our student to the console.

Scenario #2: Accessing a Function Using Indexing

Write a program that filters a list of student records and only shows the ones where a student has earned an A grade on their latest test.

We’ll start by defining an array of students:

students = [
	{ "name": "Holly", "grade": "B" },
	{ "name": "Samantha", "grade": "A" },
	{ "name": "Ian", "grade": "A" }
]

Our list of students contains three dictionaries. Each dictionary contains the name of a student and the grade they earned on their most recent test.

Next, define a function that returns a list of students who earned an A grade:

def get_a_grade_students(pupils):
	a_grade_students = []
	for p in pupils:
    		if p["grade"] == "A":
        			a_grade_students.append(p)

	print(a_grade_students)

	return a_grade_students

The function accepts a list of students called “pupils”. Our function iterates over that list using a for loop. If a particular student has earned an “A” grade, their record is added to the “a_grade_students” list. Otherwise, nothing happens.

Once all students have been searched, our code prints a list of the students who earned an “A” grade and returns that list to the main program.

We want to retrieve the first student who earned an “A” grade. To do this, we call our function and use indexing syntax to retrieve the first student’s record:

first = get_a_grade_students[0]

print(first)

Run our code:

Traceback (most recent call last):
  File "main.py", line 16, in <module>
	first = get_a_grade_students[0]
TypeError: 'function' object is not subscriptable

Our code returns an error. We’re trying to access a value from the “get_a_grade_students” function without first calling the function.

To solve this problem, we should call our function before we try to retrieve values from it:

a_grades = get_a_grade_students(students)
first = a_grades[0]

print(first)

First, we call our get_a_grade_students() function and specify our list of students as a parameter. Next, we use indexing to retrieve the record at the index position 0 from the list that the get_a_grade_students() function returns. Finally, we print that record to the console.

Let’s execute our code:

[{'name': 'Samantha', 'grade': 'A'}, {'name': 'Ian', 'grade': 'A'}]
{'name': 'Samantha', 'grade': 'A'}

Our code first prints out a list of all students who earned an “A” grade. Next, our code prints out the first student in the list who earned an “A” grade. That student was Samantha in this case.

Conclusion

The “TypeError: ‘function’ object is not subscriptable” error is raised when you try to access an item from a function as if the function were an iterable object, like a string or a list.

To solve this error, first make sure that you do not override any variables that store values by declaring a function after you declare the variable. Next, make sure that you call a function first before you try to access the values it returns.

Now you’re ready to solve this common Python error like a professional coder!

Welcome to another module of TypeError in the python programming language. In today’s article, we will be discussing an embarrassing Typeerror that usually gets landed up while we are a beginner to python. The error is named as TypeError: ‘method’ object is not subscriptable Solution.

In this guide, we’ll go through the causes and ultimately the solutions for this TypeError problem.

What are Subscriptable Objects in Python?

Subscriptable objects are the objects in which you can use the [item] method using square brackets. For example, to index a list, you can use the list[1] way.

Inside the class, the __getitem__ method is used to overload the object to make them compatible for accessing elements. Currently, this method is already implemented in lists, dictionaries, and tuples. Most importantly, every time this method returns the respective elements from the list.

Now, the problem arises when objects with the __getitem__ method are not overloaded and you try to subscript the object. In such cases, the ‘method’ object is not subscriptable error arises.

Why do you get TypeError: ‘method’ object is not subscriptable Error in python?

In Python, some of the objects can be used to access the inside elements by using square brackets. For example in List, Tuple, and dictionaries. But what happens when you use square brackets to objects which arent supported? It’ll throw an error.

Let us consider the following code snippet:

names = ["Python", "Pool", "Latracal", "Google"]
print(names[0])

int("5")[0]

OUTPUT:- Python
TypeError: int object is not subscriptable

This code returns “Python,” the name at the index position 0. We cannot use square brackets to call a function or a method because functions and methods are not subscriptable objects.

Example Code for the TypeError

x = 3
x[0] # example 1

p = True
p[0] # example 2

max[2] # example 3

OUTPUT:-

Explanation of the code

1. Here we started by declaring a value x which stores an integer value 3.
2. Then we used [0] to subscript the value. But as integer doesn’t support it, an error is raised.
3. The same goes for example 2 where p is a boolean.
4. In example 3, max is a default inbuilt function which is not subscriptable.

The solution to the TypeError: method Object is not Subscriptable

The only solution for this problem is to avoid using square brackets on unsupported objects. Following example can demonstrate it –

x = 3
print(x)

p = True
print(p)

max([1])

OUTPUT:-

Our code works since we haven’t subscripted unsupported objects.

If you want to access the elements like string, you much convert the objects into a string first. The following example can help you to understand –

x = 3
str(x)[0] # example 1

p = True
str(p)[0] # example 2

Also, Read

FAQs

1. When do we get TypeError: ‘builtin_function_or_method’ object is not subscriptable?

Ans:- Let us look as the following code snippet first to understand this.

import numpy as np
a = np.array[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

OUTPUT:-

This problem is usually caused by missing the round parentheses in the np.array line.

It should have been written as:

a = np.array([1,2,3,4,5,6,7,8,9,10])

It is quite similar to TypeError: ‘method’ object is not subscriptable the only difference is that here we are using a library numpy so we get TypeError: ‘builtin_function_or_method’ object is not subscriptable.

Conclusion

The “TypeError: ‘method’ object is not subscriptable” error is raised when you use square brackets to call a method inside a class. To solve this error, make sure that you only call methods of a class using round brackets after the name of the method you want to call.

Now you’re ready to solve this common Python error like a professional coder! Till then keep pythoning Geeks!

Sign Up for Our Newsletters

Subscribe to get notified of the latest articles. We will never spam you. Be a part of our ever-growing community.

By checking this box, you confirm that you have read and are agreeing to our terms of use regarding the storage of the data submitted through this form.