Fix Python TypeError: 'str' object is not callable

The Error

Your script just died at 2 AM with this:

TypeError: 'str' object is not callable

The traceback points to a line that looks completely fine. The real culprit is usually one level above — something you named wrong earlier in the file.

What Actually Triggers This

Python throws this when you put () after something that's a string, not a function. Three scenarios cover 95% of cases:

1. You Shadowed a Built-in

str = "some value"  # You named your variable 'str'
result = str(123)   # Python now thinks str is your string, not the built-in
# TypeError: 'str' object is not callable

2. You Called a String Variable as a Function

formatter = "Hello, {}"
output = formatter("world")  # formatter is a string, not a function
# TypeError: 'str' object is not callable

3. A Class Attribute Shadows a Method

class Report:
    def __init__(self):
        self.generate = "pending"  # This overwrites the method below

    def generate(self):
        return "report data"

r = Report()
r.generate()  # TypeError: 'str' object is not callable

Quick Diagnosis

Drop these two lines right before the crashing line:

print(type(your_variable))     # <class 'str'> = that's your culprit
print(callable(your_variable)) # False = not callable

Or step through it with the debugger:

import pdb; pdb.set_trace()
# In the prompt: print(type(the_thing_you_called))

Fix 1: Rename the Shadowed Variable

Python built-ins are not reserved keywords. Python won't stop you from naming a variable str or list — it just silently breaks anything that relied on the real built-in.

Broken:

str = "my string value"
num = 42
result = str(num)  # Crashes — str is now your variable

Fixed:

my_str = "my string value"
num = 42
result = str(num)  # Works — str() is the built-in again

Watch out for other built-ins you might innocently reuse: list, dict, id, input, print, type, format, filter, map. All of them are legal variable names. None of them should be.

Recover a Shadowed Built-in Mid-Session

Already in an interactive shell after running str = "something"? Delete the variable:

del str      # Remove your variable
str(123)     # '123' — the built-in is restored

Fix 2: Use .format() or an f-string Instead of Calling

String templates don't get called — they use .format() or an f-string.

Broken:

greeting = "Hello, {}"
message = greeting("Alice")  # TypeError

Fixed:

# Option 1: .format()
message = greeting.format("Alice")

# Option 2: f-string (cleaner)
name = "Alice"
message = f"Hello, {name}"

Was it supposed to be a real function all along? Define it properly:

def greeting(name):
    return f"Hello, {name}"

message = greeting("Alice")  # Works

Fix 3: Rename the Conflicting Class Attribute

Assigning self.generate = "pending" in __init__ silently replaces the generate method on that instance. Python looks up instance attributes before class methods — so your string wins, and then fails when called.

Broken:

class Report:
    def __init__(self):
        self.generate = "pending"  # Kills the method

    def generate(self):
        return "report data"

Fixed:

class Report:
    def __init__(self):
        self.status = "pending"    # Different name, no collision

    def generate(self):
        return "report data"

r = Report()
r.generate()  # Works

Verify the Fix

Confirm everything is back to normal in the Python shell:

>>> str(42)
'42'
>>> callable(str)
True
>>> callable("some string")
False

Running this inside a module that was already imported? Restart the Python process. The stale variable might still be alive in the module's namespace from the previous import.

Stop This From Happening Again

Install a linter. Both pylint and flake8 catch built-in shadowing before it ever reaches production:

pip install pylint
pylint your_script.py
# W0622: Redefining built-in 'str' (redefined-builtin)

VS Code with Pylance and PyCharm both highlight these conflicts inline as you type. Set them up once — you'll catch this class of bug in seconds, not at 2 AM.

• pylint: warns W0622 redefined-builtin
• flake8 + flake8-builtins: warns A001 variable is shadowing a Python builtin
• Pyright / Pylance: underlines the conflicting name in the editor

Almost always a naming collision. Find what you named the same as a function, rename it, and the TypeError: 'str' object is not callable disappears.