Working with Strings in Python

A string is a sequence of characters with type str. It can hold a name, a sentence, a code, or no characters at all. Python keeps the characters in order, including spaces and punctuation.

Write the value between matching quotes

Single and double quotes create the same kind of value: 'hello' and "hello" are equal. The outer quotes mark the boundaries; they are not characters in the value. Choose quotes that leave any quotes inside easy to read:

message = "It's late"
reply = 'She said "yes"'
empty = ""

In 'It's late', the apostrophe closes the string too soon, causing a SyntaxError. Double quotes solve this, or you can write 'It\'s late'. Use straight quotes in code.

Store line breaks and backslashes

An escape sequence begins with a backslash. Python reads \n as one newline, \t as one tab, and \\ as one backslash. Escaped quotes, \' and \", put quote characters into text.

text = "a\nb"
print(len(text))  # 3
print(text)

The final call prints a and b on separate lines. The value has three characters: a, a newline, and b. Escapes are processed when Python reads the literal. The shell displays a representation with quotes and escapes where needed; print() displays the characters themselves. For example, "\x41" becomes "A", so the shell need not show the original escape.

Triple quotes let a literal span lines. Each line break inside becomes a newline character:

notice = """Door closed
Use side entrance"""

A raw string has an r before its quotes. In r"C:\new", the backslash and n stay separate, giving six characters. In "C:\new", \n becomes a newline, giving five. Raw literals are useful when backslashes belong in the text.

Measure and combine text

len() counts every character, including spaces: len("Hi there!") is 9, and len("") is 0. More precisely, it counts Unicode code points. len("café") is 4 when é is one code point; len("👍🏽") is 2, even though the emoji looks like one symbol.

Use + to concatenate strings and * to repeat one:

first = "Ada"
last = "Lovelace"
full = first + " " + last  # "Ada Lovelace"
rule = "-" * 10           # ten dashes

Concatenation inserts nothing for you. Without " ", the names become "AdaLovelace". Repeating "ab" zero times gives the empty string.

Decide whether digits are text or numbers

Both operands of string concatenation must be strings. "Age: " + 30 raises TypeError; "Age: " + str(30) gives "Age: 30". Conversely, input() returns text: "3" + "4" gives "34". To add their numerical values, convert them first: int("3") + int("4") gives 7.

An index selects one character by its position. Python starts counting at zero, so the position of a character is one less than its place in an ordinary count from the left.

Draw the positions

For word = "Python", each character has a nonnegative index and a negative index:

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[-1])  # n

The square brackets after the string select the character. The result is a string of length one: Python has no separate character type. You can join selected characters, so word[0] + word[-1] gives "Pn".

For length n, valid indexes run from -n through n - 1 when n > 0. Nonnegative indexes count from the start; negative indexes count from the end. An index of -k selects the same character as n - k; in this six-character word, -2 and 4 both select "o".

Keep the length separate from the last index

len(word) is 6, but word[6] raises IndexError: there is no seventh character. The last character is word[len(word) - 1], or simply word[-1]. Going too far from either end fails; word[-7] also raises IndexError.

An index must be an integer. word[1.0] raises TypeError even though the float has a whole-number value. Use // when computing a middle position:

word = "Pyt"
middle = len(word) // 2  # 1
print(word[middle])      # y

The / operator would produce 1.5, which cannot index a string. For an odd length, len(word) // 2 selects the middle character. For an even length, it selects the right-hand middle character: "Python"[3] is "h".

Build initials from first characters

first = "Grace"
last = "Hopper"
initials = first[0] + last[0]
print(initials)  # GH

Each name contributes its character at index 0. Using first[-1] would contribute "e", the last letter. This method requires each name to have at least one character.

Check blank input before indexing

The empty string has length zero and no valid character index. ""[0] raises IndexError. A length check can keep a program from reading a character that does not exist:

line = input("Comment: ")
if len(line) > 0 and line[0] == "#":
    print("Comment line")

