Python: Working with Tuples

# Solution 1: Proper tuple creation and usage patterns
# Basic tuple creation
coordinates = (10, 20)
rgb_color = (255, 128, 0)
person = ("Alice", 30, "Engineer")

# Single element tuple requires comma
single_tuple = (42,)  # Note the comma
not_a_tuple = (42)    # This is just an integer

print(type(single_tuple))  # <class 'tuple'>
print(type(not_a_tuple))   # <class 'int'>

# Tuple without parentheses (tuple packing)
point = 3, 4
name_age = "Bob", 25
print(type(point))     # <class 'tuple'>

# Accessing tuple elements
print(coordinates[0])  # 10 (first element)
print(coordinates[1])  # 20 (second element)
print(coordinates[-1]) # 20 (last element)

# Tuple slicing
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(numbers[2:5])    # (2, 3, 4)
print(numbers[:3])     # (0, 1, 2)
print(numbers[7:])     # (7, 8, 9)
print(numbers[::2])    # (0, 2, 4, 6, 8) - every second element

# Tuple unpacking (destructuring)
x, y = coordinates
print(f"X: {x}, Y: {y}")  # X: 10, Y: 20

name, age, job = person
print(f"{name} is {age} years old and works as {job}")

# Advanced unpacking with asterisk
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(f"First: {first}")     # First: 1
print(f"Middle: {middle}")   # Middle: [2, 3, 4]
print(f"Last: {last}")       # Last: 5

# Solution 2: Advanced tuple operations and use cases
# Named tuples for better readability
from collections import namedtuple

# Define a named tuple type
Point = namedtuple('Point', ['x', 'y'])
Person = namedtuple('Person', ['name', 'age', 'email'])

# Create instances
p1 = Point(10, 20)
p2 = Point(x=30, y=40)  # Using keyword arguments

person1 = Person("Alice", 30, "alice@example.com")

# Access by name (more readable than index)
print(f"Point coordinates: ({p1.x}, {p1.y})")
print(f"Person: {person1.name}, Age: {person1.age}")

# Named tuples are still tuples
print(p1[0])  # 10 - index access still works
print(isinstance(p1, tuple))  # True

# Tuple methods
data = (1, 2, 3, 2, 4, 2, 5)
print(data.count(2))      # 3 - count occurrences
print(data.index(4))      # 4 - find first index of value

# Tuples as dictionary keys (because they're hashable)
locations = {
    (0, 0): "Origin",
    (10, 20): "Point A",
    (30, 40): "Point B"
}

print(locations[(10, 20)])  # "Point A"

# Tuples in sets
coordinate_set = {(0, 0), (1, 1), (2, 2), (0, 0)}  # Duplicate will be removed
print(coordinate_set)  # {(0, 0), (1, 1), (2, 2)}

# Function returning multiple values using tuples
def get_name_age():
    return "Charlie", 35  # Returns a tuple

def calculate_stats(numbers):
    if not numbers:
        return 0, 0, 0  # min, max, average
    
    min_val = min(numbers)
    max_val = max(numbers)
    avg_val = sum(numbers) / len(numbers)
    
    return min_val, max_val, avg_val

# Using returned tuples
name, age = get_name_age()
print(f"Name: {name}, Age: {age}")

stats = calculate_stats([1, 5, 3, 9, 2, 7])
min_num, max_num, avg_num = stats
print(f"Min: {min_num}, Max: {max_num}, Average: {avg_num:.2f}")

# Tuple comprehension (actually generator)
squares = (x**2 for x in range(5))  # This is a generator, not tuple
squares_tuple = tuple(x**2 for x in range(5))  # Convert to actual tuple
print(squares_tuple)  # (0, 1, 4, 9, 16)

# Comparing tuples (lexicographic order)
print((1, 2, 3) < (1, 2, 4))  # True
print((1, 2, 3) < (1, 3, 1))  # True
print((2, 1) > (1, 9))        # True

# Swapping variables using tuples
a, b = 10, 20
print(f"Before swap: a={a}, b={b}")
a, b = b, a  # Elegant swap using tuple unpacking
print(f"After swap: a={a}, b={b}")

# Enumerate with tuples
items = ['apple', 'banana', 'cherry']
for index, value in enumerate(items):
    print(f"{index}: {value}")

# Zip creates tuples
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
emails = ['alice@ex.com', 'bob@ex.com', 'charlie@ex.com']

for person_data in zip(names, ages, emails):
    name, age, email = person_data
    print(f"{name} ({age}): {email}")

# Database-like operations with tuples
employees = [
    ("Alice", "Engineering", 75000),
    ("Bob", "Sales", 65000),
    ("Charlie", "Engineering", 80000),
    ("Diana", "Marketing", 60000)
]

# Filter employees by department
engineering_staff = [emp for emp in employees if emp[1] == "Engineering"]
print("Engineering staff:", engineering_staff)

# Calculate average salary by department
from collections import defaultdict

dept_salaries = defaultdict(list)
for name, dept, salary in employees:
    dept_salaries[dept].append(salary)

for dept, salaries in dept_salaries.items():
    avg_salary = sum(salaries) / len(salaries)
    print(f"{dept} average salary: ${avg_salary:,.2f}")

# Nested tuples for complex data
matrix = (
    (1, 2, 3),
    (4, 5, 6),
    (7, 8, 9)
)

# Access nested elements
print(matrix[1][2])  # 6

# Iterate through nested tuples
for row in matrix:
    for element in row:
        print(element, end=" ")
    print()  # New line after each row

# Converting between tuples and other types
list_data = [1, 2, 3, 4, 5]
tuple_data = tuple(list_data)
print(tuple_data)  # (1, 2, 3, 4, 5)

string_data = "hello"
char_tuple = tuple(string_data)
print(char_tuple)  # ('h', 'e', 'l', 'l', 'o')

# Immutability benefits for function parameters
def process_coordinates(coords):
    """Function expects coordinates that won't change"""
    x, y = coords
    # coords is guaranteed not to change during function execution
    return x * x + y * y

result = process_coordinates((3, 4))
print(f"Distance squared: {result}")  # 25

# Memory efficiency compared to lists
import sys

list_data = [1, 2, 3, 4, 5]
tuple_data = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(list_data)} bytes")
print(f"Tuple size: {sys.getsizeof(tuple_data)} bytes")

# Performance comparison for large datasets
import time

# Tuple creation is faster for known data
start_time = time.time()
for _ in range(100000):
    data = (1, 2, 3, 4, 5)
tuple_time = time.time() - start_time

start_time = time.time()
for _ in range(100000):
    data = [1, 2, 3, 4, 5]
list_time = time.time() - start_time

print(f"Tuple creation time: {tuple_time:.4f}s")
print(f"List creation time: {list_time:.4f}s")

# Using tuples for configuration
DATABASE_CONFIG = (
    "localhost",    # host
    5432,          # port
    "myapp",       # database
    "user",        # username
    "password"     # password
)

# Unpack configuration
host, port, db_name, username, password = DATABASE_CONFIG
connection_string = f"postgresql://{username}:{password}@{host}:{port}/{db_name}"
print(connection_string)