How to Fix TypeError: ‘tuple’ object is not callable in Python

You get the tuple object is not callable error when Python sees a tuple followed by parentheses and tries to run it like a function. The fix is usually square brackets for indexing, a missing comma, or renaming a variable:

point = (3, 4)
point(0)   # TypeError: 'tuple' object is not callable
point[0]   # 3

Every traceback on this page is a real one from my Command Prompt on Python 3.12.5, pandas 3.0.6 and NumPy 2.5.3. I ran each broken script first, then the fixed version.

In this tutorial, we’ll go through the six causes I see most, from the bracket mix-up and the missing comma to pandas .shape() and properties, plus a quick way to check what a name holds.

What does TypeError: ‘tuple’ object is not callable mean?

In Python, a callable is anything you can put () after: functions, classes, methods. A tuple isn’t one. It’s a fixed sequence of values, so writing my_tuple(...) asks Python to call data, and it refuses with a TypeError.

The error never says which name was the tuple, so read the line the traceback points to and look for a tuple right before an opening parenthesis. If tuples themselves are new to you, start with getting the first element of a tuple in Python.

Cause 1: Using parentheses instead of square brackets to index a tuple

This is the most common version. Lists, tuples and strings are indexed with [], but it’s easy to type () out of habit, especially right after calling a function. Here’s the broken script:

store = ("Austin", "TX", 78701)

print(store[0])     # square brackets: indexing works
print(store(0))     # parentheses: Python tries to CALL the tuple

Output:

Austin
Traceback (most recent call last):
  File "C:\pyguides\tuple_index.py", line 4, in <module>
    print(store(0))     # parentheses: Python tries to CALL the tuple
          ^^^^^^^^
TypeError: 'tuple' object is not callable

Notice the first print() ran fine. Python only fails when it reaches the line with store(0). Switch to brackets and everything works, including negative indexes and slices:

store = ("Austin", "TX", 78701)

city = store[0]
state = store[1]
last = store[-1]
print(city, state, last)
print(store[0:2])   # slices use brackets too

Output:

Austin TX 78701
('Austin', 'TX')

If the fixed version then says the index is too big, that’s a different problem; see how to fix IndexError: tuple index out of range.

Cause 2: A missing comma between tuples in a list

When tuples sit on separate lines inside a list, one forgotten comma glues two of them together. Python reads ("Emily", 49.99)("James", 120.50) as calling the first tuple with the second one as arguments:

orders = [
    ("Emily", 49.99)
    ("James", 120.50)
]
print(orders)

Output:

C:\pyguides\missing_comma.py:2: SyntaxWarning: 'tuple' object is not callable; perhaps you missed a comma?
  ("Emily", 49.99)
Traceback (most recent call last):
  File "C:\pyguides\missing_comma.py", line 2, in <module>
    ("Emily", 49.99)
TypeError: 'tuple' object is not callable

