Python Tuples - Memory Model, Indexing, Slicing, Methods, Unpacking & For Loops

The Story That Explains Tuples ✉️Tuples समझाने वाली कहानी ✉️一个解释元组的故事 ✉️

A tuple (tuple) is Python's built-in ordered, immutable sequence. Ordered means position matters. Immutable means it cannot be changed after it is made. Think of tuples as the stricter sibling of lists: fewer features, more guarantees.

Tuple (tuple) Python का built-in क्रमबद्ध, न बदलने वाला sequence है। क्रमबद्ध यानी जगह मायने रखती है। Immutable यानी बनने के बाद बदला नहीं जा सकता। Tuples को lists का अनुशासित भाई समझें: कम features, ज़्यादा गारंटी।

元组（tuple）是 Python 内置的有序、不可变序列。有序是指位置很重要；不可变是指创建后不能修改。可以把元组看作列表更严格的兄弟：功能更少，保证更多。

Creating Tuples — Five Ways (and One Big Gotcha) ✍️Tuples बनाना — पाँच तरीक़े (और एक बड़ा जाल) ✍️创建元组 —— 五种方式（和一个大陷阱）✍️

# 1. Literal with parentheses (most common)
empty  = ()
point  = (28.6139, 77.2090)          # New Delhi (lat, lon)
rgb    = (255, 128, 0)
mixed  = ("Asha", 30, 5.4, True)
nested = ((1, 2), (3, 4), (5, 6))

# 2. Without parentheses — the COMMAS make the tuple
coords = 3, 4
person = "Ravi", 25

# 3. One item: the famous trap
not_a_tuple = (5)                    # just the int 5
real_tuple  = (5,)                   # the trailing comma makes it a tuple
also_tuple  = 5,

# 4. The tuple() constructor
from_list  = tuple([1, 2, 3])
from_str   = tuple("hello")
from_range = tuple(range(5))

# 5. A generator expression passed to tuple()
squares = tuple(x ** 2 for x in range(1, 6))
gen     = (x ** 2 for x in range(1, 6))   # NOT a tuple — a generator!

print(empty, point, rgb, mixed, nested)
print(coords, person)
print(type(not_a_tuple).__name__, type(real_tuple).__name__, also_tuple)
print(from_list, from_str, from_range)
print(squares, type(gen).__name__)

How Tuples Are Stored in Memory 🧠Tuples Memory में कैसे रहते हैं 🧠元组如何存储在内存中 🧠

Like a list, a tuple holds references to objects that live elsewhere in memory. The big difference: a tuple's slots are locked. It cannot grow, shrink, or point a slot at a different object. Because its size never changes, CPython stores the references inside the tuple object itself, with no spare room.

List की तरह tuple भी memory में कहीं और रहने वाले objects के references रखता है। बड़ा अंतर: tuple के slots बंद हैं। यह न बढ़ सकता है, न घट सकता है, न किसी slot को दूसरे object की ओर कर सकता है। आकार कभी नहीं बदलता, इसलिए CPython references को tuple object के अंदर ही रखता है, बिना ख़ाली जगह के।

和列表一样，元组保存的是指向内存中其他对象的引用。最大的区别是：元组的槽位是锁定的。它不能变长、变短，也不能让某个槽位指向另一个对象。因为大小永不改变，CPython 把引用直接存放在元组对象内部，没有预留空间。

The Visual Modelचित्र से समझें图解模型

Tuple vs List — The Memory LayoutTuple बनाम List — Memory की बनावट元组 vs 列表 —— 内存布局

Measure It Yourselfख़ुद नापें亲自测一测

import sys, timeit

print("size in bytes (the container only):")
for n in (0, 3, 10):
    t, l = tuple(range(n)), list(range(n))
    print(f"  {n:>2} items: tuple {sys.getsizeof(t):>3}, list {sys.getsizeof(l):>3}")

def best(stmt, setup="pass", number=1_000_000):
    return min(timeit.repeat(stmt, setup, number=number, repeat=7))