Python evaluates and from left to right. If the length check is false, it skips line[0]. Reversing those two tests would try the unsafe index first. When you only need to know whether a line begins with "#", line.startswith("#") also works on empty input and returns False.

A slice selects a run of characters and returns it as a string. It lets you take a prefix, remove an ending, or separate fields that occupy fixed positions.

Start is included; stop is excluded

Write text[start:stop]. With s = "Monty Python", s[0:5] gives "Monty", and s[6:12] gives "Python". The space is at index 5, so the second slice begins at 6.

Picture the slice numbers as gaps. Gap 0 is before the first character, and gap 5 is after the first five. Taking everything between them gives five characters. For 0 <= start <= stop <= len(text), the length is stop - start.

word = "Monty"
print(word[0:4])  # Mont
print(word[0:5])  # Monty

The stop position is the first position left out. Adding one to the desired last index includes that last character.

Leave out a boundary

At any split position k, s[:k] + s[k:] gives back s. The slices meet at the same gap, with no missing or repeated character.

Slice boundaries beyond the ends are clipped. "cat"[1:100] is "at"; "cat"[5:] is "". For a forward slice, a start at or after the stop gives an empty string, as in s[4:2]. Unlike a single-character index, an out-of-range slice does not raise IndexError.

Choose a step

The third slot in text[start:stop:step] sets how far to move between selected positions:

letters = "abcdefgh"
print(letters[::2])   # aceg
print(letters[1::2])  # bdfh
print(letters[::-1])  # hgfedcba

A negative step moves backward. With both boundaries omitted, [::-1] starts at the last character and visits every character in reverse order. A step of zero raises ValueError. The direction must agree with the boundaries: the “start at or after stop” empty-result rule above is for a positive step.

Apply slices to a fixed layout

d = "2026-07-04"
year = d[:4]
month = d[5:7]
day = d[8:10]
print(month + "/" + day + "/" + year)  # 07/04/2026

The positions work because this layout always uses four digits for the year and two for the month and day. Text with varying field lengths needs a search or a split.

Reversal also gives a palindrome test: word == word[::-1]. "level" passes, but "Level" fails because case counts. Assign clean = word.lower() and test clean == clean[::-1] to ignore case.

Use a loop when a decision must be made about each character. The loop can count matches, use their positions, stop at the first match, or collect the characters that belong in a result.

Visit characters directly

for ch in "hi!":
    print(ch)

The body runs three times, with ch equal to "h", "i", and "!" in turn. The empty string runs the body zero times. A direct character loop needs no index when you only use the current character.

For a count, initialize the counter before the loop and increase it only when the test passes:

text = "Programming in Python"
count = 0
for ch in text.lower():
    if ch in "aeiou":
        count += 1
print(count)  # 5

Lowercasing makes uppercase vowels match too. The test string defines the vowels being counted; it does not include y. Resetting count inside the loop would lose the total from earlier passes.

Use positions when neighboring characters matter

range(len(text)) supplies the indexes from zero through the last valid index. For a task that needs both the position and character, enumerate(text) supplies them together:

for i, ch in enumerate("abc"):
    print(i, ch)

This prints 0 a, then 1 b, then 2 c. The two loop variables receive the index and character from each pair.

To compare neighbors, the last index cannot be the current position because it has no next character:

text = "bookkeeper"
pairs = 0
for i in range(len(text) - 1):
    if text[i] == text[i + 1]:
        pairs += 1
print(pairs)  # 3

The matches are oo, kk, and ee. With range(len(text)), the last pass would try text[len(text)] and raise IndexError.

Manage a position with while

i = 0
while i < len(text):
    print(text[i])
    i += 1

The test is strictly <: position len(text) is past the end. The increment moves the loop toward stopping; leaving it out keeps reading the same character forever on nonempty text. For a backward walk, start at len(text) - 1, continue while i >= 0, and subtract one on each pass.

Search or collect

For the first digit in "Room 42B", stop once a match has been used:

