Typeerror float object is not callable как исправить

Have you ever seen the TypeError object is not callable when running one of your Python programs? We will find out together why it occurs.

The TypeError object is not callable is raised by the Python interpreter when an object that is not callable gets called using parentheses. This can occur, for example, if by mistake you try to access elements of a list by using parentheses instead of square brackets.

I will show you some scenarios where this exception occurs and also what you have to do to fix this error.

Let’s find the error!

What Does Object is Not Callable Mean?

To understand what “object is not callable” means we first have understand what is a callable in Python.

As the word callable says, a callable object is an object that can be called. To verify if an object is callable you can use the callable() built-in function and pass an object to it. If this function returns True the object is callable, if it returns False the object is not callable.

callable(object)

Let’s test this function with few Python objects…

Lists are not callable

>>> numbers = [1, 2, 3]
>>> callable(numbers)
False

Tuples are not callable

>>> numbers = (1, 2, 3)
>>> callable(numbers)
False

Lambdas are callable

>>> callable(lambda x: x+1)
True

Functions are callable

>>> def calculate_sum(x, y):
...     return x+y
... 
>>> callable(calculate_sum)
True

A pattern is becoming obvious, functions are callable objects while data types are not. And this makes sense considering that we “call” functions in our code all the time.

What Does TypeError: ‘int’ object is not callable Mean?

In the same way we have done before, let’s verify if integers are callable by using the callable() built-in function.

>>> number = 10
>>> callable(number)
False

As expected integers are not callable 🙂

So, in what kind of scenario can this error occur with integers?

Create a class called Person. This class has a single integer attribute called age.

class Person:
    def __init__(self, age):
        self.age = age

Now, create an object of type Person:

john = Person(25)

Below you can see the only attribute of the object:

print(john.__dict__)
{'age': 25}

Let’s say we want to access the value of John’s age.

For some reason the class does not provide a getter so we try to access the age attribute.

>>> print(john.age())
Traceback (most recent call last):
  File "callable.py", line 6, in <module>
    print(john.age())
TypeError: 'int' object is not callable

The Python interpreter raises the TypeError exception object is not callable.

Can you see why?

That’s because we have tried to access the age attribute with parentheses.

The TypeError‘int’ object is not callable occurs when in the code you try to access an integer by using parentheses. Parentheses can only be used with callable objects like functions.

What Does TypeError: ‘float’ object is not callable Mean?

The Python math library allows to retrieve the value of Pi by using the constant math.pi.

I want to write a simple if else statement that verifies if a number is smaller or bigger than Pi.

import math

number = float(input("Please insert a number: "))

if number < math.pi():
    print("The number is smaller than Pi")
else:
    print("The number is bigger than Pi")

Let’s execute the program:

Please insert a number: 4
Traceback (most recent call last):
  File "callable.py", line 12, in <module>
    if number < math.pi():
TypeError: 'float' object is not callable

Interesting, something in the if condition is causing the error ‘float’ object is not callable.

Why?!?

That’s because math.pi is a float and to access it we don’t need parentheses. Parentheses are only required for callable objects and float objects are not callable.

>>> callable(4.0)
False

The TypeError‘float’ object is not callable is raised by the Python interpreter if you access a float number with parentheses. Parentheses can only be used with callable objects.

What is the Meaning of TypeError: ‘str’ object is not callable?

The Python sys module allows to get the version of your Python interpreter.

Let’s see how…

>>> import sys
>>> print(sys.version())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable

No way, theobject is not callable error again!

Why?

To understand why check the official Python documentation for sys.version.

That’s why!

We have added parentheses at the end of sys.version but this object is a string and a string is not callable.

>>> callable("Python")
False

The TypeError‘str’ object is not callable occurs when you access a string by using parentheses. Parentheses are only applicable to callable objects like functions.

Error ‘list’ object is not callable when working with a List

Define the following list of cities:

>>> cities = ['Paris', 'Rome', 'Warsaw', 'New York']

Now access the first element in this list:

>>> print(cities(0))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'list' object is not callable

What happened?!?

By mistake I have used parentheses to access the first element of the list.

To access an element of a list the name of the list has to be followed by square brackets. Within square brackets you specify the index of the element to access.

So, the problem here is that instead of using square brackets I have used parentheses.

Let’s fix our code:

>>> print(cities[0])
Paris

Nice, it works fine now.

The TypeError‘list’ object is not callable occurs when you access an item of a list by using parentheses. Parentheses are only applicable to callable objects like functions. To access elements in a list you have to use square brackets instead.

