> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python float
The `float` type in Python is a built-in numeric data type used to represent real numbers with a fractional component. In CPython, a `float` is implemented as a C `double`, meaning it strictly adheres to the IEEE 754 double-precision binary floating-point standard. It occupies 64 bits of memory: 1 bit for the sign, 11 bits for the exponent, and 52 bits for the significand (mantissa).
## Instantiation and Syntax
Floats can be instantiated using numeric literals containing a decimal point, scientific notation (E-notation), or the built-in `float()` constructor.
```python theme={"dark"}
# Decimal literals
val_standard = 3.14159
val_leading = .5 # Evaluates to 0.5
val_trailing = 4. # Evaluates to 4.0
# Scientific notation (E-notation)
val_large = 1.5e5 # Evaluates to 150000.0
val_small = 2.5e-3 # Evaluates to 0.0025
# Constructor casting
from_int = float(42) # Evaluates to 42.0
from_str = float("-3.14") # Evaluates to -3.14
```
## Special Values
The `float` type supports special IEEE 754 values representing infinity and undefined mathematical operations (Not a Number). These are typically instantiated via string casting.
```python theme={"dark"}
pos_inf = float('inf') # Positive infinity
neg_inf = float('-inf') # Negative infinity
nan_val = float('nan') # Not a Number
# NaN identity quirk: NaN is never equal to itself
print(nan_val == nan_val) # False
```
## Precision and Limits
Because Python floats are 64-bit double-precision values, they are subject to strict hardware limitations regarding maximum value and precision. These system-level constraints can be inspected using the `sys` module.
```python theme={"dark"}
import sys
# Maximum representable finite float
print(sys.float_info.max) # ~1.7976931348623157e+308
# Minimum representable positive normalized float
print(sys.float_info.min) # ~2.2250738585072014e-308
# Difference between 1.0 and the least value greater than 1.0
print(sys.float_info.epsilon) # ~2.220446049250313e-16
```
## Representation Error
Because floats are stored as base-2 (binary) fractions, most base-10 (decimal) fractions cannot be represented exactly. This results in representation error, where the stored value is a highly precise approximation.
```python theme={"dark"}
# Binary approximation of 0.1 and 0.2 leads to a floating-point artifact
result = 0.1 + 0.2
print(result) # 0.30000000000000004
print(result == 0.3) # False
# Standard technical resolution for equality checks
import math
print(math.isclose(0.1 + 0.2, 0.3)) # True
```
## Type Methods
The `float` object includes several built-in methods for mathematical introspection and conversion.
```python theme={"dark"}
f = 3.125
# Returns a tuple of (numerator, denominator) in lowest terms
print(f.as_integer_ratio()) # (25, 8)
# Checks if the float has no fractional part
print(f.is_integer()) # False
print(3.0.is_integer()) # True
# Returns the exact hexadecimal string representation of the float
print(f.hex()) # '0x1.9000000000000p+1'
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
