{"title":"String Operations","description":"","content":"Strings carry a lot of built-in behavior: they can be glued together, repeated, searched, tested for numeric content, case-changed, and trimmed. This lesson covers those operations in depth. The examples use product names, customer input, order IDs, and search queries.\n\n---\n\n# Concatenation: `+` and `join`\n\nThe `+` operator glues two strings end-to-end, returning a new string:\n\n\n```python\nfirst_name = \"Aarav\"\nlast_name = \"Mehta\"\n\nfull_name = first_name + \" \" + last_name\nprint(full_name)\n```\n\n\nThree strings concatenated: the first name, a single space, the last name. Both operands of `+` must be strings; Python does not convert a number. Mixing types raises `TypeError`.\n\nFor two or three pieces, `+` works fine. The problem appears when building a long string out of many pieces in a loop:\n\n\n```python\nproduct_names = [\"Mouse\", \"Keyboard\", \"Monitor\", \"Cable\", \"Webcam\"]\n\nresult = \"\"\nfor name in product_names:\n result += name + \", \"\n\nprint(result)\n```\n\n\nThis works, but it's slow at scale. Strings are immutable, so each `+=` doesn't append in place. It allocates a brand-new string, copies the entire existing content into it, then copies the new piece on the end. For five names the cost is negligible. For fifty thousand log lines or a CSV row built from a thousand cells, the quadratic cost stacks up.\n\nThe standard fix is `str.join()`, which builds the final string in a single pass. Call it on the separator and pass an iterable of strings:\n\n\n```python\nproduct_names = [\"Mouse\", \"Keyboard\", \"Monitor\", \"Cable\", \"Webcam\"]\n\nresult = \", \".join(product_names)\nprint(result)\n```\n\n\nOne allocation, no intermediate copies. The separator goes between elements, not at the end, which is the usual goal. To join non-strings, convert them first using a generator expression:\n\n\n```python\nquantities = [3, 1, 2, 5, 4]\nprint(\", \".join(str(q) for q in quantities))\n```\n\n\n`s += piece` inside a loop is O(n²) in the total length, because each step copies everything seen so far. `\"\".join(parts)` is O(n). For a few items, either works. For thousands, use `join`.\n\n\n```mermaid\nflowchart LR\n A[Start: empty string]:::cyan -->|+= piece1| B[Allocate new
copy old
add piece1]:::orange\n B -->|+= piece2| C[Allocate new
copy all
add piece2]:::orange\n C -->|+= piece3| D[Allocate new
copy all
add piece3]:::orange\n D --> E[Each step
copies everything]:::red\n\n F[List of pieces]:::cyan -->|join| G[Measure total length
Allocate once
Copy each piece]:::green\n G --> H[\"One pass, O(n)\"]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe top path shows `+=` in a loop: every iteration allocates a fresh string and copies everything from the previous step. The bottom path shows `join`: Python walks the iterable once to compute the total size, allocates that buffer, then copies each piece into place. Same result, different performance characteristics.\n\n---\n\n# Repetition with `*`\n\nMultiplying a string by an integer repeats it that many times:\n\n\n```python\ndivider = \"-\" * 30\nseparator = \"= \" * 10\n\nprint(divider)\nprint(separator)\n```\n\n\nOrder doesn't matter: `30 * \"-\"` produces the same string as `\"-\" * 30`. Both forms are valid. The other operand must be an `int`, not a float; `\"abc\" * 2.5` raises `TypeError`.\n\nA zero or negative multiplier gives an empty string instead of an error:\n\n\n```python\nprint(repr(\"abc\" * 0))\nprint(repr(\"abc\" * -3))\n```\n\n\n`repr` is used here so the empty strings are visible. The \"negative gives empty\" behavior matters when a quantity turns negative through bad input upstream: the result is an empty divider rather than a crash.\n\nA use of `+` and `*` together for a quick banner:\n\n\n```python\ntitle = \"ORDER CONFIRMED\"\nprint(\"=\" * 40)\nprint(\" \" * 12 + title)\nprint(\"=\" * 40)\n```\n\n\nFor anything more elaborate, the f-string format spec handles alignment and padding more cleanly. For a horizontal rule or a column of stars, `*` is the simpler form.\n\n---\n\n# Membership: `in` and `not in`\n\n`in` returns `True` if the substring on the left appears anywhere in the string on the right:\n\n\n```python\nproduct_name = \"Wireless Bluetooth Headphones\"\n\nprint(\"Bluetooth\" in product_name)\nprint(\"USB\" in product_name)\nprint(\"phones\" in product_name)\nprint(\"Wireless\" not in product_name)\n```\n\n\nThe match doesn't have to align with word boundaries. `\"phones\"` matches because those characters appear inside `\"Headphones\"`. `in` is case-sensitive: `\"bluetooth\"` (lowercase) would not match. For case-insensitive checks, lowercase both sides first.\n\n`in` answers the simple \"does this contain that\" question. For position, count, or replacement, use one of the methods below (`find`, `index`, `count`, `replace`). `if s.find(sub) != -1` is verbose; `if sub in s` reads cleaner.\n\n---\n\n# Comparison: Lexicographic Order\n\nThe comparison operators (`<`, `<=`, `==`, `!=`, `>`, `>=`) all work on strings. They compare character by character based on Unicode code point values:\n\n\n```python\nprint(\"apple\" < \"banana\")\nprint(\"apple\" < \"apricot\")\nprint(\"Apple\" < \"apple\")\nprint(\"Mouse\" == \"mouse\")\nprint(\"Z\" < \"a\")\n```\n\n\nThe first comparison stops at the first character: `'a' < 'b'`, so `\"apple\" < \"banana\"`. The second goes deeper: both start with `'a'`, then `'p'`, then they differ at the third character (`'p'` vs `'r'`), and `'p' < 'r'`.\n\nThe third and fifth comparisons reveal an important detail. Uppercase letters have lower code points than lowercase ones in ASCII. `'A'` is 65, `'a'` is 97, `'Z'` is 90. So `\"Apple\" < \"apple\"` is `True`, and `\"Z\" < \"a\"` is also `True`. This is the lexicographic order Python uses, and it does not match human alphabetical order:\n\n\n```python\nproducts = [\"banana\", \"Apple\", \"Cherry\", \"apricot\"]\nprint(sorted(products))\n```\n\n\nAll the capitalized words come before all the lowercase ones, because uppercase code points are smaller. For human-friendly alphabetical sorting, pass a key function that normalizes case:\n\n\n```python\nproducts = [\"banana\", \"Apple\", \"Cherry\", \"apricot\"]\nprint(sorted(products, key=str.lower))\n```\n\n\n`str.lower` is used as the key, so the comparison happens on the lowercased version of each string. The original case in the list is preserved; only the comparison sees the lowercase version.\n\nFor sorting user-visible names with proper locale handling (Spanish ñ, German ß, accented characters), use the `locale` module or a library like PyICU. The default lexicographic order is fine for sorting order IDs or hashes; it's not a substitute for true alphabetical sorting in a UI.\n\n---\n\n# Length: `len`\n\n`len(s)` returns the number of characters in the string:\n\n\n```python\nproduct_name = \"Wireless Headphones\"\nemail = \"aarav@example.com\"\nempty = \"\"\n\nprint(len(product_name))\nprint(len(email))\nprint(len(empty))\n```\n\n\n`len` counts every character, including spaces and punctuation. It's O(1) because Python stores the length of every string when it's created; there's no walking through the characters to count them. Calling `len(s)` repeatedly inside a loop is cheap.\n\nFor ASCII text the character count matches the byte count, but for strings with accented characters or characters from other writing systems the two diverge. `\"café\"` has length `4` (four characters) but encodes to `5` bytes in UTF-8 because `é` takes two bytes.\n\n---\n\n# Iteration: `for char in s`\n\nA string is a sequence, so a `for` loop walks through its characters left to right:\n\n\n```python\norder_id = \"ORD-2024\"\n\nfor char in order_id:\n print(char)\n```\n\n\nEach iteration binds the loop variable to one character. There's no separate \"character\" type in Python; each iteration's value is a string of length one. To also get the index, use `enumerate`:\n\n\n```python\norder_id = \"ORD-2024\"\n\nfor index, char in enumerate(order_id):\n print(index, char)\n```\n\n\nThis is cleaner than writing a `range(len(s))` loop and indexing manually. Iteration combines naturally with the other string operations.\n\nA common use is counting characters that match some condition. The compact form uses `sum` with a generator expression:\n\n\n```python\nreview = \"Great laptop! Battery lasts forever. 5 stars!\"\n\nexclamations = sum(c == \"!\" for c in review)\ndigits = sum(c.isdigit() for c in review)\nspaces = sum(c == \" \" for c in review)\n\nprint(f\"Exclamations: {exclamations}\")\nprint(f\"Digits: {digits}\")\nprint(f\"Spaces: {spaces}\")\n```\n\n\n`sum` adds booleans as `1` and `0`. The expression `c.isdigit()` returns `True` for digit characters and `False` otherwise, so summing across the string counts the matches in one pass.\n\n---\n\n# Reversal: `s[::-1]`\n\nTo get a reversed copy of a string, use the slicing form `s[::-1]`.\n\n\n```python\nproduct = \"laptop\"\norder_id = \"ORD-2024\"\n\nprint(product[::-1])\nprint(order_id[::-1])\n```\n\n\nThe slice `[::-1]` means \"from start to end, step -1\", which walks the string backwards. This pattern shows up often enough to treat as a fixed idiom.\n\n`reversed(s)` returns an iterator (not a string). It's useful for iterating the characters in reverse without building a new string:\n\n\n```python\nproduct = \"laptop\"\n\nfor c in reversed(product):\n print(c)\n```\n\n\nFor the reversed string itself, `\"\".join(reversed(product))` works but `product[::-1]` is shorter and faster. Use `reversed` only when an iterator is required (memory savings on very long strings, or when feeding it to another iterator-aware function).\n\n---\n\n# Checking Properties\n\nEvery string has a family of `is...` methods that ask \"does this string consist entirely of characters from a particular category\". They all return `True` for the matching string and `False` otherwise. They also all return `False` for the empty string.\n\n\n| Method | Returns `True` when every character is | Empty string |\n| --- | --- | --- |\n| `isdigit()` | A digit (`0`-`9` and some unicode digit characters) | `False` |\n| `isalpha()` | A letter | `False` |\n| `isalnum()` | A letter or digit | `False` |\n| `isspace()` | Whitespace (space, tab, newline, etc.) | `False` |\n| `isupper()` | An uppercase letter (must have at least one letter) | `False` |\n| `islower()` | A lowercase letter (must have at least one letter) | `False` |\n| `istitle()` | Title-cased (first letter of each word upper, rest lower) | `False` |\n\n\nSeveral methods in action:\n\n\n```python\nprint(\"12345\".isdigit())\nprint(\"12.45\".isdigit())\nprint(\"ORD2024\".isalnum())\nprint(\"ORD 2024\".isalnum())\nprint(\"Aarav Mehta\".istitle())\nprint(\"aarav mehta\".istitle())\nprint(\" \\t\\n\".isspace())\n```\n\n\n`\"12.45\".isdigit()` is `False` because of the period. `\"ORD 2024\".isalnum()` is `False` because of the space. `\"Aarav Mehta\"` is title-cased: first letter of each word is upper, the rest are lower. `\"aarav mehta\"` isn't.\n\nA common (and incorrect) use is checking whether a string is a valid integer with `isdigit`. It works for unsigned positive integers, but it returns `False` for negatives because `'-'` isn't a digit:\n\n\n```python\nprint(\"42\".isdigit())\nprint(\"-42\".isdigit())\nprint(\"3.14\".isdigit())\n```\n\n\nFor a reliable \"is this convertible to an int\" check, try the conversion and catch the exception:\n\n\n```python\ndef is_integer(s):\n try:\n int(s)\n return True\n except ValueError:\n return False\n\nprint(is_integer(\"42\"))\nprint(is_integer(\"-42\"))\nprint(is_integer(\"3.14\"))\nprint(is_integer(\"\"))\n```\n\n\n`int()` accepts an optional leading sign and rejects floats, which matches the practical meaning of \"is this an integer string\". The exception-based form is the idiomatic Python approach.\n\n---\n\n# Case Operations\n\nStrings have six methods for changing case:\n\n\n| Method | What it does | Example | Result |\n| --- | --- | --- | --- |\n| `upper()` | All uppercase | `\"Hello\".upper()` | `\"HELLO\"` |\n| `lower()` | All lowercase | `\"Hello\".lower()` | `\"hello\"` |\n| `title()` | First letter of each word upper, rest lower | `\"new arrival\".title()` | `\"New Arrival\"` |\n| `capitalize()` | First letter upper, rest lower | `\"new ARRIVAL\".capitalize()` | `\"New arrival\"` |\n| `swapcase()` | Upper becomes lower, lower becomes upper | `\"Hello\".swapcase()` | `\"hELLO\"` |\n| `casefold()` | Aggressive lowercase for comparison | `\"ß\".casefold()` | `\"ss\"` |\n\n\nA practical example: case-insensitive search by normalizing both sides:\n\n\n```python\nsearch_query = \"HEADPHONES\"\nproduct_titles = [\n \"Wireless Bluetooth Headphones\",\n \"Mechanical Keyboard\",\n \"Noise Cancelling Headphones\",\n \"USB-C Charging Cable\",\n]\n\nquery_lower = search_query.lower()\nfor title in product_titles:\n if query_lower in title.lower():\n print(\"Match:\", title)\n```\n\n\nBoth the query and each title get lowercased before the `in` check, so the comparison is effectively case-insensitive. For most English text, `.lower()` is enough. For text with mixed scripts or special-cased characters like German ß, `.casefold()` is the more correct choice because it handles cases where one character lowercases to multiple. `\"Straße\".casefold()` is `\"strasse\"`, while `\"Straße\".lower()` is `\"straße\"`.\n\n`s.lower()` allocates a new string. In a tight loop comparing many strings against a constant query, lowercase the query once before the loop, not on every iteration.\n\nA common bug pattern: forgetting that case methods return new strings instead of mutating:\n\n**What's wrong with this code?**\n\n\n```python\nproduct_name = \"wireless mouse\"\nproduct_name.title()\nprint(product_name)\n```\n\n\n`product_name.title()` returns a new string but the result is thrown away. Strings are immutable; methods like `title`, `lower`, and `upper` never modify the original.\n\n**Fix:**\n\n\n```python\nproduct_name = \"wireless mouse\"\nproduct_name = product_name.title()\nprint(product_name)\n```\n\n\nAssign the result back to the variable (or to a new name) to retain it.\n\n---\n\n# Searching: `find`, `index`, `count`, `startswith`, `endswith`\n\nOnce a substring's presence is confirmed (`in`), the next questions are usually \"where\" and \"how many times\". Five methods cover those.\n\n`find(sub)` returns the lowest index of the first occurrence of `sub`, or `-1` if `sub` isn't present:\n\n\n```python\nemail = \"aarav@example.com\"\n\nprint(email.find(\"@\"))\nprint(email.find(\".\"))\nprint(email.find(\"?\"))\n```\n\n\nThe `-1` return allows checks without exceptions: `if email.find(\"@\") >= 0`. For the simple \"is it there\" question, `if \"@\" in email` reads better.\n\n`index(sub)` is like `find` but raises `ValueError` when the substring isn't present:\n\n\n```python\nemail = \"aarav@example.com\"\n\nprint(email.index(\"@\"))\ntry:\n print(email.index(\"?\"))\nexcept ValueError as e:\n print(\"Not found:\", e)\n```\n\n\nUse `find` when \"not present\" is a normal case to handle with a value. Use `index` when \"not present\" indicates a bug and should raise. The choice mirrors the one between `dict.get(key)` and `dict[key]`.\n\n`count(sub)` returns the number of non-overlapping occurrences:\n\n\n```python\nreview = \"Great product! Fast shipping! Great value!\"\n\nprint(review.count(\"Great\"))\nprint(review.count(\"!\"))\nprint(review.count(\"aa\"))\n```\n\n\nNon-overlapping matters for tricky cases. `\"aaaa\".count(\"aa\")` is `2`, not `3`, because Python finds the first `aa` (positions 0-1), then starts the next search at position 2 and finds another `aa` (positions 2-3). It doesn't double-count.\n\n`startswith(prefix)` and `endswith(suffix)` are boolean checks for the ends of the string:\n\n\n```python\nfilename = \"invoice_2024.pdf\"\norder_id = \"ORD-2024-0042\"\n\nprint(filename.endswith(\".pdf\"))\nprint(filename.endswith(\".txt\"))\nprint(order_id.startswith(\"ORD-\"))\nprint(order_id.startswith(\"INV-\"))\n```\n\n\nBoth methods accept a tuple of prefixes or suffixes and return `True` if any of them matches:\n\n\n```python\nfilename = \"invoice_2024.pdf\"\n\nprint(filename.endswith((\".pdf\", \".doc\", \".txt\")))\nprint(filename.endswith((\".jpg\", \".png\", \".gif\")))\n```\n\n\nThis is cleaner than chaining `or` conditions. It's the standard form for checking whether a filename is in a known set of extensions or whether an order ID belongs to one of several prefixes.\n\n---\n\n# Replacing: `replace`\n\n`replace(old, new)` returns a new string with every occurrence of `old` replaced by `new`:\n\n\n```python\nproduct_description = \"Wireless Bluetooth Headphones - Wireless Audio\"\n\nprint(product_description.replace(\"Wireless\", \"Wired\"))\nprint(product_description.replace(\" \", \"_\"))\nprint(product_description.replace(\"xyz\", \"abc\"))\n```\n\n\nReplacing something that isn't present is fine; the method returns the original string unchanged. To replace only the first N occurrences, pass a third integer argument:\n\n\n```python\ntext = \"one one one one\"\nprint(text.replace(\"one\", \"1\", 2))\n```\n\n\nOnly the first two occurrences become `1`; the rest stay as `one`.\n\nA common use is normalizing user input before validation: strip the dashes or spaces a customer typed into a phone number or order ID:\n\n\n```python\norder_id_input = \"ORD - 2024 - 0042\"\nclean = order_id_input.replace(\" \", \"\").replace(\"-\", \"\")\nprint(clean)\n```\n\n\nTwo `replace` calls in sequence: first remove spaces, then remove dashes. Both return new strings, so chaining works naturally.\n\n`replace` is case-sensitive. For case-insensitive replacement, either lowercase both sides (which loses the original case) or use the `re` module's `re.sub` with `re.IGNORECASE`.\n\nEach `replace` call walks the string once and allocates a new one. Chaining several `replace` calls walks the string several times. For a single pass with multiple substitutions, `str.translate` (with `str.maketrans`) does the work in O(n) regardless of how many character substitutions stack up.\n\n---\n\n# Stripping Whitespace: `strip`, `lstrip`, `rstrip`\n\nInput from a customer or a line read from a file almost always needs leading and trailing whitespace removed before processing. The three strip methods do this:\n\n\n| Method | Removes from | Example |\n| --- | --- | --- |\n| `strip()` | Both ends | `\" Mouse \".strip()` is `\"Mouse\"` |\n| `lstrip()` | Left end only | `\" Mouse \".lstrip()` is `\"Mouse \"` |\n| `rstrip()` | Right end only | `\" Mouse \".rstrip()` is `\" Mouse\"` |\n\n\nA practical use:\n\n\n```python\ncustomer_email = \" Aarav@Example.com\\n\"\n\nclean_email = customer_email.strip()\nprint(repr(clean_email))\nprint(repr(customer_email))\n```\n\n\n`strip()` removes spaces, tabs, newlines, and other whitespace characters from both ends. The middle of the string is untouched. The original `customer_email` is unchanged because, like all string methods, `strip` returns a new string.\n\nBy default the strip methods remove whitespace. A string argument specifies which characters to strip instead. Important: the argument is a **set** of characters, not a substring to remove:\n\n\n```python\norder_id = \"###ORD-2024###\"\nfilename = \"report.csv.gz\"\n\nprint(order_id.strip(\"#\"))\nprint(filename.rstrip(\".gz\"))\nprint(filename.removesuffix(\".gz\"))\n```\n\n\nThe first call strips `#` from both ends. The second call has surprising behavior: `rstrip(\".gz\")` strips any combination of `.`, `g`, and `z` from the right end, which produces `report.csv` for this input but would also strip `report.csv.gzgzgzgg` down to `report.csv.`. For substring suffix removal, Python 3.9 added `removesuffix` (and `removeprefix`), which removes the exact substring if it's there:\n\n\n```python\nfilename = \"report.csv.gz\"\nalso = \"report.csv\"\n\nprint(filename.removesuffix(\".gz\"))\nprint(also.removesuffix(\".gz\"))\nprint(filename.removeprefix(\"report_\"))\n```\n\n\n`removesuffix` returns the original string unchanged if the suffix isn't present. Use it for cleanly chopping file extensions, ID prefixes, or trailing markers. Older code often misused `rstrip` for the same purpose before 3.9 made the proper version available.\n\nA common bug is forgetting that strip takes a character set, not a substring:\n\n**What's wrong with this code?**\n\n\n```python\nurl = \"https://shop.example.com\"\nprint(url.lstrip(\"https://\"))\n```\n\n\nThis happened to produce the expected output for the input above. A different input shows the bug:\n\n\n```python\nurl = \"https://hello.example.com\"\nprint(url.lstrip(\"https://\"))\n```\n\n\n`lstrip(\"https://\")` removes any leading characters that are in the set `{'h', 't', 'p', 's', ':', '/'}`. The leading `h` of `hello` matches, then `e` doesn't, so stripping stops. But `https://h` strips down to `e`, and then `e` doesn't match. Both `h`s got eaten. Use `removeprefix(\"https://\")` for proper prefix removal.\n\n---\n\n# Best Practices Summary\n\nA short list of habits that pay off:\n\n- **Prefer `join` over `+=` for building strings in loops.** O(n) versus O(n²). For small numbers of pieces, either works.\n- **Use f-strings for building strings out of values.** `f\"{name}: ${price:.2f}\"` is faster and clearer than concatenation.\n- **Use `in` first, then `find` / `index` / `count` when position or counts are needed.** `if \"@\" in email` reads better than `if email.find(\"@\") >= 0`.\n- **Lowercase both sides for case-insensitive comparison, or use `casefold()` for stronger normalization.** Don't compare with case mismatched.\n- **Use `removeprefix` / `removesuffix` (3.9+) for exact prefix/suffix removal.** `lstrip` and `rstrip` with arguments strip character sets, not substrings.\n- **Remember immutability.** Methods return new strings. Assign the result back to retain it. The original is never modified.\n- **`strip()` with no argument removes whitespace. `strip(chars)` replaces the default with the given character set.** A common pitfall.\n- **Pass tuples to `startswith` and `endswith` for multiple-extension checks.** `filename.endswith((\".pdf\", \".doc\"))` is cleaner than `or`-chains.","pageType":"python"}

String Operations

Get Premium