Error ‘list’ object is not callable with a List Comprehension

When working with list comprehensions you might have also seen the “object is not callable” error.

This is a potential scenario when this could happen.

I have created a list of lists variable called matrix and I want to double every number in the matrix.

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> [[2*row(index) for index in range(len(row))] for row in matrix]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <listcomp>
  File "<stdin>", line 1, in <listcomp>
TypeError: 'list' object is not callable

This error is more difficult to spot when working with list comprehensions as opposed as when working with lists.

That’s because a list comprehension is written on a single line and includes multiple parentheses and square brackets.

If you look at the code closely you will notice that the issue is caused by the fact that in row(index) we are using parentheses instead of square brackets.

This is the correct code:

>>> [[2*row[index] for index in range(len(row))] for row in matrix]
[[2, 4, 6], [8, 10, 12], [14, 16, 18]]

Conclusion

Now that we went through few scenarios in which the errorobject is not callable can occur you should be able to fix it quickly if it occurs in your programs.

I hope this article has helped you save some time! 🙂

Sign Up for Our Newsletters

Subscribe to get notified of the latest articles. We will never spam you. Be a part of our ever-growing community.

By checking this box, you confirm that you have read and are agreeing to our terms of use regarding the storage of the data submitted through this form.

Floating-point values are not callable. This is because floating points store numerical values. They are not functions that return a particular value when called. If you try to call a floating-point value as if it were a function, you encounter a “TypeError: ‘float’ object is not callable” error.

In this guide, we discuss how this error works and why you may find it in your code. We walk through an example scenario to help you learn how to fix it.

TypeError: ‘float’ object is not callable

A set of parentheses denotes a function call. A function call instructs the contents of a function to run. Only functions can be called. Other values, like floating points, do not return values, and so they cannot be called.

The “TypeError: ‘float’ object is not callable” error happens if you follow a floating point value with parenthesis. This can happen if:

• You have named a variable “float” and try to use the float() function later in your code.
• You forget an operand in a mathematical problem.

Let’s look at both of these potential scenarios in detail.

Scenario #1: Naming a Variable “float”

Let’s write a program that calculates the tips each member of the wait staff at a restaurant are due. The restaurant splits all the tips equally.

We start by asking the user to tell the program how much was received in tips and how many staff members were working on a particular day using the input() method:

staff_working = input("How many staff were working today? ")
float = float(input("How much was earned in tips? "))

Next, we write a math equation that calculates how much each member of the wait staff is due in tips:

staff_due = float / float(staff_working)
rounded = round(staff_due, 2)

print(rounded)

We round the amount that each staff member is due to two decimal places so that we have a monetary value that we can give to each staff member in tips. We print this rounded amount to the console. Next, run our code and see what happens:

How many staff were working today? 7
How much was earned in tips? 300
Traceback (most recent call last):
  File "main.py", line 5, in <module>
	rounded = round(staff_due, 2)
TypeError: 'float' object is not callable

Our code returns an error. This is because we have assigned a floating point value to a variable called “float”. Later in our code, we try to use the float() function to convert a value to a float. Because we have assigned “float” a numerical value, our code cannot call the float() function.

To solve this problem, we need to rename our “float” variable:

staff_working = input("How many staff were working today? ")
earned_in_tips = float(input("How much was earned in tips?"))

staff_due = earned_in_tips / float(staff_working)
rounded = round(staff_due, 2)

print(rounded)

We have renamed the variable “float” to “earned_in_tips”. Let’s run our code:

How many staff were working today? 7
How much was earned in tips? 300
42.86

Our code runs successfully. Each member of the wait staff is due $42.86 in tips.

Scenario #2: Missing Mathematical Operator

The cause of the “TypeError: ‘float’ object is not callable” error can often be down to a missing mathematical operator.

The restaurant is offering a bonus program where the restaurant applies a 5% increase to all the tips earned in a day. This means that the wait staff will earn more money at the end of the day, depending on how much in tips they collect.

To account for this increase, we need to revise our formula for calculating the tips due to be given to the staff members:

staff_working = input("How many staff were working today? ")
earned_in_tips = float(input("How much was earned in tips? "))

staff_due = 1.05 (earned_in_tips / float(staff_working))
rounded = round(staff_due, 2)

print(rounded)

Our code calculates the amount each staff member is due by dividing how much is earned in tips by the number of staff working. We multiply this by 1.05 to calculate a 5% increase in the total tips due for each staff member. Let’s run our code:

