Immutable and Key-Value Data Structures
What Are Tuples?
A tuple is an ordered, immutable collection of elements in Python. Once created, its contents cannot be changed—making it ideal for representing fixed data like coordinates, RGB values, or database records.
- Immutable: Cannot add, remove, or modify elements after creation.
- Ordered: Elements maintain their position (indexed from 0).
- Heterogeneous: Can store mixed data types (e.g.,
("Ali", 25, True)). - Hashable: Can be used as dictionary keys or elements in sets (unlike lists).
Creating Tuples
# Empty tuple
empty = ()
# Single-element tuple (note the comma!)
single = (42,)
# Multiple elements
point = (3, 5)
person = ("Sara", 30, "Dubai")
# Without parentheses (tuple packing)
rgb = 255, 128, 0Core Operations & Examples
1. Access Elements by Index
coordinates = (10, 20)
x = coordinates[0]
y = coordinates[1]
print(f"x={x}, y={y}") # x=10, y=202. Tuple Unpacking
name, age, city = ("Omar", 28, "Abu Dhabi")
print(f"{name} is {age} and lives in {city}")
# Omar is 28 and lives in Abu Dhabi3. Swapping Variables (Pythonic Way)
a, b = 5, 10
a, b = b, a # tuple unpacking swap
print(a, b) # 10 54. Return Multiple Values from Function
def min_max(numbers):
return min(numbers), max(numbers) # returns a tuple
data = [3, 1, 4, 1, 5]
low, high = min_max(data)
print(f"Min: {low}, Max: {high}") # Min: 1, Max: 55. Immutable — Attempt to Modify Fails
colors = ("red", "green", "blue")
# colors[0] = "yellow" → ❌ TypeError: 'tuple' object does not support item assignment6. Tuple Concatenation
a = (1, 2)
b = (3, 4)
c = a + b
print(c) # (1, 2, 3, 4)7. Tuple Repetition
pattern = (0, 1)
repeated = pattern * 3
print(repeated) # (0, 1, 0, 1, 0, 1)8. Check Membership
days = ("Mon", "Tue", "Wed")
has_friday = "Fri" in days
print(has_friday) # False9. Get Length
rgb = (255, 128, 0)
print(len(rgb)) # 310. Slicing (Creates New Tuple)
data = (10, 20, 30, 40, 50)
subset = data[1:4]
print(subset) # (20, 30, 40)Advanced & Real-World Use Cases
11. Tuple as Dictionary Key
# Store city coordinates
locations = {
("Dubai", "UAE"): (25.276987, 55.296249),
("London", "UK"): (51.507351, -0.127758)
}
print(locations[("Dubai", "UAE")]) # (25.276987, 55.296249)12. Named Tuples (Readable Structs)
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(p.x, p.y) # 3 4
print(p) # Point(x=3, y=4)13. Function Arguments with *args
def summarize(*numbers): # receives tuple
return sum(numbers), len(numbers)
total, count = summarize(10, 20, 30)
print(f"Sum={total}, Count={count}") # Sum=60, Count=314. Safe Configuration Constants
# Immutable settings — prevents accidental changes
DATABASE_CONFIG = ("localhost", 5432, "mydb", "user")
HOST, PORT, DB, USER = DATABASE_CONFIG15. Loop Over Tuples
students = [("Ali", 88), ("Sara", 92), ("Omar", 78)]
for name, grade in students:
print(f"{name}: {grade}%")
# Ali: 88%
# Sara: 92%
# Omar: 78%16. Compare Tuples (Lexicographical)
a = (1, 2, 3)
b = (1, 2, 4)
print(a < b) # True — compares element by element17. Convert List to Tuple (for Safety)
user_input = [1, 2, 3]
safe_data = tuple(user_input) # now immutable
# safe_data.append(4) → ❌ AttributeError18. Nested Tuples
matrix = ((1, 2), (3, 4), (5, 6))
print(matrix[1][0]) # 319. Count Occurrences
data = (1, 2, 2, 3, 2)
print(data.count(2)) # 320. Find Index of Value
colors = ("red", "green", "blue")
print(colors.index("green")) # 1Tuples vs Lists: When to Use Which?
| Feature | Tuple | List |
|---|---|---|
| Mutability | Immutable | Mutable |
| Syntax | () or comma |
[] |
| Performance | Faster, memory-efficient | Slower for large data |
| Use Case | Fixed data, records, keys | Dynamic collections, frequent changes |
| Hashable | Yes (if elements are hashable) | No |
Best Practices
- Use tuples for **structured, unchanging data** (e.g., coordinates, RGB, database rows).
- Prefer tuple unpacking over indexing for readability:
x, y = pointvsx = point[0]. - Use named tuples (
collections.namedtuple) for better self-documenting code. - Never use mutable objects (like lists) inside tuples if you plan to use the tuple as a dictionary key.
- Remember:
(42)is an integer;(42,)is a single-element tuple.
Key Takeaways
- Tuples are **immutable sequences**—ideal for fixed data.
- They enable **safe, hashable, and efficient** data representation.
- **Tuple unpacking** is a powerful Python idiom for clean, readable code.
- Use them as **return types**, **dictionary keys**, and **configuration constants**.
- When in doubt: if the data shouldn’t change, use a tuple.