Why does code like `str = str(…)` cause a TypeError, but only the second time?

While not in your code, another hard-to-spot error is when the % character is missing in an attempt of string formatting:

"foo %s bar %s coffee"("blah","asdf")

but it should be:

"foo %s bar %s coffee"%("blah","asdf")

The missing % would result in the same TypeError: 'str' object is not callable.

In my case I had a class that had a method and a string property of the same name, I was trying to call the method but was getting the string property.

Another case of this: Messing with the __repr__ function of an object where a format() call fails non-transparently.

In our case, we used a @property decorator on the __repr__ and passed that object to a format(). The @property decorator causes the __repr__ object to be turned into a string, which then results in the str object is not callable error.

I had the same error. In my case wasn’t because of a variable named str. But because I named a function with a str parameter and the variable the same.

same_name = same_name(var_name: str)

I run it in a loop. The first time it run ok. The second time I got this error. Renaming the variable to a name different from the function name fixed this. So I think it’s because Python once associate a function name in a scope, the second time tries to associate the left part (same_name =) as a call to the function and detects that the str parameter is not present, so it’s missing, then it throws that error.

In my case, I had a Class with a method in it. The method did not have ‘self’ as the first parameter and the error was being thrown when I made a call to the method. Once I added ‘self,’ to the method’s parameter list, it was fine.

You can get this error if you have variable str and trying to call str() function.

This problem can be caused by code like:

"Foo" ("Bar" if bar else "Baz")

You can concatenate string literals by putting them next to each other, like "Foo" "Bar". However, because of the open parenthesis, the code was interpreted as an attempt to call the string "Foo" as if it were a function.

it could be also you are trying to index in the wrong way:

a = 'apple'
a(3) ===> 'str' object is not callable

a[3] = l

This error can also occur as a result of trying to call a property (as though it were a function):

class Example:
    @property
    def value():
        return 'test'

e = Example()
print(e.value()) # should just be `e.value` to get the string

Check your input parameters, and make sure you don’t have one named type. If so then you will have a clash and get this error.

Note that TypeError: 'str' object is not callable means only that there is an attempt to call (i.e., use function-call syntax) a string (i.e., any name that previously had a string assigned to it). Using any other built-in method as variable name can cause the exact same error message.

Whenever that happens, just issue the following ( it was also posted above)

>>> del str

That should fix it.

str = 'Hello World String'    
print(str(10)+' Good day!!')

Even I faced this issue with the above code as we are shadowing str() function.

Solution is:

string1 = 'Hello World String'
print(str(10)+' Good day!!')

I realize this is not a runtime warning, but PyCharm gave me this similarly-worded IDE warning:

if hasattr(w, 'to_json'):
    return w.to_json()
    # warning, 'str' object is not callable

This was because the IDE assumed w.to_json was a string. The solution was to add a callable() check:

if hasattr(w, 'to_json') and callable(w.to_json):
    return w.to_json()

Then the warning went away. This same check may also prevent the runtime exception in the original question.

it is recommended not to use str int list etc.. as variable names, even though python will allow it.
this is because it might create such accidents when trying to access reserved keywords that are named the same

FWIW I just hit this on a slightly different use case. I scoured and scoured my code looking for where I might’ve used a ‘str’ variable, but could not find it. I started to suspect that maybe one of the modules I imported was the culprit… but alas, it was a missing ‘%’ character in a formatted print statement.

Here’s an example:

x=5
y=6
print("x as a string is: %s.  y as a string is: %s" (str(x) , str(y)) )

This will result in the output:

   TypeError: 'str' object is not callable

The correction is:

x=5
y=6
print("x as a string is: %s.  y as a string is: %s" % (str(x) , str(y)) )

Resulting in our expected output:

x as a string is: 5. y as a string is: 6

This error could also occur with code like:

class Shape:
    def __init__(self, colour):
        self.colour = colour
    def colour(self):
        print("colour:", self.colour)

myShape = Shape("pink")
myShape.colour()

In the __init__ method, we assign an attribute colour, which has the same name as the method colour. When we later attempt to call the method, the instance’s attribute is looked up instead. myShape.colour is the string "pink", which is not callable.

To fix this, change either the method name or the variable name.

I also got this error.
For me it was just a typo:

I wrote:

driver.find_element_by_id("swal2-content").text()

while it should have been:

driver.find_element_by_id("swal2-content").text

It also give same error if math library not imported,

import math