Python float Function

Last modified April 11, 2025

This comprehensive guide explores Python's float function, which converts numbers and strings to floating-point values. We'll cover conversion rules, string parsing, special values, and practical examples.

Basic Definitions

The float function creates a floating-point number from a number or string. It implements Python's floating-point type which follows IEEE 754 standard for double precision (64-bit) numbers.

Key characteristics: converts integers, strings with decimal numbers, scientific notation. Returns special values like inf and nan for certain inputs. Default argument returns 0.0.

Basic Numeric Conversion

Here's simple usage showing how float converts different numeric types and string representations to floating-point numbers.

basic_float.py

# Convert integers
print(float(42))      # 42.0
print(float(-10))     # -10.0

# Convert numeric strings
print(float("3.14"))  # 3.14
print(float("-1.5"))  # -1.5

# Scientific notation
print(float("2.5e2")) # 250.0

This example shows float converting integers and strings. Integer inputs gain a decimal point. String parsing handles signs and decimal points.

Scientific notation (e/E) is supported in strings. The exponent indicates power of 10 multiplication (e2 means ×10²).

Special Floating-Point Values

Python's float supports special values like infinity and NaN (Not a Number). This example demonstrates their creation and checking.

special_values.py

# Infinity
pos_inf = float("inf")
neg_inf = float("-inf")
print(pos_inf, neg_inf)  # inf -inf

# NaN (Not a Number)
nan = float("nan")
print(nan)  # nan

# Checking these values
import math
print(math.isinf(pos_inf))  # True
print(math.isnan(nan))     # True

Infinity values can be created with string "inf" or "-inf". NaN represents undefined numerical results like 0/0. These are IEEE 754 standard values.

The math module provides functions to check for these special values, as direct equality comparisons with NaN are unreliable.

String Parsing and Locale Considerations

float has specific string parsing rules. This example shows valid and invalid formats, including locale-dependent decimal points.

string_parsing.py

# Valid formats
print(float("3.14"))     # 3.14
print(float("  3.14  ")) # 3.14 (whitespace ignored)
print(float("3.14e-2"))  # 0.0314

# Invalid formats
try:
    float("3.14.15")     # Multiple decimal points
except ValueError as e:
    print(f"Error: {e}")

try:
    float("3,14")        # Comma as decimal (locale-dependent)
except ValueError as e:
    print(f"Error: {e}")

# Locale-aware conversion
import locale
locale.setlocale(locale.LC_NUMERIC, 'de_DE')
print(float("3,14"))     # Still fails - float() doesn't use locale

float only accepts period as decimal point, regardless of system locale. For locale-specific parsing, additional processing is needed.

Whitespace around numbers is ignored. The function raises ValueError for malformed strings or unsupported formats.

Error Handling and Default Values

This example demonstrates proper error handling when converting uncertain inputs, and shows the default behavior of float.

error_handling.py

# Default value
print(float())  # 0.0

# Conversion attempts with error handling
def safe_float(value, default=0.0):
    try:
        return float(value)
    except (ValueError, TypeError):
        return default

print(safe_float("3.14"))    # 3.14
print(safe_float("abc"))     # 0.0
print(safe_float(None))      # 0.0
print(safe_float("", 99.9))  # 99.9 (custom default)

The safe_float function demonstrates robust conversion that won't raise exceptions. It returns a default value for unconvertible inputs.

Without arguments, float() returns 0.0. This is useful for initializing variables or providing default numeric values.

Precision and Representation Issues

Floating-point numbers have inherent precision limitations. This example demonstrates common representation issues and how to handle them.

precision.py

# Representation error
num = float("0.1") + float("0.2")
print(num)          # 0.30000000000000004
print(num == 0.3)   # False

# Exact decimal arithmetic
from decimal import Decimal
num = Decimal("0.1") + Decimal("0.2")
print(float(num))   # 0.3

# Large numbers lose precision
big = float("12345678901234567890")
print(big)          # 1.2345678901234567e+19

# Small numbers become zero
tiny = float("1e-324")
print(tiny)         # 0.0

Floating-point arithmetic can produce unexpected results due to binary representation. The decimal module provides exact decimal arithmetic.

Very large or small numbers may lose precision or underflow to zero. These are limitations of 64-bit floating-point representation.

Best Practices

Use for conversion: Convert strings/numbers when float type needed
Handle errors: Catch ValueError for string conversion attempts
Consider alternatives: Use decimal for financial calculations
Watch precision: Be aware of representation limitations
Document assumptions: Note when float precision is sufficient

Source References

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.

Ebooks