How to Pad Numbers With Leading Zeros in Python

By the end of this page, you will understand how to format numbers with leading zeros in Python, why zero-padding is useful, and how to use common tools like zfill(), format(), and f-strings to create fixed-width output.

Zero-padding means adding 0 characters to the left of a number so the final output has a specific width.

For example:

• 12 becomes 000012 when the width is 6
• 5 becomes 005 when the width is 3

This matters because many programs need values in a consistent format. Common examples include:

• invoice numbers like 000123
• file names like image_001.png
• log entries with aligned columns
• date and time parts like 09:05

In Python, numbers themselves do not store leading zeros in their normal decimal form. Leading zeros are usually part of string formatting, not the numeric value itself.

So the main idea is:

• keep the value as a number when you want to calculate with it
• convert or format it as a string when you want to display it with leading zeros

Think of a number as an object being placed into a box of fixed size.

If the box must hold 6 characters and the number is 12, Python puts 12 in the box and fills the empty spaces on the left with 0:

• box size: 6
• number: 12
• result: 000012

The number does not change mathematically. You are only changing how it looks when printed or stored as text.

There are several common ways to pad numbers with zeros in Python.

1. Using str.zfill()

num = 12
result = str(num).zfill(6)
print(result)

Output:

000012

zfill(6) makes the string at least 6 characters wide by adding zeros to the left.

2. Using format()

num = 12
result = format(num, "06d")
print(result)

Output:

000012

Explanation:

• 0 means pad with zeros
• 6 means total width is 6
• d means format as an integer

3. Using an f-string

num = 
result = 
(result)

Consider this example:

num = 12
formatted = f"{num:06d}"
print(formatted)

Step by step:

1. num = 12

   • A variable named num stores the integer 12.

2. formatted = f"{num:06d}"

   • Python starts an f-string.
   • num is the value to format.
   • 0 says to use zeros for padding.
   • 6 says the total width must be 6 characters.
   • d says the value is an integer.
   • Since 12 has 2 digits, Python adds 4 zeros to the left.
   • formatted becomes "000012".

3. print(formatted)

   • Python prints the final string:

Zero-padding appears in many practical situations.

File naming

for i in range(1, 4):
    print(f"image_{i:03d}.png")

Output:

image_001.png
image_002.png
image_003.png

This helps files sort correctly.

Invoice or order IDs

order_id = 27
print(f"ORD-{order_id:06d}")

Output:

ORD-000027

Time formatting

hour = 9
minute = 5
print(f"{hour:02d}:{minute:02d}")

Output:

09:05

Data export

Fixed-width text files often require exact column widths. Zero-padding helps ensure consistent formatting.

In real Python projects, zero-padding is usually used during output formatting, not while storing the original value.

Common patterns include:

1. Formatting at the boundary

Keep internal values numeric:

user_id = 12

Format only when displaying or exporting:

print(f"User ID: {user_id:06d}")

2. Building filenames

def build_filename(index):
    return f"frame_{index:04d}.jpg"

This keeps naming consistent in scripts that generate many files.

3. Report generation

def format_row(record_number, amount):
    return f"{record_number:05d} | ${amount:.2f}"

4. Validation plus formatting

Sometimes developers first validate input, then format it:

Here are common beginner mistakes when zero-padding numbers in Python.

Mistake 1: Expecting the number itself to store leading zeros

num = 000012

This is not how normal decimal integers should be written in Python. Leading zeros belong to the string representation.

Use:

num = 12
print(f"{num:06d}")

Mistake 2: Forgetting to convert to a string before zfill()

Broken code:

num = 12
print(num.zfill(6))

This fails because integers do not have a zfill() method.

Correct version:

num = 12
print(str(num).zfill(6))

Mistake 3: Using the wrong format specifier

Broken code:

num = 12
print(f"")

Here is a comparison of the main ways to add leading zeros in Python.

zfill() vs f-strings

Quick reference

Pad an integer to width 6

num = 12
f"{num:06d}"
# '000012'

Using format()

format(12, "06d")
# '000012'

Using zfill()

str(12).zfill(6)
# '000012'

Format pattern

f"{value:0Nd}"

• 0 = pad with zeros
• N = total width
• d = integer

Example:

f"{:04d}"   
  

How do I add leading zeros to a number in Python?

Use string formatting such as f"{num:06d}", format(num, "06d"), or str(num).zfill(6).

What does 06d mean in Python?

0 means pad with zeros, 6 is the total width, and d means format as an integer.

Should I store numbers with leading zeros as integers?

No. Integers do not preserve leading zeros for display. Store the value as a number and format it as a string when needed.

What is the difference between zfill() and f-strings?

zfill() pads a string, while f-strings format values directly and are more flexible for mixed output.

Can I zero-pad negative numbers in Python?

Yes. Python keeps the minus sign in front, such as -00012.

What happens if the number is longer than the requested width?

Python leaves it unchanged. It does not cut off digits.

Is zfill() only for numbers?

No. It works on any string, but it is commonly used for numeric text.

Which method is most recommended in modern Python?

• String formatting — Zero-padding is part of formatting values for display.
• f-strings — A modern and readable way to format values in Python.
• format() function — Another standard way to control number and string output.
• Strings — Leading zeros are usually added to string representations, not numeric values.
• Integers — It helps to understand that integer values themselves do not keep display padding.
• Printing output — Zero-padding is commonly used when preparing values for console output, logs, and reports.
• File naming — Fixed-width numbers are often used in filenames so sorting works correctly.