for ch in "Room 42B":
    if ch.isdigit():
        print(ch)  # 4
        break

Without break, both digits would print. For a simple presence test, "4" in text already answers yes or no.

To collect text, start with result = "" and add each wanted character. For "a b c", adding only when ch != " " builds "abc". Assigning ch = ch.upper() inside a loop changes only the loop variable; it does not change the characters stored in text.

Strings are immutable: their characters cannot be changed after the string exists. A program that seems to edit text is building another string and choosing which variable will refer to it.

Read a character, but do not assign to it

name = "Jane"
name[0] = "D"  # TypeError

The index can read "J", but it cannot be the target of an assignment. del name[0] also raises TypeError. To get "Dane", combine the desired first character with the unchanged ending:

name = "Jane"
name = "D" + name[1:]
print(name)  # Dane

Python first evaluates the right side, producing a new string. It then makes name refer to that result.

Replace or insert at a known position

For a valid nonnegative index i, these expressions use different right-hand slices:

Replacement skips the old character; insertion keeps it. With text = "cat", i = 1, and new = "X", replacement gives "cXt", while insertion gives "cXat".

Convert a negative index to its nonnegative equivalent before using this replacement pattern. For the last character of "cat", i = len(text) - 1 is 2. If you put -1 directly into text[i + 1:], it becomes text[0:], which appends the entire old string and gives "caXcat".

Retain a method's result

Transformation methods follow the same immutable rule:

msg = "hello"
msg.upper()
print(msg)       # hello
msg = msg.upper()
print(msg)       # HELLO

The first call computes a result that the program discards. The assignment keeps the second result. String methods never change the original string, but their return types differ: upper() returns a string, find() an integer, and isdigit() a Boolean.

Track two names for one value

After a = "cat" and b = a, both variables refer to "cat". Running a = a + "s" gives a the new value "cats"; b still refers to "cat". No character in the shared old string changed. a += "s" performs the same kind of reassignment for a string.

Build a changed value in a loop

word = "secret"
masked = ""
for ch in word:
    if ch in "aeiou":
        masked += "*"
    else:
        masked += ch
print(masked)  # s*cr*t
print(word)    # secret

Each pass extends masked with one chosen character. Putting each character at the front instead, with result = ch + result, reverses text: the passes over "drawer" build "d", "rd", "ard", "ward", "eward", and "reward".

Repeated concatenation is convenient for short examples. When pieces already exist in a list, "".join(pieces) builds one result directly and can also place a separator between them.

A method is a function attached to a value. String methods handle common jobs such as changing case, trimming input, and replacing text. Each call returns a result and leaves the original string unchanged.

Call a method with dot notation

Write value.method(arguments), as in "hello".upper(). Parentheses make the call happen. name.upper without parentheses refers to the method itself; it does not produce uppercase text. Writing upper(name) does not find a standalone function named upper. Use dir("") to list string methods and help(str.upper) to read about one.

Choose a case operation

capitalize() changes the first character and lowercases the rest; title() starts words again after nonletter characters. This makes "they're".title() become "They'Re", so automatic title casing can need checking.

For comparisons without case differences, casefold() handles more cases across languages than lower(). "Straße".lower() is "straße", while "Straße".casefold() is "strasse". Case-fold both strings before comparing them.

Clean the ends of text

strip() removes leading and trailing whitespace, including spaces, tabs, and newlines. It preserves internal spacing: " New York \n".strip() is "New York". lstrip() cleans only the left end; rstrip() cleans only the right.

With an argument, stripping removes any of those characters repeatedly from the ends. It does not remove an exact word:

print("...Wow!!!".strip(".!"))          # Wow
print("report.txt".rstrip(".txt"))     # repor
print("report.txt".removesuffix(".txt"))  # report

The final t in report also belongs to the stripping character set, so it disappears. removeprefix() and removesuffix() remove exact text at an end; they are available in Python 3.9 and later.

Replace matches and chain changes

