Strings: Intermediate

A string is an ordered sequence of characters, and each character sits at a numbered position called its index. Counting starts at 0. Writing text[i] reads the character at position i and returns it as a new string of length 1. An index is an offset, the number of characters you skip from the start to reach this one. The first character needs 0 skips, and the second needs 1.

The string "Python" has 6 characters, so its indexes run from 0 to 5. text[0] is P and text[1] is y; at the far end, text[5] is n. len(text) returns 6 here, the character count. Because the count of skips starts at 0, the last index of a non-empty string is len(text) - 1.

A negative index counts from the right: text[-1] is the last character, text[-2] the one before it, and text[-6] reaches back to P. Python reads -k as len(text) - k, so in this 6-character string -1 means position 5 and -6 means position 0. Negative indexes pay off when lengths vary: the final character of an order ID is order_id[-1] whether the ID has 5 characters or 50.

For the date "2024-03-15", the 2 indexes in every row differ by 10, the length of the string. So 9 and -1 both name the final 5, and 0 and -10 both name the first 2.

A 6-character string accepts indexes from -6 to 5. code[6] asks for a seventh character, so Python stops at line 4 with IndexError. Since len(code) sits 1 position past the last index, it is never a valid index; that off-by-one is how this error usually shows up, often from a loop whose range runs 1 step too far.

A single character in Python is a str of length 1, so indexing a digit hands back text. account[0] + account[-1] concatenates "4" and "7" into 47, and adding the digits as numbers takes int() on each, which gives 11. The loop at the top shows the other way to visit characters: for ch in account delivers each one in order, with no index needed.

Many record formats fix what each position means. A legacy export might pack 4 yes/no answers into one field such as "YNYY": index 0 says whether the account is active, 1 whether its email is verified, 2 whether it opted into marketing, and 3 whether it's a business account. One index reads one answer, and comparing that character with "Y" turns it into True or False.

The last 2 lines are a format check. A DD/MM/YYYY date always has its slashes at positions 2 and 5, so testing those 2 characters accepts 15/03/2024 and rejects 2024-03-15 before a later step reads 20 as the day. The positions are part of the format's contract, and an index is how code holds a value to it.

Slicing pulls out a run of characters in one step. text[start:stop] returns a new string holding the characters from index start up to, but not including, index stop. When both bounds fall inside the string, the result has stop - start characters.

text[0:6] takes positions 0 through 5, the 6 letters of Python. text[7:18] takes positions 7 through 17, the 11 letters of Programming; index 6, the space, belongs to neither slice. Because stop is excluded, 2 slices that share a boundary fit together with nothing lost and nothing doubled: text[0:7] + text[7:18] rebuilds all 18 characters.

Leave out start and the slice begins at 0; leave out stop and it runs to the end. text[:n] is the first n characters, text[n:] is the rest, and text[:n] + text[n:] equals text for every n. In an ISO timestamp such as ts = "2024-03-15T08:42:10Z", each field sits at a fixed position, so a slice reads it with no searching at all.

filename[-4:] starts 4 characters from the end, so it reads the extension however long the name is, and filename[:-4] keeps everything else. The last 3 lines show where slicing parts ways with indexing: a bound past the end is clamped to the length. filename[18:99] stops at the real end, and filename[99:] is an empty string of length 0, printed as a blank line. Clamping makes slices safe on short input and also silent: slicing [:10] from a 6-character value returns 6 characters without complaint, so check len() whenever the width matters.

The third number is the step, how far to move between characters. A step of 2 takes every second character: starting at 0 that gives the even digits, starting at 1 the odd ones. A negative step walks right to left, so [::-1] returns the string reversed. With a negative step, start must sit to the right of stop: digits[7:2:-1] reads positions 7 down to 3 and stops before 2, while digits[2:7:-1] points the wrong way and comes back empty.

Bounds never raise, but a step of 0 would never move, so Python refuses it: digits[::0] raises ValueError: slice step cannot be zero.

Slices are pieces, and + joins them back in a new order or with text added between them. Inserting new at position i is s[:i] + new + s[i:], so a compact date such as "20240315" becomes the dashed form with 2 inserts:

The first slice covers positions 0 to 3. Each later slice starts where the previous one stopped, at 4 and then at 6, and the last ends at 7, so no digit is lost or repeated. The result grows from 8 characters to 10, 1 per dash. A slice whose start equals its stop, such as compact[3:3], holds nothing: it marks the gap between 2 characters, which is where an insert lands.

Slicing needs positions you already know, and real data rarely hands them over: a log level lands wherever the timestamp ends, and an email's @ can be anywhere. Searching answers 2 questions: is this text present, and where does it begin. The in operator answers the first with True or False.

Every search is case-sensitive, so "error" misses ERROR. Lowering the line first, with the lower() method you already know, makes the match ignore case. not in is the negated form, and it reads closer to English than not ("node-9" in line).

The empty string counts as present everywhere: "" in line is True for every line, even an empty one. A search term read from a blank setting therefore matches everything, so check len(term) > 0 before searching.

s.find(sub) returns the index where the first match of sub begins, or -1 when there is none. s.rfind(sub) searches from the right and returns where the last match begins. s.index(sub) gives the same answer as find while the text is present and raises ValueError when it's missing. A Spotify track URI, spotify:track:6rqhFgbbKwnb9MLmUQDhG6, holds 2 colons to search for.

