Python Tuples Complete Guide

# Creating tuples
empty_tuple = ()
single_item = (42,)  # Note the comma!
numbers = (1, 2, 3, 4, 5)
mixed = (10, "hello", 3.14, True)

# Accessing elements
print(f"First element: {numbers[0]}")      # 1
print(f"Last element: {numbers[-1]}")      # 5

# Tuple unpacking
x, y, z = (10, 20, 30)
print(f"x={x}, y={y}, z={z}")

# Nested tuples
nested = ((1, 2), (3, 4), (5, 6))
print(f"Nested tuple: {nested}")

# Without parentheses (tuple packing)
packed = 1, 2, 3, 4, 5
print(f"Packed tuple: {packed}")

# Tuple Creation and Access Examples
print("=== Tuple Creation ===")

# Different ways to create tuples
empty_tuple = ()
single_tuple = (42,)  # Note: comma is required
numbers = (1, 2, 3, 4, 5)
mixed = (10, "Python", 3.14, True, [1, 2, 3])

print(f"Empty tuple: {empty_tuple}")
print(f"Single element: {single_tuple}")
print(f"Numbers tuple: {numbers}")
print(f"Mixed tuple: {mixed}")

# Tuple from other sequences
list_to_tuple = tuple([1, 2, 3])
string_to_tuple = tuple("Hello")
range_to_tuple = tuple(range(5))

print(f"\nFrom list: {list_to_tuple}")
print(f"From string: {string_to_tuple}")
print(f"From range: {range_to_tuple}")

print("\n=== Tuple Access ===")
# Indexing
colors = ("red", "green", "blue", "yellow", "purple")
print(f"First color: {colors[0]}")        # red
print(f"Last color: {colors[-1]}")        # purple
print(f"Third color: {colors[2]}")        # blue
print(f"Second last: {colors[-2]}")       # yellow

# Slicing
print(f"\nFirst 3 colors: {colors[:3]}")    # ('red', 'green', 'blue')
print(f"Last 3 colors: {colors[-3:]}")     # ('blue', 'yellow', 'purple')
print(f"Every other: {colors[::2]}")       # ('red', 'blue', 'purple')
print(f"Reversed: {colors[::-1]}")         # ('purple', 'yellow', 'blue', 'green', 'red')

# Nested tuple access
matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(f"\nNested access: matrix[1][2] = {matrix[1][2]}")  # 6

# Tuple Methods and Operations Examples
print("=== Tuple Methods ===")

# count() method
numbers = (1, 2, 3, 2, 4, 2, 5, 2)
print(f"Tuple: {numbers}")
print(f"Count of 2: {numbers.count(2)}")      # 4
print(f"Count of 5: {numbers.count(5)}")      # 1
print(f"Count of 10: {numbers.count(10)}")    # 0

# index() method
colors = ("red", "green", "blue", "green", "yellow")
print(f"\nColors: {colors}")
print(f"First 'green' at index: {colors.index('green')}")      # 1
print(f"'blue' at index: {colors.index('blue')}")              # 2
print(f"'green' from index 2: {colors.index('green', 2)}")     # 3

print("\n=== Tuple Operations ===")
# Concatenation
t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = t1 + t2
print(f"t1 + t2 = {t3}")  # (1, 2, 3, 4, 5, 6)

# Repetition
t4 = t1 * 3
print(f"t1 * 3 = {t4}")   # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# Membership test
print(f"\nIs 2 in t1? {2 in t1}")      # True
print(f"Is 7 in t1? {7 in t1}")        # False
print(f"Is 'red' in colors? {'red' in colors}")  # True

# Comparison
t5 = (1, 2, 3)
t6 = (1, 2, 4)
print(f"\nComparison: t5 == t6? {t5 == t6}")  # False
print(f"t5 < t6? {t5 < t6}")                 # True (3 < 4)

# Length
print(f"\nLength of t3: {len(t3)}")          # 6
print(f"Length of colors: {len(colors)}")    # 5

# Tuple Unpacking and Advanced Features
print("=== Tuple Unpacking ===")

# Basic unpacking
point = (10, 20)
x, y = point
print(f"Point: {point}")
print(f"x = {x}, y = {y}")

# Multiple assignment
a, b, c = (1, 2, 3)
print(f"\na={a}, b={b}, c={c}")

# Extended unpacking (Python 3)
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(f"\nNumbers: {numbers}")
print(f"First: {first}, Middle: {middle}, Last: {last}")

# Swapping variables
var1 = 100
var2 = 200
print(f"\nBefore swap: var1={var1}, var2={var2}")
var1, var2 = var2, var1  # Tuple packing and unpacking
print(f"After swap: var1={var1}, var2={var2}")

print("\n=== Function Return Values ===")
# Functions returning tuples
def min_max(numbers):
    return min(numbers), max(numbers)

values = [5, 2, 8, 1, 9, 3]
min_val, max_val = min_max(values)
print(f"Numbers: {values}")
print(f"Min: {min_val}, Max: {max_val}")

# Multiple return values
def get_user_info():
    return "John Doe", 30, "john@example.com"

name, age, email = get_user_info()
print(f"\nUser Info - Name: {name}, Age: {age}, Email: {email}")

print("\n=== Iterating over Tuples ===")
# Looping through tuples
coordinates = [(1, 2), (3, 4), (5, 6), (7, 8)]
print("Coordinates:")
for x, y in coordinates:
    print(f"  x={x}, y={y}")

