Pagination patterns in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is pagination in web APIs?

Pagination is a way to split large sets of data into smaller chunks or pages. It helps users get data bit by bit instead of all at once, making the app faster and easier to use.

beginner

Name two common pagination patterns used in APIs.

The two common pagination patterns are:
1. Offset-based pagination: Uses page number and page size to fetch data.
2. Cursor-based pagination: Uses a unique marker (cursor) to fetch the next set of data.

intermediate

How does offset-based pagination work in FastAPI?

Offset-based pagination uses query parameters like 'skip' and 'limit'. 'skip' tells how many items to skip, and 'limit' tells how many items to return. FastAPI reads these parameters and returns the correct slice of data.

intermediate

What is a cursor in cursor-based pagination?

A cursor is a unique identifier (like an ID or timestamp) that marks the last item fetched. The API uses this cursor to return the next set of items after it, making pagination efficient and consistent.

advanced

Why might cursor-based pagination be better than offset-based pagination?

Cursor-based pagination is better for large or changing data because it avoids skipping items or showing duplicates. It is faster and more reliable when data changes while users browse.

In FastAPI, which query parameters are commonly used for offset-based pagination?

A skip and limit

B cursor and limit

C page and size

D start and end

FastAPI commonly uses 'skip' to skip items and 'limit' to set how many items to return in offset-based pagination.

What does a cursor represent in cursor-based pagination?

A The total number of pages

B A unique marker for the last fetched item

C The page number

D The size of each page

A cursor is a unique marker like an ID or timestamp that points to the last item fetched, helping to get the next items.

Which pagination pattern can cause duplicates if data changes during browsing?

A Infinite scrolling

B Cursor-based pagination

C Offset-based pagination

D No pagination

Offset-based pagination can cause duplicates or missing items if data changes while browsing because it relies on fixed positions.

Why is pagination important in APIs?

A To split data into smaller, manageable parts

B To avoid using databases

C To make data harder to access

D To load all data at once

Pagination splits large data into smaller parts so apps load faster and users can navigate easily.

Which FastAPI feature helps read query parameters for pagination?

A Path parameters

B Request body

C Headers

D Query parameters

FastAPI uses query parameters to read pagination inputs like 'skip' and 'limit'.

Explain how offset-based pagination works in FastAPI and when you might use it.

Think about how you tell the API which items to skip and how many to return.

Describe cursor-based pagination and why it can be better for large or changing datasets.

Imagine a bookmark that remembers where you left off.

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