Beginner

Learn When You Absolutely Have to Use Floats in Python Programming: Absolute Beginners Tutorial

12 min read

Python gives you two main number types for everyday math: int and float. Integers are whole numbers. Floats carry a decimal point and can represent fractions. Knowing when you have to use a float — not just when it might be convenient — is one of the first practical skills a beginner needs to build solid Python habits.

Integers handle counting things — eggs in a carton, players on a team, lines in a file. Floats handle measuring things — the temperature outside, the distance between two GPS coordinates, the result of dividing one number by another. The line between the two is not arbitrary. Python enforces it in specific, predictable ways.

What a Float Actually Is in Python

A float in Python is a number with a decimal point. Internally, Python stores floats as 64-bit double-precision values following the IEEE 754 binary standard. That means floats can represent a huge range of numbers, but they do so using binary fractions rather than decimal fractions. The practical consequence is that floats are excellent for scientific and engineering calculations, but they are not exact for every decimal value you might type.

You can recognize a float in Python code by its decimal point, by how Python echoes it back in the REPL, or by checking its type directly.

python 
# Integers — whole numbers, no decimal
count = 7
print(type(count))      # <class 'int'>

# Floats — numbers with a decimal point
temperature = 98.6
print(type(temperature))  # <class 'float'>

# Even a whole number becomes a float if you write the decimal
whole_as_float = 5.0
print(type(whole_as_float))  # <class 'float'>

# Check with isinstance
print(isinstance(3.14, float))  # True
print(isinstance(3, float))     # False
Note

Python's float type maps directly to the C double type on the underlying hardware. You get roughly 15 to 17 significant decimal digits of precision. This is more than enough for most tasks, but it does mean floats are not the right tool for exact decimal accounting.

code builder click a token to place it

Build the statement that converts the integer 42 to a float and assigns it to the variable result:

