Python str.rjust(): Right Text Alignment & Left Padding

The str.rjust(width[, fillchar]) method returns a copy of the string right-aligned within a field of the designated width, padding the remaining space on the left with fillchar (defaulting to an ASCII space).

The Decimal Alignment Standard: In financial reporting, terminal metrics, and numerical tables, figures must be right-aligned so decimal points and place values (units, tens, hundreds) align vertically. If width ≤ len(s), Python returns the original string unaltered without truncation.

Show Table of Contents ↓

1. Method Signature & Parameters 🔝

The standard CPython signature for str.rjust() is:

str.rjust(width, fillchar=' ', /)

Parameter	Type	Default	Description
`width`	`int`	Required	Total desired field width. If `width` is less than or equal to `len(s)`, the original string is returned intact without truncation.
`fillchar`	`str`	`' '`	Optional. A single character used to fill the remaining left margin. Passing an empty string or multi-character string raises a `TypeError`.

Immutability Guarantee: Because Python strings are immutable sequences, rjust() allocates and returns a new string. The original string variable remains unmodified.

2. Basic Right Alignment & Left Margin Padding 🔝

By default, rjust() places space characters to the left of the target string until the total length matches width:

Example: Right Alignment with Spaces

price = "$149.50"

# Pad left margin to 12 characters total
aligned_price = price.rjust(12)

print("Original: ", repr(price))
print("Aligned:  ", repr(aligned_price))
print("Length:   ", len(aligned_price))

Expected Output:

Original:  '$149.50'
Aligned:   '     $149.50'
Length:    12

When the string length meets or exceeds the requested width, Python never truncates the string:

headline = "Enterprise Annual Report"
print(headline.rjust(10))  # Output: 'Enterprise Annual Report' (len 24)

3. Custom Fill Characters & Preceding Leaders 🔝

Supplying a custom character for fillchar enables preceding dot-leaders, progress trackers, and visual hashes:

Example: Preceding Dot-Leaders & Visual Delimiters

page_num = "42"
dotted = page_num.rjust(20, ".")

print("Chapter 1 " + dotted)

Expected Output:

Chapter 1 ..................42

4. The Signed Number Trap: rjust() vs. zfill() 🔝

While rjust(width, '0') appears identical to zfill(width) on positive numbers, it produces catastrophic syntax errors on negative numbers:

The Signed Numeric Corruption Bug

negative_amount = "-45.00"

# FLAWED: rjust() places zeros BEFORE the negative sign
corrupted = negative_amount.rjust(10, "0")
print("rjust(10, '0'): ", corrupted)  # Produces '0000-45.00' (Invalid numeric format!)

# ROBUST: zfill() inserts zeros AFTER the sign character
valid = negative_amount.zfill(10)
print("zfill(10):      ", valid)      # Produces '-000045.00' (Valid numeric format!)

Expected Output:

rjust(10, '0'):  0000-45.00
zfill(10):       -000045.00

Input	`str.rjust(8, '0')`	`str.zfill(8)`	Behavioral Outcome
`"250"` (Positive)	`"00000250"`	`"00000250"`	Identical output
`"-250"` (Negative)	`"0000-250"`	`"-0000250"`	`zfill()` preserves sign syntax
`"+250"` (Explicit Plus)	`"0000+250"`	`"+0000250"`	`zfill()` preserves sign syntax

5. Alignment Family Comparison: rjust() vs. ljust() vs. center() vs. f-strings 🔝

Python's alignment tools provide directional formatting across methods and formatted string literals:

Direction	Method Call	f-String Syntax	Example on `"TOTAL"` (w=10, fill='.')
Right Justified	`s.rjust(width, fill)`	`f"{s:{fill}>{width}}"`	`".....TOTAL"`
Left Justified	`s.ljust(width, fill)`	`f"{s:{fill}<{width}}"`	`"TOTAL....."`
Centered	`s.center(width, fill)`	`f"{s:{fill}^{width}}"`	`"..TOTAL..."`

6. Real-World Engineering Recipes 🔝

Recipe 1: Financial Ledger / Accounting Statement Aligner

Right-aligning credit and debit columns so currencies line up on decimal points:

def format_ledger_entry(account: str, debit: float, credit: float) -> str:
    acc_col = account.ljust(25)
    deb_col = f"${debit:,.2f}".rjust(12) if debit > 0 else "".rjust(12)
    crd_col = f"${credit:,.2f}".rjust(12) if credit > 0 else "".rjust(12)
    return f"{acc_col} | {deb_col} | {crd_col}"

print("Account Name              |        Debit |       Credit")
print("-" * 55)
print(format_ledger_entry("Operating Cash", 14500.50, 0.0))
print(format_ledger_entry("Accounts Payable", 0.0, 3200.75))
print(format_ledger_entry("Cloud Hosting Services", 495.20, 0.0))

Expected Output:

Account Name              |        Debit |       Credit
-------------------------------------------------------
Operating Cash            |   $14,500.50 |             
Accounts Payable          |              |    $3,200.75
Cloud Hosting Services    |      $495.20 |

Recipe 2: High-Precision Benchmark & Telemetry Latency Displays

Formatting execution benchmarks with aligned millisecond measurements:

