Text tools: textwrap, difflib and string

A command-line tool receives the command “staus” and should answer “did you mean status?”; a table with a 30-character column must show a 56-character lesson title; and a teammate wants to see only the lines that changed in a settings file. None of these jobs needs a pattern, and Python’s standard library has a module for each.

textwrap fits text to a width: it wraps paragraphs, shortens titles and fixes indentation. difflib compares texts: it suggests the closest known word and prints patch-style diffs. string holds ready-made character sets and string.Template, a fill-in-the-blanks format with $name placeholders that suits text other people write. All three work on ordinary str values and come with Python.

textwrap fits text to a width counted in characters

import textwrap

lessons = [
    ("Introduction to data structures and algorithms in Python", 22),
    ("SQL joins", 14),
    ("Designing a rate limiter for a public API", 30),
]

# shorten() collapses spaces, then cuts at a word boundary and adds a placeholder.
print(f"{'Lesson':<30} {'Min':>3}")
for title, minutes in lessons:
    print(f"{textwrap.shorten(title, width=30, placeholder=' …'):<30} {minutes:>3}")

# fill() wraps a paragraph to a width; wrap() returns the lines as a list.
note = "Fees paid after the due date carry a late charge, which is added to the next month's invoice automatically."
print(textwrap.fill(note, width=38))
print(len(textwrap.wrap(note, width=38)), "lines")

# dedent() removes the indentation that every line shares; indent() adds a prefix.
reply = """
    Dear Asha,
      your receipt is attached.
    Thanks"""
print(textwrap.indent(textwrap.dedent(reply).strip(), "> "))

Lesson                         Min
Introduction to data …          22
SQL joins                       14
Designing a rate limiter for …  30
Fees paid after the due date carry a
late charge, which is added to the
next month's invoice automatically.
3 lines
> Dear Asha,
>   your receipt is attached.
> Thanks

shorten() first collapses runs of spaces, then cuts at a word boundary and appends its placeholder, which counts towards the width, so every title fits the 30-character column. Step through the third title:

fill() wraps a paragraph to a width and returns one string; wrap() returns the lines as a list. dedent() removes the indentation that every line shares, which helps with triple-quoted text inside indented code, and indent() adds a prefix to every line that is not blank. The width counts characters, not screen columns, which matters for text in Hindi, Chinese or with emoji.

wrap() and fill() take more settings as keyword arguments. max_lines=2 stops after two lines and ends the last one with the placeholder, which makes a short preview of a long description. break_long_words=False keeps a long address or a URL whole instead of cutting it at the width, and initial_indent and subsequent_indent indent the first line and the rest differently, as in a numbered list.

difflib suggests the close matches that score 0.6 or more

import difflib

COMMANDS = ["status", "stash", "start", "push", "pull", "checkout", "commit", "config"]

for typed in ["staus", "chekout", "comit", "pussh", "deploy"]:
    matches = difflib.get_close_matches(typed, COMMANDS)
    print(f"{typed:8} -> {matches}")

# The score behind each suggestion: 1.0 means identical, and 0.6 is the default cutoff.
for word in ["status", "stash", "start", "push"]:
    print(f"staus vs {word:6} {difflib.SequenceMatcher(None, 'staus', word).ratio():.3f}")

staus    -> ['status', 'stash', 'start']
chekout  -> ['checkout']
comit    -> ['commit']
pussh    -> ['push', 'stash']
deploy   -> []
staus vs status 0.909
staus vs stash  0.800
staus vs start  0.600
staus vs push   0.444

get_close_matches(word, possibilities) returns up to three possibilities, the most similar first, and leaves out any that score below 0.6. The scores come from SequenceMatcher.ratio(), which compares two sequences exactly as they are, case and spaces included, and returns a number from 0, nothing in common, to 1, identical. “deploy” resembled no command, so it got an empty list, which is the honest answer. quick_ratio() and real_quick_ratio() are cheaper estimates that can only overstate the score. The autojunk setting makes long sequences ignore their most common items.

A unified diff turns two lists of lines into a patch

import difflib

old = """[server]
host = 0.0.0.0
port = 8000
workers = 2

[cache]
ttl = 60
""".splitlines(keepends=True)

