How to Fix: TypeError: ‘list’ object is not callable

This TypeError list not callable means: “You are trying to use a list as if it were a function.”

A “callable” is anything you can put parentheses () after, like print() or my_function(). A list, like [1, 2, 3], is just a container for data.

# WRONG — () calls a function, [] accesses a list item
my_list = [10, 20, 30]
print(my_list(0))         # TypeError: 'list' object is not callable

# WRONG — 'list' is now your list [1, 2, 3], not the built-in
list = [1, 2, 3]          # list built-in silently overwritten
my_tuple = (4, 5, 6)
new_list = list(my_tuple) # TypeError: 'list' object is not callable

# RIGHT — [] for index access, () only for function calls
print(my_list[0])         # Output: 10

# RIGHT — never use built-in names as variable names
my_list = [1, 2, 3]       # safe name — list built-in stays intact
my_tuple = (4, 5, 6)
new_list = list(my_tuple) # works — list() converts the tuple

# RIGHT — restore the built-in in the same session if overwrite already happened
del list                   # removes local variable, restores built-in
new_list = list(my_tuple) # works again

Cause 1: Accidental Parentheses (The Typo)

You meant to use square brackets [] to get an item, but you typed parentheses () instead.

Problem Code:

my_list = [10, 20, 30]
print(my_list(0)) # CRASH!
# Python thinks you are trying to "call" the list

The Fix: Use square brackets [] to access items by their index.

my_list = [10, 20, 30]
print(my_list[0]) # Correct! Output: 10

Cause 2: Overwriting a Built-in Function (The Real Culprit)

This is the most common and confusing cause. You created a variable and accidentally named it list.

Problem Code:

# This line is the problem!
# You overwrite the built-in list() function
list = [1, 2, 3]

# ... later in your code ...

# You try to use the *real* list() function
# to convert a tuple into a list
my_tuple = (4, 5, 6)
new_list = list(my_tuple)
# CRASH! TypeError: 'list' object ([1, 2, 3]) is not callable

The Fix: NEVER use built-in function names as variable names. Rename your list variable to something safe, like my_list.

my_list = [1, 2, 3] # Safe!

my_tuple = (4, 5, 6)
new_list = list(my_tuple) # Works perfectly

Other names to avoid: sum, str, dict, int, min, max.

TypeError: ‘list’ object is not callable — Two Causes, One Naming Rule That Prevents Both Permanently

TypeError: ‘list’ object is not callable fires when Python sees () after a variable that holds a list. Python checks the object before executing the call — lists have no call() method, so Python stops immediately.

Two causes produce this error. Identify yours in 30 seconds.

Parentheses where brackets belong. my_list(0) attempts to call my_list as a function. my_list[0] accesses the item at index 0. The characters look similar under pressure. If the crash line accesses a list item — switch every () to [].

The list built-in overwritten with a list variable. Python’s built-in namespace has no protection. Name a variable list and Python replaces the list() conversion function with that variable in your local scope. Every subsequent call to list() — to convert a tuple, a set, a generator, or a range — crashes with TypeError: ‘list’ object is not callable. The same trap exists for every other built-in: tuple, dict, set, str, int, float, len, sum, max, min, sorted, reversed, print, input.

The full list of names to never use as variable names:

list, tuple, dict, set, str, int, float, bool,
len, sum, max, min, abs, round, sorted, reversed,
print, input, open, type, id, zip, map, filter, enumerate

Your editor flags these in a distinct colour as built-in names. If the variable name you’re assigning to is highlighted as a built-in, rename it before you write another line.

If the overwrite already happened and you need the built-in back without restarting:

del list # removes the local variable
new_list = list((4, 5, 6)) # built-in list() works again