replace(old, new) replaces every exact match. A third argument limits how many matches change: "a-b-c".replace("-", "", 1) gives "ab-c". An empty replacement deletes matches. Case counts, so "Cat cat".replace("cat", "dog") gives "Cat dog".

answer = "  YES \n"
answer = answer.strip().lower()
print(answer == "yes")  # True

The calls run left to right: strip() returns "YES", then lower() returns "yes". A chain works when the next method fits the previous result's type. A search result is an integer, so it does not support string cleanup methods.

For padding, "7".zfill(3) gives "007", "Total".ljust(8) adds three spaces on the right, and "Hi".center(8, "*") gives "***Hi***". rjust() pads on the left. These widths are minimums; longer text is kept in full.

Searching can answer three different questions: whether text occurs, where it starts, and how often it occurs. Choose the result that fits the decision your program needs to make.

Choose a search result

A substring is a consecutive run of characters. "py" in "happy" is True, but "hpy" in "happy" is False. Matching is case-sensitive: "Py" in "python" is False. not in reverses the presence test. The empty string occurs in every string.

Find the right occurrence

text = "banana"
print(text.find("an"))     # 1
print(text.find("an", 2))  # 3
print(text.rfind("an"))    # 3

The optional start position skips earlier candidates. The returned index still counts from the beginning of the whole string. index() returns the same position when a match exists, but its missing-match error makes it useful when absence signals an unexpected problem.

Check a position before slicing

email = "maria.lopez@example.org"
at = email.find("@")
if at != -1:
    user = email[:at]
    domain = email[at + 1:]
    print(user)    # maria.lopez
    print(domain)  # example.org

The search returns 11. The first slice stops before @; the second starts one character after it. If the marker were absent, at would be -1. Using that as a slice boundary would silently select text near the end, so handle the missing marker before extracting parts.

Do not use if text.find("x"): as a presence test. A match at index 0 counts as false in a condition, while the missing-result value -1 counts as true. Use if "x" in text: or compare the position explicitly with -1.

Search from a known marker

For line = "Order #4521 shipped", the number follows # and ends at the next space:

start = line.find("#") + 1
end = line.find(" ", start)
number = line[start:end]
print(number)  # 4521

Here both markers exist. Starting the second search at start skips the earlier space after Order. If markers may be missing, check each raw search result before adding one or slicing; adding one to -1 would hide the failed search by turning it into 0.

Count whole matches

"banana".count("a") is 3, and "banana".count("ana") is 1. The two possible ana matches overlap, so count() does not count both. Similarly, "aaaa".count("aa") is 2.

To ignore case, search a converted version, such as "python" in sentence.lower(). The search still matches exactly within that version. Counts and presence tests can use the converted string directly; an index belongs to the particular string searched.

String tests return Booleans that can guide a condition. They help you accept input that matches a rule and compare text in a consistent form.

Test the ends or the characters

startswith() and endswith() test exact text at the ends. A tuple lets one test accept several endings: name.endswith((".jpg", ".png")). Uppercase "photo.PNG" fails that test unless you lowercase it first.

All five return False for "". Letters need not be English: "café".isalpha() is True. The space in "hello world" makes isalpha() false.

isupper() and islower() look at cased characters and require at least one. "ABC1".isupper() is True; the digit does not spoil uppercase letters. "123" has no cased characters, so both tests are false.

Validate before conversion

A digit test does not describe every number Python can read. "-5".isdigit(), "3.5".isdigit(), and " 42".isdigit() are false because a sign, point, or space is not a digit. Also, "²".isdigit() is true even though int("²") fails. isdecimal() rejects that superscript and suits a plain nonnegative whole-number entry.

text = input("Tickets: ").strip()
if text.isdecimal() and int(text) > 0:
    print("Accepted")
else:
    print("Enter a positive whole number")

The string test runs first. When it is false, and skips the conversion, protecting blank or nonnumeric input. " 12 " becomes "12" and passes; "0" converts safely but fails the positive-value test. This rule deliberately rejects signed or decimal-point entries.