new = """[server]
host = 0.0.0.0
port = 8080
workers = 4

[cache]
ttl = 60
size = 512
""".splitlines(keepends=True)

diff = difflib.unified_diff(old, new, fromfile="settings.ini (before)", tofile="settings.ini (after)", n=1)
print("".join(diff), end="")

--- settings.ini (before)
+++ settings.ini (after)
@@ -2,4 +2,4 @@
 host = 0.0.0.0
-port = 8000
-workers = 2
+port = 8080
+workers = 4
 
@@ -7 +7,2 @@
 ttl = 60
+size = 512

unified_diff() takes two lists of lines, with their line endings kept by splitlines(keepends=True), and yields the lines of a patch: the two file names, then hunksA block of a unified diff that covers one region of change: an @@ line with the line ranges it covers in the old and the new file, then the lines of that region. that start with @@, and inside them lines marked with a space, a minus or a plus. n=1 keeps one line of context around each change; the default is three. The output lines end with a newline, so join them with "". When your lines have no endings, as with text.splitlines(), pass lineterm="" and join with "\n" instead; without it, joining with "" runs the changed lines together and joining with "\n" doubles the line breaks after the headers. The same module offers ndiff(), which marks every line, get_opcodes(), which describes the edits as data, and HtmlDiff, which builds a side-by-side HTML table and supports dark mode since Python 3.14.

string.Template fills $name placeholders and nothing more

import string
from string import Template

# The constants are plain strings, handy for building simple checks.
print(string.ascii_lowercase, string.digits, string.punctuation)
ALLOWED = set(string.ascii_lowercase + string.digits + "_")
for name in ["asha_k", "Asha K", "ravi99"]:
    print(f"{name!r:9} allowed: {set(name) <= ALLOWED}")

# Template: $name or ${name} is replaced, and $$ is a literal dollar sign.
note = Template("Hi $name, order ${order}s ships $day. Save $$5 next time.")
print(note.substitute(name="Asha", order="A17", day="on Monday"))
print(note.safe_substitute(name="Ravi"))
try:
    note.substitute(name="Ravi")
except KeyError as missing:
    print("KeyError:", missing)
print(note.get_identifiers())

abcdefghijklmnopqrstuvwxyz 0123456789 !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
'asha_k'  allowed: True
'Asha K'  allowed: False
'ravi99'  allowed: True
Hi Asha, order A17s ships on Monday. Save $5 next time.
Hi Ravi, order ${order}s ships $day. Save $5 next time.
KeyError: 'order'
['name', 'order', 'day']

The string constants are plain strings, so set(name) <= ALLOWED checks in one line that a user name uses only lower-case letters, digits and the underscore. Template replaces $name and ${name}; the braces are needed when letters follow, as in ${order}s, and $$ stands for a dollar sign. substitute() raises KeyError when a value is missing, while safe_substitute() leaves the placeholder as it was, which suits drafts. A placeholder name is made of ASCII letters, digits and underscores and does not start with a digit, so $5 is not a placeholder at all. get_identifiers(), added in Python 3.11, lists the placeholders a template uses.

Template only ever replaces names with values, which makes it a good format for text that staff or users edit, such as email wording. str.format() can do far more, reading attributes and items of the values it formats. Do not confuse string.Template with t-strings, the template string literals of Python 3.14, which the next lesson covers: a Template is filled from a dictionary at run time, while a t-string is written in your code.

Which text tool fits which job

Read the table by its last two rows, what to watch out for and when to choose each tool:

Check yourself

Wrapping, close matches, diffs and templates are what this practice asks about, one question at a time, beginning with whichever of the four your answers show you know least.

How difflib scores similarity, and where the scores mislead Pro: opens with a Pro, Premium or Ultimate pass

Text that looks right on screen, and templates people can edit safely Pro: opens with a Pro, Premium or Ultimate pass

Interview questions

Key takeaways

• textwrap.shorten(), fill(), wrap(), dedent() and indent() fit text to a width that is counted in characters, not screen columns.
• difflib.get_close_matches() suggests up to three similar words that score at least 0.6, and unified_diff() prints a patch from two lists of lines.
• The string constants make quick character checks, and string.Template fills $name placeholders from a mapping, while safe_substitute() keeps the ones it cannot fill.
• string.Template is the format for text other people edit, and t-strings are a different tool, written in code.