Skip to main content

How to Resolve Python "TypeError: 'tuple' object is not callable"

The TypeError: 'tuple' object is not callable is a common Python error indicating you've attempted to execute a tuple using call parentheses () as if it were a function. Tuples are ordered, immutable data containers and cannot be called like functions or methods.

This guide explains the various scenarios that lead to this error, such as incorrect indexing syntax or name collisions, and provides clear solutions.

Understanding the Error: Tuples are Not Functions​

  • Tuples (tuple): Ordered, immutable sequences of items, usually created with parentheses () or just commas. They store data. Examples: (1, 2), 'a', 'b', ().
  • Callable Objects: Things that can be executed using parentheses (). This includes functions (defined with def or lambda), methods (functions bound to objects), and class constructors (MyClass()).
  • The Error: Occurs when you place call parentheses () after an object that is a tuple, attempting to execute it like a function.

Cause 1: Using () Instead of [] for Indexing/Slicing (Most Common)​

This is the most frequent mistake leading to this error. To access elements within a tuple by their position (index) or get a sub-sequence (slice), you must use square brackets [].

Error Scenario: Using () for indexing

my_tuple = ('red', 'green', 'blue')

# Error Scenario: Using () for indexing
# ⛔️ TypeError: 'tuple' object is not callable
first_item = my_tuple(0) # Should be my_tuple[0]
print(first_item)

Correct Solution:

my_tuple = ('red', 'green', 'blue')

# Solution: Use [] for indexing and slicing
# ✅ Correct Indexing
first_item_fixed = my_tuple[0]
print(f"First item (index 0): '{first_item_fixed}'")

# ✅ Correct Slicing
first_two_items = my_tuple[0:2]
print(f"First two items (slice 0:2): {first_two_items}")

Output:

First item (index 0): 'red'
First two items (slice 0:2): ('red', 'green')

Remember: [] for accessing elements, () for calling functions/methods.

Cause 2: Accidental Call on a Tuple Variable (my_tuple())​

Simply adding parentheses after a variable that holds a tuple.

coordinates = (10, 20)

# Error Scenario
# ⛔️ TypeError: 'tuple' object is not callable
coordinates() # Mistakenly added parentheses

Correct Solution:

coordinates = (10, 20)

# Solution: Remove the parentheses
print(f"Tuple value: {coordinates}")

Output:

Tuple value: (10, 20)

Cause 3: Variable Name Clashing with Function Name​

Assigning a tuple to a variable with the same name as a function hides the function. Calling the name later attempts to call the tuple.

def get_settings():
    return "Settings Function Result"

# Function works
print(get_settings())

# --- Later ---
# ⚠️ Variable assignment shadows the function
get_settings = ('dark', 12)
print(f"Variable 'get_settings' now holds: {get_settings}")

# Error Scenario
try:
    # ⛔️ TypeError: 'tuple' object is not callable
    # Tries to call the tuple ('dark', 12)
    result = get_settings()
    print(result)
except TypeError as e:
    print(f"Error: {e}")

# Solution: Use distinct names
def get_settings_func(): return "Settings Func Result"
current_settings = ('dark', 12)

print(f"Calling fixed function: {get_settings_func()}")     # Output: Calling fixed function: Settings Func Result
print(f"Accessing variable: {current_settings}")            # Output: Accessing variable: ('dark', 12)

Output:

ERROR!
Settings Function Result
Variable 'get_settings' now holds: ('dark', 12)
Error: 'tuple' object is not callable
Calling fixed function: Settings Func Result
Accessing variable: ('dark', 12)

Cause 4: Shadowing the Built-in tuple Type​

Naming a variable tuple overrides the built-in tuple() constructor.

Example of Error Scenario:

# Error Scenario
# ⚠️ Variable 'tuple' hides the built-in tuple() constructor
tuple = (1, 2, 3)
print(f"Variable 'tuple' holds: {tuple}")

# ⛔️ TypeError: 'tuple' object is not callable
# Tries to call the variable tuple = (1, 2, 3)
new_tuple = tuple([4, 5, 6]) # Attempting to use the constructor
print(new_tuple)

Correct Solution

# Solution: Use a different variable name
my_actual_tuple = (1, 2, 3)

