str.translate: Translating Characters in a String in Python: Complete Character Mapping and Transformation Guide

For a long time, I handled character-level text cleanup with chains of .replace() calls — stripping punctuation, swapping accented letters, building simple ciphers, one .replace() at a time. It worked, but it was slow and repetitive. Then I actually sat down and learned str.translate() properly, and it changed how I approach any task involving character-by-character substitution. This guide covers everything I’ve learned about str.translate() and its companion str.maketrans(), from the basics to real performance comparisons.

What str.translate() Actually Does

str.translate() maps individual characters in a string to other characters (or removes them entirely), all in a single pass, using a translation table. It’s fundamentally different from .replace(), which operates on whole substrings — translate() works at the level of individual Unicode code points.

text = "hello"
table = str.maketrans("el", "ip")
print(text.translate(table))
# Output: hippo

Here, every "e" becomes "i" and every "l" becomes "p" — the substitution happens character by character, all in one traversal of the string.

Building Translation Tables With str.maketrans()

str.maketrans() is the tool used to construct the mapping dictionary that translate() consumes. It has three usage forms.

Form 1: Two Equal-Length Strings

table = str.maketrans("abc", "xyz")
print("cab".translate(table))
# Output: zxy

Each character in the first string maps to the character at the same position in the second string — "a" → "x", "b" → "y", "c" → "z".

Form 2: Two Strings Plus a Deletion String

table = str.maketrans("abc", "xyz", "d")
print("cabd".translate(table))
# Output: zxy

The third argument specifies characters to delete entirely from the string — here, every "d" is removed, in addition to the a/b/c → x/y/z mapping.

Form 3: A Dictionary Mapping

table = str.maketrans({"a": "1", "b": "2", "c": None})
print("cab".translate(table))
# Output: 21

This is the most flexible form. Keys can be single characters (or their Unicode ordinal values), and values can be replacement strings, single characters, or None to delete the character entirely. I use this form whenever the mapping isn’t a simple one-to-one character swap — for example, mapping a character to a multi-character replacement.

table = str.maketrans({"&": "and", "@": "at"})
print("cats & dogs @ home".translate(table))
# Output: cats and dogs at home

Removing Characters: Punctuation Stripping

One of my most common uses of translate() is stripping punctuation from text efficiently:

import string

text = "Hello, World! How are you?"
table = str.maketrans("", "", string.punctuation)
print(text.translate(table))
# Output: Hello World How are you

Passing empty strings for the first two arguments means no characters are remapped — only the deletion set (string.punctuation) takes effect, removing every punctuation character from the string in one pass.

How translate() Compares to Chained .replace() Calls

Before I understood translate(), I’d have written the punctuation-stripping example above like this:

text = "Hello, World! How are you?"
for char in ",!?":
    text = text.replace(char, "")
print(text)

This works, but each .replace() call scans the entire string again from scratch. For k characters to remove and a string of length n, this chained approach costs roughly O(n × k) — the string gets fully rescanned once per character being removed. translate(), by contrast, builds the lookup table once and then processes the string in a single pass, making it O(n) regardless of how many characters are being mapped or removed.

import timeit
import string

text = "Hello, World! " * 1000
punctuation_chars = string.punctuation

def with_replace():
    result = text
    for char in punctuation_chars:
        result = result.replace(char, "")
    return result

def with_translate():
    table = str.maketrans("", "", punctuation_chars)
    return text.translate(table)

print(timeit.timeit(with_replace, number=100))
print(timeit.timeit(with_translate, number=100))

When I ran this comparison myself, translate() was noticeably faster, and the gap grows larger as the number of characters being mapped increases — which makes sense given the O(n × k) vs O(n) difference.

Case Conversion Ciphers: Building a Simple Caesar Cipher

translate() is a natural fit for character-substitution ciphers, since that’s essentially what a Caesar cipher is — a fixed character-to-character mapping.

import string

def caesar_cipher(text, shift):
    lower = string.ascii_lowercase
    upper = string.ascii_uppercase
    shifted_lower = lower[shift:] + lower[:shift]
    shifted_upper = upper[shift:] + upper[:shift]
    table = str.maketrans(lower + upper, shifted_lower + shifted_upper)
    return text.translate(table)

