📊 Day 05 : Tuples

🎯 Enterprise Objective

Tuples are Python's immutable sequences — faster, safer, and more memory-efficient than lists. Today we master tuple creation, unpacking, named tuples, and professional patterns. Understanding tuples is essential because Python uses them everywhere: function returns, dict iteration, enumerate, and zip.

📋 Strategic Overview

A tuple is an ordered, immutable collection created with parentheses () or just commas. Once created, elements cannot be added, removed, or changed. This immutability makes tuples faster, hashable, and safer than lists.

• Database records: Query results are returned as tuples — immutable rows

• Function returns: Functions return multiple values as tuples: return x, y

• Configuration: Immutable settings that should not be accidentally modified

Tuples use less memory than lists and are faster to create and access. Use them for fixed collections.

Tuples support the same indexing and slicing as lists and strings. Since tuples are immutable, they have only two methods: .count() and .index(). No append, remove, or sort.

• Record access: Access database row fields by position: row[0] for ID, row[1] for name

• Data validation: .count() to verify expected occurrences in fixed datasets

• Slicing subsets: Extract specific fields from structured records

Tuples support all the same built-in functions as lists: len(), min(), max(), sum(), sorted() (returns a list).

# Packing
point = 10, 20, 30

# Unpacking
x, y, z = point

# Extended unpacking
first, *rest = [1, 2, 3, 4, 5]  # first=1, rest=[2,3,4,5]
first, *mid, last = [1, 2, 3, 4, 5]  # first=1, mid=[2,3,4], last=5

• Multiple returns: mean, std = compute_stats(data) — unpack function results

• Swap variables: a, b = b, a — Pythonic swap without temp variable

• Iteration: for name, age in pairs: — unpack in loops

• CSV parsing: date, *values = row.split(',') — separate header from data

Unpacking requires exact count match: a, b = (1, 2, 3) raises ValueError. Use to absorb extras: a, b, rest = (1, 2, 3).

from collections import namedtuple
Employee = namedtuple('Employee', ['name', 'age', 'dept'])
emp = Employee('Alice', 30, 'Engineering')
print(emp.name)  # Alice (instead of emp[0])

• Database rows: Map query results to named fields for readable access

• Config objects: Immutable configuration with meaningful attribute names

• API responses: Structure API data with clear field names

• CSV records: Parse CSV rows into typed, named records

Named tuples support ._asdict() to convert to dict, ._replace() to create modified copies, and ._fields to list field names.

The choice between tuple and list depends on your intent: use tuples for fixed, heterogeneous records (like database rows) and lists for variable-length, homogeneous collections (like a series of measurements). Tuples signal "this data should not change."

• Dict keys: Tuples can be dictionary keys (hashable): {(lat, lon): 'city'}

• Set elements: Tuples can be added to sets; lists cannot

• Thread safety: Immutable tuples are inherently thread-safe

• Performance: Tuple creation is ~5-10x faster than list creation

A tuple containing a list t = ([1, 2], 3) cannot be hashed (unhashable). The tuple itself is immutable, but the list inside can still be modified: t[0].append(99) works!

Tuples shine in specific patterns: multiple return values, dict items iteration, enumerate results, and zip pairings. Recognizing where Python already uses tuples helps you write more idiomatic code.

Where Python uses tuples implicitly:

• dict.items() → (key, value) tuples

• enumerate() → (index, value) tuples

• zip() → tuples of paired elements

• Multiple return → return a, b packs a tuple

• String % formatting → '%s is %d' % (name, age)

• Multi-value returns: mean, std = get_statistics(data) — clean function interfaces

• Sorting with keys: sorted(data, key=lambda x: (x['dept'], -x['salary'])) — multi-level sort

• Record comparison: Tuples compare element-by-element: (1, 'b') < (1, 'c') → True

Tuples compare lexicographically: element by element, left to right. Use this for multi-level sorting: sorted(items, key=lambda x: (x.dept, -x.salary)).

Theory is useless without muscle memory. Complete these tasks to solidify your understanding.

✅ Instructor's End-of-Day Checklist

• [ ] I understand tuple immutability and when to prefer tuples over lists.

• [ ] I can use packing/unpacking including extended * syntax.

• [ ] I can create and use named tuples for readable records.

• [ ] I know that tuples are hashable and can be dict keys.

• [ ] I understand lexicographic tuple comparison for multi-level sorting.

• [ ] I have completed all 5 practice tasks.

• [ ] I have reviewed all 25 interview questions.