Fix TypeError: 'tuple' Object Is Not Callable

TypeError: 'tuple' object is not callable means Python found parentheses after a tuple object. Parentheses are call syntax, so the expression before them must be a function, class, method, or another callable object. A tuple is a sequence of values, not a function. The usual repairs are to use square brackets for indexing, add a missing comma between tuple rows, or stop a tuple from overwriting a function name.

Contents

Quick answer

Inspect the object immediately before (). If it is a tuple, change items(0) to items[0]. If the traceback is inside a list literal, look for adjacent tuple rows without a comma. If the name used to be a function, search earlier assignments for a tuple that replaced it.

The error is about the operation, not necessarily about the tuple data. Tuples can be indexed, sliced, unpacked, iterated, and compared. They cannot be called. Python’s references for tuple objects, call expressions, and the callable() helper make that distinction explicit.

Three Python tuple object is not callable causes with corrected indexing comma and function-name examples — Use call syntax for callables, square brackets for tuple items, and commas between adjacent tuple rows.

Reproduce the error

A tuple is valid data in this example. The invalid part is using function-call parentheses to request an item.

pair = ("python", 3)

try:
    print(pair(0))
except TypeError as error:
    print(type(error).__name__)
    print(error)

Python evaluates pair(0) as a call to the object stored in pair. Since that object is a tuple, the interpreter raises the exact TypeError. The number 0 is not the issue; the brackets are.

Python Pool infographic showing tuple value, parentheses call syntax, TypeError, and callable expectation — The name before parentheses refers to a tuple, not a function or other callable object.

Use square brackets for tuple access

Use subscription syntax when you want an item by position. Tuple indexes start at zero, just like list and string indexes.

pair = ("python", 3)

name = pair[0]
version = pair[1]

print(name)
print(version)

For a dynamic position, keep the index inside brackets: pair[index]. If the tuple has a known small shape, unpacking can make the intent clearer and remove repeated numeric indexes.

record = ("Ada", "admin", True)
name, role, active = record

print(name)
print(role)
print(active)

Do not replace brackets with parentheses just because both forms contain a number. Brackets select from a container; parentheses call a callable or group an expression.

Check for a missing comma

A missing comma between tuple rows can produce the same error. Python may interpret the second parenthesized row as an argument to the first tuple.

import warnings

source = """steps = [
    ("load", 2)
    ("save", 4)
]"""

with warnings.catch_warnings():
    warnings.simplefilter("ignore", SyntaxWarning)
    compiled = compile(source, "", "exec")

try:
    exec(compiled, {})
except TypeError as error:
    print(type(error).__name__)
    print(error)

The intended data looks like two rows, but the missing comma leaves Python with an expression equivalent to ("load", 2)("save", 4). The first tuple becomes the call target. A traceback often points near the second row, so inspect the line immediately above it too.

Python Pool infographic comparing tuple, brackets, index, selected item, and incorrect call syntax — Use square brackets for tuple indexing and parentheses only when invoking a callable.

Add the comma between rows

The repair is to separate each tuple with a comma. A trailing comma on the last row is also useful when the data is formatted vertically.

steps = [
    ("load", 2),
    ("save", 4),
]

for action, seconds in steps:
    print(action, seconds)

This mistake is common in test parameters, coordinates, menu definitions, and lookup tables. Formatters and linters can make the missing separator easier to spot, but understanding the parse explains why the runtime says a tuple is not callable.

Do not overwrite a function name

Python names can be rebound. If a function name is later assigned a tuple, code that still calls that name will fail even though the function definition itself is correct.

def get_score():
    return 91

get_score = ("cached", 91)

try:
    print(get_score())
except TypeError as error:
    print(error)

Keep callable names and data names distinct. A name such as get_score should continue to refer to the function, while a tuple can use a name such as score_record. In a notebook, restart or clear the kernel after renaming so an old binding does not survive.

Python Pool infographic showing function name, tuple reassignment, later call, and shadowing error — Reassigning a callable name to a tuple removes the function from that scope.

Inspect the call target

When the traceback is complicated, test the type of the expression before the parentheses. callable() is a quick diagnostic, not a replacement for understanding the intended operation.

def make_pair():
    return ("python", 3)

pair = ("python", 3)

print(type(pair).__name__, callable(pair))
print(type(make_pair).__name__, callable(make_pair))
print(make_pair()[0])

The tuple reports False, while the function reports True. The last line calls the function first, receives a tuple, and then indexes that result with brackets. That order is valid.

Debugging checklist

Read the traceback and mark the expression immediately before ().
Print its type and check whether it is callable.
Search upward for a tuple assignment or a missing comma.
Use brackets for item access, or rename data that shadowed a function.

Do not remove every tuple from the file. The goal is to match syntax to intent: () for calling, [] for subscription, and commas for separating neighboring values. Once the call target is corrected, the TypeError disappears without special exception handling.

Python Pool infographic testing type, commas, brackets, parentheses, scope, and validation — Check tuple construction commas, access syntax, scope assignments, and the exact value at the traceback line.

Read the traceback in context

The highlighted line is where Python attempted the call, but the wrong value may have been created much earlier. Trace the variable backward through assignments, function returns, unpacking, and loop updates. A value that starts as a function can become a tuple after one branch reuses the same name.

When the error occurs in a comprehension or a long expression, split the expression into named steps. Print the intermediate type, then decide whether the next operation should be a call or a subscription. This small refactor often exposes a missing comma or shadowed name faster than adding a broad exception handler.

Keep data shapes explicit

Type hints can document whether a function returns a tuple and what its positions mean. Named tuples or dataclasses can make a multi-field result easier to read, but they still must be accessed according to their API. A clearer data shape reduces the chance that a reader will mistake a returned record for a callable.

For tuple-related mistakes, compare the Pandas tuple-key error guide with sorting lists of tuples. Read solved key of type tuple not found and not a multiindex and python sort list of tuples for the related workflow.