Pagination patterns in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the FastAPI class.

FastAPI

from fastapi import [1]
app = [1]()

Drag options to blanks, or click blank then click option'

AFastAPI

BRequest

CResponse

DDepends

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request or Response instead of FastAPI.

Forgetting to create the app instance.

The FastAPI class is imported from the fastapi module to create the app instance.

2fill in blank

medium

Complete the code to add query parameters for pagination: skip and limit.

FastAPI

@app.get('/items/')
async def read_items(skip: int = [1], limit: int = 10):
    return {'skip': skip, 'limit': limit}

Drag options to blanks, or click blank then click option'

A1

B0

CNone

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting skip default to 1, which skips the first item unintentionally.

Using None as default which causes errors.

Setting skip default to 0 means start from the first item.

3fill in blank

hard

Fix the error in the code to correctly use the Query function for limit with a default and max value.

FastAPI

from fastapi import Query

@app.get('/items/')
async def read_items(limit: int = Query([1], le=100)):
    return {'limit': limit}

Drag options to blanks, or click blank then click option'

ANone

B100

C10

D'10'

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string '10' instead of integer 10.

Using None which causes validation errors.

The default value for limit should be an integer, here 10, and le=100 limits max to 100.

4fill in blank

hard

Fill both blanks to create a paginated response with skip and limit parameters and return sliced items.

FastAPI

items = ['apple', 'banana', 'cherry', 'date', 'elderberry']

@app.get('/fruits/')
async def get_fruits(skip: int = [1], limit: int = [2]):
    return items[skip:skip + limit]

Drag options to blanks, or click blank then click option'

A0

B5

C10

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting skip to 1 which skips the first item.

Setting limit too large or zero.

Skip starts at 0 to begin from the first item, limit is 1 to return one item per page.

5fill in blank

hard

Fill all three blanks to implement cursor-based pagination using a query parameter 'cursor' and slicing the items list.

FastAPI

items = ['a', 'b', 'c', 'd', 'e', 'f']

@app.get('/letters/')
async def get_letters(cursor: int = [1], limit: int = [2]):
    start = cursor if cursor >= 0 else 0
    end = start + limit
    return {'items': items[start:end], 'next_cursor': [3] if end < len(items) else None}

Drag options to blanks, or click blank then click option'

A0

B3

Cend

Dcursor + limit

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'end' as next_cursor which is a variable but not the cursor position.

Setting cursor default to negative values.

Using limit as next_cursor.

Cursor starts at 0, limit is 3 items per page, next_cursor is cursor + limit for next page.

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