{"title":"Tuple Operations","description":"","content":"A tuple looks like a list with parentheses, but every operation on it has a small twist: the original tuple cannot change. Concatenation builds a new tuple, slicing copies into a new tuple, and the only methods available are `count()` and `index()`. This lesson walks through `+`, `*`, `in`, `==` and ordering, slicing, iteration, the two tuple methods, nested access, and the common pattern of building a list of tuples to represent product records.\n\n---\n\n# Concatenation With +\n\nThe `+` operator joins two tuples and returns a brand-new tuple. The original tuples are left alone, because tuples are immutable. You cannot modify a tuple in place at all, so there is no in-place equivalent of `extend()` or `+=` that mutates the original.\n\n\n```python\ncart_a = (\"Wireless Mouse\", \"USB Cable\")\ncart_b = (\"HDMI Cable\", \"Webcam\")\n\ncombined = cart_a + cart_b\nprint(combined)\nprint(cart_a)\nprint(cart_b)\n```\n\n\n`combined` is a fresh tuple that holds references to the same string objects from both sources. `cart_a` and `cart_b` are unchanged, because no tuple can ever be changed after it is created.\n\nBoth operands have to be tuples. Mixing a tuple with a list or a string raises `TypeError`:\n\n\n```python\ncart = (\"Wireless Mouse\", \"USB Cable\")\nextra = [\"HDMI Cable\"]\nprint(cart + extra)\n```\n\n\nIf you need to mix sides, convert one of them first: `cart + tuple(extra)`.\n\n\n> **INFO**\n>\n> **Cost:** `t1 + t2` allocates a new tuple of length `len(t1) + len(t2)` and copies every reference from both sides. That is O(n + m). It looks cheap on small tuples, but inside a loop the cost compounds.\n\n\nThe compound assignment `t += other` exists, but on a tuple it does not mutate. It rebinds the name to a brand-new tuple, leaving any other names that pointed at the original tuple still looking at the original.\n\n\n```python\ncart = (\"Wireless Mouse\", \"USB Cable\")\nalias = cart\n\ncart += (\"HDMI Cable\",)\n\nprint(cart)\nprint(alias)\n```\n\n\nFor lists, `+=` mutates the underlying list and both names would see the change. For tuples, `+=` is just a shortcut for `cart = cart + (\"HDMI Cable\",)`, which builds a new tuple and points only `cart` at it. `alias` keeps the original two-item tuple.\n\nA common beginner pattern that grows a tuple in a loop is slow for exactly this reason. Every `all_items = all_items + batch` line builds an entirely new tuple. For a thousand batches, that is a thousand allocations, each one larger than the last, and the total work grows quadratically with the number of iterations.\n\n\n> **INFO**\n>\n> **Cost:** Do not grow a tuple in a loop with `+` or `+=`. If you are accumulating values, collect them in a list with `list.append`, then convert to a tuple at the end with `tuple(my_list)`. Lists are designed for in-place growth; tuples are not.\n\n\n---\n\n# Repetition With *\n\nThe `*` operator on a tuple builds a new tuple by repeating its contents a given number of times. The shape mirrors what `*` does on lists.\n\n\n```python\ndivider = (\"-\",) * 5\nblack = (0,) * 3\nstars_empty = (\"☆\",) * 5\n\nprint(divider)\nprint(black)\nprint(stars_empty)\n```\n\n\nThese are common e-commerce shapes: a divider row of dashes, an RGB color of pure black, an empty star-rating row. You can combine `*` with `+`, and the usual precedence applies: `*` runs before `+`.\n\n\n```python\nstar_rating = (\"★\",) * 3 + (\"☆\",) * 2\nprint(star_rating)\n```\n\n\nA few small rules. Multiplying by `0` or any negative number gives an empty tuple. The multiplier has to be an integer; a float raises `TypeError`:\n\n\n```python\nprint((1, 2) * 0)\nprint((\"a\",) * 2.5)\n```\n\n\nTuples avoid one of the classic list traps. With lists, `[[]] * 3` produces three references to the same inner list, so mutating one row appears to mutate all three. Tuples cannot be mutated, so the shared-reference issue cannot cause that kind of surprise. The references are still shared, but you cannot change the things they point to.\n\n\n> **INFO**\n>\n> **Cost:** `t * n` allocates a new tuple of length `len(t) * n` and copies references. The references all point to the same underlying objects, which is fast and safe for tuples because nothing about a tuple can be changed after creation.\n\n\n---\n\n# Membership With in and not in\n\nThe `in` operator asks whether a value is somewhere inside the tuple, returning `True` or `False`. `not in` is the inverse.\n\n\n```python\nwishlist = (\"Wireless Mouse\", \"HDMI Cable\", \"Webcam\")\n\nprint(\"Wireless Mouse\" in wishlist)\nprint(\"Charger\" in wishlist)\nprint(\"Charger\" not in wishlist)\n```\n\n\nComparison uses `==` under the hood, so it finds values that are equal, not just objects that are identical in memory. For numeric tuples, that means `14.99 in prices` works exactly as a beginner would expect.\n\n\n```python\nprices = (29.99, 14.99, 9.99)\nprint(14.99 in prices)\n```\n\n\nA typical use is gating a piece of logic on whether a product category appears in an allow-list:\n\n\n```python\nallowed_categories = (\"Electronics\", \"Books\", \"Home\")\ncategory = \"Electronics\"\n\nif category in allowed_categories:\n print(f\"{category} is allowed\")\nelse:\n print(f\"{category} is not allowed\")\n```\n\n\nThis is one of the most readable uses of a tuple in real code. A fixed allow-list, comparison-based lookup, no method calls.\n\n\n> **INFO**\n>\n> **Cost:** `x in some_tuple` is O(n). Python walks the tuple from left to right and compares each element with `==` until it finds a match or runs off the end. For a five-item allow-list this is invisible; for a million-item tuple it is slow. If you are checking the same collection many times, build a `set` once and check membership against the set. Sets give O(1) membership on average.\n\n\nThe left-to-right scan also means `in` returns as soon as it finds a match. Checking for an item near the front is cheap; checking for one that is not present is the worst case, because Python has to look at every element to be sure.\n\n---\n\n# Comparing Tuples With ==, <, and >\n\nTwo tuples are equal (`==`) when they have the same length and every pair of corresponding items is equal. Order matters, and the comparison runs recursively through nested tuples.\n\n\n```python\nprint((1, 2, 3) == (1, 2, 3))\nprint((1, 2, 3) == (3, 2, 1))\nprint((1, 2) == (1, 2, 3))\nprint(((1, 2), (3, 4)) == ((1, 2), (3, 5)))\n```\n\n\nOnly the first pair is equal. The second has the same items in different order. The third has different lengths. The fourth differs at the last nested element.\n\nThe ordering operators `<`, `<=`, `>`, and `>=` use **lexicographic** comparison, the same rule a dictionary uses to order words. Python walks both tuples in parallel and compares items at matching positions. The first pair that differs decides the result.\n\n\n```python\nprint((1, 2, 3) < (1, 2, 4))\nprint((1, 2, 3) < (1, 3, 0))\nprint((1, 2) < (1, 2, 0))\n```\n\n\nIn the first line, positions 0 and 1 match, then `3 < 4` at position 2 settles it. In the second, `2 < 3` at position 1 decides things before the loop even reaches the third item. In the third, the tuples match up to where the shorter one ends, and the shorter tuple is considered \"less than\" the longer one. That is the same rule that makes `\"go\" < \"goal\"` for strings.\n\nAll items being compared have to be comparable types. Comparing a tuple of numbers with a tuple of strings raises `TypeError` as soon as Python hits the first mismatched pair. Within the same tuple, mixed types are fine for `==` (they just compare unequal); they only become a problem for ordering when the comparator actually has to decide which is smaller.\n\nA practical e-commerce use is sorting product records. A list of `(price, name)` tuples sorts cleanly by price first, then alphabetically by name on ties, because tuple comparison naturally handles both keys in one pass.\n\n\n```python\nproducts = [\n (29.99, \"Wireless Mouse\"),\n (14.99, \"USB Cable\"),\n (29.99, \"HDMI Cable\"),\n (9.99, \"Cable Tie\"),\n]\n\nfor record in sorted(products):\n print(record)\n```\n\n\nThe two products that share a price of `29.99` get a stable secondary sort by name, because Python's tuple comparison moves on to the next element when the first ones are equal. No custom key function needed.\n\n---\n\n# Slicing a Tuple\n\nSlicing on a tuple has the same shape as slicing on a list: `t[start:stop]`, `t[start:stop:step]`, with the same defaults and the same half-open `stop`. The difference is the return type: slicing a tuple returns a new tuple, not a list.\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\")\n\nprint(products[0:2])\nprint(products[:3])\nprint(products[2:])\nprint(type(products[0:2]))\n```\n\n\nThe stop index is exclusive, so `products[0:2]` covers indices `0` and `1`. Omitting `start` defaults to `0` and omitting `stop` defaults to the tuple length, exactly as in lists.\n\nOut-of-range bounds are lenient, just like with lists. No `IndexError`, just whatever the tuple has in that range:\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\")\n\nprint(products[0:100])\nprint(products[5:10])\n```\n\n\nNegative indices count from the end. `products[-2:]` gives the last two items, `products[:-1]` gives everything except the last. Combining a step with a negative direction gives the reversal idiom you already know from lists:\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\")\n\nprint(products[-2:])\nprint(products[:-1])\nprint(products[::-1])\nprint(products[::2])\n```\n\n\n`products[::-1]` walks the tuple from end to start with a negative step. `products[::2]` walks forward but skips every other element. All four results are tuples, never lists.\n\n### A Subtle Case: `t[:]` on a Tuple\n\nFor lists, `cart[:]` is the standard way to make a shallow copy. For tuples, the same expression behaves differently because of immutability. Since a tuple cannot be changed after creation, Python is free to return the original tuple itself when you ask for a \"copy\" via `t[:]`. CPython does this as an optimization. The two names just point at the same object.\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\")\ncopy_one = products[:]\ncopy_two = tuple(products)\n\nprint(copy_one is products)\nprint(copy_two is products)\n```\n\n\nBoth `products[:]` and `tuple(products)` return the exact same object as `products`. The `is` check confirms identity, not just equality. With a list, `cart[:]` would return a new list object every time. With a tuple, there is no observable difference between \"the original\" and \"a copy\", so Python skips the allocation. This is a CPython optimization. Other Python implementations are allowed to allocate a new tuple if they choose, but the behavior you can rely on is that the copy has the same contents and the same `==` result.\n\nSlicing that produces a strict subset always returns a new tuple. The optimization only applies when the slice covers the entire tuple.\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\")\n\nprint(products[1:3] is products)\nprint(products[:] is products)\n```\n\n\n\n> **INFO**\n>\n> **Cost:** A non-full slice copies `stop - start` references into a fresh tuple, which is O(k) in time and memory. The full-tuple slice `t[:]` may return the original tuple itself (CPython optimization), which is effectively free. Either way, the contents inside the tuple are never deep-copied; only the references are.\n\n\n---\n\n# What `+`, `*`, and Slicing All Have in Common\n\nEverything that produces a tuple result, whether through concatenation, repetition, or slicing, produces a brand-new tuple. Compare that to the list world, where some operations build new lists and others mutate the original in place. With tuples, there is no in-place option at all, so the picture is simpler.\n\n\n```mermaid\nflowchart LR\n T1[tuple t1
Mouse, Cable]:::cyan\n T2[tuple t2
HDMI]:::cyan\n\n PLUS[\"t1 + t2\"]:::orange\n STAR[\"t1 * 2\"]:::orange\n SLICE[\"t1[0:1]\"]:::orange\n\n NEW1[New tuple
Mouse, Cable, HDMI]:::green\n NEW2[New tuple
Mouse, Cable, Mouse, Cable]:::green\n NEW3[New tuple
Mouse]:::green\n\n T1 --> PLUS\n T2 --> PLUS\n PLUS --> NEW1\n\n T1 --> STAR\n STAR --> NEW2\n\n T1 --> SLICE\n SLICE --> NEW3\n\n UNCHANGED[t1 and t2 unchanged
always]:::teal\n T1 -.-> UNCHANGED\n T2 -.-> UNCHANGED\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 classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe diagram shows what every tuple operation does: the originals stay put, and a new tuple is produced. With lists, the equivalent diagram would have two branches at every operation, one for the build-new path (`+`, slicing) and one for the mutate-in-place path (`extend`, `+=`, `sort`). Tuples remove the second branch entirely. The single exception is `t[:]` and `tuple(t)`, where CPython may return the same object because there is nothing to gain from copying an immutable structure.\n\n---\n\n# Iterating With for\n\nA `for` loop walks a tuple one item at a time. The mechanics are the same as for lists or any other iterable.\n\n\n```python\ncart = (\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\")\n\nfor item in cart:\n print(item)\n```\n\n\nWhen you need both the index and the value, `enumerate()` works the same way it does on a list:\n\n\n```python\ncart = (\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\")\n\nfor index, item in enumerate(cart, start=1):\n print(f\"{index}. {item}\")\n```\n\n\n`enumerate()` returns an iterable of `(index, value)` pairs. You may have spotted that each pair is itself a tuple. Iterating over a tuple of tuples is one of the most common shapes in everyday Python, and we look at that pattern in detail at the end of this lesson.\n\n---\n\n# The Two Tuple Methods: count() and index()\n\nA tuple is so minimal that it has only two methods. That is not a typo. Lists have `append`, `extend`, `insert`, `pop`, `remove`, `sort`, `reverse`, and more, because lists can be modified. Tuples cannot be modified, so most of those operations have nowhere to land. The two methods that survive are `count()` and `index()`, both of which only read the tuple.\n\n### count()\n\n`count(value)` returns how many times `value` appears in the tuple. It uses `==` for comparison, so it counts items that compare equal, not just identical objects. A value that never appears returns `0`, never raises.\n\n\n```python\nreviews = (5, 4, 5, 3, 5, 4, 2, 5, 1, 5)\n\nfor stars in range(5, 0, -1):\n print(f\"{stars} stars: {reviews.count(stars)}\")\n```\n\n\n\n> **INFO**\n>\n> **Cost:** `count()` walks the entire tuple, so it is O(n) regardless of how many matches it finds. It cannot stop early, because it has to count every match. If you need counts for several values, building a `collections.Counter` once is more efficient than calling `count()` repeatedly.\n\n\n### index()\n\n`index(value)` returns the position of the first occurrence of `value` in the tuple. If the value is not present, it raises `ValueError`.\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Cable\")\n\nprint(products.index(\"HDMI\"))\nprint(products.index(\"Cable\"))\n```\n\n\n`Cable` appears twice, at index `1` and index `4`. `index()` returns the first occurrence, which is `1`. To find later occurrences, pass a `start` argument:\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Cable\")\n\nprint(products.index(\"Cable\", 2))\n```\n\n\nThe signature is `index(value, start=0, stop=len(tuple))`. The search runs over the slice `[start:stop]`, and the returned index is the absolute position in the original tuple, not an offset into the slice.\n\nWhen the value is missing, `index()` raises `ValueError`. This is unlike `in`, which returns `False` for missing values.\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\")\n\nprint(products.index(\"Charger\"))\n```\n\n\nThe conventional pattern is to guard with `in` first if you are not sure the value is there:\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\")\ntarget = \"Charger\"\n\nif target in products:\n print(products.index(target))\nelse:\n print(f\"{target} is not in the catalog\")\n```\n\n\nThere is a cost trade-off worth knowing about. The `if target in products` check walks the tuple once, and `products.index(target)` walks it again. Two scans on the worst case. For small tuples this is fine. For large tuples where the value is likely missing, it can be cheaper to try `index()` and catch the exception:\n\n\n```python\nproducts = (\"Mouse\", \"Cable\", \"HDMI\")\n\ntry:\n position = products.index(\"Charger\")\n print(position)\nexcept ValueError:\n print(\"not in catalog\")\n```\n\n\nThis is the classic \"look before you leap\" versus \"easier to ask forgiveness than permission\" choice, and both styles are common in Python. Use whichever fits the surrounding code.\n\n\n> **INFO**\n>\n> **Cost:** `index()` is O(n) in the worst case, because Python has to scan until it finds the value or runs off the end. It does return as soon as it finds a match, so a value near the front is cheap.\n\n\n---\n\n# Accessing Nested Tuples\n\nA tuple can hold other tuples. Reading values from a nested tuple uses chained indexing: one set of brackets per layer.\n\n\n```python\norder = (\"Wireless Mouse\", \"Electronics\", (29.99, \"USD\"), (12, 5, 3))\n\nproduct = order[0]\nprice = order[2][0]\ncurrency = order[2][1]\nwidth = order[3][0]\n\nprint(product, price, currency, width)\n```\n\n\n`order[2]` returns the inner tuple `(29.99, \"USD\")`. Adding `[0]` reads the first element of that inner tuple. The brackets read left to right, so `order[2][0]` is \"the first element of the third element of `order`\".\n\nA nested tuple is common in coordinate data. A GPS location can be modeled as a tuple of latitude and longitude paired with a name:\n\n\n```python\nwarehouse = (\"Main Warehouse\", (37.7749, -122.4194))\n\nprint(f\"{warehouse[0]} is at {warehouse[1][0]}, {warehouse[1][1]}\")\n```\n\n\nThe same pattern works for arbitrarily deep nesting, but the readability falls off fast once you get past two levels. If you find yourself writing `data[0][2][1][3]`, the data structure probably wants a different shape, or a `namedtuple`.\n\n---\n\n# Building a List of Tuples\n\nTuples are most useful when each one represents a small, fixed record with parts of different types, and you have many such records. A product can be `(name, category, price, stock)`. An order line can be `(product_name, quantity)`. A coordinate can be `(lat, lon)`. A list of these tuples is one of the most common shapes in everyday Python.\n\n\n```python\nproducts = [\n (\"Wireless Mouse\", \"Electronics\", 29.99, 12),\n (\"HDMI Cable\", \"Electronics\", 14.99, 50),\n (\"Coffee Mug\", \"Home\", 9.99, 8),\n (\"Yoga Mat\", \"Fitness\", 24.99, 3),\n (\"Notebook\", \"Stationery\", 4.99, 100),\n]\n\nfor product in products:\n print(product)\n```\n\n\nThe list grows and shrinks as products are added and removed; the tuples inside it represent individual records that do not need to change.\n\nReading from such a list typically uses indexing inside the loop. To compute the total stock value across the catalog, multiply price by stock for each record:\n\n\n```python\nproducts = [\n (\"Wireless Mouse\", \"Electronics\", 29.99, 12),\n (\"HDMI Cable\", \"Electronics\", 14.99, 50),\n (\"Coffee Mug\", \"Home\", 9.99, 8),\n (\"Yoga Mat\", \"Fitness\", 24.99, 3),\n (\"Notebook\", \"Stationery\", 4.99, 100),\n]\n\ntotal_value = 0\nfor product in products:\n price = product[2]\n stock = product[3]\n total_value += price * stock\n\nprint(f\"Total stock value: ${total_value:.2f}\")\n```\n\n\nAccessing fields by index works, but `product[2]` and `product[3]` are not self-documenting. A reader has to remember which position holds the price. A cleaner pattern uses tuple unpacking in the loop variable. For now, the index-based style is enough to see how a list of tuples behaves.\n\nA filter is just as direct. Print every product priced under twenty dollars by reading the price at index `2`:\n\n\n```python\nfor product in products:\n if product[2] < 20.00:\n print(f\"{product[0]}: ${product[2]:.2f}\")\n```\n\n\nThis is the pattern you will see most often when tuples appear in real Python code: a list of homogeneous records, each one a small tuple, walked with a `for` loop, fields read by index or by unpacking.\n\n---\n\n# What's Wrong With This Code?\n\n\n```python\ndef add_color(palette, color):\n palette += (color,)\n return palette\n\noriginal = (\"red\", \"green\")\nresult = add_color(original, \"blue\")\n\nprint(original)\nprint(result)\n```\n\n\nThe output may surprise someone who expects `+=` to behave the way it does on lists. For lists, `palette += (color,)` would mutate the underlying list, and `original` would hold three items afterward. For tuples, `+=` is rebinding, not mutation. The function builds a new tuple and rebinds its local `palette` to that new tuple. `original` outside the function still points at the unchanged two-item tuple. Tuples cannot be modified, so any expression that looks like it is changing one is really building a new tuple and rebinding a name.\n\n**Fix:** return the new tuple and let the caller reassign.\n\n\n```python\ndef add_color(palette, color):\n return palette + (color,)\n\noriginal = (\"red\", \"green\")\noriginal = add_color(original, \"blue\")\n\nprint(original)\n```\n\n\nThe function returns a new tuple, and the caller overwrites the name `original` with that returned value.","pageType":"python"}

Tuple Operations

Get Premium