Fixing ‘builtin_function_or_method’ Object Is Not Subscriptable?

Encountering a ‘builtin_function_or_method’ object is not subscriptable error in Python can be mystifying for beginner and experienced Pythonistas alike. But with the right troubleshooting techniques, this error can be quickly deciphered and resolved.

In this comprehensive guide, we’ll cover what causes this subscriptable error, explain why built-in functions trigger it, provide actionable solutions, and give tips on avoiding it in your Python code going forward. Let’s overcome this peculiar Python problem!

What Does ‘builtin_function_or_method’ Object Is Not Subscriptable Mean?

When you attempt to run Python code that applies a subscript on a built-in function, method, or property, you may see an error like

TypeError: 'builtin_function_or_method' object is not subscriptable

This occurs when trying to use bracket notation on something that isn’t actually a subscriptable sequence like a list or tuple. Built-in functions fall into this non-subscriptable category.

For example, code trying to get the first character of the len() function like len()[0] would result in this exception, since len() isn’t a sequence that can be indexed with [0].

Understanding the root of why built-in functions trigger this helps fix it. Let’s explore some specific examples.

Attempting to Subscript print()

A common source of this error is trying to get portions of the print() function like a string:


This causes the not subscriptable error, since print() is a function.

Same with trying to slice it:


Or get its length:


print() is a function, not a sequence. The proper solutions are:

  • Call it directly: print('hello')
  • Assign it: p = print; p('hello')

This allows using it properly without illegal subscripts.

Attempting to Subscript len()

Similarly, the len() function triggers this:

len()[0] #Error

Since len() is builtin function, not a string or collection.

To fix, call it properly:

len('hello') #5

And assign if needed:

l = len
l('hello') #5

Never try to subscript Python builtin functions!

Attempting to Subscript str() and int()

This also applies to the str() and int() type conversion functions:

str()[0] #Error

int()[0] #Error

Since they are not strings or sequences.

To use them correctly:

str(5)[0] #'5'

int('5')[0] #5

Wrap values you want to convert and then subscript.

Attempting to Subscript Class Methods

The issue also occurs with class methods, since they too are non-subscriptable functions:

class Person:
  def print(self):
p = Person()

p.print()[0] #Error

Fix by calling the method properly on an instance:

p.print() #Calls print() method

The key takeaway is not to treat methods like class properties or sequenced objects. Call them correctly.

Attempting to Subscript Mapped Functions

Trying to subscript lambda functions or mappings like dictionaries will also fail:

func_map = {'print': lambda x: print(x)}

func_map['print'][0] #Error

Instead, call the mapped function:

func_map['print']('hello') #Prints hello

So don’t try to illegally subscript any callable mappings.

Subscripting the Return Value Instead of Function

One common source of this error is trying to subscript the return value of a function, rather than the function itself:

len('hello')[0] #Error

This attempts to subscript the integer return value 5, not the len function itself.

To fix, be clear to operate on the return value:

result = len('hello') #Get return value
result[0] # Error

str(result)[0] # '5' - subscript stringified result

So be cognizant that you are not trying to subscript return values rather than the functions themselves.

Summary of Resolutions

To recap, here are the main solutions to avoid the “X object is not subscriptable” error in Python:

  • Call built-in functions directly vs trying to subscript them
  • Assign functions to variables if needed before calling
  • Ensure you are subscribing return values not functions themselves
  • Never treat class methods like subscribable properties
  • Call lambdas and function mappings directly without subscripts

Keeping these mistakes in mind will help you identify and correct illegal subscripts on non-subscriptable objects.

Leveraging Error Context Clues

Beyond the generic error message, Python also provides clues in the full Traceback detailing exactly what object caused the problem:

Traceback (most recent call last):
  File "", line 2, in <module>
    print()[0] #Error highlights this line
TypeError: 'builtin_function_or_method' object is not subscriptable

This reveals print() is the specific builtin causing illegal subscripts.

Likewise the class method version shows:

Traceback (most recent call last):
  File "", line 9, in <module>
    p.print()[0] #Error highlights method  
TypeError: 'method' object is not subscriptable

Pinpointing that p.print() method triggered the subscript issue.

Use these contextual clues to identify problematic objects and calling patterns.

Avoiding Subscript Errors

Once you understand the root causes of this error, avoiding future occurrences comes down to:

  • Not treating built-in functions as sequences
  • Calling methods properly on instances
  • Correctly operating on return values after function calls

Essentially – don’t mix up functions/methods with subscriptable objects!

Especially as you incorporate more built-ins and custom functions, keep this distinction in mind.

Common Built-In Functions That Trigger This Error

To commit the most common builtin functions that can cause illegal subscripts to memory, here is a handy reference table:

Built-In Function Usage

Built-In FunctionLegal UsageIllegal Subscripting
Custom class methodsinstance.method()instance.method()[0]

Avoiding the mistake of subscripting the functions in the right column and using legal calling conventions instead will steer clear of errors.

Key Takeaways for ‘X Is Not Subscriptable’ Issues

To recap, the main takeaways to avoid the “X is not subscriptable” error in Python:

  • Built-in functions are not sequences – call them directly instead of subscripting
  • Class methods are just callable functions – invoke them properly on instances
  • Be careful to subscript return values not the functions themselves
  • Use error context clues to pinpoint the problematic function

By identifying illegal subscripts on non-subscriptable objects and converting them to proper function calls, you can avoid and troubleshoot these issues smoothly. Never let the peculiar “builtin is not subscriptable” error slow you down again!

Leave a Comment