Since Python 3.8, the compiler spots a literal tuple followed by ( and warns you before the code even runs. Take that hint: add the comma, and add a trailing comma after the last item so the next row you paste can’t cause it again.

orders = [
    ("Emily", 49.99),
    ("James", 120.50),
    ("Olivia", 15.25),
]
for name, total in orders:
    print(f"{name:<7} ${total:,.2f}")

Output:

Emily   $49.99
James   $120.50
Olivia  $15.25

Looping over the pairs like this is covered in more detail in iterating through tuples in Python.

Cause 3: A variable named tuple that hides the built-in tuple()

Naming a variable tuple works until you need the real tuple() function later. Your variable now owns that name, so tuple(prices) tries to call your data:

tuple = (10.00, 24.50, 7.25)   # this name now hides the built-in tuple()
print(sum(tuple))

prices = [3.99, 12.00]
frozen = tuple(prices)          # calls the variable, not the built-in

Output:

41.75
Traceback (most recent call last):
  File "C:\pyguides\shadow_tuple.py", line 5, in <module>
    frozen = tuple(prices)          # calls the variable, not the built-in
             ^^^^^^^^^^^^^
TypeError: 'tuple' object is not callable

In a script, rename the variable, for example to prices or amounts. In a notebook or the REPL, the bad name lives on after you edit the cell, so run del tuple to remove it:

tuple = (10.00, 24.50, 7.25)
del tuple                      # removes your variable; the built-in is visible again

prices = [3.99, 12.00]
frozen = tuple(prices)
print(frozen, type(frozen).__name__)

Output:

(3.99, 12.0) tuple

The same trap applies to list, str, sum and other built-ins. I’ve collected the naming rules in my guide to Python variables.

Cause 4: Reusing a function’s name for the tuple it returns

This one hides well in longer scripts. A function returns a tuple, and you store the result under the function’s own name. The first call works, every call after that fails:

def get_location():
    return ("Denver", "CO")

get_location = get_location()   # the name now holds the returned tuple
print(get_location)

print(get_location())           # second call fails

Output:

('Denver', 'CO')
Traceback (most recent call last):
  File "C:\pyguides\location.py", line 7, in <module>
    print(get_location())           # second call fails
          ^^^^^^^^^^^^^^
TypeError: 'tuple' object is not callable

Give the result its own name, like location = get_location(), and keep the function name for the function. Returning several values this way is explained in returning a tuple in Python, and splitting them into variables in unpacking a tuple in Python.

Cause 5: Calling .shape() on a pandas DataFrame or NumPy array

Data folks hit this one constantly. .shape on a DataFrame, Series or NumPy array is an attribute that already holds a tuple, like (3, 2). Adding () calls that tuple:

import pandas as pd

sales = pd.DataFrame({"region": ["East", "West", "South"],
                      "revenue": [1250.00, 980.50, 1430.75]})
print(type(sales.shape), sales.shape)
rows, cols = sales.shape       # attribute, no parentheses
print(f"{rows} rows, {cols} columns")

print(sales.shape())           # calling the tuple

Output:

<class 'tuple'> (3, 2)
3 rows, 2 columns
Traceback (most recent call last):
  File "C:\pyguides\df_shape.py", line 9, in <module>
    print(sales.shape())           # calling the tuple
          ^^^^^^^^^^^^^
TypeError: 'tuple' object is not callable

Drop the parentheses: df.shape, df.shape[0] for rows and arr.shape for arrays. The same goes for .size, which is a number, not a method.

Cause 6: Calling a @property that returns a tuple

A method marked with @property runs automatically when you read it. So obj.coordinates already gives you the tuple, and obj.coordinates() tries to call the result:

class Warehouse:
    def __init__(self, lat, lon):
        self._lat, self._lon = lat, lon

    @property
    def coordinates(self):
        return (self._lat, self._lon)

dallas = Warehouse(32.78, -96.80)
print(dallas.coordinates)       # property: read it like an attribute
print(dallas.coordinates())     # extra () calls the returned tuple

Output:

(32.78, -96.8)
Traceback (most recent call last):
  File "C:\pyguides\warehouse.py", line 11, in <module>
    print(dallas.coordinates())     # extra () calls the returned tuple
          ^^^^^^^^^^^^^^^^^^^^
TypeError: 'tuple' object is not callable

Remove the parentheses where you read the property. If you’d rather call it, delete the @property line so it’s a normal method. Decorators like this are explained in Python class decorators with examples.

How do I find which name is a tuple?

When the line has several calls, print type() or callable() for each suspect right before it. callable() returns True only for things you can call, which I cover in the Python callable() function:

store = ("Austin", "TX", 78701)
helpers = [store, len, str.upper, print]

for obj in helpers:
    name = getattr(obj, "__name__", repr(obj))
    print(f"{name:<26} {type(obj).__name__:<27} callable: {callable(obj)}")

Output:

('Austin', 'TX', 78701)    tuple                       callable: False
len                        builtin_function_or_method  callable: True
upper                      method_descriptor           callable: True
print                      builtin_function_or_method  callable: True

The tuple is the only entry that reports False. In VS Code or PyCharm, hovering over the name shows the same thing without changing any code.

Causes and fixes for the tuple not callable error at a glance

Cause	Broken code	Fix
Parentheses for indexing	t(0)	t[0]
Missing comma	[(1, 2) (3, 4)]	[(1, 2), (3, 4)]
Shadowed buil