A username rule can combine length and character checks: 3 <= len(name) <= 12 and name.isalnum(). "ada99" passes, "ada 99" fails the character test, and "ad" fails the length test.

Compare cleaned text

Equality requires the same characters in the same order. "Yes" == "yes" and "yes " == "yes" are false. For answers where case and outer whitespace should be ignored, compare typed.strip().casefold() with expected.strip().casefold().

Ordering works character by character. The first differing Unicode code point decides. ord("A") is 65, ord("Z") is 90, and ord("a") is 97; chr(97) gives "a". Thus "Zebra" < "apple" is true. When one string is a prefix of the other, the shorter one comes first: "app" < "apple".

Digit strings also use character order: "10" < "9" is true because "1" comes before "9". Convert to numbers when comparing quantities. Accented letters need care too: ord("é") is 233, so "école" > "zoo" is true. This built-in order follows code points, not a language's dictionary order.

split() turns one string into a list of strings. A list is an ordered collection written in square brackets. You can read an item by index, loop over the items, or count them with len().

Choose whitespace or an exact separator

Without an argument, split() treats a run of whitespace as one boundary and ignores whitespace at both ends:

words = "  the quick  brown fox ".split()
print(words)       # ['the', 'quick', 'brown', 'fox']
print(len(words))  # 4
print(words[0])    # the

With an explicit separator, each exact occurrence makes a cut. Consecutive separators preserve an empty field:

fields = "red,green,,blue".split(",")
# ["red", "green", "", "blue"]

The empty third item may represent a value that was left blank. It still counts as an item in the list.

A separator can contain several characters, but all of them must match. If no separator occurs, the result holds the whole original string as one item. Splitting on comma-space therefore differs from splitting on a comma.

Limit how much text is split

The second argument, maxsplit, limits the number of cuts, not the number of resulting items:

print("key=value=more".split("=", 1))
# ["key", "value=more"]
print("archive.tar.gz".rsplit(".", 1))
# ["archive.tar", "gz"]

split() starts from the left; rsplit() starts from the right. One right-hand split separates the last file extension without cutting earlier periods.

Read fields and convert quantities

line = "Lovelace,Ada,1815"
parts = line.split(",")
if len(parts) == 3:
    last = parts[0]
    first = parts[1]
    year = int(parts[2])
    print(f"{first} {last} was born in {year}.")

The output is "Ada Lovelace was born in 1815.". The length check prevents a missing item from causing IndexError. It does not check that the year is numeric; that needs a separate input rule when the data may be invalid.

Every split part starts as a string. To total "3 14 15", initialize total = 0, loop over line.split(), and add int(part). The result is 32; concatenating the unconverted pieces would join digits.

An explicit separator keeps surrounding spaces. "a, b".split(",") gives ["a", " b"]. Call strip() on each part if those spaces are unwanted.

Recognize two related results

splitlines() separates line breaks: "line one\nline two".splitlines() gives two strings. partition("=") always returns a three-part tuple: the text before the first separator, the separator, and the text after. "user=ada".partition("=") gives ("user", "=", "ada"); with "user", it gives ("user", "", "").

join() builds one string from a sequence of strings. The string before the dot supplies the separator, which appears between adjacent items.

Put the separator first

colors = ["red", "green", "blue"]
text = ", ".join(colors)
print(text)  # red, green, blue

Read this as “use comma-space to join the colors.” There is no separator before the first item or after the last. You can change the output layout by changing only the separator:

join() belongs to the separator string. Writing ["a", "b"].join(",") raises AttributeError because the list has no join method. A single call also adapts to the number of pieces; you do not need to write a new chain of + operations for each different list length.

Convert nonstring pieces first

All pieces must already be strings. ", ".join([1, 2, 3]) raises TypeError. map(str, items) applies str() to each item, so this works:

items = [1, 2, 3]
text = " ".join(map(str, items))
print(text)  # 1 2 3