encrypted = caesar_cipher("Hello, World!", 3)
print(encrypted)
# Output: Khoor, Zruog!

Building the full alphabet-shift mapping once, then applying it with a single translate() call, is both readable and efficient compared to manually shifting character codes in a loop.

Removing Digits or Non-Printable Characters

text = "Order #12345 shipped on 07/30/2026"
table = str.maketrans("", "", string.digits)
print(text.translate(table))
# Output: Order # shipped on //

I use variations of this constantly when cleaning up text fields before further processing — stripping digits, control characters, or other unwanted character classes in a single efficient pass.

Working With Unicode Ordinals Directly

str.maketrans()‘s dictionary form also accepts integer Unicode code points as keys, which is useful when working with characters that are awkward to type directly in source code:

table = str.maketrans({8217: "'"})  # Right single quotation mark → apostrophe
text = "It\u2019s a nice day"
print(text.translate(table))
# Output: It's a nice day

This came in handy for me when cleaning up text copied from word processors or web pages, which often contain “smart quotes” and other typographic characters that don’t match plain ASCII equivalents.

Internal Working: How translate() Processes a String

Internally, translate() builds (or receives) a dictionary-like mapping from Unicode ordinals to replacement values. It then iterates through the original string exactly once, and for each character:

1. Looks up its ordinal in the translation table.
2. If found and mapped to a string, inserts that replacement.
3. If found and mapped to None, skips the character (deletes it).
4. If not found in the table, keeps the character unchanged.

Because this is a single linear pass with O(1) dictionary lookups per character, the overall time complexity is O(n) — proportional to the length of the string, regardless of how large the translation table is.

Common Mistakes I’ve Made or Seen

• Confusing translate() with .replace() — translate() maps individual characters, not multi-character substrings (except when a mapped value happens to be a longer string).
• Passing mismatched-length strings to the two-argument form of maketrans() — the first two strings must be the same length, or a ValueError is raised.
• Forgetting str.maketrans() is a separate step — translate() expects a translation table, not raw strings passed directly.
• Using translate() for substring replacement, which doesn’t work the way people expect since it operates character by character.

table = str.maketrans("cat", "dog")
# This does NOT replace "cat" with "dog" as a substring;
# it maps c->d, a->o, t->g individually.
print("cat".translate(table))  # Output: dog (coincidentally correct length-wise)
print("scatter".translate(table))  # Output: sdoggen  — clearly not substring replacement

Real-World Applications

• Text sanitization — stripping punctuation, control characters, or unwanted symbols from user input before storage or processing.
• Simple encoding/decoding — building lightweight ciphers or character-obfuscation schemes.
• Normalizing typographic characters — converting smart quotes, em dashes, or other typographic variants into plain ASCII equivalents.
• Tokenization preprocessing in NLP pipelines — removing punctuation before splitting text into words.
• Data cleaning in ETL pipelines — efficiently removing unwanted character classes from large volumes of text at scale.

FAQs

Q: Is str.translate() faster than .replace()? For character-level substitutions or removals involving multiple characters, yes — translate() processes the string in a single pass, while chained .replace() calls rescan the string once per replacement.

Q: Can str.translate() replace multi-character substrings? Not directly through character mapping, but the dictionary form of maketrans() can map a single character to a multi-character replacement string.

Q: How do I delete characters using translate()? Either pass a third string of characters to delete in str.maketrans(x, y, deletion_chars), or map specific characters to None in the dictionary form.

Q: Does translate() work with Unicode characters beyond ASCII? Yes — since Python 3 strings are Unicode by default, translate() works with any Unicode code point, including using integer ordinals as table keys.

Summary

str.translate(), paired with str.maketrans(), is the most efficient built-in tool in Python for character-level string transformation — whether that means remapping characters, stripping unwanted ones, or building simple substitution ciphers. Once I understood that it processes a string in a single linear pass rather than the repeated rescans that chained .replace() calls require, it became my default choice anytime a task involved transforming individual characters rather than whole substrings.

References

• Python Documentation: str.translate()
• Python Documentation: str.maketrans()
• Python Documentation: string — Common string operations