Python - Floats (float)

Floats in Python

Python provides various numerical types to represent numbers, and one of the most fundamental types among them is the float type. Floats in Python represent real numbers, which are numbers that can contain a decimal point. They are essential in scientific computing, mathematical calculations, financial operations, and any application that involves measurements or approximate values.

Introduction to Floats in Python

The float type in Python is used to represent decimal or fractional numbers. These numbers are specified using a decimal point or using exponential notation. Unlike integers, floats can represent non-whole numbers and can even approximate very large or very small values using scientific notation.

Examples of Floats

a = 3.14
b = -0.00025
c = 1.5e2  # 1.5 × 10² = 150.0
d = -2.4E-3  # -2.4 × 10⁻³ = -0.0024

All of the above values are of float type, even if they are expressed in scientific notation.

Creating Float Values

You can create float values in various ways:

Direct Assignment

x = 7.5
y = -13.0

Using Type Conversion

float_from_int = float(10)  # Result: 10.0
float_from_string = float("3.1415")  # Result: 3.1415

Note: Passing an invalid string to float will raise a ValueError.

Using Expressions

result = 5 / 2  # Result: 2.5

Type Checking

To verify if a value is a float, use the type() function or isinstance() function:

type(3.14)  # Returns: 
isinstance(3.14, float)  # Returns: True

Floating Point Arithmetic

Floating-point arithmetic involves operations with decimal values. These operations include addition, subtraction, multiplication, division, and more.

Basic Operations

a = 4.5
b = 2.0

add = a + b      # 6.5
sub = a - b      # 2.5
mul = a * b      # 9.0
div = a / b      # 2.25

Floor Division and Modulo

floor_div = a // b  # 2.0
mod = a % b         # 0.5

Exponentiation

exp = a ** b  # 20.25

Precision and Floating Point Errors

Floating-point numbers are represented in computer hardware as binary fractions, which can lead to small rounding errors. This is not a bug in Python but rather a characteristic of how computers handle floating point arithmetic.

Example

x = 0.1 + 0.2
print(x)  # Output: 0.30000000000000004

To compare float numbers, it is better to use a tolerance approach rather than using `==`.

Comparing Floats Safely

import math

math.isclose(0.1 + 0.2, 0.3)  # Returns: True

Rounding Floats

Python provides built-in tools to round floats.

Using round()

round(3.14159, 2)  # 3.14

Using format()

format(3.14159, ".2f")  # '3.14'

Using f-strings

value = 3.14159
f"{value:.2f}"  # '3.14'

Special Float Values

Python recognizes special float values like Infinity, Negative Infinity, and NaN (Not a Number).

Infinity

pos_inf = float("inf")
neg_inf = float("-inf")

NaN (Not a Number)

nan = float("nan")

Checking Special Values

math.isinf(pos_inf)  # True
math.isnan(nan)  # True

Float vs Integer

Differences

• Integers do not have a decimal component.
• Floats are used to represent numbers with fractional parts.
• Arithmetic between ints and floats usually results in a float.

a = 5      # int
b = 2.0    # float
result = a + b  # Result is 7.0 (float)

Conversions Between Float and Other Types

Float to Integer

int(4.7)  # 4 (truncates decimal)

Float to String

str(3.14159)  # "3.14159"

String to Float

float("2.718")  # 2.718

Using Floats in Data Structures

In Lists

float_list = [1.0, 2.5, 3.75]

In Dictionaries

float_dict = {"pi": 3.14159, "e": 2.71828}

In Sets

float_set = {1.1, 2.2, 3.3}

Float Formatting Techniques

Floats can be formatted for display using string interpolation or formatting functions.

Using f-strings

value = 123.4567
f"{value:.2f}"  # '123.46'

Using format()

format(123.4567, ".2f")  # '123.46'

Math Functions for Floats

Python’s math module provides several functions for operating on floats:

• math.floor(x): Largest integer less than or equal to x
• math.ceil(x): Smallest integer greater than or equal to x
• math.sqrt(x): Square root
• math.exp(x): e^x
• math.log(x): Natural logarithm

Example

import math

value = 2.7
math.floor(value)  # 2
math.ceil(value)   # 3
math.sqrt(16.0)    # 4.0

Common Float Pitfalls

Precision Loss

Floating-point numbers are not always accurate. Do not use them for money calculations.

Incorrect Comparisons

Avoid using == to compare floats directly. Use math.isclose instead.

Overflows and Underflows

Extremely large or small floats can lead to infinity or zero due to the limits of floating-point representation.

Best Practices with Floats

• Use the decimal module for precise decimal arithmetic when required.
• Use math.isclose() for float comparisons.
• Always round values to required precision when displaying or storing.
• Avoid subtracting large nearly equal floats; it may amplify errors.

Using the Decimal Module for Accurate Float Arithmetic

The decimal module offers a way to perform arithmetic with exact decimal representation, which is useful in financial applications.

Example

from decimal import Decimal

a = Decimal('0.1')
b = Decimal('0.2')
c = a + b  # Exact: 0.3

Scientific Notation with Floats

Scientific notation is useful for very large or very small numbers. Python supports it natively.

large = 1.2e10  # 1.2 × 10^10 = 12000000000.0
small = 4.5e-6  # 4.5 × 10^-6 = 0.0000045

Using Floats in Functions

Function Example

def area_of_circle(radius):
    pi = 3.14159
    return pi * radius * radius

area = area_of_circle(5.5)  # 95.0332225

Float Limits

Python floats are based on the IEEE 754 standard (64-bit binary format double precision).

Maximum and Minimum Float Values

import sys

sys.float_info.max  # Largest representable float
sys.float_info.min  # Smallest positive float

Floats are an essential part of programming in Python, allowing you to work with real-world numerical values. Understanding how floats work, their limitations, and how to mitigate floating point errors is vital for writing reliable and accurate Python programs. For most typical uses, Python floats are sufficient. For more precise decimal arithmetic, the decimal module is a better choice. Always remember to use float comparisons with caution, and format your float values appropriately for clarity in output and logs.