Python float()

Python float() function is a handy for converting numbers and strings into floating-point numbers. It can handle integers, strings, and special values like infinity and NaN. However, it’s important to handle exceptions like ValueError and OverflowError to ensure your program runs smoothly.
Table of Contents

Understanding Python float() Function

Python float() is a built-in function that converts a number or a string representing a number into a floating-point number. A floating-point number, or simply a float, is a number with a decimal point, like 3.14 or -2.5. If you don’t provide any argument to Python float(), it returns 0.0. If you give a string, the string should be a valid representation of a number, optionally with a decimal point or in scientific notation. This function is essential when you must ensure that a value is treated as a float, which is often necessary for mathematical operations requiring decimal precision.

Syntax of Python float()

float_number = float(x)

Explanation

  • float_number: Variable will store the resulting floating-point number.
  • float(): Built-in function that performs the conversion to a float.
  • x (optional): Number or string you want to convert to a float. It is the input for float() function. If not provided, it defaults to 0.0.

Example of Python float()

float_num = float("3.14")
print(float_num)

Explanation

  • float_num = float("3.14"): Converts the string “3.14” to a float and assigns it to float_num.
  • print(float_num): Prints the value of float_num, which is 3.14.

Output

3.14


float() Parameters

Python float() function accepts one optional parameter: a number (integer or floating-point) or a string representing a number. If you provide a number, float() returns that number as a float. Suppose you give a string, float() attempts to convert it to a float. Still, the string must be a valid numeric representation, optionally including a decimal point or using scientific notation (e.g., “1e3” for 1000). If you don’t provide any parameter, float() returns 0.0 by default.

Syntax

float_value = float(x)

Example

result = float(10)
print(result)

Explanation

  • result = float(10): Converts the integer 10 to a float and assigns it to result.
  • print(result): Prints the value of result, which is 10.0.

Output

10.0


float() Return Type

Python float() function always returns a floating-point number. If you pass it an integer or a string representing an integer, it converts it to a float. If you pass it a string representing a floating-point number, it converts it to a float. If you pass it with no arguments, it returns 0.0. The returned value will always have a decimal point, even if the fractional part is zero.

Syntax

float_number = float(x)

Explanation

  • float_number: Variable will store the floating-point number returned by float().
  • float(): Function returns a float representation of x.
  • x (optional): Number or string to convert to a float. It is the parameter for float(). Defaults to 0.0 if not provided.

Example

float_value = float()
print(float_value)

Explanation

  • float_value = float(): Calls float() with no arguments, so it returns the default value, 0.0, and assigns it to float_value.
  • print(float_value): Prints the value of float_value, which is 0.0.

Output

0.0


float() for infinity and NaN (Not a Number)

Python float() function can also create special floating-point values like infinity and NaN (Not a Number). To represent positive infinity, you can pass the string “inf” or “infinity” (case-insensitive) to float(). For negative infinity, use “-inf” or “-infinity”. You can pass the string “nan” (case-insensitive) to represent NaN. These values are often used in numerical computations to represent undefined or unrepresentable values.

Syntax

float_representation = float(special_string)

Explanation

  • float_representation: Variable will store the special float value.
  • float(): Function converts the special_string to a float.
  • special_string: String representing infinity (“inf”, “infinity”) or NaN (“nan”), case-insensitive, optionally preceded by a sign. It is the input for float().

Example

pos_infinity = float("inf")
neg_infinity = float("-Infinity")
not_a_number = float("nan")

print(pos_infinity)
print(neg_infinity)
print(not_a_number)

Explanation

  • pos_infinity = float("inf"): Creates a float representing positive infinity and assigns it to pos_infinity.
  • neg_infinity = float("-Infinity"): Creates a float representing negative infinity and assigns it to neg_infinity.
  • not_a_number = float("nan"): Creates a float representing NaN (Not a Number) and assigns it to not_a_number.
  • print(pos_infinity): Prints the value of pos_infinity.
  • print(neg_infinity): Prints the value of neg_infinity.
  • print(not_a_number): Prints the value of not_a_number.

Output

inf
-inf
nan


Integer Datatype with Python float()

Passing an integer to the Python float() function converts the integer into its floating-point representation. This means it adds a decimal point and a zero at the end of the integer. For example, if you pass the integer 10 to float(), it will return 10.0. This conversion is valid when you need to perform operations that require floating-point numbers or when you need to ensure consistency in your data types.

Syntax

float_representation = float(integer_value)

Explanation

  • float_representation: Variable will store the float representation of the integer.
  • float(): Function converts the integer_value to a float.
  • integer_value: Integer you want to convert. It is the input for float().

Example

float_num = float(42)
print(float_num)

