Pagination patterns in FastAPI - Mini Project: Build & Apply

Pagination patterns with FastAPI

📖 Scenario: You are building a simple API to serve a list of books. Since the list can be very long, you want to show only a few books per page. This is called pagination.Users will ask for a specific page number and get back only the books on that page.

🎯 Goal: Create a FastAPI app that returns a paginated list of books. The user can specify the page number and the number of books per page.

📋 What You'll Learn

Create a list of books as initial data

Add variables for page number and page size

Write the logic to select only the books for the requested page

Create a FastAPI endpoint that returns the paginated books

💡 Why This Matters

🌍 Real World

Pagination is used in APIs to avoid sending too much data at once. It helps users load data faster and reduces server load.

💼 Career

Understanding pagination is important for backend developers building APIs that serve large datasets efficiently.

1

Create the list of books

Create a list called books with these exact strings: 'Book A', 'Book B', 'Book C', 'Book D', 'Book E', 'Book F', 'Book G', 'Book H'.

FastAPI

# Create the list of books
# Your code here

Hint

Use a Python list with the exact book names as strings.

2

Add pagination parameters

Create two variables: page set to 1 and page_size set to 3.

FastAPI

books = ['Book A', 'Book B', 'Book C', 'Book D', 'Book E', 'Book F', 'Book G', 'Book H']
# Create variables page and page_size
# Your code here

Hint

Set page to 1 and page_size to 3 to show 3 books per page starting from page 1.

3

Select books for the current page

Create a variable start that calculates the first index for the current page using page and page_size. Then create end as start + page_size. Finally, create paginated_books as the slice of books from start to end.

FastAPI

books = ['Book A', 'Book B', 'Book C', 'Book D', 'Book E', 'Book F', 'Book G', 'Book H']
page = 1
page_size = 3
# Calculate start and end indexes and slice books
# Your code here

Hint

Remember that list slicing in Python uses list[start:end] and that page 1 starts at index 0.

4

Create FastAPI endpoint for pagination

Import FastAPI and create an app instance called app. Then create a GET endpoint /books/ that accepts query parameters page and page_size with default values 1 and 3. Inside the endpoint function, calculate start and end as before, slice books to get paginated_books, and return it as JSON.

FastAPI

books = ['Book A', 'Book B', 'Book C', 'Book D', 'Book E', 'Book F', 'Book G', 'Book H']
page = 1
page_size = 3
start = (page - 1) * page_size
end = start + page_size
paginated_books = books[start:end]

# Import FastAPI and create app
# Create GET endpoint /books/ with page and page_size query parameters
# Calculate start, end, and return paginated_books
# Your code here

Hint

Use query parameters with default values in the endpoint function. Return the sliced list as JSON.

Practice

1. What is the main purpose of pagination in a FastAPI application?

easy

A. To split large data sets into smaller, manageable parts

B. To speed up the server hardware

C. To encrypt data before sending it

D. To change the database schema automatically

Solution

1. Step 1: Understand pagination concept

   Pagination divides large data into smaller chunks to avoid overwhelming users or servers.

2. Step 2: Identify the main goal in FastAPI

   FastAPI uses pagination to send only a part of data per request, improving performance and usability.

3. Final Answer:

   To split large data sets into smaller, manageable parts -> Option A

4. Quick Check:

   Pagination = split data [OK]

Hint: Pagination means breaking data into pages [OK]

Common Mistakes:

• Thinking pagination speeds up hardware
• Confusing pagination with encryption
• Assuming pagination changes database structure

2. Which of the following is the correct way to declare pagination parameters in a FastAPI endpoint using query parameters?

easy

A. def get_items(offset: str = '0', count: str = '10'):

B. def get_items(page: str = '1', size: str = '10'):

C. def get_items(skip: int = 0, limit: int = 10):

D. def get_items(start: int, end: int):

Solution

1. Step 1: Check parameter types for pagination

   Pagination parameters should be integers with default values for skip and limit.

2. Step 2: Validate correct syntax in FastAPI

   Using skip and limit as integers with defaults is standard and valid for query parameters.

