{"title":"Tuples Basics","description":"","content":"A tuple is Python's container for a small, fixed group of values that belong together. The two numbers in a GPS coordinate, the three channels in an RGB color, the name and price of a product on a receipt: each of those is a tuple in spirit, and Python gives you a built-in type that matches the shape. This lesson covers what a tuple is, the several ways to create one (including the singleton case that catches every beginner), indexing, iteration, and the immutability rule with the one important caveat.\n\n---\n\n# What a Tuple Is\n\nA tuple is an **ordered**, **immutable** sequence of values. The word \"sequence\" should already feel familiar from lists. Order and indexing work the same way. The difference is the second word: a tuple cannot be changed after it's created.\n\n**Ordered** means each item has a fixed position. If you write `(40.7128, -74.0060)` for a New York coordinate, the latitude is at position `0` and the longitude is at position `1`. The order is part of the meaning, not an accident.\n\n**Immutable** means once you build a tuple, its slots are frozen. You can't assign to `point[0]`, you can't append to it, you can't sort it in place. To \"change\" a tuple, you build a new one. This is the same contract strings give you, just generalized to arbitrary values.\n\nHere's a tuple in its simplest form:\n\n\n```python\ncoordinate = (40.7128, -74.0060)\nprint(coordinate)\n```\n\n\nTwo numbers, stored in the order you wrote them. Python prints tuples with parentheses and comma-separated values, which is exactly how you usually write them in source code. Tuples are what you reach for when the group of values is small, the positions have specific meanings, and the whole thing should travel together as one unit.\n\nA useful mental shorthand: lists are for \"a bunch of things of the same kind\" (a cart of products, prices in an order), and tuples are for \"one structured record\" (a coordinate, an RGB color, a row in a spreadsheet). That framing helps the rest of this lesson land.\n\n---\n\n# Creating Tuples\n\nThere are several ways to make a tuple, and one of them has a sharp edge you need to know about up front.\n\nThe most common form is a **tuple literal**: values separated by commas, usually wrapped in parentheses.\n\n\n```python\nempty = ()\ncoordinate = (40.7128, -74.0060)\nrgb_red = (255, 0, 0)\nproduct = (\"Wireless Mouse\", 29.99, 142)\n\nprint(empty)\nprint(coordinate)\nprint(rgb_red)\nprint(product)\n```\n\n\n`()` is the empty tuple. `(255, 0, 0)` packs three integers (red, green, blue). `(\"Wireless Mouse\", 29.99, 142)` packs a product name, its price, and its stock count into one record.\n\nHere's the surprise: the parentheses are not actually what makes a tuple. **It's the commas.** Python is happy with this:\n\n\n```python\ncoordinate = 40.7128, -74.0060\nprint(coordinate)\nprint(type(coordinate))\n```\n\n\nNo parentheses, still a tuple. The comma is the signal that says \"these values belong together as a sequence\". Python adds parentheses when it prints, which is why the output still looks normal. Most Python developers write the parentheses anyway because the visual grouping makes the intent obvious, especially in arguments and return statements. But it's worth knowing that the commas are the real syntax.\n\nThat fact leads directly to the trickiest case in this section.\n\n---\n\n# The Singleton Tuple Trap\n\nTo create a tuple with exactly one item, you need a trailing comma. Parentheses alone aren't enough.\n\n\n```python\nnot_a_tuple = (\"Wireless Mouse\")\nactual_tuple = (\"Wireless Mouse\",)\n\nprint(type(not_a_tuple))\nprint(type(actual_tuple))\n```\n\n\n`(\"Wireless Mouse\")` is just the string `\"Wireless Mouse\"` with extra parentheses around it, the same way `(1 + 2)` is just the number `3`. Parentheses are used everywhere in Python for grouping, so Python can't tell whether you meant \"a tuple of one item\" or \"an expression I wrapped for clarity\". The comma resolves the ambiguity:\n\n\n```python\nsingle = (\"Wireless Mouse\",)\nprint(single)\nprint(len(single))\n```\n\n\nThe trailing comma is what makes it a tuple. Python even prints the comma when displaying single-element tuples to make this visible. Notice the output: `('Wireless Mouse',)` with that lonely comma stuck on the end. That printed comma is your reminder that this is a one-element tuple, not a parenthesized string.\n\nThe same rule applies to numbers and any other value:\n\n\n```python\nprint(type((42)))\nprint(type((42,)))\n```\n\n\nEmpty tuples don't have this problem because there's nothing to confuse them with. `()` is unambiguously the empty tuple. The trap only exists for the one-item case.\n\n---\n\n# The `tuple()` Constructor\n\nThe other way to make a tuple is the `tuple()` built-in. Called with no arguments, it returns an empty tuple:\n\n\n```python\nempty = tuple()\nprint(empty)\nprint(empty == ())\n```\n\n\n`tuple()` and `()` produce the same empty tuple. Most code uses `()` because it's shorter and reads as \"an empty tuple\" at a glance. The constructor earns its keep when you pass it an **iterable**, anything Python can walk through one item at a time, the same idea you saw with `list()`. `tuple(iterable)` builds a tuple from those items:\n\n\n```python\ncharacters = tuple(\"RGB\")\ndigits = tuple(range(5))\nfrom_list = tuple([\"Wireless Mouse\", 29.99, 142])\n\nprint(characters)\nprint(digits)\nprint(from_list)\n```\n\n\n`tuple(\"RGB\")` walks the string one character at a time. `tuple(range(5))` materializes a range into a real tuple. `tuple([...])` copies a list's items into a tuple of the same items, which is useful when you want a frozen snapshot of a list that callers can't accidentally modify.\n\nThe same gotcha that hit `list()` hits `tuple()` too:\n\n\n```python\nprint(tuple(\"Mouse\"))\nprint((\"Mouse\",))\n```\n\n\n`tuple(\"Mouse\")` iterates the string and gives you a tuple of single characters. `(\"Mouse\",)` wraps the whole string as a single item. Pick the literal form for everyday tuple creation. Reach for `tuple(...)` when you have an existing iterable you want to materialize into a tuple, often to freeze it.\n\n---\n\n# Indexing and Negative Indexing\n\nIndexing on a tuple works exactly the same way it does on a list. Position `0` is the first item, position `1` is the second, and negative indices count from the back.\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142, \"Electronics\")\n\nprint(product[0])\nprint(product[1])\nprint(product[-1])\nprint(product[-2])\n```\n\n\n`product[0]` is the name. `product[1]` is the price. `product[-1]` is the last item (the category), and `product[-2]` is one position before that (the stock count). The numbering scheme is identical to lists, both the positive and negative directions.\n\nOut-of-range indices raise the same `IndexError`:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142, \"Electronics\")\nprint(product[10])\n```\n\n\nThe error message says `tuple index out of range` instead of `list index out of range`, but the meaning is the same. The valid indices for a four-item tuple run from `-4` to `3`. Anything outside that range fails loudly.\n\nIndexing on a tuple is O(1), just like a list. Tuples are also stored as a contiguous block of references, so jumping to position `5000` costs the same as jumping to position `0`.\n\n\n> **INFO**\n>\n> **Cost:** Indexing a tuple by position is O(1). Negative indexing has the same cost; Python converts the negative index to a positive one internally and jumps to the slot directly.\n\n\n---\n\n# Length With `len()`\n\n`len()` returns the number of items in a tuple. It works exactly the way it does on lists and strings:\n\n\n```python\ncoordinate = (40.7128, -74.0060)\nrgb_red = (255, 0, 0)\nempty = ()\n\nprint(len(coordinate))\nprint(len(rgb_red))\nprint(len(empty))\n```\n\n\nTwo items, three items, zero items. `len()` always returns an integer and never raises on a normal tuple. The cost is O(1) regardless of tuple size, because Python stores the length on the tuple object itself.\n\nThe length is also fixed for the lifetime of the tuple. A list's length can grow and shrink as you call `append` or `pop`. A tuple's length is set when you build it and stays the same forever. If you need a different size, you build a new tuple.\n\n\n> **INFO**\n>\n> **Cost:** `len(tup)` is O(1). Same as lists: the count is stored on the object, so Python doesn't walk the items to compute it.\n\n\n---\n\n# Iterating With `for`\n\nTuples are iterable, which means you can walk through them with a `for` loop the same way you walk a list or a string.\n\n\n```python\nrgb_red = (255, 0, 0)\n\nfor channel in rgb_red:\n print(channel)\n```\n\n\nThe variable `channel` takes on each value in turn. The loop body runs once per item.\n\n`enumerate()` works on tuples too, just like it did on lists, when you want both the position and the value:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142)\nlabels = (\"name\", \"price\", \"stock\")\n\nfor i, value in enumerate(product):\n print(f\"{labels[i]}: {value}\")\n```\n\n\nThis pattern (pair each tuple item with a label by position) shows up often when you're dealing with records. There's a cleaner way to do it using named tuples, but the index-based version is a fine starting point.\n\nYou can also iterate a tuple of tuples, which is common when you have a list of records and don't need them mutable:\n\n\n```python\naddresses = (\n (\"Alice\", \"221B Baker Street\", \"London\"),\n (\"Bob\", \"1600 Pennsylvania Ave\", \"Washington\"),\n (\"Carol\", \"10 Downing Street\", \"London\"),\n)\n\nfor name, street, city in addresses:\n print(f\"{name} lives at {street}, {city}\")\n```\n\n\nThat `for name, street, city in addresses:` line is unpacking each inner tuple into three variables in one step. Unpacking is such a natural pairing with iteration that you'll see it everywhere.\n\n---\n\n# Tuples Can Hold Mixed Types\n\nLike lists, tuples don't care whether all the items are the same type. The whole point of a tuple is often to bundle related but differently-typed values.\n\n\n```python\ncustomer = (\"Alice\", 29, \"alice@shop.com\", True)\nproduct = (\"Wireless Mouse\", 29.99, 142)\norder_line = (\"ORD-1023\", 3, 89.97)\n\nprint(customer)\nprint(product)\nprint(order_line)\n```\n\n\nA customer tuple holds a name (string), an age (int), an email (string), and a premium flag (bool). A product tuple holds a name, a price, and a stock count. An order line holds an order ID, a quantity, and a subtotal. Each position has a meaning, and the positions don't have to share a type.\n\nThis is part of why tuples feel different from lists in practice. A list of mixed types usually means \"a record where I forgot to use a named structure\". A tuple of mixed types usually means \"a record on purpose, where the positions are stable and known.\"\n\n---\n\n# Nested Tuples\n\nA tuple can contain other tuples, just like a list can contain other lists. This is useful when you have a small, fixed structure with sub-structures inside it.\n\n\n```python\norder = (\n \"ORD-1023\",\n (\"Alice\", \"alice@shop.com\"),\n (\n (\"Wireless Mouse\", 29.99),\n (\"USB Cable\", 4.99),\n (\"HDMI Cable\", 14.99),\n ),\n)\n\nprint(order[0])\nprint(order[1])\nprint(order[2])\n```\n\n\nThe order has an ID, a customer (a two-item tuple of name and email), and a tuple of items (each itself a two-item tuple of name and price). To dig into the structure, you index step by step:\n\n\n```python\nprint(order[1][0])\nprint(order[2][1][0])\nprint(order[2][1][1])\n```\n\n\n`order[1][0]` is \"the first item of the customer tuple\" (the name). `order[2][1][0]` is \"the second item in the items tuple, then its first item\" (the name of the second product). Each `[...]` step drills one level deeper.\n\nNested tuples are convenient, but the readability falls off fast once you get past two levels of nesting. By the time you'd write `data[2][1][3][0]`, the structure deserves real names. Dictionaries or named tuples will fit better.\n\n---\n\n# Immutability: Why Tuples Reject Reassignment\n\nThe defining feature of a tuple is that you can't change it. The same `cart[1] = \"Ethernet Cable\"` pattern that works on lists fails on tuples:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142)\nproduct[1] = 24.99\n```\n\n\nNotice the error type: `TypeError`, not `IndexError`. Python isn't saying \"that index doesn't exist\", it's saying \"tuples don't support this operation at all\". The same message comes up for any in-place mutation attempt:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142)\ndel product[0]\n```\n\n\nAnd tuples don't have the mutating methods that lists do. There's no `tuple.append`, no `tuple.sort`, no `tuple.remove`. They simply aren't part of the type.\n\nTo \"change\" a tuple, you build a new one. If a product's price needs updating, you make a fresh tuple with the new value and rebind the name:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142)\nproduct = (\"Wireless Mouse\", 24.99, 142)\nprint(product)\n```\n\n\nThe variable `product` now points to a different tuple. The original tuple still exists in memory for a moment (until Python garbage-collects it), but the name is now bound to the new one. This is the same pattern strings force on you. The cost is that you allocate a new object every time. The benefit is what comes next.\n\n---\n\n# Immutability With Mutable Contents\n\nHere's the caveat that trips people up: a tuple is immutable, but it doesn't make its **contents** immutable. If a tuple holds a reference to a mutable object (like a list), that inner object can still be mutated.\n\n\n```python\norder = (\"ORD-1023\", [\"Wireless Mouse\", \"USB Cable\"])\norder[1].append(\"HDMI Cable\")\nprint(order)\n```\n\n\nThe tuple itself never changed. Position `0` still points to the string `\"ORD-1023\"`. Position `1` still points to the same list it pointed to before. What changed is the list at position `1`, which now has three items instead of two. The tuple's structure (which references it holds) is frozen. The objects it references are not.\n\nThis split looks subtle until you've seen it once. The diagram below shows what's actually going on:\n\n\n```mermaid\nflowchart LR\n T[\"Tuple
order\"]:::cyan\n S[\"'ORD-1023'
(string, immutable)\"]:::green\n L[\"List object
(mutable)\"]:::orange\n I1[\"'Wireless Mouse'\"]:::teal\n I2[\"'USB Cable'\"]:::teal\n I3[\"'HDMI Cable'
(appended later)\"]:::teal\n\n T -->|slot 0| S\n T -->|slot 1| L\n L --> I1\n L --> I2\n L --> I3\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\nThe two arrows coming out of the tuple are the tuple's slots. Those arrows can never be repointed; that's what immutability means. But the list at the other end of one of those arrows is a normal mutable list, and `append` is allowed on it. The tuple has no idea the list grew; it just keeps pointing at the same list object.\n\nIn practice, this means a tuple is only fully \"frozen\" when all of its contents are themselves immutable (numbers, strings, other tuples, frozensets). A tuple of strings is completely frozen. A tuple containing a list is half-frozen: the structure is locked but the inner list can still change. This becomes important later when we talk about hashing and using tuples as dictionary keys, because only fully-immutable tuples are safe to hash.\n\n\n> **INFO**\n>\n> **Cost:** Immutability is a property of the tuple's own slots, not of the values inside it. Mutating an inner list is the same cost as mutating any list (the operation on the list itself); the surrounding tuple doesn't add any cost or any protection.\n\n\n---\n\n# Printing Tuples\n\nPython prints tuples using the same parenthesized, comma-separated form you use to write them in source code:\n\n\n```python\ncoordinate = (40.7128, -74.0060)\nrgb_red = (255, 0, 0)\nsingle = (\"Wireless Mouse\",)\nempty = ()\n\nprint(coordinate)\nprint(rgb_red)\nprint(single)\nprint(empty)\n```\n\n\nA few details are worth noticing. Multi-item tuples print without a trailing comma. Single-item tuples print **with** a trailing comma, which is Python's way of reminding you that the value is a tuple rather than a parenthesized expression. The empty tuple prints as `()`, the same way you write it.\n\nIf you want a different formatted display, use an f-string and pull out the parts by position:\n\n\n```python\ncoordinate = (40.7128, -74.0060)\nprint(f\"lat={coordinate[0]}, lon={coordinate[1]}\")\n```\n\n\nThat's the same indexing as before, just used in a formatted context. It's a common pattern for displaying records: index the tuple by position, label each value in the output.\n\n---\n\n# What's Wrong With This Code?\n\nA common beginner mistake is reaching for an in-place modification on a tuple as if it were a list:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142)\nproduct[1] = 24.99\nprint(product)\n```\n\n\nThe fix depends on what you actually want. If the value really does need to change over time, the type should be a list, not a tuple:\n\n\n```python\nproduct = [\"Wireless Mouse\", 29.99, 142]\nproduct[1] = 24.99\nprint(product)\n```\n\n\nIf the value is fixed for the lifetime of one record but might be replaced wholesale (a product with a new price becomes a new product record), build a new tuple and rebind:\n\n\n```python\nproduct = (\"Wireless Mouse\", 29.99, 142)\nproduct = (\"Wireless Mouse\", 24.99, 142)\nprint(product)\n```\n\n\nPicking between these is a design choice. The short version: use a tuple when the values stay put, use a list when you'll be modifying the collection over time.\n\nA second common mistake is the singleton-tuple trap from earlier:\n\n\n```python\nsingle = (\"Wireless Mouse\")\nfor item in single:\n print(item)\n```\n\n\n`single` here is a string, not a tuple, so iterating it walks the characters. The fix is the trailing comma:\n\n\n```python\nsingle = (\"Wireless Mouse\",)\nfor item in single:\n print(item)\n```\n\n\nOne iteration, one item. The trailing comma is the difference between \"a tuple holding one string\" and \"a string with redundant parentheses\".\n\n---\n\n# Quiz","pageType":"python"}

Tuples Basics

Get Premium