# With enumerate
fruits = ("apple", "banana", "cherry")
print("\nFruits with index:")
for index, fruit in enumerate(fruits):
    print(f"  {index}: {fruit}")

# Demonstrating Tuple Immutability
print("=== Tuple Immutability ===")

# Creating a tuple
my_tuple = (1, 2, 3, 4, 5)
print(f"Original tuple: {my_tuple}")

# This works - accessing elements
print(f"First element: {my_tuple[0]}")
print(f"Slice: {my_tuple[1:4]}")

# This causes ERROR - cannot modify
try:
    my_tuple[0] = 10  # TypeError: 'tuple' object does not support item assignment
    print("This won't print")
except TypeError as e:
    print(f"ERROR: {e}")

# This causes ERROR - cannot append
try:
    my_tuple.append(6)  # AttributeError: 'tuple' object has no attribute 'append'
except AttributeError as e:
    print(f"ERROR: {e}")

# This causes ERROR - cannot remove
try:
    my_tuple.remove(3)  # AttributeError: 'tuple' object has no attribute 'remove'
except AttributeError as e:
    print(f"ERROR: {e}")

print("\n=== Workarounds for Immutability ===")

# 1. Create a new tuple with modifications
original = (1, 2, 3)
# "Modify" by creating new tuple
modified = original[:1] + (99,) + original[2:]
print(f"Original: {original}")
print(f"Modified: {modified}")

# 2. Convert to list, modify, convert back
tuple_to_modify = (1, 2, 3, 4, 5)
temp_list = list(tuple_to_modify)
temp_list[2] = 999
new_tuple = tuple(temp_list)
print(f"\nOriginal tuple: {tuple_to_modify}")
print(f"Modified tuple: {new_tuple}")

# 3. Concatenation for "adding" elements
base_tuple = (1, 2, 3)
added_tuple = base_tuple + (4, 5, 6)
print(f"\nBase tuple: {base_tuple}")
print(f"After adding elements: {added_tuple}")

print("\n=== Benefits of Immutability ===")
# 1. Hashable - can be used as dictionary keys
coordinates_dict = {
    (10, 20): "Point A",
    (30, 40): "Point B",
    (50, 60): "Point C"
}
print(f"Dictionary with tuple keys: {coordinates_dict}")
print(f"Value at (30, 40): {coordinates_dict[(30, 40)]}")

# 2. Thread-safe in multi-threaded environments
# 3. Can be used in sets
unique_points = {(1, 2), (3, 4), (1, 2), (5, 6)}
print(f"\nSet of tuples (duplicates removed): {unique_points}")

# Python Tuples Practice Exercises

print("=== Exercise 1: Tuple Basics ===")
# Create a tuple with 5 different data types
mixed_tuple = (42, 3.14, "Hello", True, [1, 2, 3])
print(f"Mixed tuple: {mixed_tuple}")

print("\n=== Exercise 2: Tuple Operations ===")
# Given two tuples, combine them and repeat
t1 = (1, 2, 3)
t2 = (4, 5, 6)
combined = t1 + t2
repeated = t1 * 3
print(f"t1: {t1}, t2: {t2}")
print(f"Combined: {combined}")
print(f"Repeated t1: {repeated}")

print("\n=== Exercise 3: Tuple Unpacking ==")
# Unpack a tuple into variables
coordinates = (10, 20, 30)
x, y, z = coordinates
print(f"Coordinates: {coordinates}")
print(f"x={x}, y={y}, z={z}")

print("\n=== Exercise 4: Tuple Methods ===")
# Use count() and index() methods
numbers = (1, 2, 3, 2, 4, 2, 5, 2, 6, 2)
print(f"Numbers: {numbers}")
print(f"Count of 2: {numbers.count(2)}")
print(f"First index of 5: {numbers.index(5)}")

print("\n=== Exercise 5: Nested Tuples ===")
# Access elements in nested tuples
matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(f"Matrix: {matrix}")
print(f"Element at row 1, column 2: {matrix[1][2]}")

print("\n=== Exercise 6: Tuple as Dictionary Key ===")
# Create a dictionary with tuple keys
student_grades = {
    ("John", "Doe"): 85,
    ("Jane", "Smith"): 92,
    ("Bob", "Johnson"): 78
}
print("Student grades:")
for (first, last), grade in student_grades.items():
    print(f"  {first} {last}: {grade}")

print("\n=== Exercise 7: Function Returning Tuple ===")
# Write function that returns multiple values as tuple
def circle_properties(radius):
    import math
    area = math.pi * radius ** 2
    circumference = 2 * math.pi * radius
    return area, circumference

area, circumference = circle_properties(5)
print(f"Circle with radius 5:")
print(f"  Area: {area:.2f}")
print(f"  Circumference: {circumference:.2f}")

print("\n=== Exercise 8: Tuple Comparison ===")
# Compare tuples
tuple_a = (1, 2, 3)
tuple_b = (1, 2, 4)
tuple_c = (1, 2, 3)
print(f"tuple_a: {tuple_a}, tuple_b: {tuple_b}, tuple_c: {tuple_c}")
print(f"tuple_a == tuple_b: {tuple_a == tuple_b}")
print(f"tuple_a == tuple_c: {tuple_a == tuple_c}")
print(f"tuple_a < tuple_b: {tuple_a < tuple_b}")