3. Final Answer:

   def get_items(skip: int = 0, limit: int = 10): -> Option C

4. Quick Check:

   skip and limit as int with defaults [OK]

Hint: Use int with defaults for skip and limit [OK]

Common Mistakes:

• Using strings instead of integers for pagination
• Missing default values for query parameters
• Using unclear parameter names like start/end

3. Given this FastAPI endpoint snippet, what will be the output if called with ?skip=2&limit=3 on a list [10, 20, 30, 40, 50, 60]?

items = [10, 20, 30, 40, 50, 60]

@app.get('/items')
def read_items(skip: int = 0, limit: int = 5):
    return items[skip : skip + limit]

medium

A. [40, 50, 60]

B. [20, 30, 40]

C. [10, 20, 30]

D. [30, 40, 50]

Solution

1. Step 1: Understand slicing with skip and limit

   With skip=2 and limit=3, slice is items[2:5].

2. Step 2: Extract slice from list

   items[2:5] = [30, 40, 50] from the list.

3. Final Answer:

   [30, 40, 50] -> Option D

4. Quick Check:

   items[2:5] = [30, 40, 50] [OK]

Hint: Slice list from skip to skip+limit [OK]

Common Mistakes:

• Confusing skip with page number
• Using limit as end index instead of length
• Off-by-one errors in slicing

4. Identify the error in this FastAPI pagination endpoint:

@app.get('/users')
def get_users(page: int = 1, size: int = 10):
    skip = page * size
    users = get_all_users()
    return users[skip : skip + size]

medium

A. The calculation of skip should be (page - 1) * size

B. The function should use skip and limit parameters instead of page and size

C. The slice should be users[skip : size] instead of users[skip : skip + size]

D. The default size should be 1, not 10

Solution

1. Step 1: Analyze skip calculation

   Skip should start from zero on page 1, so skip = (page - 1) * size.

2. Step 2: Check slicing correctness

   Current skip calculation skips too many items, causing wrong slice.

3. Final Answer:

   The calculation of skip should be (page - 1) * size -> Option A

4. Quick Check:

   skip = (page - 1) * size [OK]

Hint: Page 1 means skip zero items [OK]

Common Mistakes:

• Using page * size instead of (page - 1) * size
• Confusing slice end index
• Ignoring zero-based indexing

5. You want to create a FastAPI endpoint that returns paginated results along with total count of items. Which of the following code snippets correctly implements this pattern?

hard

A. def get_paginated(page: int = 0, size: int = 10):
data = get_all_data()
skip = (page - 1) * size
return {"total": len(data), "items": data[skip:skip+size]}

B. def get_paginated(skip: int = 0, limit: int = 10):
data = get_all_data()
return {"total": len(data), "items": data[skip:skip+limit]}

C. def get_paginated(offset: int = 0, count: int = 10):
data = get_all_data()
return {"total": len(data), "items": data[offset:count]}

D. def get_paginated(page: int = 1, size: int = 10):
data = get_all_data()
skip = page * size
return {"count": len(data), "results": data[skip:skip+size]}

Solution

1. Step 1: Check pagination calculation

   def get_paginated(skip: int = 0, limit: int = 10): data = get_all_data() return {"total": len(data), "items": data[skip:skip+limit]} correctly uses skip and limit with default values and slices data properly.

2. Step 2: Verify total count and returned keys

   def get_paginated(skip: int = 0, limit: int = 10): data = get_all_data() return {"total": len(data), "items": data[skip:skip+limit]} returns total count and paginated items with clear keys "total" and "items".

3. Final Answer:

   def get_paginated(skip: int = 0, limit: int = 10):\n data = get_all_data()\n return {"total": len(data), "items": data[skip:skip+limit]} -> Option B

4. Quick Check:

   Skip/limit with total count returned [OK]

Hint: Return total count and slice with skip/limit [OK]

Common Mistakes:

• Wrong skip calculation with page * size
• Incorrect slice indices causing empty results
• Using page=0 instead of page=1 for pagination