{"title":"String Basics","description":"","content":"Strings are how Python programs hold any kind of text: a customer's name, a product title, an email address, an order ID. The type is `str`, and every product page, search box, and confirmation message you've ever clicked is, somewhere, a `str` value moving through code. This lesson covers what a string is, how to write one, how to count its characters, how to glue strings together, how to peek inside one character at a time, and how strings behave in `if` and `for`.\n\n---\n\n# What a String Is\n\nA string is a sequence of characters. Concretely, it's a value of the built-in type `str`, and you create one by wrapping text in quotes:\n\n\n```python\nproduct_name = \"Wireless Headphones\"\ncustomer_name = \"Aarav Mehta\"\norder_status = \"shipped\"\n\nprint(product_name)\nprint(customer_name)\nprint(order_status)\nprint(type(product_name))\n```\n\n\nThe variable doesn't store the characters one by one in some loose pile. It stores a single `str` object that holds the whole sequence in order. The order matters: `\"abc\"` and `\"cba\"` are different strings, even though they share the same characters.\n\nPython treats a string as a sequence in the same way it treats a list. You can ask for its length, check whether something is in it, grab one character by position, and walk through it with a `for` loop. We'll go through each of those in turn.\n\nTwo more things to know up front. First, a string can be empty. `\"\"` is a valid `str` with zero characters in it, and you'll create plenty of empty strings as starting points for accumulators or as default values. Second, strings are immutable: once you create one, you can't change a character inside it. We'll just touch on this idea here, the deeper treatment lives in a later lesson.\n\n---\n\n# Single Quotes, Double Quotes, and What's Inside\n\nPython lets you write a string with single quotes or double quotes. Both produce the exact same `str` object:\n\n\n```python\ntitle_a = \"Wireless Headphones\"\ntitle_b = 'Wireless Headphones'\n\nprint(title_a == title_b)\nprint(type(title_a))\nprint(type(title_b))\n```\n\n\nThere's no \"double-quote string\" type and \"single-quote string\" type. The quote characters are just the boundary markers Python uses to figure out where the string starts and ends.\n\nSo why two choices? Because text often contains a quote character, and you want the freedom to pick the boundary that keeps the value readable. If your string has an apostrophe in it, wrap it in double quotes so the apostrophe doesn't end the string early:\n\n\n```python\nreview = \"It's the best laptop I've ever owned.\"\nprint(review)\n```\n\n\nIf your string has double quotes inside it, wrap it in single quotes:\n\n\n```python\nproduct_blurb = 'Now featuring the new \"Pro\" mode for power users.'\nprint(product_blurb)\n```\n\n\nPick the quote style that lets the value sit cleanly inside without escaping. When the text contains neither, the choice is style. Many Python codebases default to double quotes (the `black` formatter, for example, normalizes everything to double quotes), but plenty of projects use single quotes everywhere. Both are fine; just be consistent within a project.\n\nIf a string contains both single and double quotes, you have a few options. The simplest is to escape one of them with a backslash:\n\n\n```python\nmixed = \"He said \\\"It's on sale\\\" and walked off.\"\nprint(mixed)\n```\n\n\nThe `\\\"` tells Python \"this double quote is part of the string, not the end of it.\" Backslash escapes are a topic of their own, and we cover them properly in a later lesson. For now, just know the trick exists.\n\n---\n\n# Counting Characters with `len()`\n\nTo find out how many characters a string has, pass it to the built-in `len()`:\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. The space between `\"Wireless\"` and `\"Headphones\"` adds one to the count. The `@` and `.` in the email each count as one character. An empty string has length `0`.\n\n`len()` is a built-in function, not a method on the string. You call it as `len(s)`, not `s.len()`. This is the same `len()` you've already used (or will use) on lists and other sequences.\n\nA common use case is checking whether some text the customer typed is short enough or long enough to be valid:\n\n\n```python\nsearch_query = \"wireless\"\n\nif len(search_query) < 3:\n print(\"Search must be at least 3 characters\")\nelse:\n print(\"Searching for: \" + search_query)\n```\n\n\nIf the customer typed `\"hi\"`, the length would be `2` and the first branch would fire. Length checks like this are everywhere in form validation: a name must be at least one character, a postal code must be exactly six, an email can't be longer than 320 characters.\n\nOne subtle point. `len()` counts characters, not bytes. For plain ASCII text the two happen to match, but for text that includes accented letters or characters from other writing systems they won't. We come back to that in the unicode lesson; for now, treat `len()` as \"number of characters.\"\n\n---\n\n# Turning Other Values into Strings with `str()`\n\nYou'll often have a value that isn't text yet (a number, a boolean) that you want to treat as a string, usually so you can stick it inside a message. The built-in `str()` does that conversion:\n\n\n```python\nquantity = 3\nprice = 29.99\nin_stock = True\n\nquantity_text = str(quantity)\nprice_text = str(price)\nin_stock_text = str(in_stock)\n\nprint(quantity_text)\nprint(price_text)\nprint(in_stock_text)\nprint(type(quantity_text))\n```\n\n\nThe original `quantity` is still an integer. `str(quantity)` returns a brand-new `str` object that contains the characters `'3'`. Same idea for the float and the boolean. The original variables are untouched, you just have a string version available now.\n\nWhy bother converting? Because Python is strict about mixing types in some places. Trying to glue a number directly onto a string fails until you convert it.\n\nThere's a lot more to formatting numbers (currency symbols, fixed decimal places, padding). `str()` is the no-frills version: take a value, give me its default text form.\n\n---\n\n# Concatenation: Gluing Strings with `+`\n\nThe `+` operator joins two strings end-to-end. The result is a new string containing the characters from the left side followed by the characters from the right side:\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 glued together: the first name, a single space, and the last name. Notice that the space had to be its own string. `+` doesn't add spaces for you. If you write `first_name + last_name`, you get `\"AaravMehta\"`, no gap.\n\nYou can build up longer messages the same way:\n\n\n```python\nproduct = \"Wireless Headphones\"\nstatus = \"shipped\"\n\nconfirmation = \"Your order for \" + product + \" has been \" + status + \".\"\nprint(confirmation)\n```\n\n\nThis is the most basic way to assemble text from pieces. It's not always the prettiest (the chain of `+` and quoted spaces gets noisy fast), and Python has cleaner alternatives, which we cover in the formatting lesson. For two or three pieces, `+` is fine.\n\nThe big rule: both operands must be strings. Python won't quietly convert a number into text for you. This breaks:\n\n**What's wrong with this code?**\n\n\n```python\nquantity = 3\nmessage = \"You have \" + quantity + \" items in your cart.\"\nprint(message)\n```\n\n\n`quantity` is an `int`, not a `str`. The `+` operator doesn't know how to combine those two types, so it raises `TypeError`. The fix is to convert the integer to a string first with `str()`:\n\n**Fix:**\n\n\n```python\nquantity = 3\nmessage = \"You have \" + str(quantity) + \" items in your cart.\"\nprint(message)\n```\n\n\n`str(quantity)` produces `\"3\"`, which `+` is happy to glue onto the surrounding text.\n\nA different (and often cleaner) workaround is to let `print` itself handle the mixed types. `print()` accepts any number of arguments of any type, converts each one to its string form, and joins them with a space:\n\n\n```python\nquantity = 3\nprint(\"You have\", quantity, \"items in your cart.\")\n```\n\n\nNo `str()` needed, no `+` needed. The trade-off: you can't capture this into a variable the same way. `print()` returns `None`, and the string it builds lives only on the screen. When you need the assembled string for further processing, you'll convert and concatenate. When you just want to display it, `print()` with multiple arguments is the easy path.\n\n\n> **INFO**\n>\n> **Cost:** Building a long string by repeated `+=` inside a loop is slower than it looks. Each `+=` allocates a fresh string and copies every character from both sides. For two or three pieces it's invisible; for thousands of pieces it becomes a real cost. The string-immutability lesson covers this in detail and shows the standard `\"\".join(parts)` fix.\n\n\n---\n\n# Repetition with `*`\n\nMultiplying a string by an integer repeats it that many times. The result is a new string:\n\n\n```python\ndivider = \"-\" * 30\nprint(divider)\n\nseparator = \"= \" * 10\nprint(separator)\n```\n\n\n`\"-\" * 30` produces a string of thirty hyphens. `\"= \" * 10` repeats the two-character pattern ten times, giving a 20-character string with alternating equals signs and spaces. Repetition is handy for printing simple visual dividers between sections of a receipt or report.\n\nOrder doesn't matter: `\"-\" * 30` and `30 * \"-\"` give the same result. Both forms are valid Python.\n\nIf you multiply by zero or a negative number, you get an empty string:\n\n\n```python\nnothing = \"abc\" * 0\nalso_nothing = \"abc\" * -5\n\nprint(repr(nothing))\nprint(repr(also_nothing))\nprint(len(nothing))\nprint(len(also_nothing))\n```\n\n\n`repr()` is shown here so the empty strings are visible (otherwise `print('')` just prints a blank line). Both produce a `str` of length `0`. Python doesn't raise an error for negative counts; it treats them as zero. That's worth knowing: if a quantity slips into the wrong sign somewhere upstream, you'll get an empty string rather than a crash.\n\nThe other operand must be an integer. `\"abc\" * 2.5` raises `TypeError`. You can't repeat a string a fractional number of times.\n\nA nice combination of `+` and `*` for visual receipts:\n\n\n```python\ntitle = \"ORDER SUMMARY\"\nprint(\"=\" * 40)\nprint(\" \" * 13 + title)\nprint(\"=\" * 40)\n```\n\n\nTwo rows of equals signs sandwiching a centered title. The title gets centered by prepending the right number of spaces. Crude, but it works for quick console output. Real formatting helpers handle centering for you, but the trick of `\"=\" * 40` for a horizontal rule is something you'll keep using.\n\n---\n\n# Membership: `in` and `not in`\n\nTo check whether a string contains a smaller string, use `in`. The result is a boolean:\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\n`\"Bluetooth\" in product_name` is `True` because those exact characters appear somewhere inside the larger string. `\"USB\" in product_name` is `False`. `\"phones\" in product_name` is also `True`, because `\"phones\"` is the tail end of `\"Headphones\"`. The match doesn't have to align with word boundaries.\n\n`in` is case-sensitive: `\"bluetooth\" in product_name` would be `False` because the stored value capitalizes the `B`. Case-insensitive checks require string methods.\n\n`in` works against single characters too, since a single character is just a string of length one:\n\n\n```python\nemail = \"aarav@example.com\"\n\nprint(\"@\" in email)\nprint(\".\" in email)\nprint(\"?\" in email)\n```\n\n\nA common pattern is a quick category filter for a search box. Here `in` does the substring check directly, with no methods needed:\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\nfor title in product_titles:\n if search_query in title:\n print(\"Match:\", title)\n```\n\n\nTwo of the four titles contain the substring `\"Headphones\"`, so they get printed. This is the simplest possible search: substring match, exact case.\n\n`not in` is just the inverse. It's clearer than writing `not (x in y)`:\n\n\n```python\nemail = \"aarav@example.com\"\n\nif \"@\" not in email:\n print(\"Invalid email address\")\nelse:\n print(\"Looks like an email\")\n```\n\n\nUse `not in` when the natural way to read the condition is \"X isn't in Y.\"\n\n---\n\n# Indexing: Reaching into a String by Position\n\nA string is a sequence, and like any sequence in Python, you can grab one character at a time by writing the position in square brackets. Position counts from zero on the left:\n\n\n```python\nproduct = \"laptop\"\n\nprint(product[0])\nprint(product[1])\nprint(product[2])\nprint(product[5])\n```\n\n\n`product[0]` is the first character, `product[1]` is the second, and so on. The last character of `\"laptop\"` sits at index `5`, because the string has six characters and indexing starts at zero.\n\nYou can also count from the right using negative indices. `-1` is the last character, `-2` is the second-to-last, and so on:\n\n\n```python\nproduct = \"laptop\"\n\nprint(product[-1])\nprint(product[-2])\nprint(product[-6])\n```\n\n\n`product[-6]` and `product[0]` refer to the same character (the leading `l`), just from opposite directions. Negative indices are useful when you don't know (or don't want to compute) the length of the string.\n\nHere's the index map for `\"laptop\"`:\n\n\n```mermaid\nflowchart LR\n L[l
0 / -6]:::cyan --> A[a
1 / -5]:::cyan --> P1[p
2 / -4]:::cyan --> T[t
3 / -3]:::cyan --> O[o
4 / -2]:::cyan --> P2[p
5 / -1]:::cyan\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n```\n\n\nEach box shows the character along with both its forward and backward index. Forward goes left-to-right starting at `0`. Backward goes right-to-left starting at `-1`. Both index systems point to the exact same characters; you choose whichever reads more clearly for what you're doing.\n\nThe result of indexing a string is always another string, of length one. There's no separate \"char\" type in Python:\n\n\n```python\nproduct = \"laptop\"\n\nfirst = product[0]\nprint(first)\nprint(type(first))\nprint(len(first))\n```\n\n\n`first` is a `str` of length `1`. This is different from many other languages, which have a distinct character type. In Python, a single character is just a one-character string, and it behaves like every other string.\n\nIf you ask for an index that isn't there, you get an `IndexError`:\n\n\n```python\nproduct = \"laptop\"\nprint(product[10])\n```\n\n\n`\"laptop\"` only has six characters, so the largest valid forward index is `5` and the smallest valid negative index is `-6`. Anything outside that range raises `IndexError` immediately. There's no \"default\" or \"empty\" character returned for an out-of-range index. If you're not sure a string is long enough, check `len()` first:\n\n\n```python\nproduct_code = \"AB\"\n\nif len(product_code) >= 4:\n category_code = product_code[3]\n print(\"Category:\", category_code)\nelse:\n print(\"Code too short\")\n```\n\n\nThis is the standard guard pattern: check the length, then index. Indexing a single character at a time is fine for occasional access. When you want a slice (the first three characters, the last four characters, every other character), Python has a much nicer notation, and that's the topic of the next-but-one chapter.\n\n---\n\n# Iterating Through a String with `for`\n\nBecause a string is a sequence, you can walk through its characters one at a time with a `for` loop. The loop variable holds each character in turn:\n\n\n```python\nproduct = \"laptop\"\n\nfor char in product:\n print(char)\n```\n\n\nSix iterations, one per character, in left-to-right order. There's no need to manage an index by hand. Python takes care of stepping through the sequence and binds each character to the loop variable.\n\nThe loop variable can be named anything; `char` is just a common convention. Some people use `c`, others use `letter`. Pick what reads well:\n\n\n```python\nemail = \"aarav@example.com\"\nat_count = 0\n\nfor c in email:\n if c == \"@\":\n at_count = at_count + 1\n\nprint(\"Number of @ signs:\", at_count)\n```\n\n\nThis loop scans every character, and every time it sees an `@`, it bumps a counter. The same idea works for counting digits, spaces, or any other character class.\n\nA useful pattern is using the boolean-as-integer trick from the last section's lesson on booleans, combined with `sum()`:\n\n\n```python\nreview = \"Great laptop! Battery lasts forever.\"\nexclamations = sum(c == \"!\" for c in review)\nprint(\"Exclamation marks:\", exclamations)\n```\n\n\nThe generator expression yields `True` and `False`, `sum()` adds them as 1s and 0s, and you get the count without writing an explicit counter and `if`. Same outcome as the loop above, fewer lines.\n\nIf you also want the index alongside the character, use `enumerate()`:\n\n\n```python\nproduct = \"laptop\"\n\nfor index, char in enumerate(product):\n print(index, char)\n```\n\n\n`enumerate()` pairs each character with its position. Without it, you'd be tempted to write a `range(len(product))` loop and index into the string by hand, which works but reads worse.\n\nOne thing to keep in mind: iteration always goes from the start of the string to the end, one character at a time. If you want every other character, the last three characters, or the string in reverse, that's slicing, which has its own dedicated chapter. For \"look at every character once,\" `for char in s` is the right tool.\n\n---\n\n# The Empty String and Truthiness\n\n`\"\"` is a perfectly valid string, just one with zero characters. You'll create empty strings as starting points for accumulators, as default values when you have nothing to show, and as the result of operations that simply produce no characters.\n\n\n```python\ngreeting = \"\"\nprint(repr(greeting))\nprint(len(greeting))\nprint(type(greeting))\n```\n\n\n`repr()` shows the empty string with its surrounding quotes so it's actually visible. Without `repr()`, `print(greeting)` would print a blank line and you couldn't tell the empty string apart from a regular newline.\n\nIn Python, every value has a truth value. When a value is used in an `if` condition or a `while` loop or with `bool()`, Python decides whether to treat it as true or false. For strings, the rule is simple: an empty string is falsy, every other string (no matter what's in it) is truthy:\n\n\n```python\nprint(bool(\"\"))\nprint(bool(\"a\"))\nprint(bool(\" \"))\nprint(bool(\"0\"))\nprint(bool(\"False\"))\n```\n\n\nThe first one is `False` because the string has no characters. Every other case is `True`, including `\" \"` (a single space, one character), `\"0\"` (one character, the digit zero), and `\"False\"` (the letters spelling out `False`). Python doesn't look at what the string says, only at whether it has any characters at all.\n\nThis makes empty-checks read naturally:\n\n\n```python\ncustomer_address = \"\"\n\nif customer_address:\n print(\"Shipping to:\", customer_address)\nelse:\n print(\"No address on file\")\n```\n\n\nWriting `if customer_address:` is the Pythonic way to ask \"does this customer have an address?\" You don't need `if customer_address != \"\":` or `if len(customer_address) > 0:`, although both would also work. The shorter form is preferred in idiomatic Python.\n\nThe same trick works for `not`:\n\n\n```python\nsearch_query = \"\"\n\nif not search_query:\n print(\"Please enter a search term\")\n```\n\n\n`not search_query` is `True` exactly when `search_query` is empty. Reads cleanly: \"if there's no search query, ask for one.\"\n\nOne pitfall to be aware of: a string containing only whitespace (like `\" \"`) is *not* empty. It has three space characters in it, so it's truthy:\n\n\n```python\nmaybe_address = \" \"\n\nif maybe_address:\n print(\"Has an address (technically)\")\n\nprint(len(maybe_address))\n```\n\n\nIf you want to treat a whitespace-only string as \"empty for practical purposes,\" you'll need to strip the whitespace first using a string method. For now, just remember that \"empty\" means zero characters, and a string of spaces isn't empty.\n\n---\n\n# A Note on Immutability\n\nOnce a string exists, you can't change a character inside it. Trying to assign into a position raises an error:\n\n\n```python\nproduct = \"laptop\"\nproduct[0] = \"L\"\n```\n\n\nTo \"change\" a string, you build a new string and re-bind the name:\n\n\n```python\nproduct = \"laptop\"\nproduct = \"L\" + product[1:]\nprint(product)\n```\n\n\nThe original `\"laptop\"` object isn't modified; it's discarded (assuming nothing else points at it) and `product` now refers to the brand-new string `\"Laptop\"`. The slice `product[1:]` is the topic of the next-but-one chapter, and the deeper consequences of immutability (memory, performance, why `+=` in a loop is slow) get their own dedicated chapter later in this section. The takeaway here is just the rule: a `str` object is fixed once created.\n\n---\n\n# Summary\n\n- A string is a `str` value, an ordered sequence of characters created by wrapping text in single or double quotes. Both quote styles produce identical objects; pick whichever avoids escaping inner quotes.\n- `len(s)` returns the number of characters in the string. The empty string `\"\"` has length `0`. `len()` is a built-in, not a method.\n- `str(value)` converts a number, boolean, or other value to its string form. You'll need it before concatenating non-string values onto a string with `+`.\n- Concatenation with `+` glues strings end-to-end. Both operands must be strings, or you get `TypeError`. Repetition with `*` copies a string an integer number of times; multiplying by zero or a negative gives an empty string.\n- `in` and `not in` test whether a substring (or single character) is present. The check is case-sensitive and matches anywhere in the string, not just at word boundaries.\n- Indexing with `s[i]` returns a one-character string. Forward indices start at `0`; negative indices count from the right starting at `-1`. An out-of-range index raises `IndexError`.\n- A `for c in s` loop walks every character left to right. Use `enumerate(s)` when you need the index alongside the character. Strings have no separate \"char\" type; each character is itself a `str` of length one.\n- Strings are immutable. `s[0] = \"X\"` raises `TypeError`; you build a new string and re-bind the name instead. The empty string is falsy in `if`; every non-empty string (even `\" \"` or `\"0\"`) is truthy.\n\nIn the next lesson, we look at the rich set of methods every `str` object carries: case conversion (`upper`, `lower`, `title`), trimming whitespace (`strip`), splitting and joining, searching (`find`, `count`, `replace`, `startswith`, `endswith`), and the case-insensitive search and validation tricks we kept deferring throughout this lesson.","pageType":"python"}

String Basics

Get Premium