The first colon is at 7 and the last at 13, so the ID starts at 14. find("track") returns 8, the position of the t that opens the match. Pick by what a missing match means. Use find and test for -1 when absence is normal, as in a log line with no level. When absence means the record is broken, index halts the program at that line, which beats writing a wrong value downstream.

first + 1 steps past the first colon so it stays out of the result, and last as the stop keeps the second colon out because the stop is excluded. The code never mentions the word's length, so a playlist URI yields playlist with the same 2 searches. The filename shows why the direction matters: find stops at the first dot and returns 2024-03-15.csv, while rfind lands on the last dot and returns csv.

For "user42", find returns -1, and -1 + 1 is 0, so the slice becomes s[0:], the whole input, returned as if it were the answer with nothing to flag it. Used as an index, the same -1 reads the last character, because -1 is a valid negative index. Test the result before treating it as a position:

find takes an optional start index: s.find(sub, start) ignores everything before start. Starting each search 1 position after the previous hit walks through every match, and the loop ends when find returns -1.

The loop counts 3 matches, the last starting at 17 after ones at 0 and 7, which agrees with log.count("ERR"). count reports matches without overlap: "aaaa".count("aa") is 2, because the scan resumes after the end of each match rather than 1 character later.

startswith and endswith test a prefix or suffix with no length arithmetic. path[-4:] == ".csv" gives the same answer, but its 4 must be edited by hand when the suffix becomes .json, while endswith(".json") carries its own length. Both accept a start index, so startswith("orders", 4) checks the text that begins at index 4.

Strings are immutable: once a string exists, none of its characters can change. Reading by index works, and assigning to an index is refused.

Every edit therefore produces a new string. You can assemble it yourself from slices, as "P" + status[1:] gives Pending, or call a method that assembles it for you. replace(old, new) is the method for substituting one piece of text with another.

Line 2 calls replace and discards the result, so sku prints unchanged; storing the result in clean keeps it. The optional third argument caps how many replacements happen, counting from the left, so replace("-", "", 1) removes only the first dash, and an empty new deletes the text. When old is absent, replace returns an unchanged copy and raises nothing, which hides typos: the red call above did nothing and reported nothing.

Because a missed match is silent, a cleanup that must change something can count first. sku.count("-") is 2, the number of substitutions replace("-", "_") will make, and a count of 0 warns that the call would hand back its input untouched.

replace scans left to right. After substituting a match, it resumes past the text it consumed. "aaaa" holds 2 non-overlapping aa runs, so it becomes bb. In banana the first ana covers positions 1 to 3, the scan resumes at 4, and the ana that would start at 3 is never seen. Inserted text is never rescanned, so replacing each dash with 2 dashes turns a-b into a--b and stops there. Matching is case-sensitive, so only the lowercase cat changes.

Because replace returns a string, another method can run on its result in the same expression. Python evaluates the chain left to right, and each call works on the string the call before it produced:

Each call here removes or swaps a character that no later call looks for, so the calls could run in any order and still give order_date_utc. A chain goes wrong when a later call matches text an earlier call inserted, because a string keeps no record of which characters were original.

Street begins with St, so the second pass turns it into Streetreet. The function checks for the suffix with endswith and rewrites it with a slice, so a second call finds no St ending and returns its input untouched. Calling it once or 5 times produces the same address.

replace works by content: it changes every copy of some text wherever it appears. Masking by position needs find for the position and slices for the edit. With at at 9, the result keeps email[0], adds "*" * (at - 1), which repeats the star 8 times to cover positions 1 to 8, and keeps everything from the @ onward.

An f-string is a string literal with an f before the opening quote. Each pair of braces inside it holds a Python expression; when the line runs, Python evaluates the expression, converts the result to text, and puts that text in place of the braces.

The concatenated version needs str(rows), because + between a string and an int raises TypeError. The f-string converts for you, and the sentence reads in one piece with each value where it appears. {rows // 100} and {table.upper()} put arithmetic and method calls inside the braces, which accept any expression.

Everything from the earlier sections works inside braces. The ID comes from slicing after the last colon, and the share link is assembled around it. len and an index also run in place. A long expression is clearer as a variable of its own, as track_id is here, which keeps the template readable.

A colon after the expression starts a format spec. .2f prints a float with exactly 2 decimals. .1% multiplies by 100 and adds a percent sign, and , groups thousands. For 02, Python pads with zeros to a width of 2. Zero padding matters in dates and partition paths: as text, month=10 sorts before month=3, while month=03 sorts before month=10.

Each spec applies only to the value in its own braces, so one f-string can hold a slice with no spec, a count grouped with ,, and a ratio shown with .1%. The division happens inside the braces and gives 0.125; the spec decides how that float looks and leaves the computed value alone.

Doubled braces {{ and }} print 1 literal brace each, which JSON-shaped text needs. Writing = after an expression prints the expression and its value joined by an equals sign, with quotes around strings: key='region'. Before Python 3.12, including the 3.9 these examples run on, quotes inside the braces must differ from the ones around the f-string: f"{name.replace('-', '_')}" works, and reusing double quotes inside is a SyntaxError. From 3.12 on, reusing the same quotes is allowed.

An f-string is evaluated once, on the line where it appears. msg holds the finished text job is running, and changing status afterwards can't reach back into it. The second print evaluates a fresh f-string, so it sees done.

Inside a loop, the f-string sits on a line that runs once per pass, so each pass evaluates it with that pass's hour. A job that writes one partition per hour runs the same template 24 times and gets 24 different paths, from hour=00 to hour=23.