your code will appear here...
float( int( 42 result = ) str(
Why: The correct statement is result = float(42). The function float() takes an integer and returns its float equivalent — here, 42.0. Using int() would keep it as an integer, and str() would give you a string, not a number.

Division: Where Floats Are Unavoidable

Division is the most common place beginners encounter an unexpected float. Python has two division operators and they behave very differently.

The / operator is true division. It always returns a float, no matter what the operands are. Even 10 / 2, which divides evenly with no remainder, gives you 5.0, not 5. The // operator is floor division. It always discards the fractional part and returns an integer when both operands are integers.

python 
# True division — always returns float
print(10 / 2)    # 5.0
print(7 / 3)     # 2.3333333333333335
print(1 / 4)     # 0.25

# Floor division — returns int when both operands are int
print(10 // 2)   # 5
print(7 // 3)    # 2
print(1 // 4)    # 0

# If either operand is a float, // returns a float
print(7.0 // 3)  # 2.0  (still a float, despite losing the decimal)
Pro Tip

If you need to split something into equal parts and want a fractional answer — like splitting a bill between three people — use /. If you need to know how many complete groups fit without a remainder — like how many full boxes you can pack — use //.

This behavior changed in Python 3. In Python 2, dividing two integers with / performed floor division automatically. Python 3 changed / to always mean true division, which eliminated a large category of bugs where programmers expected fractions and got truncated integers.

Returns
Always a float
Example
9 / 3 gives 3.0
Use when
You need the exact quotient, including any fractional part
Returns
Integer if both operands are integers; float if either operand is a float
Example
9 // 2 gives 4; 9.0 // 2 gives 4.0
Use when
You only want the whole-number part of the quotient
Returns
Same type rules as floor division — float if either operand is a float
Example
9 % 2 gives 1; 9.5 % 2 gives 1.5
Use when
You need the leftover after dividing — checking even/odd, cycling through values

The math Module Always Returns Floats

Python's built-in math module is designed for floating-point calculations. Every function in it returns a float, even when the mathematical result is a perfect integer. This is not a bug — it is a deliberate design that keeps the module's behavior consistent and predictable.

python 
import math

# Square root — always returns float
print(math.sqrt(9))    # 3.0, not 3
print(math.sqrt(2))    # 1.4142135623730951

# Trigonometric functions — always return float
print(math.sin(0))     # 0.0
print(math.cos(0))     # 1.0

# Logarithm — always returns float
print(math.log(1))     # 0.0
print(math.log(math.e))  # 1.0

# Constants are floats
print(math.pi)    # 3.141592653589793
print(math.e)     # 2.718281828459045
print(math.tau)   # 6.283185307179586

# Ceiling and floor return int in Python 3, not float
print(type(math.ceil(4.2)))   # <class 'int'>
print(type(math.floor(4.9)))  # <class 'int'>

Notice the last two lines above — math.ceil() and math.floor() are the exception in the math module. They return integers in Python 3, because their purpose is specifically to round to whole numbers. Every other computational function in the module returns a float.

Scientific constants like math.pi and math.e are floats. Whenever your code uses one of these constants in a calculation, the result is automatically a float, because any arithmetic involving a float produces a float.

python 
import math

# Area of a circle — radius is an integer, result is a float
# because math.pi is a float
radius = 5
area = math.pi * radius ** 2
print(area)          # 78.53981633974483
print(type(area))    # <class 'float'>

# Circumference
circumference = 2 * math.pi * radius
print(circumference)  # 31.41592653589793
spot the bug click the line that contains the bug

This function is supposed to return the area of a circle as a float. One line has an error that causes it to return the wrong type. Find it.

1 import math
2
3 def circle_area(radius):
4 return int(math.pi * radius ** 2)
5
6 print(circle_area(5)) # expected 78.53..., got 78
The fix: Remove the int() wrapper — use return math.pi * radius ** 2. Wrapping the result in int() truncates the floating-point value to a whole number, discarding all the decimal precision. Since math.pi is a float, the multiplication already produces a float naturally — there is no need to convert it.

Real-World Data That Is Always a Float

Certain categories of real-world data are floats by their very nature. When you write code that works with any of the following, plan to use floats from the start.

Physical measurements

Temperature, weight, pressure, voltage, distance, and speed are continuous quantities. They are never exactly a whole number in reality. A thermometer reading of 98 degrees is stored as 98.0 or, more likely, something like 98.4. Sensor libraries return floats. GPS coordinates — latitude and longitude — are always floats, because the precision required to locate a specific address on Earth demands many decimal places.

python 
# GPS coordinates — must be float
latitude  = 29.7604    # Houston, TX
longitude = -95.3698

# Temperature from a sensor
body_temp_celsius = 37.2

# Weight in kilograms
package_weight_kg = 4.85

# Voltage from an ADC reading
voltage = 3.307

# All of these are floats
print(type(latitude))         # <class 'float'>
print(type(body_temp_celsius))  # <class 'float'>

Percentages and rates

A percentage is a ratio multiplied by 100. The moment you compute one, you almost certainly have a float. An interest rate, a test score expressed as a decimal, a success rate, a CPU utilization percentage — all of these require floats to represent accurately.

python 
# Pass rate from a test
correct = 17
total = 20
pass_rate = correct / total         # true division — always float
print(pass_rate)                    # 0.85
print(f"Pass rate: {pass_rate:.1%}")  # Pass rate: 85.0%

# Annual interest rate
annual_rate = 0.0475   # 4.75%

# CPU usage
cpu_utilization = 63.7  # percent
"A float is the right tool any time you are measuring rather than counting." — Python Software Foundation documentation philosophy

How to Decide: Float or Integer?

Choosing the right numeric type is a decision you will make hundreds of times as a Python programmer. This four-step process covers the situations where you have no choice but to use a float.

  1. Ask whether your result can ever be fractional

    If your calculation might produce a value with a decimal component — such as a division, a square root, or a physical measurement — you need a float. If the result is always a whole number, an integer may be sufficient. A count of users is an integer. An average of user scores is a float.

  2. Check which operator or function you are using

    The / operator always returns a float. Functions from the math module always return floats. If your expression includes either of these, your result is a float whether you plan for it or not. Writing total / count gives you a float. Writing math.sqrt(total) gives you a float.

  3. Consider the data source

    Sensor readings, GPS coordinates, temperatures, timestamps with sub-second precision, and scientific measurements are nearly always floats by nature. Design your variables accordingly from the start. Assume any value coming from hardware, an API returning measurements, or a CSV of scientific data will be a float until you confirm otherwise.

  4. Decide whether float precision is sufficient

    For general scientific and engineering work, IEEE 754 double precision (about 15 significant digits) is more than adequate. For financial or accounting calculations that require exact decimal arithmetic, use Python's decimal module instead of float. The decimal module is slower but eliminates the binary approximation errors that float inherits from IEEE 754.

Float Precision and When It Trips You Up

One of the first surprises beginners encounter with floats is this:

python 
print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)  # False

This is not a Python bug. It is a fundamental property of binary floating-point representation. The decimal value 0.1 has no exact binary equivalent — like trying to write one third as a terminating decimal. The storage approximation is tiny (about 5.5 × 10−18), but when you add two approximations together, the combined error becomes visible.

The practical rule: never use == to compare two floats. Use round() to limit decimal places before comparing, or use math.isclose() which checks whether two floats are close enough to be considered equal.

python 
import math

# Wrong way — direct equality on floats
result = 0.1 + 0.2
print(result == 0.3)          # False — do not rely on this

# Better way 1 — round to a known number of decimal places
print(round(result, 10) == 0.3)  # True

# Better way 2 — math.isclose() (recommended)
print(math.isclose(result, 0.3))  # True

# For exact decimal arithmetic, use the decimal module
from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))  # 0.3  (exact)
Warning

Do not use float to store money values in production code. Use Python's decimal.Decimal type instead. Floating-point rounding errors can cause your calculated totals to drift from the correct values over thousands of transactions.

Python Learning Summary Points

  1. The / operator in Python 3 always returns a float, even when dividing two integers that divide evenly. This is true division. Use // if you want the integer quotient.
  2. Every function in the math module (except math.ceil() and math.floor()) returns a float. Mathematical constants like math.pi and math.e are floats, and any arithmetic that involves them produces a float.
  3. Physical measurements — temperature, distance, voltage, GPS coordinates — are always floats by nature. Percentages, rates, and averages computed by dividing integers are also floats.
  4. Floats follow IEEE 754 binary representation and cannot exactly represent all decimal values. Never compare two floats with ==; use math.isclose() or round() instead.
  5. When exact decimal precision matters — especially for currency — use Python's decimal.Decimal type rather than float.

The distinction between integers and floats is one of the clearest signals in Python that tells you how a value behaves in your program. A float says: this value lives on a continuous scale and may carry precision beyond a whole number. An integer says: this is a count and only whole units make sense here. Training yourself to ask which one is appropriate before you write a variable is a habit that prevents a category of bugs before they start.

check your understanding question 1 of 5

Frequently Asked Questions

You must use a float when your calculation produces or requires a fractional result. The most common situations are: using the / (true division) operator, calling functions from the math module such as math.sqrt() or math.sin(), working with physical measurements or sensor readings, using scientific constants like math.pi or math.e, and representing values that are inherently continuous such as a temperature or GPS coordinate.

The / operator is true division and always returns a float, even when dividing two integers with no remainder — for example, 10 / 2 returns 5.0. The // operator is floor division and always discards any remainder — for example, 10 // 3 returns 3. When both operands to // are integers, the result is an integer. If either operand is a float, the result is a float whole number such as 4.0.

Yes. math.sqrt() always returns a float, even when the result is a perfect square. For example, math.sqrt(9) returns 3.0, not 3. This is because the math module is designed to work with floating-point numbers throughout. If you need an integer square root, use the ** exponentiation operator with a rational exponent inside int(), or use Python's math.isqrt() function which returns an integer.

Yes. Use float() to convert an integer to a float — for example, float(5) returns 5.0. Use int() to convert a float to an integer — for example, int(3.9) returns 3. Note that int() truncates toward zero rather than rounding, so int(3.9) is 3, not 4. Use round() if you want standard rounding behavior.

Python floats follow the IEEE 754 binary floating-point standard. Some decimal fractions cannot be represented exactly in binary, so 0.1 and 0.2 each have tiny rounding errors in memory. When added together, those errors compound and the result is 0.30000000000000004. Use math.isclose() to compare floats instead of ==, or use the decimal module when exact decimal arithmetic is required.

IEEE 754 is the international standard that defines how floating-point numbers are stored and calculated in binary hardware. Python floats are 64-bit double-precision IEEE 754 values, meaning they have a fixed number of binary digits available. This limits precision to about 15 to 17 significant decimal digits and causes some decimal values to be stored as approximations. The standard is used by virtually all modern programming languages and CPUs, so this behavior is not specific to Python.

For currency work where rounding errors matter, the decimal module is the better choice because it offers exact decimal arithmetic. Floats introduce small binary approximation errors that can accumulate in financial calculations. Use from decimal import Decimal and create values with string arguments like Decimal("0.10") to avoid any floating-point contamination from the start. Use float only when rough IEEE 754 precision is acceptable for your use case.

type(3.14) returns <class 'float'>. You can also use isinstance(3.14, float) which returns True. Both approaches confirm that a value belongs to Python's built-in float type. The isinstance() approach is generally preferred in production code because it handles subclassing correctly.

Python Fundamentals