The str passed to map() is the conversion function. join() receives the converted pieces and returns one string.

A string is itself a sequence of one-character strings, so " ".join("ABC") gives "A B C". This can be useful, but passing one word when you meant a list of words puts separators between its characters.

Reshape spacing and separators

text = "too   many    spaces"
cleaned = " ".join(text.split())
print(cleaned)  # too many spaces

First, whitespace splitting produces the three words. Joining them with one space chooses a consistent gap and leaves no outer spaces. Original spacing is lost at the split step.

With an explicit separator, the empty fields preserve enough information to rebuild the exact text. If s = "a,,b,", then s.split(",") gives ["a", "", "b", ""], and ",".join(...) gives "a,,b," again. The separator must be the same for that exact reconstruction.

Changing the separator changes the layout: "-".join("2026/07/04".split("/")) gives "2026-07-04". Here replace("/", "-") is also a direct solution.

Collect a small result from words

For an acronym, split "portable network graphics", start acronym = "", and add word[0].upper() for each word. Whitespace splitting supplies nonempty words, so their first characters exist. This builds "PNG". If the letters are already in a list, ".".join(["P", "N", "G"]) builds "P.N.G" with no trailing period.

An f-string is a string literal with f or F before its opening quote. Inside it, braces hold expressions whose values are inserted into the text.

Insert variables and expressions

name = "Ada"
age = 36
message = f"{name} is {age} years old."
print(message)  # Ada is 36 years old.

Numbers become text automatically inside a field. The same message could use concatenation and str(age), but the f-string keeps the final layout visible in one place.

The braces can hold arithmetic, method calls, or function calls:

price = 4.5
qty = 3
print(f"Cost: {price * qty}")  # Cost: 13.5
print(f"Name: {name.upper()}")  # Name: ADA
word = "Python"
print(f"{len(word)} letters")  # 6 letters

Python evaluates each expression when the line runs. A saved string does not stay connected to the variables used to build it. If qty changes after message has been built, that string keeps its existing characters.

Distinguish ordinary text from fields

Without the prefix, "Hello {name}" is ordinary text and keeps its braces. The missing f is a common reason a program prints the variable name instead of its value. With the prefix, a name that has not been assigned raises NameError when the expression runs.

To show a literal brace, double it:

x = 5
print(f"{{x}} = {x}")  # {x} = 5

The doubled braces supply the literal text {x}. The single pair around the final x supplies its value.

Keep quoted expressions easy to read

Use the other kind of quote inside a field:

print(f"Shout: {'hi'.upper()}")  # Shout: HI

This style works in all Python versions with f-strings, which began in 3.6. Python 3.12 and later also allow reusing the outer quote type inside the field. Escape sequences still work in f-strings: f"Name: {name}\nAge: {age}" prints on two lines.

For a quick debugging display, Python 3.8 and later accept = after an expression. With x = 5, f"{x=}" gives "x=5"; with total = 12, f"{total = }" gives "total = 12". Spaces typed around the expression and equals sign appear in the display.

Read older formatting styles

Existing Python code may build the same text in other ways:

str.format() fills brace fields from its arguments. Numbered fields can reuse an argument: "{0} {1} {0}".format("a", "b") gives "a b a". In percent formatting, %s inserts text and %d a whole number. Recognizing those fields helps you read a program even when it was written before f-strings were common.

A format specifier controls how a value is displayed. Put a colon after the expression, then the instructions: f"{value:spec}". Formatting returns text and leaves the original numerical value unchanged.

Set decimal places and understand rounding

.Nf shows exactly N digits after the decimal point. f"{3.14159:.2f}" gives "3.14", f"{2/3:.3f}" gives "0.667", and f"{5:.2f}" gives "5.00". .0f shows no decimal point: f"{7.6:.0f}" gives "8".