How many staff were working today? 7
How much was earned in tips? 300
Traceback (most recent call last):
  File "main.py", line 4, in <module>
	staff_due = 1.05 (earned_in_tips / float(staff_working))
TypeError: 'float' object is not callable

We encounter an error. This is because we have forgotten a mathematical operator in our code. 1.05 is followed immediately by a set of parenthesis. Python treats this as a function call on the 1.05 value. Our “staff_due” formula should include a multiplication sign (*):

staff_due = 1.05 * (earned_in_tips / float(staff_working))

Our new code separates the 1.05 value and the result of our math equation in brackets with a multiplication sign. Let’s run our code:

How many staff were working today? 7
How much was earned in tips? 300
45.0

Each member of the wait staff is entitled to $45.00 from the tip pot. This includes the 5% bonus the restaurant is offering its staff.

Conclusion

The “TypeError: ‘float’ object is not callable” error is raised when you try to call a floating-point number as a function.

You can solve this problem by ensuring that you do not name any variables “float” before you use the float() function. If that does not solve the problem, make sure that your code includes all the right mathematical operands.

Now you’re ready to solve this common Python error like a pro!

✋ Update: This post was originally published on my blog decodingweb.dev, where you can read the latest version for a 💯 user experience. ~reza

The “TypeError: ‘float’ object is not callable” error occurs when you try to call a floating-point number (float object) as if it was a function!

Here’s what the error looks like:

Traceback (most recent call last):
  File "/dwd/sandbox/test.py", line 8, in 
    sum += sum(values) # we're calling 88.6()
           ^^^^^^^^^^^
TypeError: 'float' object is not callable

Calling a floating-point number as if it’s a callable isn’t what you’d do on purpose, though. It usually happens due to a wrong syntax or overriding a function name with a floating-point number.

Let’s explore the common causes and their solutions.

How to fix TypeError: ‘float’ object is not callable?

This TypeError happens under various scenarios:

1. Declaring a variable with a name that’s also the name of a function
2. Calling a method that’s also the name of a property
3. Calling a method decorated with @property
4. Missing a mathematical operator after a floating-point number

Declaring a variable with a name that’s also the name of a function: A Python function is an object like any other built-in object, such as int, float, dict, list, etc.

All built-in functions are defined in the builtins module and assigned a global name for easier access. For instance, sum() refers to the __builtins__.sum() function.

That said, overriding a function (accidentally or on purpose) with a floating-point number is technically possible.

For instance, if you define a variable named sum and assign it to the value of 88.6, it’ll no longer point to __builtins__.sum().

values = [34, 43.5, 2, 8.1, 1]

sum = sum(values) # ⚠️ The value of sum is 88.6 from now on 
# it's no longer pointing the built-in function sum

values = [34, 12]
# ⛔ Raises TypeError: 'float' object is not callable
sum += sum(values) # we're calling 88.6()

If you run the above code, Python will complain with a «TypeError: ‘float’ object is not callable» error because 88.6 (the new value of sum) isn’t callable.

You have two ways to fix the issue:

1. Rename the variable sum
2. Explicitly access the sum function from the builtins module (__bultins__.sum)

The second approach isn’t recommended unless you’re developing a module. For instance, if you want to implement an open() function that wraps the built-in open():

# Custom open() function using the built-in open() internally
def open(filename):
     # ...
     __builtins__.open(filename, 'w', opener=opener)
     # ...

In almost every other case, you should always avoid naming your variables as existing functions and methods. But if you’ve done so, renaming the variable would solve the issue.

So the above example could be fixed like this:

values = [34, 43.5, 2, 8.1, 1]
sum_of_values = sum(values) 

values = [34, 12]
sum_of_values += sum(values)

print(sum_of_values)
# Output: 134.6

Here’s another example with the built-in max() function:

items = [1, 45, 54, 165.3, 0, 2]
max = max(items) # max = 165.3

# ...

# ⛔ Raises "TypeError: 'float' object is not callable"
print(max(12, max))

And to fix it, we rename the max variable name to max_value:

items = [1, 45, 54, 165.3, 0, 2]
max_value = max(items) # max = 165.3

# ...

print(max(12, max_value))
# Output: 165.3

Another common reason is accidentally overriding the range() function with a floating-point value before using it in a for loop:

range = 34.5

# some code here

# ⛔ Raises "TypeError: 'float' object is not callable"
for i in range(0, 10):
print(i)

To fix it, we rename the range variable:

range_start = 34.5

# some code here

for i in range(0, 10):
print(i)

⚠️ Long story short, you should never use a function name (built-in or user-defined) for your variables!