Explanation

  • float_num = float(42): Converts the integer 42 to a float and assigns it to float_num.
  • print(float_num): Prints the value of float_num, which is 42.0.

Output

42.0


String Datatype with Python float()

You can use the Python float() function to convert a string to a float, provided the string represents a valid number. The string can contain an integer, a decimal number, or even a number in scientific notation (like “1.2e3”). float() will parse the string and return the corresponding floating-point value. If the string contains leading or trailing whitespace, float() will automatically remove it before attempting the conversion.

Syntax

float_representation = float(string_value)

Explanation

  • float_representation: Variable will store the float representation of the string.
  • float(): Function converts the string_value to a float.
  • string_value: String you want to convert. It is the input for float().

Example

float_num = float("123.45")
print(float_num)

Explanation

  • float_num = float("123.45"): Converts the string “123.45” to a float and assigns it to float_num.
  • print(float_num): Prints the value of float_num, which is 123.45.

Output

123.45


Python float() Exceptions and Errors

When using Python float(), you might encounter exceptions and errors if the input is not a valid number or string representation of a number. It’s important to handle these exceptions to prevent your program from crashing. Here are a few exceptions.


Python float() exception

The most common exception with Python float() is a ValueError. This occurs when you try to convert a string that does not represent a valid number into a float. For example, if the string contains letters (other than those used for “inf”, “infinity”, or “nan”) or other non-numeric characters, float() will raise a ValueError. To handle this, you can use a try-except block to catch the exception and provide an alternative course of action or error message.

Syntax

try:
    float_value = float(value)
except ValueError:
    # Handle the error

Explanation

  • try:: Keyword starts a block of code that you want to monitor for exceptions.
  • float_value = float(value): Attempts to convert value to a float.
  • except ValueError:: Catches a ValueError if it occurs in the try block.
  • # Handle the error: Here you write code to handle the ValueError, such as printing an error message.

Example

try:
    float_num = float("abc")
    print(float_num)
except ValueError:
    print("Invalid input for float()")

Explanation

  • try:: Block attempts to execute the code that might raise a ValueError.
  • float_num = float("abc"): Tries to convert the string “abc” to a float, which will raise a ValueError.
  • print(float_num): Print the float if the conversion succeeded.
  • except ValueError:: Block catches the ValueError if it occurs.
  • print("Invalid input for float()"): Prints an error message.

Output

Invalid input for float()


Python float() OverflowError

An OverflowError occurs when you try to convert a number too large to be represented as a float in Python. This is less common than ValueError but can happen when dealing with huge numbers. Python floats have a maximum limit; if you exceed that, you’ll get an OverflowError.

Syntax

try:
    float_value = float(very_large_number)
except OverflowError:
    # Handle the error

Explanation

  • except OverflowError:: Catches an OverflowError if it occurs in the try block.

Example

try:
    float_num = float("1e400")
    print(float_num)
except OverflowError:
    print("Number too large to convert to float")

Explanation

  • try:: Block attempts to execute the code that might raise an OverflowError.
  • float_num = float("1e400"): Tries to convert a very large number (in string form) to a float, which will raise an OverflowError.
  • print(float_num): Print the float if the conversion succeeded.
  • except OverflowError:: Block catches the OverflowError if it occurs.
  • print("Number too large to convert to float"): Prints an error message.

Output

Number too large to convert to float


Handling ValueError with float()

When using Python float() with string inputs, it’s good practice to handle potential ValueError exceptions using a try-except block. This allows your program to gracefully handle cases where the input string is not a valid number. You can print an error message, return a default value, or implement other error-handling logic inside the except block.

Syntax

try:
    float_value = float(input_string)
except ValueError:
    # Handle the ValueError

Explanation

  • except ValueError:: This catches a ValueError if it occurs during the conversion.

Example

try:
    float_num = float("xyz")
    print(float_num)
except ValueError:
    print("Could not convert string to float")

Explanation

  • try:: Block attempts to execute the code that might raise a ValueError.
  • float_num = float("xyz"): Tries to convert the string “xyz” to a float, which will raise a ValueError.
  • print(float_num): Print the float if the conversion succeeded.
  • except ValueError:: Block catches the ValueError if it occurs.
  • print("Could not convert string to float"): Prints an error message.

Output

Could not convert string to float


Conclusion

Python float() function is essential for converting numbers and strings into floating-point numbers. It handles integers, valid numeric strings, and special values like infinity and NaN. Understanding how Python float works, including its parameters, return type, and the exceptions it might raise, is crucial for writing robust numerical code in Python. Remember to handle potential ValueError exceptions when working with string inputs to ensure your program doesn’t crash unexpectedly.


Also Read

Python eval()

Python format()


Python Reference

python float()

Table of Contents