def format_benchmark_metric(operation: str, duration_ms: float, total_width: int = 45) -> str:
    metric_str = f"{duration_ms:>8.3f} ms"
    prefix = (operation + " ").ljust(total_width - len(metric_str), ".")
    return f"{prefix}{metric_str}"

print(format_benchmark_metric("TLS Handshake", 24.152))
print(format_benchmark_metric("Database Query Execution", 3.840))
print(format_benchmark_metric("JSON Response Serialization", 0.125))

Expected Output:

TLS Handshake .....................  24.152 ms
Database Query Execution ..........   3.840 ms
JSON Response Serialization .......   0.125 ms

Recipe 3: Document Table of Contents Page Leaders

Formatting book chapters and page numbers with trailing right-aligned pages:

def format_toc_line(chapter_title: str, page_number: int, line_width: int = 40) -> str:
    pg_str = str(page_number)
    # Right-align the page number with dot padding
    return chapter_title.ljust(line_width - len(pg_str), ".") + pg_str

print(format_toc_line("1. Python Environment Setup", 1))
print(format_toc_line("2. Built-in String Methods", 24))
print(format_toc_line("3. Memory Optimization & O(N) Passes", 188))

Expected Output:

1. Python Environment Setup............1
2. Built-in String Methods............24
3. Memory Optimization & O(N) Passes.188

Recipe 4: Terminal Process Memory & Resource Tables

Aligning process IDs and memory usage stats in Unix top-style CLI dashboards:

def format_process_stat(pid: int, name: str, memory_mb: float) -> str:
    p_id = str(pid).rjust(6)
    p_name = name.ljust(18)
    p_mem = f"{memory_mb:,.1f} MB".rjust(12)
    return f"{p_id}  {p_name}  {p_mem}"

print(format_process_stat(1, "systemd", 14.2))
print(format_process_stat(1048, "nginx: master", 48.5))
print(format_process_stat(48920, "postgres: worker", 1250.8))

Expected Output:

     1  systemd                14.2 MB
  1048  nginx: master          48.5 MB
 48920  postgres: worker    1,250.8 MB

7. Common Pitfalls & Edge Cases 🔝

Pitfall 1: Multi-Character fillchar TypeError

Just like ljust() and center(), passing a multi-character string to fillchar raises an immediate exception:

# TypeError: The fill character must be exactly one character long
"100".rjust(6, "00")

# Valid:
"100".rjust(6, "0")

Pitfall 2: No Truncation on Oversized Inputs

If a string is wider than width, rjust() leaves it completely intact. In strict tabular reports where columns must not break, apply slicing: val[:width].rjust(width).

8. Production Implementation & Self-Checking Assertions 🔝

Below is a production-grade utility class, RightAligner, demonstrating financial ledger formatting, latency display, and automated unit assertions:

Production RightAligner Class with Unit Assertions

class RightAligner:
    @staticmethod
    def align_currency(amount: float, field_width: int = 12) -> str:
        """Right-aligns currency strings for tabular alignment."""
        formatted = f"${amount:,.2f}"
        return formatted.rjust(field_width)

    @staticmethod
    def align_preceding_leader(title: str, page: int, total_width: int = 35) -> str:
        """Formats chapter and page with dot leaders."""
        pg_str = str(page)
        return title.ljust(total_width - len(pg_str), ".") + pg_str


# ==========================================
# SELF-CHECKING UNIT ASSERTIONS
# ==========================================
aligner = RightAligner()

# 1. Basic space right alignment
assert "test".rjust(8) == "    test"
assert "test".rjust(4) == "test"
assert "test".rjust(2) == "test"  # Overflow: no truncation

# 2. Custom fillchar
assert "50".rjust(6, "0") == "000050"
assert "End".rjust(8, "*") == "*****End"

# 3. Currency alignment
c1 = aligner.align_currency(1250.50, 12)
c2 = aligner.align_currency(45.00, 12)
assert c1 == "   $1,250.50"
assert c2 == "      $45.00"
assert len(c1) == 12
assert len(c2) == 12

# 4. Dot leader TOC line
toc = aligner.align_preceding_leader("Chapter 1", 5, 25)
assert toc == "Chapter 1...............5"
assert len(toc) == 25

# 5. Contrast with zfill on negative numbers
assert "-42".rjust(6, "0") == "000-42"  # Corrupts sign
assert "-42".zfill(6) == "-00042"      # Correct sign

# 6. TypeError validation on invalid fillchar
try:
    "sample".rjust(10, "--")
    assert False, "Expected TypeError not raised"
except TypeError as e:
    assert "must be exactly one character" in str(e)

print("Currency aligned: ", repr(c1))
print("TOC line created: ", toc)
print("All str.rjust() unit assertions passed successfully!")

Practice in Google Colab & GitHub 🔝

Open in Google Colab View on GitHub

Run all right-alignment examples interactively, contrast rjust() with zfill(), construct financial ledger tables, and test dot leaders in Google Colab.

str.ljust() Function — Left-aligning text with custom right margin padding.
str.center() Function — Centering strings with symmetrical padding margins.
str.zfill() Function — Zero-padding numbers with sign preservation.
Python String Formatting — Advanced format specification mini-language alignment.
str.rstrip() Function — Stripping trailing characters from the right edge.
Python String Methods Overview — Complete reference of built-in string methods.

String Methods str.ljust() str.count() Python Tutorials

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author Watch on YouTube

Connect: