Book Pagination in Python

Book pagination is a common requirement when displaying large amounts of text content in manageable chunks. In Python, we can implement pagination by calculating the starting index based on the page number and page size, then extracting the appropriate slice of data.

Given a list of strings representing a book, a page index (0-indexed), and a page size, we need to return the list of words on that specific page. If the page is out of bounds, we return an empty list.

Problem Example

If we have:

• book = ["hello", "world", "programming", "language", "python", "c++", "java"]

• page = 1 (second page, since 0-indexed)

• page_size = 3

The output should be ['language', 'python', 'c++'] because page 1 contains elements at indices 3, 4, and 5.

Solution Approach

To solve this problem, we follow these steps:

• Calculate the starting index: start_index = page × page_size

• Return elements from start_index to start_index + page_size

• Python's list slicing automatically handles out-of-bounds indices

Implementation

class Solution:
    def solve(self, book, page, page_size):
        start_index = page * page_size
        return book[start_index:start_index + page_size]

# Test the solution
solution = Solution()
book = ["hello", "world", "programming", "language", "python", "c++", "java"]
page = 1
page_size = 3

result = solution.solve(book, page, page_size)
print(f"Page {page} content: {result}")

Page 1 content: ['language', 'python', 'c++']

Testing Different Pages

Let's test our solution with different page numbers to understand how pagination works:

class Solution:
    def solve(self, book, page, page_size):
        start_index = page * page_size
        return book[start_index:start_index + page_size]

solution = Solution()
book = ["hello", "world", "programming", "language", "python", "c++", "java"]
page_size = 3

# Test different pages
for page_num in range(4):
    result = solution.solve(book, page_num, page_size)
    print(f"Page {page_num}: {result}")

Page 0: ['hello', 'world', 'programming']
Page 1: ['language', 'python', 'c++']
Page 2: ['java']
Page 3: []

How It Works

Alternative Implementation

Here's a more robust version that includes bounds checking:

def paginate_book(book, page, page_size):
    """
    Paginate a book list and return the content of a specific page.
    
    Args:
        book: List of strings representing the book content
        page: Page number (0-indexed)
        page_size: Number of items per page
    
    Returns:
        List of strings for the requested page, empty if out of bounds
    """
    if page < 0 or page_size <= 0:
        return []
    
    start_index = page * page_size
    
    # Return empty list if start_index is beyond the book length
    if start_index >= len(book):
        return []
    
    return book[start_index:start_index + page_size]

# Test with different scenarios
book = ["hello", "world", "programming", "language", "python", "c++", "java"]

test_cases = [
    (0, 3),  # First page
    (1, 3),  # Second page  
    (2, 3),  # Third page (partial)
    (3, 3),  # Out of bounds
    (-1, 3), # Negative page
    (1, 0)   # Invalid page size
]

for page, page_size in test_cases:
    result = paginate_book(book, page, page_size)
    print(f"Page {page}, Size {page_size}: {result}")

Page 0, Size 3: ['hello', 'world', 'programming']
Page 1, Size 3: ['language', 'python', 'c++']
Page 2, Size 3: ['java']
Page 3, Size 3: []
Page -1, Size 3: []
Page 1, Size 0: []

Conclusion

Book pagination in Python can be efficiently implemented using list slicing with calculated start and end indices. The key is to multiply the page number by page size to find the starting position, and Python's slicing automatically handles out-of-bounds cases by returning partial results or empty lists.