print("time for 1,000,000 runs (best of 7):")
print(f"  build (1, 2, 3, 4, 5): {best('(1, 2, 3, 4, 5)'):.3f} s")
print(f"  build [1, 2, 3, 4, 5]: {best('[1, 2, 3, 4, 5]'):.3f} s")
setup = "t = tuple(range(100)); l = list(range(100))"
print(f"  loop over 100-item tuple: {best('for x in t: pass', setup, 100_000) * 10:.3f} s")
print(f"  loop over 100-item list:  {best('for x in l: pass', setup, 100_000) * 10:.3f} s")

What Happens If You Try to Change a TupleTuple बदलने की कोशिश करें तो क्या होता है尝试修改元组会发生什么

t = (10, 20, 30)
for attempt in ("t[0] = 99", "t.append(40)", "del t[0]"):
    try:
        exec(attempt)
    except (TypeError, AttributeError) as err:
        print(f"{attempt:<13} → {type(err).__name__}: {err}")

old = t
t = t + (40,)                        # builds a NEW tuple and rebinds the name
print(t, old, t is old)

data = ([1, 2], [3, 4])
data[0].append(99)                   # the LIST inside can change
print(data)
try:
    data[0] = [7, 8, 9]              # but the slot itself is locked
except TypeError as err:
    print("TypeError:", err)

Notice the two different ideas. t = t + (40,) is fine: it builds a new tuple and moves the name t to it (t is old is False). And a list inside a tuple can still change, because the tuple only locks which object each slot points to — not the object itself.

दो अलग विचार देखें। t = t + (40,) ठीक है: यह एक नया tuple बनाता है और नाम t को उस पर ले जाता है (t is old False है)। और tuple के अंदर की list अब भी बदल सकती है, क्योंकि tuple सिर्फ़ यह बंद करता है कि हर slot किस object की ओर है — object को ख़ुद नहीं।

注意两个不同的概念。t = t + (40,) 是可以的：它构建一个新元组，并把名字 t 移过去（t is old 为 False）。而元组里面的列表仍然可以改变，因为元组锁定的只是每个槽位指向哪个对象 —— 而不是对象本身。

Why Use a Tuple? — Four Real Advantages 💡Tuple क्यों? — चार असली फ़ायदे 💡为什么用元组？—— 四个真正的优点 💡

distances = {                        # road distance in km (approx.)
    ("Delhi", "Agra"): 233,
    ("Delhi", "Jaipur"): 281,
    ("Agra", "Jaipur"): 239,
}
print(distances[("Delhi", "Agra")])
try:
    bad = {["Delhi", "Agra"]: 233}
except TypeError as err:
    print("TypeError:", err)

visited = {(0, 0), (1, 2), (3, 4)}   # tuples can live in a set
print((1, 2) in visited)

try:
    hash((1, [2, 3]))                # a tuple is hashable only if its items are
except TypeError as err:
    print("TypeError:", err)

def min_max(numbers):
    return min(numbers), max(numbers)   # returns ONE tuple

low, high = min_max([3, 1, 4, 1, 5, 9])
print(low, high, min_max([3, 1, 4]))

The second-to-last line shows the fine print: (1, [2, 3]) is a tuple, but it holds a list, so it cannot be hashed or used as a key.

आख़िरी से पहली line बारीक बात दिखाती है: (1, [2, 3]) tuple है, पर उसमें list है, इसलिए उसका hash नहीं बनता और वह key नहीं बन सकता।

倒数第二行说明了一个细节：(1, [2, 3]) 是元组，但它里面有列表，所以不能被哈希，也不能作键。

Tuple vs List — Side by Side ⚖️Tuple बनाम List — आमने-सामने ⚖️元组 vs 列表 —— 并排对比 ⚖️

Indexing — Reaching One Item 🎯Indexing — एक Item तक पहुँचना 🎯索引 —— 取到单个项 🎯

Tuples are ordered, so every item has a numbered position. As with lists and strings, Python counts from zero and also accepts negative indexes, which count from the end. Reading works; assigning does not.

