Strings and f-strings: Immutability, Formatting, and the Quadratic Loop

An immutable sequence

Strings index, slice and iterate exactly like lists — but nothing can be assigned:

s = "hello"
print(s[0], s[-1], s[1:4], len(s))   # -> h o ell 5

s[0] = "H"
# TypeError: 'str' object does not support item assignment

So s.upper() returns a new string and leaves s alone. Forgetting to bind the result — writing s.strip() on a line by itself and wondering why the whitespace survived — is the single most common string bug.

Iterating a string yields one-character strings; there is no separate character type. Concatenation is +, repetition is *, and membership is a substring test: "ell" in "hello" is True.

The methods worth knowing

All are \(O(n)\) or better, and none mutate — there is nothing to mutate.

line = "  name, age , city  "
print(line.split(","))                            # -> ['  name', ' age ', ' city  ']
print([p.strip() for p in line.strip().split(",")])   # -> ['name', 'age', 'city']
print("a-b-c".split("-", 1))                      # -> ['a', 'b-c']
print("-".join(["a", "b", "c"]))                  # -> a-b-c

Two details that catch people. split() with no argument is not the same as split(" "): the former collapses runs of whitespace and drops empty fields, the latter does neither. And strip("xy") removes any leading or trailing character in the set {x, y} — it is not a prefix removal. For that, Python 3.9 added removeprefix and removesuffix.

t = "hello world"
print(t.replace("o", "0"))       # -> hell0 w0rld
print(t.replace("o", "0", 1))    # -> hell0 world
print(t.find("world"), t.find("zzz"))   # -> 6 -1
print(t.endswith(("x", "ld")))          # -> True

f-strings

An f-string evaluates the expressions inside its braces at runtime and formats each with the mini-language after the colon. It is faster than str.format (the interpolation is compiled in, not parsed at call time) and far easier to read.

name, n, pi = "ada", 7, 3.14159
print(f"{name} has {n} items")   # -> ada has 7 items

The = suffix (Python 3.8+) prints the source text of the expression together with its value — a debugging shortcut worth using constantly:

print(f"{n=}, {pi=}")     # -> n=7, pi=3.14159

The format spec is [[fill]align][sign][#][0][width][,][.precision][type]:

print(f"{pi:.2f}")           # -> 3.14
print(f"|{pi:10.3f}|")       # -> |     3.142|   width 10, numbers right-align
print(f"|{pi:<10.3f}|")      # -> |3.142     |
print(f"{n:03d}")            # -> 007
print(f"{n:+d}")             # -> +7
print(f"{1234567:,}")        # -> 1,234,567
print(f"{0.256:.1%}")        # -> 25.6%
print(f"{1234.5678:e}")      # -> 1.234568e+03

Alignment uses < left, > right, ^ centre, with an optional fill character in front:

print(f"|{name:>10}|")   # -> |       ada|
print(f"|{name:<10}|")   # -> |ada       |
print(f"|{name:^10}|")   # -> |   ada    |
print(f"|{name:*^11}|")  # -> |****ada****|

Integers can be rendered in other bases with b, o, x, X, and # adds the prefix:

print(f"{255:b} {255:o} {255:x} {255:#x}")    # -> 11111111 377 ff 0xff

Two more pieces. !r applies repr() instead of str(), which is what you want in log messages because it shows the quotes:

print(f"{'quoted'!r}")    # -> 'quoted'

And the spec itself can be computed, by nesting braces:

w = 8
print(f"|{pi:{w}.3f}|")   # -> |   3.142|

The older mechanisms still appear in code you will read: "{} and {}".format(a, b) with positional or named fields, and the C-style "%s is %d" % (a, b). Both work; neither is a reason to write new code that way.

Raw strings

A raw string literal, prefixed r, turns off backslash escape processing:

print(repr("C:\\path\\n"))   # -> 'C:\\path\\n'
print(repr(r"C:\path\n"))    # -> 'C:\\path\\n'

Both lines produce the same string — r changes how the literal is read, not what type you get. It matters most for regular expressions, where the pattern language has its own backslashes:

import re
print(re.findall(r"\d+", "a1b22"))   # -> ['1', '22']

Without the r, you would be writing "\\d+" and hoping you counted correctly. One restriction: a raw string cannot end in an odd number of backslashes.

str is not bytes

A str is a sequence of Unicode code points — abstract characters. A bytes object is a sequence of integers in \([0, 255]\). Converting between them requires naming an encoding, and there is no default that is safe to assume:

b = "café".encode("utf-8")
print(b, len(b), len("café"))   # -> b'caf\xc3\xa9' 5 4
print(b.decode("utf-8"))        # -> café

Four characters, five bytes: é needs two in UTF-8. So len on encoded data does not count characters, and slicing bytes can split a character in half.

The two types never mix implicitly:

b + "x"
# TypeError: can't concat str to bytes

"café".encode("ascii")
# UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 3

Indexing a bytes gives an int, not a one-byte bytes — b[0] is 99, the code for c. The practical rule is to decode at the boundary of your program, work in str throughout, and encode again on the way out. Always pass encoding="utf-8" explicitly to open(), because the default is platform-dependent.

Why += in a loop is the wrong tool

Since strings are immutable, s += piece must in principle allocate a new string of length \(\lvert s\rvert + \lvert p\rvert\) and copy everything. Do that \(n\) times and you copy \(1 + 2 + \dots + n = O(n^2)\) characters.

CPython partly hides this: when the target is a simple local name and the string has exactly one reference, it resizes the buffer in place instead. The optimisation is real but fragile — store the string anywhere else, and the quadratic cost comes straight back. Measured on CPython 3.13, appending "abc" \(n\) times while a second name also refers to the result:

Doubling \(n\) roughly quadruples the left column and doubles the right — quadratic against linear, and a factor of about 1,660 at the bottom row. join wins because it walks the iterable once to total the lengths, allocates exactly one buffer, and copies each piece exactly once.

# don't
s = ""
for p in parts:
    s += p

# do
s = "".join(parts)

Next, the functions chapter, where mutability produces its most notorious surprise of all.

References

1. Python Software Foundation. Text Sequence Type — str.
2. Python Software Foundation. Format Specification Mini-Language.
3. Python Software Foundation. Unicode HOWTO.
4. Smith, E. V. PEP 498 — Literal String Interpolation.
5. Talin. PEP 3101 — Advanced String Formatting.
6. Python Software Foundation. What’s New in Python 3.8 — f-string = specifier.
7. Python Software Foundation. re — Regular expression operations.