Overriding functions (and calling them later on) is the most common cause of this type error. It’s similar to calling integer numbers as if they’re callables.

Now, let’s get to the less common mistakes that lead to this error.

Calling a method that’s also the name of a property: When you define a property in a class constructor, any further declarations of the same name (e.g., methods) will be ignored.

class Book:
    def __init__(self, book_title, book_price):
        self.title = book_title
        self.price = book_price

    def price(self):
        return self.price

book = Book('Head First Python', 49.5)

# ⛔ Raises "TypeError: 'float' object is not callable"
print(book.price())

In the above example, since we have a property named price, the method price() is ignored. As a result, any reference to the price will return the property price. Obviously, calling price() is like calling 49.5(), which raises the type error.

To fix this TypeError, we need to change the method name:

class Book:
    def __init__(self, book_title, book_price):
        self.title = book_title
        self.price = book_price

    def get_price(self):
        return self.price

book = Book('Head First Python', 49.5)

print(book.get_price())
# Output: 49.5

Calling a method decorated with @property decorator: The @property decorator turns a method into a “getter” for a read-only attribute of the same name.

class Book:
    def __init__(self, book_title, book_price):
        self._title = book_title
        self._price = book_price

    @property
    def price(self):
        """Get the book price"""
        return self._price

book = Book('Head First Python', 49.5)

# ⛔ Raises "TypeError: 'float' object is not callable"
print(book.price())

You need to access the getter method without the parentheses:

book = Book('Head First Python', 49.5)

print(book.price)
# Output: 49.5

Missing a mathematical operator after a float variable: In algebra, we can remove the multiplication operator to avoid ambiguity in our expressions. For instance, a × b, can be ab, or a × (b + c) can become a(b + c).

But not in Python!

In the above example, if you remove the multiplication operator in a * (b + c), Python’s interpreter would consider it a function call! And since the value of a is numeric (a floating-point number in this case), it’ll raise the error.

So if you have something like this in your code:

a = 12.5
b = 12
c = 87

# ⛔ raises  TypeError: 'float' object is not callable
result = a (b + c)

You’d have to change it like so:

a = 12.5
b = 12.3
c = 34.7

result = a * (b + c)

print(result)
# Output: 587.5

Problem solved!

Alright, I think it does it! I hope this quick guide helped you fix your problem.

Thanks for reading.

❤️ You might like:

• How to fix «TypeError: ‘float’ object is not callable» in Python
• TypeError: ‘int’ object is not callable in Python (Fixed)
• TypeError: can only concatenate str (not “float”) to str (solutions)
• TypeError: can only concatenate str (not “int”) to str (Solutions)
• TypeError: can only concatenate str (not «bool») to str (Fixed)

Functions can be thought of as reusable code that can be called and used anywhere in the program. We can only call functions in Python.

To call functions, we use the parentheses with the function name. Any arguments or parameters to be provided for the function are specified within these parentheses.

the float object is not callable Error in Python and How to Solve It

This tutorial will discuss Python’s float object is not callable error.

This is a TypeError, which indicates that some invalid operation is associated with a given object. In Python, we can only call functions. This error indicates that a float object is being called.

For example,

Output:

TypeError: 'float' object is not callable

In the above example, we get the error because we created a float variable a and tried to call it. We will now discuss various scenarios where such an error may occur.

In Python, we sometimes perform complex complications and may use parentheses to separate operators and operands. Sometimes, one may pace the parentheses in the wrong position where it may seem to represent a function call statement.

For example,

a = 1.5
b = 5
c = 8*10/5*a(2)*5
print(c)

Output:

TypeError: 'float' object is not callable

We need to be careful of the parentheses and place the operands accordingly to fix this. It is a simple fix for the previous example, as shown below.

a = 1.5
b = 5
c = 8*10/5*(a*2)*5
print(c)

Output:

Let us now discuss another situation. See the code below.

def mul(a,b):
    return a*b

mul = mul(7,4.2)
print(mul)

mul = mul(13,8.2)
print(mul)

Output:

29.400000000000002
TypeError: 'float' object is not callable

In the above example, we created a function and then assigned it to the same name variable twice.

This works for the first call but returns the float object is not callable is caused due to the second function call. This happens because the function gets overridden with the variable name in the second function call statement.

It also has a simple fix. We should change the function’s name or the variable to solve this error.

See the code below.

def mul_cal(a,b):
    return a*b

mul = mul_cal(7,4.2)
print(mul)

mul = mul_cal(13,8.2)
print(mul)

Output: