{"title":"String Methods","description":"","content":"A Python string carries dozens of built-in methods. They cover the day-to-day work you'll do on text: cleaning up user input, searching for substrings, replacing characters, splitting an address into parts, joining items into a single line. This lesson groups those methods into families so you can pick the right tool fast, and it shows the gotchas that trip people up when methods look almost identical but behave differently.\n\nOne rule applies to every method below: strings are immutable, so every method that \"changes\" a string actually returns a brand new string. The original is untouched. For now, just know that `name.upper()` doesn't change `name`, it gives you back a new uppercase string that you have to assign somewhere.\n\n---\n\n# Case Methods\n\nUser input is messy. A customer types `\"john@example.com\"`, another types `\"JOHN@Example.COM\"`, a third types `\" John@Example.Com \"`. Before you can compare them, search for them in a database, or use them as a dictionary key, you need a normalized form. Case methods are how you get there.\n\n\n```python\nemail = \"John@Example.COM\"\n\nprint(email.lower())\nprint(email.upper())\nprint(email.title())\nprint(email.swapcase())\nprint(email.capitalize())\n```\n\n\nEach call returns a fresh string. The variable `email` still holds `\"John@Example.COM\"` after all five calls. If you want to keep the lowercase version, you have to assign it: `email = email.lower()`.\n\n`.title()` capitalizes the first letter of every \"word\", where a word is a run of letters separated by non-letters. That's why it capitalizes the `E` in `Example` and the `C` in `Com`. It works for product names but breaks on apostrophes, so `\"o'brien\".title()` gives `\"O'Brien\"` (correct) but `\"don't\".title()` gives `\"Don'T\"` (wrong). Use it only when you trust the input.\n\n`.capitalize()` is different: it uppercases the first character of the whole string and lowercases everything else. That's why the `E` in `Example` and the `C` in `Com` came back as lowercase. Useful for normalizing a single product name where you want exactly one capital letter at the start.\n\n`.swapcase()` flips the case of every letter. It's rarely useful in production code, but you'll see it in puzzles and string-manipulation interview questions.\n\nThere's one more method in this family worth knowing about: `.casefold()`. It looks like `.lower()` but is more aggressive when it comes to non-ASCII characters. The German letter `ß` lowercases to itself, but casefolds to `\"ss\"`, which is the form you actually want for case-insensitive comparison. For any text outside plain English, `.casefold()` is the safer choice for normalizing before a comparison.\n\n\n```python\ngerman_word = \"STRAßE\"\nprint(german_word.lower())\nprint(german_word.casefold())\n```\n\n\nA summary of the case methods:\n\n\n| Method | Returns | Mutates? | Example |\n| --- | --- | --- | --- |\n| `.lower()` | Lowercased copy | No | `\"ABC\".lower()` is `\"abc\"` |\n| `.upper()` | Uppercased copy | No | `\"abc\".upper()` is `\"ABC\"` |\n| `.title()` | Title-cased copy | No | `\"hello world\".title()` is `\"Hello World\"` |\n| `.capitalize()` | First char up, rest lower | No | `\"hELLO\".capitalize()` is `\"Hello\"` |\n| `.swapcase()` | Each letter's case flipped | No | `\"AbC\".swapcase()` is `\"aBc\"` |\n| `.casefold()` | Aggressive lowercase | No | `\"STRAßE\".casefold()` is `\"strasse\"` |\n\n\n---\n\n# Whitespace Methods\n\nThe most common cleanup task on user input is stripping whitespace. A customer types their email into a form, hits paste, and accidentally grabs a leading space. Now `\" alice@shop.com\"` won't match `\"alice@shop.com\"` in your database lookup, and you'll send back a \"user not found\" error for no good reason. The strip family fixes this in one call.\n\n\n```python\nemail = \" alice@shop.com \"\n\nprint(email.strip())\nprint(email.lstrip())\nprint(email.rstrip())\n```\n\n\n`.strip()` removes whitespace from both ends. `.lstrip()` only from the left, `.rstrip()` only from the right. None of them touch whitespace in the middle, so `\" hello world \".strip()` gives `\"hello world\"` with the inner spaces intact.\n\nWhitespace here means more than just the space character. It includes tabs (`\\t`), newlines (`\\n`), carriage returns (`\\r`), and a few other Unicode whitespace characters. That covers most of what shows up when someone copies and pastes.\n\n\n```python\nmessy = \"\\n\\t Wireless Mouse \\r\\n\"\nprint(messy.strip())\n```\n\n\nAll the leading newlines, tabs, and trailing carriage returns are gone in one shot.\n\nThe strip methods also accept an argument: a string of characters to strip. This is where people get burned. The argument is treated as a **set of characters**, not as a substring to remove.\n\n**What's wrong with this code?**\n\n\n```python\nfilename = \"product.png\"\nprint(filename.strip(\".png\"))\n```\n\n\nThe reader expected `\"product\"`. Instead they got `\"roduct\"`, with the leading `p` chewed off. That's because `.strip(\".png\")` doesn't strip the substring `\".png\"`. It strips any character that appears in the set `{\".\", \"p\", \"n\", \"g\"}` from both ends, repeatedly, until it hits a character not in the set. So it removed the trailing `g`, `n`, `p`, `.`, then started on the front and removed the leading `p` too.\n\nIf you want to remove a specific suffix, use `.removesuffix()` (added in Python 3.9):\n\n\n```python\nfilename = \"product.png\"\nprint(filename.removesuffix(\".png\"))\nprint(\"checkout-page.html\".removeprefix(\"checkout-\"))\n```\n\n\n`.removesuffix()` and `.removeprefix()` only remove the exact substring if it's there, and return the original string unchanged if it isn't. They're the right tool whenever you mean \"trim this exact ending\" rather than \"trim any of these characters\".\n\nThe strip-with-argument form is useful when you really do want to strip a set of characters. Trimming punctuation, for example:\n\n\n```python\nreview = \"!!!Great product...???\"\nprint(review.strip(\"!.?\"))\n```\n\n\nEvery leading and trailing `!`, `.`, or `?` gets removed. The interior text is left alone.\n\n\n| Method | What it strips | Example |\n| --- | --- | --- |\n| `.strip()` | Whitespace from both ends | `\" hi \".strip()` is `\"hi\"` |\n| `.lstrip()` | Whitespace from left only | `\" hi \".lstrip()` is `\"hi \"` |\n| `.rstrip()` | Whitespace from right only | `\" hi \".rstrip()` is `\" hi\"` |\n| `.strip(\"xyz\")` | Any char in the set, both ends | `\"xyhixy\".strip(\"xy\")` is `\"hi\"` |\n| `.removeprefix(\"...\")` | Exact prefix substring | `\"a-b\".removeprefix(\"a-\")` is `\"b\"` |\n| `.removesuffix(\"...\")` | Exact suffix substring | `\"a.txt\".removesuffix(\".txt\")` is `\"a\"` |\n\n\n\n> **INFO**\n>\n> **Cost:** All of these allocate a new string. For a one-off strip on user input, that's fine. If you're stripping millions of strings in a loop, the allocations add up; consider whether you can avoid the work entirely (for example, by validating input before storing).\n\n\n---\n\n# Search Methods\n\nSearching is the next big family. You want to know whether one string contains another, where it appears, how many times it appears, or whether it starts or ends with something specific. Python gives you a method for each.\n\nThe simplest check is the `in` operator, which returns a boolean:\n\n\n```python\nproduct = \"Wireless Bluetooth Headphones\"\n\nprint(\"Bluetooth\" in product)\nprint(\"Wired\" in product)\n```\n\n\nThat's the answer to \"does it contain\". For \"where does it appear\", use `.find()` or `.index()`:\n\n\n```python\nproduct = \"Wireless Bluetooth Headphones\"\n\nprint(product.find(\"Bluetooth\"))\nprint(product.find(\"USB\"))\n```\n\n\n`.find()` returns the index of the first occurrence, or `-1` if the substring isn't there. The `-1` sentinel is the source of an entire category of bugs. People write `if product.find(\"Bluetooth\"):` and forget that `0` (a valid index) is falsy in Python. If \"Bluetooth\" appeared at the very start, the `if` would be skipped. The right pattern is to compare explicitly:\n\n\n```python\nposition = product.find(\"Bluetooth\")\n\nif position != -1:\n print(\"Found it at index \" + str(position))\nelse:\n print(\"Not found\")\n```\n\n\n`.index()` does the same search but raises `ValueError` if the substring is missing, instead of returning `-1`:\n\n\n```python\nproduct = \"Wireless Bluetooth Headphones\"\n\nprint(product.index(\"Bluetooth\"))\nprint(product.index(\"USB\"))\n```\n\n\nSo `.find()` is for \"I might not find it, give me a sentinel.\" `.index()` is for \"I expect this to be here, complain loudly if it isn't.\" Pick based on whether absence is normal (find) or exceptional (index).\n\n`.rfind()` and `.rindex()` are the right-hand counterparts: they return the index of the **last** occurrence, scanning from the right. Handy when you want the position of the final separator, like the last dot in a filename:\n\n\n```python\nfilename = \"product.image.thumbnail.png\"\n\nprint(filename.find(\".\"))\nprint(filename.rfind(\".\"))\n```\n\n\nThe first dot is at index 7, the last dot at index 22. To get the file extension you'd use `.rfind(\".\")` and then slice from there.\n\nTo count how often a substring appears, use `.count()`:\n\n\n```python\nreview = \"Great great great product. Five stars.\"\n\nprint(review.count(\"great\"))\nprint(review.count(\"Great\"))\nprint(review.lower().count(\"great\"))\n```\n\n\n`.count()` is case-sensitive. To count all variants regardless of case, lowercase first. Note that `.count()` finds non-overlapping occurrences, scanning left to right. For example, `\"aaaa\".count(\"aa\")` returns `2`, not `3`, because after matching the first `\"aa\"` it picks up at index 2.\n\n\n> **INFO**\n>\n> **Cost:** `.find()`, `.index()`, `.count()`, and `in` all scan the string. The cost is roughly proportional to the length of the string and the substring (worst case, length of string times length of pattern). For everyday strings this is invisible. For huge documents, consider whether you can index or pre-process once instead of searching repeatedly.\n\n\n`.startswith()` and `.endswith()` answer the boolean questions \"does this start with X\" and \"does this end with X\":\n\n\n```python\norder_id = \"ORD-2024-00478\"\n\nprint(order_id.startswith(\"ORD-\"))\nprint(order_id.endswith(\".png\"))\nprint(order_id.endswith(\"0478\"))\n```\n\n\nThe hidden-gem feature here is that both methods accept a **tuple** of options, and return `True` if any of them match. This is way cleaner than chaining `or`:\n\n\n```python\nfilename = \"invoice.pdf\"\n\nprint(filename.endswith((\".pdf\", \".png\", \".jpg\", \".jpeg\")))\nprint(filename.endswith((\".txt\", \".csv\")))\n```\n\n\nOne call covers any number of allowed extensions. Use this whenever you find yourself writing `name.endswith(\".pdf\") or name.endswith(\".png\") or name.endswith(...)`.\n\nThe same trick works for prefixes:\n\n\n```python\nurl = \"https://shop.example.com/products\"\n\nprint(url.startswith((\"http://\", \"https://\")))\n```\n\n\nA summary of the search family:\n\n\n| Method | Returns | If not found | Example |\n| --- | --- | --- | --- |\n| `in` | `bool` | `False` | `\"abc\" in \"xabcx\"` is `True` |\n| `.find(sub)` | First index | `-1` | `\"hello\".find(\"l\")` is `2` |\n| `.rfind(sub)` | Last index | `-1` | `\"hello\".rfind(\"l\")` is `3` |\n| `.index(sub)` | First index | Raises `ValueError` | `\"hello\".index(\"l\")` is `2` |\n| `.rindex(sub)` | Last index | Raises `ValueError` | `\"hello\".rindex(\"l\")` is `3` |\n| `.count(sub)` | Number of occurrences | `0` | `\"banana\".count(\"a\")` is `3` |\n| `.startswith(s)` | `bool` (accepts tuple) | `False` | `\"hello\".startswith(\"he\")` is `True` |\n| `.endswith(s)` | `bool` (accepts tuple) | `False` | `\"hello\".endswith(\"lo\")` is `True` |\n\n\n---\n\n# Modify Methods\n\nThe most-used method in this family is `.replace()`. It returns a new string with every occurrence of one substring swapped for another:\n\n\n```python\ndescription = \"Bluetooth Speaker, Bluetooth Headphones, Bluetooth Mouse\"\n\nprint(description.replace(\"Bluetooth\", \"Wireless\"))\n```\n\n\nBy default `.replace()` swaps every occurrence. If you only want to swap the first N matches, pass a third argument:\n\n\n```python\nprint(description.replace(\"Bluetooth\", \"Wireless\", 1))\nprint(description.replace(\"Bluetooth\", \"Wireless\", 2))\n```\n\n\nThe `count` argument is useful for surgical edits where you know exactly how many to change.\n\n`.replace()` is also the standard tool for stripping unwanted characters out of a string entirely. Replace with the empty string and they vanish:\n\n\n```python\nphone_input = \"(555) 123-4567\"\n\ncleaned = phone_input.replace(\"(\", \"\").replace(\")\", \"\").replace(\"-\", \"\").replace(\" \", \"\")\nprint(cleaned)\n```\n\n\nThree chained replacements clear out the formatting characters. Each `.replace()` allocates a new string, so for a single short input this chained form is fine. For heavy cleanup work, the next method is more efficient.\n\n\n> **INFO**\n>\n> **Cost:** Each `.replace()` call scans the entire string and allocates a new one. Chaining four replaces on a one-megabyte string does roughly four megabytes of work. For light cleanup this is fine; for bulk work, see `.translate()` below.\n\n\n`.translate()` paired with `str.maketrans()` does multiple character substitutions in a single pass. The `maketrans()` helper builds a translation table mapping characters to characters (or to `None`, which deletes them):\n\n\n```python\nphone_input = \"(555) 123-4567\"\n\nremove_chars = str.maketrans(\"\", \"\", \"() -\")\nprint(phone_input.translate(remove_chars))\n```\n\n\nThe first two arguments to `maketrans()` are paired character mappings (we don't need any here, so they're empty). The third argument is a string of characters to delete. The resulting table tells `.translate()` \"drop every `(`, `)`, space, and `-`\". One pass through the string handles all four deletions.\n\nYou can also use `.translate()` for character substitutions. Build the table from two equal-length strings, where each character in the first maps to the character at the same index in the second:\n\n\n```python\nswap_table = str.maketrans(\"aeiou\", \"AEIOU\")\nprint(\"alice's wishlist\".translate(swap_table))\n```\n\n\nEvery vowel got uppercased in one pass. For a single character class like vowels this is overkill (you could use a regex or a comprehension), but for transliteration tasks (like normalizing accented characters) it's a fast, clean approach.\n\n\n| Method | Purpose | Returns |\n| --- | --- | --- |\n| `.replace(old, new)` | Replace all occurrences | New string |\n| `.replace(old, new, count)` | Replace first `count` occurrences | New string |\n| `.translate(table)` | Map or delete characters using a table | New string |\n| `str.maketrans(...)` | Build a translation table for `.translate()` | Dict-like table |\n\n\nHere's a small flow showing a common normalization pipeline: take a messy product name from user input, and turn it into a clean URL slug.\n\n\n```mermaid\nflowchart LR\n INPUT[\" Bluetooth Speaker \"]:::cyan --> S1[\".strip()\"]:::orange\n S1 --> S2[\"Bluetooth Speaker\"]:::green\n S2 --> S3[\".lower()\"]:::orange\n S3 --> S4[\"bluetooth speaker\"]:::green\n S4 --> S5[\".replace(' ', '-')\"]:::orange\n S5 --> OUT[\"bluetooth-speaker\"]:::teal\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 teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nIn code:\n\n\n```python\nraw_name = \" Bluetooth Speaker \"\nslug = raw_name.strip().lower().replace(\" \", \"-\")\nprint(slug)\n```\n\n\nMethod chaining like this is everyday Python. Each call returns a new string, and the next method is invoked on that result. The original `raw_name` stays exactly as it was.\n\n---\n\n# Split and Join Methods\n\nSplitting and joining are how you move between strings and lists. Splitting takes one string and breaks it into a list of pieces. Joining takes a list of pieces and stitches them back into one string. Together they handle most CSV-like text processing without ever needing a regex.\n\n`.split()` breaks a string at every occurrence of a separator:\n\n\n```python\ncsv_line = \"alice,bob,charlie,diana\"\nprint(csv_line.split(\",\"))\n\naddress = \"742 Evergreen Terrace, Springfield, OR, 97477\"\nprint(address.split(\", \"))\n```\n\n\nThe separator can be any string, not just a single character. That's why `\", \"` (comma plus space) cleanly splits the address into its four parts.\n\nIf you call `.split()` with no argument, it does something special: it splits on any run of whitespace, and ignores leading and trailing whitespace entirely:\n\n\n```python\nreview = \" Great product excellent value \"\nprint(review.split())\nprint(review.split(\" \"))\n```\n\n\nThe two calls give very different results. `.split()` with no argument is the right call for parsing words out of natural text. `.split(\" \")` is literal: every single space becomes a delimiter, so consecutive spaces produce empty strings, and leading/trailing spaces produce empty strings too. Beginners reach for `.split(\" \")` thinking it's the same thing. It almost never is.\n\nYou can also limit the number of splits with the `maxsplit` argument:\n\n\n```python\nlog_line = \"ERROR: Payment failed: card declined: insufficient funds\"\nprint(log_line.split(\": \", 1))\nprint(log_line.split(\": \", 2))\n```\n\n\n`maxsplit=1` gives you \"head\" and \"everything else\", which is great for parsing log lines or `Key: Value` headers. `maxsplit=2` gives you the first two pieces and the rest as one string.\n\n`.rsplit()` works the same way but counts from the right. With no `maxsplit` it produces the same result as `.split()`. The difference shows up only when you cap the split count:\n\n\n```python\nfilepath = \"data/products/electronics/laptops.csv\"\nprint(filepath.split(\"/\", 1))\nprint(filepath.rsplit(\"/\", 1))\n```\n\n\n`.rsplit(\"/\", 1)` is the standard pattern for separating a path into \"directory\" and \"filename\" without writing index math.\n\n`.splitlines()` is the right way to break text into a list of lines. It handles every line ending Python knows about (`\\n`, `\\r\\n`, `\\r`, plus a few exotic Unicode line separators) without you having to think about it:\n\n\n```python\nmulti = \"Wireless Mouse\\nBluetooth Speaker\\r\\nUSB Charger\"\nprint(multi.splitlines())\nprint(multi.split(\"\\n\"))\n```\n\n\n`.split(\"\\n\")` doesn't know about Windows-style `\\r\\n`, so it leaves a stray `\\r` on the second line. `.splitlines()` handles all line-ending styles in one call. Always prefer it for text that came from a file or the network.\n\nBy default `.splitlines()` drops the line endings from each line. Pass `keepends=True` if you want them preserved:\n\n\n```python\nprint(multi.splitlines(keepends=True))\n```\n\n\n`.join()` is the inverse of `.split()`. It takes an iterable of strings and stitches them together with a separator. The method is called on the separator, not on the list, which trips up people who are new to Python:\n\n\n```python\nitems = [\"Wireless Mouse\", \"Bluetooth Speaker\", \"USB Charger\"]\n\nprint(\", \".join(items))\nprint(\" | \".join(items))\nprint(\"\\n\".join(items))\n```\n\n\nThe separator goes between elements, never at the start or end. So `\", \".join([\"a\", \"b\", \"c\"])` gives `\"a, b, c\"`, not `\"a, b, c, \"`.\n\n`.join()` only works on iterables of strings. Pass it a list of integers and you'll get a `TypeError`:\n\n\n```python\nprices = [29, 14, 9]\nprint(\", \".join(prices))\n```\n\n\nThe fix is a generator expression that converts each item to a string first:\n\n\n```python\nprices = [29, 14, 9]\nprint(\", \".join(str(price) for price in prices))\n```\n\n\n\n> **INFO**\n>\n> **Cost:** `.split()` allocates a new list and a new string for every piece. For a megabyte of CSV with ten thousand rows, that's ten thousand small string objects plus a list. Usually this is fine; if you're processing huge files line-by-line, iterate over the file object instead of reading it all and splitting.\n\n\n`.partition()` and `.rpartition()` are a different take on splitting. They always return a 3-tuple: the part before the separator, the separator itself, and the part after. If the separator isn't found, the first part contains the whole string and the other two are empty.\n\n\n```python\nemail = \"alice@shop.example.com\"\n\nprint(email.partition(\"@\"))\nprint(email.rpartition(\".\"))\nprint(email.partition(\"#\"))\n```\n\n\n`.partition(\"@\")` cleanly splits an email into local part and domain. `.rpartition(\".\")` pulls the file extension off the end. The fixed three-tuple shape makes unpacking convenient:\n\n\n```python\nemail = \"alice@shop.example.com\"\n\nlocal, _, domain = email.partition(\"@\")\nprint(\"Local: \" + local)\nprint(\"Domain: \" + domain)\n```\n\n\nThe `_` is a Python convention for \"I don't care about this value\". Here we don't need the separator string, just the parts on either side.\n\n\n| Method | Returns | Notes |\n| --- | --- | --- |\n| `.split(sep)` | List of pieces | No-arg form splits on any whitespace, drops empties |\n| `.rsplit(sep, maxsplit)` | List of pieces | Counts splits from the right |\n| `.splitlines()` | List of lines | Handles `\\n`, `\\r\\n`, `\\r` |\n| `sep.join(iterable)` | One joined string | All items in iterable must be strings |\n| `.partition(sep)` | 3-tuple `(before, sep, after)` | Splits on first occurrence only |\n| `.rpartition(sep)` | 3-tuple `(before, sep, after)` | Splits on last occurrence only |\n\n\n---\n\n# Predicate (Test) Methods\n\nPredicate methods return a boolean answer to a question about the entire string: \"is every character a digit\", \"is every character a letter\", \"is the whole thing whitespace\". They're the right tool when you want to validate input cheaply, before reaching for a regex or a try/except.\n\nA common job is checking whether a string of digits really only contains digits, before you try to convert it to an integer:\n\n\n```python\nzip_input = \"97477\"\nprint(zip_input.isdigit())\n\nbad_input = \"97477x\"\nprint(bad_input.isdigit())\n\nempty_input = \"\"\nprint(empty_input.isdigit())\n```\n\n\n`.isdigit()` is `True` only if the string is non-empty and every character is a digit. The empty string returns `False`, which matches the intuition: \"is every character a digit\" is vacuously satisfiable, but Python chose to return `False` to make the method useful as a guard.\n\nThere are three closely related predicates that all answer \"is this digits\": `.isdigit()`, `.isnumeric()`, and `.isdecimal()`. They differ in what they accept beyond plain ASCII digits:\n\n\n| Method | Accepts | Example of what's `True` for this but `False` for the others |\n| --- | --- | --- |\n| `.isdecimal()` | Only decimal digit characters (0-9 and equivalents in other scripts) | `\"٠١٢\"` (Arabic-Indic digits) |\n| `.isdigit()` | All `.isdecimal()` plus things like superscripts | `\"²\"` (superscript 2) |\n| `.isnumeric()` | All `.isdigit()` plus fractions and Roman numerals | `\"½\"`, `\"Ⅻ\"` |\n\n\nFor e-commerce work where you want to validate a quantity, stock count, or zip code, `.isdecimal()` is the safest choice because it only accepts characters that `int()` can actually parse. `.isdigit()` will say `True` for `\"²\"` even though `int(\"²\")` raises `ValueError`. For everyday English-only input the three behave identically; the differences only matter when you handle text from other scripts.\n\n`.isalpha()` is true only when every character is a letter:\n\n\n```python\nprint(\"Alice\".isalpha())\nprint(\"Alice 1\".isalpha())\nprint(\"\".isalpha())\n```\n\n\nThe space in `\"Alice 1\"` and the digit both knock it out of \"all letters\". A typical check for a customer's first name would use `.isalpha()` after you've stripped whitespace.\n\n`.isalnum()` widens to letters and digits, both ASCII and Unicode:\n\n\n```python\nprint(\"ABC123\".isalnum())\nprint(\"ABC 123\".isalnum())\nprint(\"ABC_123\".isalnum())\n```\n\n\nThe space and the underscore both make `.isalnum()` return `False`. Useful for validating product codes that should be alphanumeric only.\n\n`.isspace()` is `True` only when the string is non-empty and every character is whitespace. Handy for detecting \"the user just hit space and submitted\":\n\n\n```python\nprint(\" \".isspace())\nprint(\" a \".isspace())\nprint(\"\".isspace())\n```\n\n\nFor case predicates, `.isupper()` and `.islower()` ignore characters that have no case (digits, punctuation, spaces) and check the cased characters:\n\n\n```python\nprint(\"HELLO\".isupper())\nprint(\"HELLO123\".isupper())\nprint(\"Hello\".isupper())\nprint(\"123\".isupper())\n```\n\n\nThe third example fails because of the lowercase letters in `\"Hello\"`. The fourth fails because `\"123\"` has no cased characters at all, so the method returns `False` (it needs at least one cased character to evaluate).\n\n\n> **INFO**\n>\n> **Cost:** Predicate methods scan the whole string. They short-circuit on the first failing character, so for a long string with a non-matching character early on, they return fast. They never allocate a new string, which makes them noticeably cheaper than calling `.strip()` followed by an equality check.\n\n\nA summary of the predicates worth remembering:\n\n\n| Method | Returns `True` when | Empty string returns |\n| --- | --- | --- |\n| `.isdecimal()` | Every char is a decimal digit | `False` |\n| `.isdigit()` | Every char is a digit (including superscripts) | `False` |\n| `.isnumeric()` | Every char is numeric (digits, fractions, Roman) | `False` |\n| `.isalpha()` | Every char is a letter | `False` |\n| `.isalnum()` | Every char is a letter or digit | `False` |\n| `.isspace()` | Every char is whitespace | `False` |\n| `.isupper()` | All cased chars are uppercase, at least one cased | `False` |\n| `.islower()` | All cased chars are lowercase, at least one cased | `False` |\n\n\n---\n\n# A Note on Immutability\n\nEvery method in this lesson returns a brand new string. None of them change the original. This is a recurring source of bugs for people new to Python:\n\n\n```python\nname = \"alice\"\nname.upper()\nprint(name)\n```\n\n\n`name.upper()` produced the string `\"ALICE\"`, but nothing caught it, so it was discarded. To actually update `name`, you have to assign:\n\n\n```python\nname = \"alice\"\nname = name.upper()\nprint(name)\n```\n\n\nThis isn't an oversight in the language; it's the deliberate design of strings as immutable objects. The rule of thumb is simple: if a string method seems to \"do nothing\", you probably forgot to assign the result.\n\n---\n\n# Quiz","pageType":"python"}

Get Premium