String indexing, slicing, and methods

Understand the concept

Strings are immutable Unicode sequences

A Python string contains Unicode code points. Indexing returns a one-character string for one code point, and slicing returns another string. Its characters cannot be replaced by item assignment. Methods such as replace and strip produce new strings, so keep the returned value when you need the transformation.

The length of a string counts code points, not bytes, display columns, or every user's idea of a visible character. An accented character can use one composed code point or a letter plus a combining mark. This course's simple ASCII task labels avoid those complexities in their acceptance fixtures, but real text processing needs a clear policy.

The stop boundary of a slice is excluded. An index outside a string raises IndexError, while an oversized slice is clipped. Empty strings therefore support slices but not a required first-character lookup. Check the actual operation before choosing an emptiness guard.

Strip, split, and join solve different tasks

strip() removes leading and trailing whitespace. It does not remove whitespace inside the string. With an explicit argument, strip treats that argument as a set of characters to remove at the edges, not an exact prefix. Use removeprefix or removesuffix when a literal boundary substring is intended.

split() without an argument groups whitespace-separated text and ignores leading/trailing whitespace runs. split(',') uses that exact separator and can retain empty fields. Those contracts differ: an empty CSV-like field may be evidence of missing data rather than something to delete.

separator.join(parts) builds one string from a sequence of strings. A separator belongs between items rather than after every item. Every item must be a string; join does not automatically convert integers. Separating text preparation from formatting makes these requirements easier to test.

Define what a cleaning rule may change

A topic label might ignore surrounding whitespace and case. A person's display name should often preserve their chosen spelling. An account ID may require exact case. A password should not be normalized without a specific contract. “Clean everything” is not a sufficient field-level policy.

Preserve an original value when transformed text is used as a comparison key. Several originals can produce one key; that can be useful for search and dangerous for unique identities. See the linked Unicode article in the source notes for deeper normalization and collision examples.

Worked example

raw = "  Lists, Functions,, Dictionaries  "
fields = raw.strip().split(",")
topics = []
for field in fields:
    cleaned = field.strip().casefold()
    if cleaned:
        topics.append(cleaned)

report = " | ".join(topics)
print("Original:", repr(raw))
print("Fields:", fields)
print("Report:", report)
assert topics == ["lists", "functions", "dictionaries"]
assert report == "lists | functions | dictionaries"
assert raw.startswith("  ")

The literal vertical bars in the displayed report are separators, not set-union operators. Context determines the meaning of the character. The original source is unchanged because the transformations created new strings and lists.

Guided practice

1. Predict: compare "a,,b".split(',') with " a b ".split(). The first retains an empty comma-separated field; the second produces two whitespace-separated words.
2. Modify: preserve original case for display while using casefolded keys only for duplicate detection. Explain which collection stores display labels and which stores membership keys.
3. Reconstruct: remove a literal prefix "topic:" from a label using removeprefix, then trim surrounding whitespace. Compare that with strip using the same characters and explain why the latter can remove unintended edge letters.

Before using a string method, write one expected transformation and one value that should remain unchanged. This discourages a broad rule that looks convenient but damages valid data.

Daily challenge

Implement clean_topic_list(text). Accept comma-separated topic labels. Trim each field, exclude blanks, deduplicate case-insensitively, and preserve the first cleaned spelling and original order. Return a list of display labels. Do not sort it and do not change interior spaces.

The final case demonstrates the exact policy: surrounding whitespace is ignored, while internal spacing remains significant. A different application may collapse internal runs, but this contract does not.

Reference solution

def clean_topic_list(text):
    result = []
    seen = set()
    for field in text.split(","):
        display = field.strip()
        key = display.casefold()
        if not display or key in seen:
            continue
        seen.add(key)
        result.append(display)
    return result

assert clean_topic_list(" Lists, functions,LISTS, , Strings ") == ["Lists", "functions", "Strings"]
assert clean_topic_list("") == []
assert clean_topic_list("  Data Science ,data science ") == ["Data Science"]
assert clean_topic_list("A  B,A B") == ["A  B", "A B"]
print("Text policy passed")

Debug and explain

If a transformation has no visible effect, check whether you ignored the returned string. If blank fields disappear unexpectedly, check which split form you used. If distinct IDs merge, inspect the equality policy before blaming the set or dictionary.

Explain why the final two labels in the last case remain distinct, why deduplication retains the first spelling, and why this function is not a CSV parser. Quoted commas require a CSV-aware parser, not this deliberately simple separator contract.

Review and next step

This second checkpoint connects functions, lists, tuples, dictionaries, sets, and strings. Rebuild clean_topic_list and explain each container's purpose. Day 13 adds escapes and formatted reports while keeping original data separate from its presentation.