TypeError: 'list' object is not callable means Python found a list where your code tried to call something with parentheses. In practice, the error usually comes from one of two mistakes: a variable named list shadows Python’s built-in list() constructor, or code uses parentheses instead of square brackets to access a list item.
Quick Fix
Check the line in the traceback where the error is raised. If the code looks like items(0), change it to items[0]. If the code tries to call list(...) after assigning a variable named list, rename the variable and rerun the program from a clean interpreter session.
items = ["Python", "NumPy", "Pandas"]
# Wrong: parentheses call the object.
# first = items(0)
# Right: square brackets index the list.
first = items[0]
print(first)
Python lists are documented as built-in sequence types in the official list documentation. They support indexing, slicing, appending, popping, and iteration, but a normal list is not a function.
Cause 1: Naming a Variable list
The name list is also Python’s built-in constructor for creating lists. The official list() documentation lists it with the built-in functions and types. If you reuse that name for your own variable, later calls to list() will try to call your variable instead of the built-in constructor.
text = "Python"
list = ["already", "a", "list"]
# This raises: TypeError: 'list' object is not callable
letters = list(text)
print(letters)
The fix is simple: choose a descriptive variable name such as items, names, rows, or letters. If you made this mistake in a notebook or REPL, restart the kernel or delete the shadowing name before testing again.
text = "Python"
items = ["already", "a", "list"]
letters = list(text)
print(items)
print(letters)
Using clear names also makes list operations easier to read. For related list basics, see Python list length, list pop, and checking whether a list is empty.
Cause 2: Using Parentheses for Indexing
Parentheses call a callable object. Square brackets access an item by index. The Python data model explains callable behavior through __call__; built-in list instances do not become callable just because they contain data.
scores = [91, 84, 76]
# Wrong: scores(1)
second_score = scores[1]
last_score = scores[-1]
print(second_score)
print(last_score)
If the index is wrong, Python raises a different error: IndexError. Our guide to Python list index out of range covers that case separately.
Cause 3: Replacing a Function with a List
This error can also happen when a function name is reassigned to a list. The first call works while the name still points to a function. After reassignment, the same name points to a list, so the next call fails.
def get_names():
return ["Ada", "Grace", "Linus"]
names = get_names()
get_names = names
# This now raises: TypeError: 'list' object is not callable
again = get_names()
Avoid reusing function names for results. Use names that describe the type or meaning of the value, such as names for a list and get_names for the function that returns it.
Debug with type() and callable()
When the traceback is not obvious, print the object type and check whether Python considers it callable. The official callable() documentation says it returns whether an object appears callable. It is a quick way to confirm that the name you are about to call still points to a function, class, or callable instance.
items = [1, 2, 3]
print(type(items))
print(callable(items))
print(callable(len))
If callable(items) is False, do not use items(). Use indexing, iteration, or a list method instead. For more detail on callability, see our Python callable guide.
Find the Shadowed Name in Larger Code
In a larger file, start from the traceback line and search upward for the same name on the left side of an assignment. Look for patterns such as list =, items =, or a function name being reused for a result. In notebooks, also inspect earlier cells because old variables remain in memory until the kernel is restarted.
If the object comes from another function, print it before the failing call. A quick print(type(value), callable(value)) usually tells you whether the value is still a function or has already become a list. This is faster than guessing at every list in the program.
Checklist to Fix the Error
- Search for assignments such as
list = ...and rename them. - Replace
my_list(index)withmy_list[index]. - Restart notebooks after renaming a shadowed built-in.
- Use
type(name)andcallable(name)when the traceback points to a confusing name. - Keep function names and result variable names different.
The same pattern can affect other built-ins and types too. If you are seeing a similar message for strings, read TypeError: ‘str’ object is not callable. If your list is involved in hashing or set operations, see unhashable type: list. For output cleanup, the guide on removing brackets from a list may also help.
Summary
TypeError is raised when an operation is applied to an object of an inappropriate type. In this case, the inappropriate operation is calling a list. Rename variables that shadow list(), use square brackets for indexing, and check suspicious names with callable(). Those three steps fix the vast majority of 'list' object is not callable errors.