How to Resolve Python "TypeError: 'bool' object is not callable"

The TypeError: 'bool' object is not callable is a common error in Python indicating that you've attempted to use parentheses () to call something that holds a boolean value (True or False) as if it were a function. Functions and methods are callable, but simple boolean values are not.

This guide explains the common scenarios that lead to this error and provides clear solutions to fix your code.

Understanding the Error: Calling Non-Callables

In Python, parentheses () after a name signify a function or method call. You use them to execute the code within that function/method. A TypeError: '...' object is not callable occurs when the object preceding the parentheses is not something that can be executed, like a simple integer, string, or, in this case, a boolean (True or False).

my_bool_value = True
another_value = False

print(type(my_bool_value)) # Output: <class 'bool'>

try:
    my_bool_value()
except TypeError as e:
    print(e)

try:
    another_value()
except TypeError as e:
    print(e)

You can not execute True or False as if they were functions.

Cause 1: Adding Parentheses to a Boolean Variable

The most straightforward cause is accidentally adding parentheses when you simply meant to check the value of a boolean variable, often within an if statement.

is_logged_in = True

try:
    if is_logged_in():
        print("User is logged in.")
except TypeError as e:
    print(f"Error: {e}")


if is_logged_in:
    print("User is logged in (Correct check).")
else:
    print("User is not logged in (Correct check).")

Cause 2: Calling a Function That Returns a Boolean Twice

If you have a function that returns a boolean, calling it once gives you True or False. Adding a second set of parentheses attempts to call that returned boolean value.

def check_status():
  print("Checking status...")
  return True # This function returns a boolean

try:
    result = check_status()()   
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

result = check_status()                     # Removed the extra pair of parentheses
print(f"Result (Correct call): {result}")   # Output: True
if result:
     print("Status check passed.")

Cause 3: Variable Name Clashing with Function Name

If you define a function and later create a variable with the exact same name, the variable name "shadows" or hides the function name. Subsequent attempts to call the function will actually try to call the variable's value.

def send_message():
  print("Sending message...")
  return True

send_message()

send_message = False # Now 'send_message' refers to False, not the function

try:
    status = send_message()
    print(f"Status: {status}")
except TypeError as e:
    print(f"Error: {e}")

def send_message_func(): # Renamed function (or rename variable below)
  print("Sending message (fixed)...")
  return True

message_sent_status = False # Use a different variable name

status_fixed = send_message_func()
print(f"Status (fixed): {status_fixed}") # Output: True

Use distinct names for variables and functions to avoid these clashes.

Cause 4: Shadowing the Built-in bool Type

Accidentally naming a variable bool overrides Python's built-in bool() type constructor. If you later try to use the actual bool() function (e.g., for type conversion), you'll be trying to call the value you assigned to your variable.

bool = True

try:
    is_non_empty = bool("hello")
    print(is_non_empty)
except TypeError as e:
    print(e)

my_custom_bool = True

is_non_empty_fixed = bool("hello")
print(f"Is 'hello' truthy? {is_non_empty_fixed}") # Output: True

Cause 5: Class Attribute Name Clashing with Method Name

Within a class, if an instance attribute (set in __init__ or directly on the instance) has the same name as a method, accessing that name on an instance will typically retrieve the attribute value first, hiding the method. Trying to call it will result in the error if the attribute holds a boolean.

class User:
    def __init__(self, is_admin):
        self.is_admin = is_admin # Holds True or False

    def is_admin(self):
        print("Method is_admin called!") # This won't be reached easily
        return "Admin Status Method"

user_instance = User(True)
print(f"Attribute value: {user_instance.is_admin}") # Accesses the attribute -> True

try:
    status = user_instance.is_admin()
    print(status)
except TypeError as e:
    print(f"Error: {e}")


class UserFixed:
    def __init__(self, is_admin_flag):
        self.is_admin_flag = is_admin_flag

    def check_admin_status(self):
        print("Method check_admin_status called!")
        return self.is_admin_flag

user_fixed = UserFixed(True)

status_fixed = user_fixed.check_admin_status()
print(f"Status (fixed): {status_fixed}") # Output: True (from the flag)

Use different names for instance attributes and methods within your classes. Prefixing "internal" attributes with an underscore (self._is_admin) is a common convention.

Debugging Tip: Check Variable Types

If you're unsure why the error is happening, print the type of the object you are trying to call right before the line that raises the error:

variable_causing_error = ... # The variable involved in the error

print(f"Type before call: {type(variable_causing_error)}")
try:
    variable_causing_error()
except TypeError as e:
     print(f"Error confirms type issue: {e}")

If the output shows <class 'bool'>, you know you need to apply one of the solutions above.

Conclusion

The TypeError: 'bool' object is not callable arises when you attempt to execute True or False using call parentheses (). The primary solutions involve:

1. Removing unnecessary parentheses when checking a boolean variable's value (if my_bool: instead of if my_bool():).
2. Avoiding double function calls (my_func() instead of my_func()()).
3. Using distinct names for variables and functions to prevent shadowing.
4. Never overriding built-in type names like bool.
5. Using distinct names for class attributes and methods.

By identifying which of these scenarios applies to your code, you can quickly resolve this common Python error.