# Basic tuple unpacking
point = (10, 20)
x, y = point

person = ("Alice", 25, "Engineer")
name, age, job = person

print(f"Point coordinates: x={x}, y={y}")
print(f"Person: {name}, age {age}, job {job}")

# Swapping variables elegantly
a, b = 5, 15
print(f"Before swap: a={a}, b={b}")
a, b = b, a
print(f"After swap: a={a}, b={b}")

# Simple unpacking examples
rgb_color = (255, 128, 0)
red, green, blue = rgb_color

coordinates = (100, 200)
x, y = coordinates

student_info = ("Bob", 20, "Mathematics")
name, age, major = student_info

print(f"RGB: R={red}, G={green}, B={blue}")
print(f"Position: ({x}, {y})")
print(f"Student: {name}, {age} years old, studying {major}")

# Multiple assignment with unpacking
# Assign multiple variables at once
first, second, third = 1, 2, 3
name, email = "Alice", "alice@email.com"

print(f"Numbers: {first}, {second}, {third}")
print(f"Contact: {name} - {email}")

# Parallel assignment
user1, user2 = ("Alice", 25), ("Bob", 30)
print(f"User 1: {user1}")
print(f"User 2: {user2}")

# Variable swapping
x, y = 10, 20
print(f"Original: x={x}, y={y}")

# Swap variables elegantly
x, y = y, x
print(f"Swapped: x={x}, y={y}")

# Multiple variable rotation
a, b, c = 1, 2, 3
print(f"Original: a={a}, b={b}, c={c}")

a, b, c = b, c, a
print(f"Rotated: a={a}, b={b}, c={c}")

# Capturing rest elements
numbers = (1, 2, 3, 4, 5, 6)
first, *rest = numbers
print(f"First: {first}")
print(f"Rest: {rest}")

# Capture beginning and end
data = ("header", "item1", "item2", "item3", "footer")
header, *items, footer = data
print(f"Header: {header}")
print(f"Items: {items}")
print(f"Footer: {footer}")

# Selective unpacking
log_entry = ("2024-01-15", "14:30", "ERROR", "Database", "Connection failed")

# Extract date and message, ignore time and level details
date, _, _, *message_parts = log_entry
message = " ".join(message_parts)

print(f"Date: {date}")
print(f"Message: {message}")

# Extract first and last, ignore middle
scores = (95, 87, 92, 78, 88, 94)
highest, *_, lowest = sorted(scores, reverse=True)
print(f"Highest: {highest}, Lowest: {lowest}")

# Nested unpacking
line = ((0, 0), (10, 5))
(x1, y1), (x2, y2) = line

triangle = ((0, 0), (5, 0), (2.5, 4.33))
point1, point2, point3 = triangle

print(f"Line: from ({x1}, {y1}) to ({x2}, {y2})")
print(f"Triangle points: {point1}, {point2}, {point3}")

# Mixed nested unpacking
user_data = ("Alice", (25, "Engineer"), ["Python", "JavaScript"])
name, (age, job), skills = user_data
print(f"User: {name}, {age}, {job}, skills: {skills}")

# Functions with multiple returns
def get_name_parts(full_name):
    parts = full_name.split()
    if len(parts) >= 2:
        return parts[0], parts[-1]  # first, last
    return parts[0], ""  # first only

def calculate_stats(numbers):
    if not numbers:
        return 0, 0, 0
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    return total, count, average

# Unpacking function returns
first_name, last_name = get_name_parts("Alice Johnson")
total, count, avg = calculate_stats([85, 92, 78, 96, 88])

print(f"Name: {first_name} {last_name}")
print(f"Stats: total={total}, count={count}, average={avg:.1f}")

# Safe unpacking with error handling
def divide_with_remainder(a, b):
    if b == 0:
        return None, "Division by zero"
    quotient, remainder = divmod(a, b)
    return (quotient, remainder), "Success"

def parse_coordinate(coord_string):
    try:
        parts = coord_string.split(',')
        x, y = float(parts[0]), float(parts[1])
        return x, y, True
    except (ValueError, IndexError):
        return 0, 0, False

# Safe unpacking
result, message = divide_with_remainder(10, 3)
if result:
    quotient, remainder = result
    print(f"10 ÷ 3 = {quotient} remainder {remainder}")
else:
    print(f"Error: {message}")

x, y, success = parse_coordinate("10.5,20.3")
if success:
    print(f"Coordinates: ({x}, {y})")

# Status and result patterns
def validate_user_data(name, age, email):
    errors = []
    if not name:
        errors.append("Name required")
    if age < 0 or age > 150:
        errors.append("Invalid age")
    if "@" not in email:
        errors.append("Invalid email")
    
    is_valid = len(errors) == 0
    return is_valid, errors

