Selecting Appropriate Data Structures for Different Problems

Combining Data Structures for Complex Problems

Real-world problems often require multiple data structures working together. Let's examine some composite examples:

A Simple Library Management System

This example shows how different data structures handle different aspects of the problem:

# File: library_system.py
# Location: ~/python_examples/week2/

# Book database as a dictionary with ISBN as key
books = {
    "978-1451673319": {
        "title": "Fahrenheit 451",
        "author": "Ray Bradbury",
        "year": 1953,
        "copies": 3
    },
    "978-0061120084": {
        "title": "To Kill a Mockingbird",
        "author": "Harper Lee",
        "year": 1960,
        "copies": 5
    },
    "978-0451524935": {
        "title": "1984",
        "author": "George Orwell",
        "year": 1949,
        "copies": 4
    }
}

# Checked out books with due dates (dictionary of sets)
checked_out = {
    "user1": {("978-1451673319", "2023-06-15")},
    "user2": {("978-0061120084", "2023-06-10"), ("978-0451524935", "2023-06-20")}
}

# Available books (calculated using sets)
def get_available_books():
    all_isbns = set(books.keys())
    checked_out_isbns = set()
    
    for user_checkouts in checked_out.values():
        for isbn, _ in user_checkouts:
            checked_out_isbns.add(isbn)
    
    available_isbns = all_isbns - checked_out_isbns
    
    # Create a list of available book details
    available_books = []
    for isbn in available_isbns:
        book = books[isbn].copy()  # Copy the book details
        book["isbn"] = isbn  # Add the ISBN to the details
        available_books.append(book)
    
    return available_books

# Check out a book
def checkout_book(user_id, isbn, due_date):
    if isbn not in books:
        return False, "Book not found"
    
    # Check if book is already checked out
    for user_checkouts in checked_out.values():
        for checkout_isbn, _ in user_checkouts:
            if checkout_isbn == isbn:
                return False, "Book already checked out"
    
    # Add to user's checkouts
    if user_id not in checked_out:
        checked_out[user_id] = set()
    
    checked_out[user_id].add((isbn, due_date))
    return True, "Book checked out successfully"

# Print available books
print("Available Books:")
for book in get_available_books():
    print(f"- {book['title']} by {book['author']} (ISBN: {book['isbn']})")

# Demonstrate checkout
status, message = checkout_book("user3", "978-0451524935", "2023-07-01")
print(f"\nCheckout result: {message}")
            

In this example:

• A dictionary stores the book database, allowing fast lookups by ISBN
• Nested dictionaries store book details
• A dictionary of sets tracks checked-out books
• Set operations find available books efficiently

Customer Order Processing System

Let's examine another composite example:

# File: order_processing.py
# Location: ~/python_examples/week2/

# Product catalog (dictionary for fast lookup)
products = {
    "SKU001": {"name": "Desk Lamp", "price": 19.99, "weight": 2.5},
    "SKU002": {"name": "Office Chair", "price": 149.99, "weight": 15.0},
    "SKU003": {"name": "Notebook", "price": 4.99, "weight": 0.5},
    "SKU004": {"name": "Pen Set", "price": 12.99, "weight": 0.3},
    "SKU005": {"name": "Desk Organizer", "price": 24.99, "weight": 1.8}
}

# Orders as a list (to maintain chronological order)
orders = [
    {
        "order_id": "ORD-001",
        "customer_id": "CUST-1234",
        "date": "2023-05-15",
        "items": [("SKU002", 1), ("SKU003", 2)]
    },
    {
        "order_id": "ORD-002",
        "customer_id": "CUST-5678",
        "date": "2023-05-16",
        "items": [("SKU001", 1), ("SKU004", 1), ("SKU005", 1)]
    }
]

# Process orders and calculate totals
def process_orders():
    for order in orders:
        print(f"\nProcessing Order: {order['order_id']}")
        print(f"Customer: {order['customer_id']}")
        print(f"Date: {order['date']}")
        print("Items:")
        
        total_price = 0
        total_weight = 0
        
        for sku, quantity in order["items"]:
            if sku in products:
                product = products[sku]
                item_price = product["price"] * quantity
                item_weight = product["weight"] * quantity
                
                print(f"  - {product['name']} × {quantity}: ${item_price:.2f}")
                
                total_price += item_price
                total_weight += item_weight
            else:
                print(f"  - Unknown product: {sku}")
        
        print(f"Total Price: ${total_price:.2f}")
        print(f"Total Weight: {total_weight:.1f} lbs")

# Find popular products (using a dictionary for counting)
def analyze_popular_products():
    product_counts = {}
    
    for order in orders:
        for sku, quantity in order["items"]:
            if sku in products:
                if sku not in product_counts:
                    product_counts[sku] = 0
                product_counts[sku] += quantity
    
    # Sort by popularity
    popular_products = sorted(
        product_counts.items(),
        key=lambda x: x[1],
        reverse=True
    )
    
    return popular_products

# Process all orders
process_orders()

# Show popular products
print("\nPopular Products:")
for sku, count in analyze_popular_products():
    product = products[sku]
    print(f"- {product['name']}: {count} units sold")
            

This example demonstrates:

• A dictionary for the product catalog, enabling fast lookups
• A list for orders, maintaining chronological sequence
• Tuples for order items (SKU and quantity)
• Another dictionary for counting product popularity

Real-world insight: In professional software development, these composite patterns are extremely common. Database records often become dictionaries, collections of unique identifiers become sets, and ordered operations use lists. Mastering when to use each structure and how to combine them effectively is a hallmark of experienced programmers.