Tuples क्रमबद्ध हैं, इसलिए हर item की एक गिनती वाली जगह है। Lists और strings की तरह Python शून्य से गिनता है और अंत से गिनने वाले negative indexes भी लेता है। पढ़ना चलता है; assign करना नहीं।

元组是有序的，所以每一项都有编号位置。与列表和字符串一样，Python 从零开始数，也接受从末尾数的负索引。读取可以，赋值不行。

rgb = ("red", 255, 128, 0, "hex:#FF8000")
print(rgb[0], rgb[3], rgb[-1], rgb[-4])
print(len(rgb), 128 in rgb, "green" in rgb)
try:
    rgb[0] = "blue"
except TypeError as err:
    print("TypeError:", err)

mixed = (1, 2, [3, 4])
mixed[2].append(5)                   # mutating the inner list is allowed
print(mixed)

Slicing — Taking Sub-Tuples ✂️Slicing — छोटे Tuples निकालना ✂️切片 —— 取出子元组 ✂️

Slicing works exactly as it does for lists and strings, and the result is always a tuple. Out-of-range numbers never crash. Slice assignment, which lists allow, is blocked for tuples.

Slicing lists और strings जैसी ही चलती है, और नतीजा हमेशा tuple होता है। सीमा से बाहर के अंक कभी नहीं रोकते। Slice assignment, जो lists में चलता है, tuples में रोका गया है।

切片与列表、字符串完全相同，结果总是元组。越界数字永不报错。列表允许的切片赋值，元组不允许。

nums = (10, 20, 30, 40, 50, 60, 70, 80)
print(nums[2:5], nums[:3], nums[5:])
print(nums[-3:], nums[:-2])
print(nums[::2], nums[::-1])
print(nums[100:200], type(nums[2:5]).__name__)
print(nums[:] is nums)               # CPython returns the SAME tuple — no copy needed
try:
    nums[1:4] = (99, 99)
except TypeError as err:
    print("TypeError:", err)

Tuple Methods — Only Two Exist 🧰Tuple Methods — सिर्फ़ दो हैं 🧰元组方法 —— 只有两个 🧰

Because a tuple cannot change, it needs only 2 methods: .count() and .index(). Both just read. There is no append, sort or reverse — those would need to change the tuple. The last line of the output below lists them straight from dir(tuple).

Tuple बदल नहीं सकता, इसलिए उसे सिर्फ़ 2 methods चाहिए: .count() और .index()। दोनों बस पढ़ते हैं। न append है, न sort, न reverse — इनके लिए tuple को बदलना पड़ता। नीचे output की आख़िरी line इन्हें सीधे dir(tuple) से दिखाती है।

因为元组不能改变，它只需要 2 个方法：.count() 和 .index()。两者都只读取。没有 append、sort 或 reverse —— 它们都需要修改元组。下面输出的最后一行直接从 dir(tuple) 列出了它们。

votes = ("yes", "no", "yes", "yes", "no", "abstain")
print(votes.count("yes"), votes.count("no"), votes.count("maybe"))
print(votes.index("no"), votes.index("abstain"))
try:
    votes.index("maybe")
except ValueError as err:
    print("ValueError:", err)

scores = (88, 75, 92, 60, 83)
print(len(scores), min(scores), max(scores), sum(scores))
print(sorted(scores))                # sorted() always returns a LIST
print(tuple(sorted(scores)))         # convert back for a tuple
print((1, 2) + (3,), (0,) * 3)      # + and * build NEW tuples
print([m for m in dir(tuple) if not m.startswith("_")])

Packing & Unpacking — Python's Superpower 🎁Packing और Unpacking — Python की ख़ास ताक़त 🎁打包与拆包 —— Python 的超能力 🎁

This is where tuples shine. Multiple assignment, returning several values, swapping two variables and looping over pairs all use tuple packing (putting values together) and unpacking (taking them apart) behind the scenes.

यहीं tuples चमकते हैं। एक साथ कई assignment, कई मान लौटाना, दो variables की अदला-बदली, और जोड़ियों पर loop — ये सब परदे के पीछे tuple packing (मानों को साथ रखना) और unpacking (उन्हें अलग करना) लगाते हैं।