def fetch_user_profile(user_id):
    # Simulate database lookup
    if user_id == 1:
        profile = {"name": "Alice", "age": 25, "role": "Engineer"}
        return profile, True, "Success"
    else:
        return None, False, "User not found"

# Using status patterns
valid, errors = validate_user_data("Alice", 25, "alice@email.com")
if valid:
    print("User data is valid")
else:
    print(f"Validation errors: {errors}")

profile, found, message = fetch_user_profile(1)
if found:
    name, age, role = profile["name"], profile["age"], profile["role"]
    print(f"Profile: {name}, {age}, {role}")

# Unpacking in loops
points = [(10, 20), (30, 40), (50, 60)]
students = [("Alice", 85), ("Bob", 92), ("Carol", 78)]

print("Points:")
for x, y in points:
    print(f"Point at ({x}, {y})")

print("\nStudent grades:")
for name, grade in students:
    status = "Pass" if grade >= 80 else "Needs improvement"
    print(f"{name}: {grade} - {status}")

# Nested tuple unpacking in loops
lines = [((0, 0), (10, 10)), ((5, 5), (15, 15))]
for (x1, y1), (x2, y2) in lines:
    length = ((x2-x1)**2 + (y2-y1)**2)**0.5
    print(f"Line from ({x1},{y1}) to ({x2},{y2}), length: {length:.1f}")

# Enumerate with unpacking
colors = [("red", 255, 0, 0), ("green", 0, 255, 0), ("blue", 0, 0, 255)]

print("Color definitions:")
for index, (name, r, g, b) in enumerate(colors):
    print(f"{index + 1}. {name}: RGB({r}, {g}, {b})")

# Processing with positions
coordinates = [(10, 20), (30, 40), (50, 60)]
for i, (x, y) in enumerate(coordinates):
    print(f"Point {i}: coordinates ({x}, {y}), distance from origin: {(x**2 + y**2)**0.5:.1f}")

# Dictionary unpacking
user_scores = {"Alice": 95, "Bob": 87, "Carol": 92}
coordinates = {"origin": (0, 0), "center": (50, 50), "corner": (100, 100)}

print("User scores:")
for name, score in user_scores.items():
    grade = "A" if score >= 90 else "B" if score >= 80 else "C"
    print(f"{name}: {score} (Grade {grade})")

print("\nCoordinates:")
for location, (x, y) in coordinates.items():
    print(f"{location}: ({x}, {y})")

# Good unpacking practices
def process_order():
    return "ORD123", "Alice", ["laptop", "mouse"], 1299.99, "pending"

# Descriptive variable names
order_id, customer_name, items, total_amount, status = process_order()

print(f"Order {order_id}")
print(f"Customer: {customer_name}")
print(f"Items: {', '.join(items)}")
print(f"Total: ${total_amount:.2f}")
print(f"Status: {status}")

# For complex data, consider named tuples
from collections import namedtuple
Order = namedtuple('Order', ['id', 'customer', 'items', 'total', 'status'])
order = Order("ORD124", "Bob", ["keyboard"], 75.99, "shipped")
print(f"Named tuple order: {order.customer} - ${order.total:.2f}")

# Safe unpacking techniques
def safe_unpack_coordinate(coord_tuple, default=(0, 0)):
    """Safely unpack coordinate tuple with defaults"""
    try:
        x, y = coord_tuple
        return x, y
    except (ValueError, TypeError):
        return default

def safe_unpack_with_length(data_tuple, expected_length):
    """Safely unpack with length validation"""
    if len(data_tuple) != expected_length:
        raise ValueError(f"Expected {expected_length} elements, got {len(data_tuple)}")
    return data_tuple

# Using safe unpacking
test_data = [(10, 20), (30,), "invalid", (40, 50, 60)]

for data in test_data:
    try:
        x, y = safe_unpack_coordinate(data)
        print(f"Coordinate: ({x}, {y})")
    except:
        print(f"Failed to unpack: {data}")

# Performance considerations
large_dataset = [(i, i*2, i*3) for i in range(1000)]

# Efficient unpacking in comprehensions
squared_sums = [x**2 + y**2 + z**2 for x, y, z in large_dataset[:5]]
print(f"First 5 squared sums: {squared_sums}")

# Memory-efficient processing
def process_coordinates(coord_list):
    """Process coordinates efficiently"""
    total_distance = 0
    for x, y in coord_list:
        distance = (x**2 + y**2)**0.5
        total_distance += distance
    return total_distance

sample_coords = [(3, 4), (5, 12), (8, 15)]
total = process_coordinates(sample_coords)
print(f"Total distance: {total:.1f}")