How to Write Decimal Numbers in Python Code: Absolute Beginners Tutorial

Every Python program that handles prices, measurements, sensor readings, or scientific data needs decimal numbers. Python calls them floats, and writing them is straightforward once you know the rules. This tutorial walks you through every way to create and work with decimal numbers in Python, starting from the simplest float literal and building up to the decimal module for precision-critical work.

If you have ever typed a number like 9.99 or 0.5 into a Python file, you have already created a float. The decimal point is the signal that tells Python to treat the number as a floating-point value rather than an integer. But there is more to the story than just adding a dot. Python gives you multiple ways to write decimal numbers, each suited to different situations, and understanding them all makes your code cleaner and more intentional.

What Is a Float in Python?

A float (short for floating-point number) is Python's primary type for representing numbers that have a fractional component. When you write 42, Python creates an int. When you write 42.0, Python creates a float. The decimal point is what separates the two types.

whole_number = 42
decimal_number = 42.0

print(type(whole_number))    # <class 'int'>
print(type(decimal_number))  # <class 'float'>

Under the hood, Python stores floats using the IEEE 754 double-precision format, which gives you roughly 15 to 17 significant digits of precision. This is the same standard used by C, Java, JavaScript, and virtually every other mainstream language. It means Python floats occupy 64 bits of memory regardless of the number's size.

Python also has a built-in float() function that converts other types into floats, and a decimal module in the standard library for situations where the default float precision is not sufficient. We will cover both of these later in this tutorial.

Four Ways to Write Decimal Numbers

Python offers several syntactic forms for expressing decimal values. Each one produces a float, but they serve different readability and convenience goals.

1. Standard Float Literals

The simplest and most common approach is to type the number with a decimal point. You can include digits on both sides of the point, or you can omit digits from one side. All three of the following lines create a valid float:

full_form  = 3.14    # both sides of the decimal point
short_left = .5      # no digit before the point (same as 0.5)
short_right = 5.     # no digit after the point (same as 5.0)

print(full_form)     # 3.14
print(short_left)    # 0.5
print(short_right)   # 5.0

2. Scientific (Exponential) Notation

When you need to express very large or very small numbers, scientific notation keeps your code readable. The letter e (or E) separates the base number from the power of 10:

speed_of_light = 3e8       # 300,000,000.0
electron_mass  = 9.109e-31 # 0.0000000000000000000000000000009109

print(speed_of_light)      # 300000000.0
print(electron_mass)       # 9.109e-31

The number after e tells Python how many positions to shift the decimal point. A positive exponent shifts it to the right (making the number larger), and a negative exponent shifts it to the left (making it smaller). The result is always a float, even if the final value is a whole number like 3e8.

3. Underscores for Readability

Since Python 3.6, you can insert underscores between digits in any numeric literal. The underscores are purely visual separators and have no effect on the stored value:

budget = 1_500_000.75
pi     = 3.141_592_653

print(budget)   # 1500000.75
print(pi)       # 3.141592653

This feature was introduced by PEP 515 and works the same way for integers, floats, and even hexadecimal or binary literals. The only rule is that underscores must appear between digits -- not at the start, end, or directly next to the decimal point.

4. The float() Constructor

The built-in float() function converts integers, strings, and other compatible types into floats:

from_int    = float(42)        # 42.0
from_string = float("3.14")   # 3.14
from_sci    = float("2.5e-3") # 0.0025
no_args     = float()          # 0.0

# Special values
positive_inf = float("inf")   # inf
negative_inf = float("-inf")  # -inf
not_a_number = float("nan")   # nan

The float() function is essential when you need to convert user input (which Python reads as a string) or data from a file into a numeric value you can do math with. It also provides the only way to create the special float values inf, -inf, and nan, which have no literal syntax in Python.

Why Floats Are Not Perfectly Precise

One of the things that surprises beginners about Python floats is that they cannot represent every decimal value exactly. Try this in a Python shell:

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

This is not a Python bug. It happens because the computer stores floats as binary (base-2) fractions. The value 0.1 does not have an exact binary representation, just as the fraction 1/3 does not have an exact decimal representation (0.333... repeats forever). The computer stores the closest possible approximation, and when you combine multiple approximations, the tiny errors can become visible.

For general-purpose math, the slight imprecision of floats is harmless. But for financial calculations, accounting ledgers, or anywhere you need numbers to match exactly, Python provides the decimal module (covered in the next section) and the fractions module for rational arithmetic.

The decimal Module: When Precision Matters

Python's standard library includes the decimal module, which provides the Decimal type for exact base-10 arithmetic. Unlike the built-in float, Decimal stores numbers exactly as you write them, preserving trailing zeros and avoiding binary rounding errors.

from decimal import Decimal

# Always initialize with strings to preserve precision
a = Decimal("0.1")
b = Decimal("0.2")

print(a + b)              # 0.3
print(a + b == Decimal("0.3"))  # True

# Trailing zeros are preserved
total = Decimal("1.20") + Decimal("1.30")
print(total)              # 2.50

Notice that Decimal("1.20") + Decimal("1.30") produces 2.50, not 2.5. The Decimal type preserves the significance of the trailing zero, which matters in financial reporting and scientific measurement.

One important rule: always pass strings to the Decimal constructor, not floats. Writing Decimal(0.1) first creates a float approximation of 0.1 and then converts that imprecise value into a Decimal, carrying the rounding error along with it. Writing Decimal("0.1") avoids this entirely.

from decimal import Decimal

# Do this:
correct = Decimal("0.1")
print(correct)  # 0.1

# Not this:
wrong = Decimal(0.1)
print(wrong)    # 0.1000000000000000055511151231257827021181583404541015625

"Computers must provide an arithmetic that works in the same way as the arithmetic that people learn at school." — General Decimal Arithmetic Specification

Python Learning Summary Points

1. The decimal point creates a float. Writing 42.0 instead of 42 changes the type from int to float. Python treats these as fundamentally different types, even when the numeric value appears identical.
2. Python offers four ways to express float values. Standard literals (3.14), scientific notation (3e8), underscore-separated literals (1_000.50), and the float() constructor all produce the same float type but serve different readability goals.
3. Floats are approximations. Because Python stores floats in binary (IEEE 754), values like 0.1 cannot be represented exactly. Use math.isclose() for comparisons and the decimal module for precision-critical work like financial calculations.
4. Initialize Decimal with strings. Always write Decimal("0.10"), never Decimal(0.10). The string form preserves exact base-10 precision and avoids inheriting the rounding error that already exists in the float.
5. Round and format deliberately. Use round(value, n) for numeric rounding and f-strings like f"{value:.2f}" for display formatting. These tools give you full control over how your decimal numbers appear to users.

Decimal numbers are one of the building blocks you will use in almost every Python program. Now that you know how to write them, convert them, and handle their precision limits, you have a solid foundation to work with prices, measurements, scientific data, and any other values that need a fractional component.