这正是元组大放异彩的地方。多重赋值、返回多个值、交换两个变量、遍历成对数据 —— 背后都在使用元组打包（把值放在一起）和拆包（把它们分开）。

point = 3, 4                         # packing
person = "Asha", 30, "Pune"
print(type(point).__name__, person)

x, y = point                         # unpacking
print(x, y)
try:
    a, b = (1, 2, 3)
except ValueError as err:
    print("ValueError:", err)

a, b = 5, 10
a, b = b, a                          # swap: pack the right, unpack on the left
print(a, b)

numbers = (1, 2, 3, 4, 5)
first, *rest = numbers
*init, last = numbers
head, *middle, tail = numbers
print(first, rest, init, last)
print(head, middle, tail)            # the starred name always gets a LIST

name, age, _, _ = ("Asha", 30, "Pune", "engineer")
print(name, age)

record = ("Asha", (18.5204, 73.8567))
name, (lat, lon) = record            # nested unpacking
print(f"{name} at {lat}, {lon}")

Multiple Return Values — Tuples Under the Hoodकई लौटे मान — परदे के पीछे Tuples多个返回值 —— 背后是元组

def divmod_custom(a, b):
    return a // b, a % b             # actually returns ONE tuple

result = divmod_custom(17, 5)
print(result, type(result).__name__)
quotient, remainder = divmod_custom(17, 5)
print(quotient, remainder)
print(divmod(17, 5))                 # the built-in does the same

The for Loop — Walking Through Tuples 🔄for Loop — Tuples में चलना 🔄for 循环 —— 遍历元组 🔄

Looping over a tuple works just like looping over a list. And because a tuple cannot change, you cannot accidentally change it in the middle of a loop.

Tuple पर loop बिल्कुल list जैसा चलता है। और tuple बदल नहीं सकता, इसलिए loop के बीच गलती से उसे बदल भी नहीं सकते।

遍历元组和遍历列表完全一样。而且元组不能改变，所以你也不可能在循环中途意外修改它。

Patterns 1 and 2 — Values, and Values With an IndexPatterns 1 और 2 — मान, और Index के साथ मान模式 1 和 2 —— 取值，以及带索引取值

colors = ("red", "green", "blue")
for color in colors:
    print(f"Rendering {color}")
for i, color in enumerate(colors):
    print(f"{i}: {color}")
print(list(enumerate(colors)))       # enumerate gives (index, value) tuples

The last line shows the secret: enumerate() hands out (index, value) tuples, and for i, color in ... unpacks each one.

आख़िरी line राज़ बताती है: enumerate() (index, value) tuples देता है, और for i, color in ... हर एक को unpack करता है।

最后一行揭示了秘密：enumerate() 产出的是 (索引, 值) 元组，for i, color in ... 把每个元组拆包。

Pattern 3 — A Tuple of Tuples (a Table of Records)Pattern 3 — Tuples का Tuple (Records की Table)模式 3 —— 元组的元组（记录表）

A tuple of tuples is a light, read-only table. Unpacking each record as you loop reads almost like English.

Tuples का tuple एक हल्की, सिर्फ़ पढ़ने वाली table है। Loop करते हुए हर record को unpack करना लगभग अंग्रेज़ी जैसा पढ़ा जाता है।

元组的元组是一张轻量、只读的表。遍历时拆包每条记录，读起来几乎像英语。

students = (
    ("Asha",  92, "A"),
    ("Ravi",  78, "C"),
    ("Meena", 85, "B"),
    ("Dev",   60, "D"),
)
for name, score, grade in students:
    print(f"{name:<6} scored {score} → grade {grade}")

top = [name for name, score, _ in students if score >= 85]
print(top)

Patterns 4 and 5 — zip() and dict.items()Patterns 4 और 5 — zip() और dict.items()模式 4 和 5 —— zip() 与 dict.items()

names  = ("Asha", "Ravi", "Meena")
scores = (92, 78, 85)
for name, score in zip(names, scores):
    print(f"{name}: {score}")
