Library Management System

Display All Books (List Iteration & Unpacking)

Function: display_books(books)

Must use: Tuple unpacking in loop

• Loop through books list
• Unpack each tuple: book_id, title, author, genre, year, total, available = book
• Print formatted book details (ID, title, author, available/total copies)

def display_books(books):
    """Display all books with unpacking."""
    for book_id, title, author, genre, year, total, available in books:
        print(f"{book_id}: {title} by {author} - {available}/{total} available")
    # Must use tuple unpacking in the loop

Find Book by ID (List Search & Unpacking)

Function: find_book(books, book_id)

Must use: Loop with unpacking, return tuple

• Search for book matching the given book_id
• Return the entire book tuple if found
• Return None if not found

def find_book(books, book_id):
    """Find and return book tuple by ID."""
    for book in books:
        bid, title, author, genre, year, total, available = book
        if bid == book_id:
            return book
    return None

Search Books by Genre (List Comprehension)

Function: get_books_by_genre(books, genre)

Must use: List comprehension with unpacking

• Filter books matching the given genre (case-insensitive)
• Return list of tuples: (book_id, title, author)
• Use list comprehension for filtering

def get_books_by_genre(books, genre):
    """Return list of (id, title, author) tuples for matching genre."""
    # Must use list comprehension with tuple unpacking
    return [(bid, title, author) for bid, title, author, g, *_ in books 
            if g.lower() == genre.lower()]

Get Unique Genres (Set from List)

Function: get_unique_genres(books)

Must use: Set comprehension or set constructor

• Extract all unique genres from books
• Return a sorted list of unique genres

def get_unique_genres(books):
    """Return sorted list of unique genres using set."""
    genres = {genre for _, _, _, genre, *_ in books}
    return sorted(genres)

Get Available Books (Slicing & Filtering)

Function: get_available_books(books)

Must use: List comprehension, check availability

• Filter books where copies_available > 0
• Return list of available book tuples

def get_available_books(books):
    """Return list of books that have copies available."""
    return [book for book in books if book[-1] > 0]  # Check last element (available)

Add New Member (Dictionary & List)

Function: add_member(members, member_id, name, email, join_year)

Must use: Dictionary creation, list append

• Create a new member dictionary with given details
• Initialize books_borrowed as empty list
• Append to members list
• Return True if added, False if member_id already exists

Find Member by ID (Dictionary Search)

Function: find_member(members, member_id)

Must use: Loop through list of dictionaries

• Search for member with matching member_id
• Return member dictionary if found, None otherwise

Borrow Book (List/Dict Modification)

Function: borrow_book(books, members, records, member_id, book_id, borrow_date, due_date)

Must use: List operations, dictionary update

• Check if member exists and book is available
• Decrease book's available copies (requires replacing tuple in list!)
• Add book_id to member's books_borrowed list
• Create new borrowing record tuple and add to records
• Return (True, "Success message") or (False, "Error message")

def borrow_book(books, members, records, member_id, book_id, borrow_date, due_date):
    """Process book borrowing - modify data structures appropriately."""
    # 1. Find member and book
    # 2. Check availability
    # 3. Update book tuple (create new tuple with decreased available count)
    # 4. Update member's books_borrowed list
    # 5. Add record tuple to records
    # Return tuple: (success_boolean, message_string)

Return Book (List/Dict Modification)

Function: return_book(books, members, records, member_id, book_id, return_date)

Must use: List operations, tuple replacement

• Find the borrowing record (where return_date is None)
• Update record with return_date (replace tuple)
• Increase book's available copies
• Remove book_id from member's books_borrowed
• Return (True, "Success") or (False, "Error")

Get Overdue Books (Filtering with Unpacking)

Function: get_overdue_books(records, current_date)

Must use: List comprehension with unpacking

• Filter records where return_date is None and due_date < current_date
• Return list of tuples: (record_id, member_id, book_id, due_date)
• Use tuple unpacking in comprehension

Get Books Borrowed by Member (Dictionary Access)

Function: get_member_books(members, books, member_id)

Must use: Dictionary operations, list filtering

• Find member's books_borrowed list
• Return list of book titles (look up each book_id)

Get Most Popular Genre (Dictionary/Set Operations)

Function: get_popular_genre(records, books)

Must use: Dictionary for counting, unpacking

• Count how many times books from each genre were borrowed
• Use dictionary to track genre: count
• Return tuple: (genre_name, borrow_count)

Get Recent Books (Slicing)

Function: get_recent_books(books, n=5)

Must use: Sorting and slicing

• Sort books by publication year (descending)
• Return top N most recent books using slice
• Use sorted() with lambda key

def get_recent_books(books, n=5):
    """Return n most recent books using sorting and slicing."""
    sorted_books = sorted(books, key=lambda b: b[4], reverse=True)  # Sort by year
    return sorted_books[:n]  # Slice first n

Generate Library Report (String Formatting)

Function: generate_report(books, members, records)

Must use: All data structures, unpacking, len()

• Print total books, total members, total borrowed currently
• Print all unique genres
• Print top 3 most recent books
• Print members with currently borrowed books

Main Program (Integration)

Function: main()

Must use: All previous functions

• Initialize the three data structures with sample data
• Demonstrate at least 3 book borrowings
• Demonstrate at least 1 book return
• Display library report
• Show overdue books (if any)
• Use if __name__ == "__main__": pattern

def main():
    # Initialize data
    books = [...]  # Your book data
    members = [...]  # Your member data
    borrowing_records = []  # Start empty
    
    # Demo operations
    print("=== Library Management System ===\n")
    
    # Display all books
    display_books(books)
    
    # Borrow some books
    borrow_book(books, members, borrowing_records, "M001", "B002", "2024-01-20", "2024-02-03")
    # ... more operations
    
    # Generate report
    generate_report(books, members, borrowing_records)
    
if __name__ == "__main__":
    main()