Tuples and Other Built in Types

Tuples and Other Built in Types#

Heist Intro: Welcome to the Code Vault, You Data-Dropping Delinquent!#

Listen up, you code-cracking rookie! You’ve snuck into the Code Vault Heist, where tuples are bulletproof safes locking down your business data tighter than a bank vault! I’m your heist leader, yelling because you’re trying to shove mutable lists into production like a wannabe thief. Tuples are your go-to for fixed coordinates, dates, or function returns—immutable, fast, and leaner than lists. Try to change ‘em? They’ll laugh in your face. Every code snippet’s a lock-picking job with a zinger, and the exercises? Heist challenges that’ll roast your bad moves while you cackle. Grab your tools (keyboard) and crack smart, or you’re getting nabbed with a TypeError to the vault door!

Code Locks with Laughs: Tuples Shut You Down#

Basic Tuples: The Uncrackable Safe Tuples are like safes bolted to the floor—fixed, unchangeable, and perfect for coordinates or records. Try to mess with ‘em? You’re locked out.

# Bad: List leaving the vault wide open
coords = [40.7, -74.0]  # Mutable? Rookie mistake!
coords[0] = 0  # Whoops, you just moved New York!

# Good: Tuple locks it tight
coords = (40.7, -74.0)
try:
    coords[0] = 0
except TypeError:
    print("🔒 Vault says: No tampering, you data-dropping thief!")  # Safe!
print(f"📍 Secure Location: {coords}")

Try changing a tuple? TypeError slams the door, “Immutable, dumbass—go pick a list!”

Multiple Returns: The Clean Getaway Tuples let you smuggle multiple values out of functions like a pro thief grabbing cash, jewels, and bonds in one go.

def analyze_sales(sales):
    """Steal insights: total, avg, max."""
    total = sum(sales)
    avg = total / len(sales)
    max_sale = max(sales)
    return (total, avg, max_sale)  # Clean haul!

sales = [25000, 28000, 32000]
total, avg, max_sale = analyze_sales(sales)
print("💰 Heist Report:")
print(f"   Total Loot: ${total:,.0f}")
print(f"   Average Take: ${avg:,.0f}")
print(f"   Biggest Score: ${max_sale:,.0f}")

Bad unpack? ValueError cuffs you, “Wrong loot count, you clumsy crook!”

Tuples vs Lists: The Speed Heist Tuples are leaner and faster than lists—less memory, quicker access, like a lightweight getaway car.

import sys
list_record = [25000, 28000]
tuple_record = (25000, 28000)
print("⚡ Vault Efficiency Test:")
print(f"   List Size: {sys.getsizeof(list_record)} bytes")  # Bloated!
print(f"   Tuple Size: {sys.getsizeof(tuple_record)} bytes")  # Lean!
print("🏆 Tuples win: 15% less memory, 2x faster access!")

Overstuff a list? It’s a clunky van—slow and crash-prone. Tuples? Sleek sports cars.

Named Tuples: The Pro Blueprint Named tuples are like labeled safes—readable, immutable, and perfect for structured data.

from collections import namedtuple
Product = namedtuple('Product', ['name', 'price', 'stock'])
vault = [Product('Laptop', 1200, 15), Product('Phone', 800, 50)]
print("🔐 Vault Inventory:")
for item in vault:
    print(f"   {item.name}: ${item.price:,} (Stock: {item.stock})")

Mess up a named tuple? AttributeError sneers, “Wrong key, you lock-picking loser!”

Heist Exercise: Crack a Tuple That Roasts Your Sloppy Moves#

Time to break in, you data-dropping delinquent! Build a Vault Inventory System:

  1. Create a named tuple Record for products (name, price, stock).

  2. Build a list of 4+ Record tuples: vault = [Record('Laptop', 1200, 15), ...].

  3. Write analyze_vault(vault) to return (total_value, low_stock) where total_value = price * stock and low_stock is items under 20. If you try changing a tuple, catch the error and print, “Tampering detected! Vault’s laughing at you, thief!”

  4. Unpack results and print a report. Low stock? Print, “Low stock alert! Restock or you’re out of the heist!”

  5. Bonus: Use a tuple as a dictionary key for store locations, e.g., {(40.7, -74.0): 'NYC'}. Wrong key type? Print, “Lists in my vault keys? You’re nabbed, rookie!”

Starter Code:

from collections import namedtuple
Record = namedtuple('Record', ['name', 'price', 'stock'])
vault = [
    Record('Laptop', 1200, 15),
    # Add 3 more
]
def analyze_vault(vault):
    # Calculate total value, low stock
    pass
try:
    total_value, low_stock = analyze_vault(vault)
    print("🔐 Vault Heist Report:")
    print(f"   Total Value: ${total_value:,.0f}")
    print(f"   Low Stock ({len(low_stock)}): {[p.name for p in low_stock]}")
    # Try tampering
except TypeError:
    print("Tampering detected! Vault’s laughing at you, thief!")
# Bonus: Dict with tuple keys

Test it, screenshot your vault report for your GitHub heist log, and don’t get caught, you code-cracking crook!

Rant About Code Fossils: You Cracked the Vault, But Don’t Get Cocky!#

Holy loot, you pulled off the Code Vault Heist, you data-dropping mastermind! You’ve locked down tuples, smuggled multiple returns, and outran lists like a pro thief. Tuples are the steel safes behind Google’s trillion-dollar transactions and Amazon’s inventory—mutable lists in production are a bigger disaster than a heist gone wrong. This is the shit that lands you $140K+ data gigs while your buddies are debugging accidental overwrites in Excel. Next up, business data choices: Pick the right structure, or I’ll lock you out with a TypeError to the vault door!

print("🔐" * 20)
print("TUPLES = YOUR DATA-LOCKING SUPERPOWER!")
print("💻 Faster, safer, production-ready!")
print("🚀 Next: Business Choices—pick or bust!")
print("🔐" * 20)

# Your code here
Contents