How to Resolve Python "TypeError: 'function' object is not subscriptable"

The TypeError: 'function' object is not subscriptable is a common Python error indicating that you've tried to use square bracket notation ([]) on a function object itself, as if you were trying to access an element by index or key. Functions are callable code blocks, not data containers like lists or dictionaries that support subscripting.

This guide explains the main causes for this error – typically confusing function calls with indexing or name conflicts – and provides clear solutions.

Understanding the Error: Functions vs. Subscriptable Objects

• Functions: Defined using def or lambda. They represent blocks of executable code. You execute them by calling them with parentheses: my_function(arguments). Function objects themselves are not designed to be accessed by index or key.
• Subscriptable Objects: Data types that allow accessing their internal elements using square brackets []. These include:
  • list: Access by numerical index (e.g., my_list[0]).
  • tuple: Access by numerical index (e.g., my_tuple[1]).
  • str: Access individual characters by numerical index (e.g., my_string[-1]).
  • dict: Access values by key (e.g., my_dict['key']).

The TypeError: 'function' object is not subscriptable occurs because you applied the subscripting operation ([]) directly to an object that is a function, not one of the subscriptable data types.

Cause 1: Using Square Brackets [] Instead of Parentheses () to Call a Function

This is a frequent syntax mistake. You intend to call a function but accidentally use square brackets instead of the required parentheses.

def calculate_total(a, b):
  """Adds two numbers."""
  return a + b

try:
    result = calculate_total[5, 10]
    print(result)
except TypeError as e:
    print(e)

Python interprets calculate_total[5, 10] as trying to access an index or key (5, 10) within the function object calculate_total, which is not allowed.

Solution 1: Use Parentheses () to Call Functions

Always use parentheses () to call functions and pass arguments inside them.

def calculate_total(a, b):
  """Adds two numbers."""
  return a + b

result = calculate_total(5, 10)          # Pass arguments inside parentheses

print(f"Function call result: {result}") # Output: Function call result: 15

def process_name(name):
    return f"Processing {name}"

processed_name = process_name("Alice")   # Call with ()
print(processed_name)                    # Output: Processing Alice

Output:

Function call result: 15
Processing Alice

Cause 2: Name Conflict Between a Function and a Variable

If you define a function and then later (or in the same scope) create a variable with the exact same name, the variable name overrides (shadows) the function name. If you then try to use square brackets ([]) intending to access the original variable (which might have been subscriptable, like a list), you will actually be attempting to subscript the function object that the name now refers to.

user_list = ["admin", "editor", "viewer"]

def user_list(): # This function now hides the list above
    print("This is the user_list function!")
    return ["guest"]

try:
    first_user = user_list[0]
    print(first_user)
except TypeError as e:
    print(e)

function_result = user_list() # Calls the function
print(f"Function result: {function_result}") # Output: ['guest']

Output:

'function' object is not subscriptable
This is the user_list function!
Function result: ['guest']

Solution 2: Rename the Function or the Variable

To avoid this conflict, use distinct names for your variables and functions.

users = ["admin", "editor", "viewer"] # Variable name changed

def get_user_list(): # Function name changed
    print("This is the get_user_list function!")
    return ["guest"]

first_user = users[0]
print(f"First user from list: '{first_user}'")          # Output: First user from list: 'admin'

function_result = get_user_list()
print(f"Result from function call: {function_result}")  # Output: Result from function call: ['guest']

Output:

First user from list: 'admin'
This is the get_user_list function!
Result from function call: ['guest']

Choose clear, distinct names to prevent shadowing.

Accessing Elements Returned by a Function

If a function returns a subscriptable object (like a list or string), you first call the function using parentheses () to get the returned object, and then use square brackets [] on the result.

def get_data():
  """Returns a list of sensor readings."""
  return [10.5, 11.2, 10.9, 11.5]

data_list = get_data()
print(f"List returned by function: {data_list}")    # Output: [10.5, 11.2, 10.9, 11.5]

first_reading = data_list[0]
print(f"First reading: {first_reading}")            # Output: 10.5

second_reading = get_data()[1] # Call get_data(), then access index 1 of the result
print(f"Second reading (chained): {second_reading}") # Output: 11.2

Output:

List returned by function: [10.5, 11.2, 10.9, 11.5]
First reading: 10.5
Second reading (chained): 11.2

When to Use Square Brackets ([])

Remember, square brackets [] are used for:

• Accessing list/tuple/string elements by numerical index: my_list[0], my_string[-1]
• Slicing sequences: my_list[1:3], my_string[:-2]
• Accessing dictionary values by key: my_dict['user_name']

They are not used for calling functions.

Conclusion

The TypeError: 'function' object is not subscriptable error arises from incorrectly trying to use square bracket indexing ([]) on a function object.

The primary solutions are:

1. Use parentheses () to call functions, passing arguments inside them: my_function(arg1, arg2).
2. Ensure distinct names for functions and variables to avoid accidentally shadowing a function with a variable (or vice-versa) when you intend to use subscripting on the variable.

If a function returns a list, dictionary, or other subscriptable object, call the function first (result = my_func()) and then apply the square brackets to the result.