Rounding uses the value actually stored. Most decimal fractions are very close binary approximations. The float 2.675 is slightly below that exact decimal, so f"{2.675:.2f}" gives "2.67". Exactly halfway values round to the even final digit: 0.125 displays as "0.12", while 0.375 displays as "0.38" at two decimal places. f"{2.5:.0f}" gives "2". Programs needing exact money calculations often store whole cents as integers.

Add grouping and percentages

A comma groups thousands; the point introduces decimal precision. For a dollar amount, keep the dollar sign outside the field: with amount = 1250.5, f"${amount:,.2f}" gives "$1,250.50".

The % type multiplies by 100 and adds %. Use a fraction such as 0.256 to display 25.6%. If you supply 25.6, the displayed percentage is multiplied again. Without an explicit precision, % shows six decimal places.

Format whole numbers and date parts

d is for integers. f"{42:d}" works, but f"{3.0:d}" raises ValueError because a float is not an integer. A leading zero before a width adds zero padding; a plus sign requests a visible sign:

print(f"{7:03d}")   # 007
print(f"{5:+d}")    # +5
print(f"{-5:+d}")   # -5

For month 7, day 4, and year 2026, f"{month:02d}/{day:02d}/{year}" builds "07/04/2026". For hour 9 and minute 5, f"{hour}:{minute:02d}" builds "9:05". The zero padding prevents a one-digit minute from appearing as "9:5".

Combine instructions in order

The order is fill, alignment, sign, zero, width, grouping, precision, type. You can omit unneeded parts. f"{12345.678:>12,.2f}" uses right alignment, width 12, comma grouping, and two decimals, giving " 12,345.68".

Precision can come from another variable: with places = 3, f"{3.14159:.{places}f}" gives "3.142". The same specifiers work in format(value, spec) and str.format() fields. Keep the original number for calculations; round(value, 2) returns a rounded number when that is what the calculation needs.

A field width reserves a minimum number of character positions for a value. Combining widths makes short tables and receipts readable in a terminal.

Choose width and alignment

Strings align left by default, and numbers align right. f"{'cat':6}" gives "cat ", while f"{42:6}" gives " 42". Use an alignment character to choose explicitly:

When centering leaves an odd number of spaces, f-string alignment puts the extra space on the right: f"{'hi':^7}" gives " hi ".

Width is a minimum. f"{'elephant':4}" still gives "elephant"; it does not cut the word. A long entry can therefore push later columns out of line.

Add a fill character or limit text

A fill character goes immediately before alignment. f"{'hi':*^10}" gives "****hi****", and f"{7:0>3}" gives "007". Fill needs an alignment character. f"{'':-^20}" fills an empty field with twenty dashes.

String precision limits the number of characters shown:

place = "Washington"
print(f"{place:.4}")      # Wash
print(f"|{place:10.4}|")  # |Wash      |

The precision first limits the displayed text to four characters; the width then pads it to ten. Use matching width and precision when text must stay inside a fixed column. The original place is still "Washington".

Build one receipt row

item = "Apples"
qty = 3
price = 4.50
row = f"{item:<8}{qty:>4}{qty * price:>9.2f}"
print(row)

The result is "Apples 3 13.50". The item field has six letters and two spaces. The quantity field adds three spaces before 3. The cost field adds four spaces before 13.50, which has five characters. Together the fields occupy 21 characters.

Reuse those widths for bread (1 at 2.25) and coffee (2 at 11.00). Their rows are "Bread 1 2.25" and "Coffee 2 22.00". A total row can combine the first two fields:

print(f"{'Total':<12}{37.75:>9.2f}")
# "Total           37.75"

The cost field begins at the same position and has the same decimal precision, so the amounts align.

Match the layout to its display

Choose widths that leave room for the longest entries and spacing, or shorten text deliberately. A variable can supply a width: with w = 10, f"{name:<{w}}" pads name to ten characters.

Character-based columns need a monospaced font such as a terminal uses. For plain padding outside an f-string, ljust() and rjust() behave like < and >. center() and ^ both center text but can split odd padding differently: "hi".center(7) gives " hi ", while f"{'hi':^7}" gives " hi ".