# ✅ tuple() now refers to the built-in constructor
new_tuple_fixed = tuple([4, 5, 6])
print(f"Using built-in tuple(): {new_tuple_fixed}") 
# Output: Using built-in tuple(): (4, 5, 6)
note

Never use built-in type/function names (tuple, list, str, int, sum, etc.) for variables. Restart your interactive session if needed.

Cause 5: Class Attribute vs. Method Name Conflict​

An instance attribute holding a tuple can shadow a method with the same name.

Example of Error Scenario:

class Point:
    def __init__(self, coords_tuple):
        self.coords = coords_tuple # Attribute 'coords' holds a tuple

    def coords(self): # Method with the SAME name 'coords'
        print("Method 'coords' called")
        return self.coords[0] # Example action

# Error Scenario
p = Point((10, 20))
print(f"Attribute: {p.coords}") # Output: (10, 20)

# ⛔️ TypeError: 'tuple' object is not callable
# p.coords refers to the tuple attribute, not the method
result = p.coords()
print(result)

Correct Solution:

# Solution: Rename method or attribute
class PointFixed:
    def __init__(self, coordinates):
        self._coords = coordinates # Use different name (e.g., leading underscore)

    def get_coordinates(self): # Renamed method
        print("Method 'get_coordinates' called")
        return self._coords

p_fixed = PointFixed((10, 20))
result_fixed = p_fixed.get_coordinates()
print(f"Fixed result: {result_fixed}")

Output:

Method 'get_coordinates' called
Fixed result: (10, 20)

Cause 6: Calling a Function That Returns a Tuple Twice (func()())​

Calling func() returns the tuple. The second () then tries to call that tuple.

Example of Error Scenario:

def get_rgb_values():
    return (255, 100, 50) # Returns a tuple

# Error Scenario
# ⛔️ TypeError: 'tuple' object is not callable
# get_rgb_values() returns (255, 100, 50). Second () calls the tuple.
values = get_rgb_values()()
print(values)

Correct Solution:

def get_rgb_values():
    return (255, 100, 50) # Returns a tuple

# Solution: Call only once
# ✅ Call function once to get the tuple
values = get_rgb_values()
print(f"RGB values: {values}")

Output:

RGB values: (255, 100, 50)

Cause 7: Missing Comma Between Tuples in a List ([()()])​

This is a subtle syntax error where Python interprets adjacent tuples within list brackets as an attempt to call the first tuple with the second one as an argument.

Example of Error Scenario:

# Error Scenario: Missing comma between tuples
# ⛔️ TypeError: 'tuple' object is not callable
# Python sees ('a', 'b') ('c', 'd') and thinks you're calling the first tuple
my_list = [('a', 'b') ('c', 'd')]
print(my_list)

Correct Solution:

# Solution: Add the comma
# ✅ Add comma to separate list elements
my_list_fixed = [('a', 'b'), ('c', 'd')]
print(f"Corrected list: {my_list_fixed}")
# Output: Corrected list: [('a', 'b'), ('c', 'd')]

Solutions Summary​

  • Use square brackets [] for tuple indexing and slicing.
  • Remove extra call parentheses () after tuple variables or function calls returning tuples.
  • Use distinct names for variables and functions/methods.
  • Avoid using built-in names like tuple for variables.
  • Add missing commas between elements in lists or tuples.

How Tuples Are Created (Reminder)​

  • () or tuple(): Empty tuple
  • 'a', or ('a',): Single-element tuple (comma is essential)
  • 'a', 'b' or ('a', 'b'): Multi-element tuple

Debugging Tip: Check Variable Types (type())​

If the error source isn't obvious, print the type:

maybe_tuple = ('x',)
print(f"Type of variable: {type(maybe_tuple)}")
# Output: Type of variable: <class 'tuple'>

Seeing <class 'tuple'> confirms the object type involved in the error.

Conclusion​

The TypeError: 'tuple' object is not callable arises from treating an immutable tuple data structure as an executable function via call parentheses ().

The most common causes are incorrect syntax for accessing elements (using () instead of []) or name conflicts where a function name is shadowed by a tuple variable. By using the correct syntax ([] for access) and ensuring distinct names for variables and functions, you can easily prevent and fix this error.

Table of Contents