pairs = tuple(zip(names, scores))
print(pairs)

ages = {"Asha": 30, "Ravi": 25, "Meena": 35}
for name, age in ages.items():       # .items() gives (key, value) tuples
    print(f"{name} is {age}")
print(list(ages.items()))

Both zip() and dict.items() hand out tuples — (name, score) and (key, value) — which the loop unpacks for you.

zip() और dict.items() दोनों tuples देते हैं — (name, score) और (key, value) — जिन्हें loop आपके लिए unpack करता है।

zip() 和 dict.items() 都产出元组 —— (name, score) 和 (key, value) —— 循环会替你拆包。

Complete Practice Program — GPS Waypoints 🧭पूरा अभ्यास Program — GPS Waypoints 🧭完整练习程序 —— GPS 航点 🧭

This program uses tuple records, nested unpacking, enumerate(), zip() over a tuple and its slice, a function that returns four values, and tuples as dictionary keys. We also print each leg of the path so you can check the total.

यह program tuple records, nested unpacking, enumerate(), tuple और उसकी slice पर zip(), चार मान लौटाने वाला function, और dictionary keys के रूप में tuples लगाता है। हम रास्ते का हर हिस्सा भी छापते हैं ताकि आप कुल दूरी जाँच सकें।

这个程序用到了元组记录、嵌套拆包、enumerate()、对元组及其切片使用 zip()、返回四个值的函数，以及用元组作字典键。我们还打印了路径的每一段，方便你核对总长度。

# waypoints.py — every tuple concept in one program

import math

def distance(p1, p2):
    """Straight-line distance between two (x, y) tuples."""
    x1, y1 = p1                      # unpacking!
    x2, y2 = p2
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

def bounding_box(points):
    """Return (min_x, min_y, max_x, max_y) — a tuple of 4 values."""
    xs = tuple(x for x, _ in points)
    ys = tuple(y for _, y in points)
    return min(xs), min(ys), max(xs), max(ys)

def main():
    # A tuple of waypoint records: (name, (x, y))
    waypoints = (
        ("Start",        (0.0,  0.0)),
        ("Checkpoint A", (3.0,  4.0)),
        ("Checkpoint B", (6.0,  8.0)),
        ("Peak",         (10.0, 6.0)),
        ("Finish",       (15.0, 0.0)),
    )

    line = "─" * 36
    print(f"{line}\n  WAYPOINT TRACKER\n{line}")

    # Loop + unpack each record
    print(f"  {'#':>2}  {'NAME':<15}{'COORDS':>13}")
    for i, (name, coords) in enumerate(waypoints, 1):
        print(f"  {i:>2}  {name:<15}{str(coords):>13}")

    # Total path: pair each point with the next one
    total = 0.0
    for (_, p1), (_, p2) in zip(waypoints, waypoints[1:]):
        leg = distance(p1, p2)
        total += leg
        print(f"      {str(p1):>11} → {str(p2):<11} {leg:5.2f}")
    print(f"  Total path length: {total:.2f} units")

    # Indexing & slicing
    print(f"\n  First waypoint: {waypoints[0][0]}")
    print(f"  Last waypoint:  {waypoints[-1][0]}")
    print(f"  Middle 3:       {tuple(w[0] for w in waypoints[1:-1])}")

    # Bounding box (multiple return via a tuple)
    coords_only = tuple(c for _, c in waypoints)
    min_x, min_y, max_x, max_y = bounding_box(coords_only)
    print(f"\n  Bounding box: ({min_x}, {min_y}) → ({max_x}, {max_y})")

    # Tuples as dict keys
    labels = {c: n for n, c in waypoints}
    lookup = (10.0, 6.0)
    print(f"  What's at {lookup}? → {labels.get(lookup, 'unknown')}")

    # Prove immutability
    try:
        waypoints[0] = ("Hacked", (0, 0))
    except TypeError as e:
        print(f"\n  Tuple protects its data: {e}")

if __name__ == "__main__":
    main()

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