Route with dynamic parameters in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when accessing /user/42?

Given the Flask route below, what will be the response text when a client visits /user/42?

Flask

from flask import Flask
app = Flask(__name__)

@app.route('/user/<int:user_id>')
def show_user(user_id):
    return f"User ID is {user_id}"

A User ID is 42

B User ID is <int:user_id>

C User ID is user_id

D 404 Not Found

💡 Hint

Look at how the route captures the integer parameter and uses it in the function.

The route uses <int:user_id> to capture an integer from the URL and passes it as an argument to the function. The function returns a string with that integer included.

📝 Syntax

intermediate

Which route definition correctly captures a string username?

Select the correct Flask route decorator to capture a string username from the URL path /profile/<username>.

A @app.route('/profile/<int:username>')

B @app.route('/profile/<path:username>')

C @app.route('/profile/<float:username>')

D @app.route('/profile/<username>')

💡 Hint

The default converter for dynamic parts is string.

Using <username> captures a string by default. The other converters expect specific types like int or float.

🔧 Debug

advanced

Why does this route cause a 404 error for /item/abc123?

Examine the Flask route below. Why does visiting /item/abc123 return a 404 error?

Flask

from flask import Flask
app = Flask(__name__)

@app.route('/item/<int:item_id>')
def get_item(item_id):
    return f"Item {item_id}"

A The function get_item is missing a return statement.

B The route expects an integer, but 'abc123' is not an integer, so no match is found.

C Flask routes cannot have dynamic parameters.

D The route should use <string:item_id> instead of <int:item_id>.

💡 Hint

Check the type converter in the route and the URL parameter.

The route uses <int:item_id>, so Flask only matches URLs where the part after /item/ is an integer. 'abc123' is not an integer, so Flask returns 404.

❓ state_output

advanced

What is the output of this route with multiple parameters?

Given the Flask route below, what is the response when visiting /order/7/item/3?

Flask

from flask import Flask
app = Flask(__name__)

@app.route('/order/<int:order_id>/item/<int:item_id>')
def order_item(order_id, item_id):
    return f"Order {order_id}, Item {item_id}"

A Order order_id, Item item_id

B Order <int:order_id>, Item <int:item_id>

C Order 7, Item 3

D 404 Not Found

💡 Hint

Look at how multiple dynamic parameters are captured and used.

The route captures two integers from the URL and passes them as arguments to the function, which returns a formatted string with those values.

🧠 Conceptual

expert

What happens if two routes overlap with dynamic parameters?

Consider these two Flask routes:

@app.route('/page/about')
def about():
    return "About Page"

@app.route('/page/')
def page(page_name):
    return f"Page: {page_name}"

What will be the response when visiting /page/about?

A About Page

B Page: about

C 404 Not Found

D RuntimeError due to route conflict

💡 Hint

Flask matches routes in the order they are defined and prefers exact matches over dynamic ones.

Flask matches routes in the order they are added. Since /page/about is an exact static route, it matches before the dynamic /page/<page_name> route. So the 'About Page' response is returned.

Practice

1. What does the dynamic parameter in a Flask route do?
@app.route('/user/<username>')

easy

A. It captures the part of the URL as a variable passed to the function.

B. It creates a fixed URL that never changes.

C. It makes the route only accept numbers.

D. It disables the route from working.

Solution

1. Step 1: Understand dynamic parameters in Flask routes

   Dynamic parameters are parts of the URL wrapped in <> that Flask captures as variables.

2. Step 2: How Flask uses the captured variable

   The captured part is passed as an argument to the view function to use inside the code.

3. Final Answer:

   It captures the part of the URL as a variable passed to the function. -> Option A

4. Quick Check:

   Dynamic parameter = variable in function [OK]

Hint: Dynamic parts in <> become function arguments [OK]

Common Mistakes:

• Thinking dynamic means fixed URL
• Assuming only numbers can be captured
• Believing dynamic disables the route

2. Which of these is the correct syntax to define a route with an integer parameter named post_id?

easy

A. @app.route('/post/')

B. @app.route('/post/<post_id>')

C. @app.route('/post/')

D. @app.route('/post/')

Solution

1. Step 1: Identify the type syntax for dynamic parameters

   Flask uses <type:name> to specify the parameter type, like int for integers.

2. Step 2: Match the correct syntax for integer parameter

   The correct syntax is <int:post_id> to ensure only integers are accepted.

3. Final Answer:

   @app.route('/post/<int:post_id>') -> Option A

4. Quick Check:

   Integer type uses <int:name> [OK]

Hint: Use <int:name> for integer parameters in routes [OK]

Common Mistakes:

• Omitting the type for integer parameters
• Using str instead of int for numbers
• Using float when integer is needed

3. What will be the output if you visit /product/42 given this Flask route?

@app.route('/product/')
def product(id):
    return f"Product ID: {id}"

medium

A. 404 Not Found error

B. Product ID:

C. Product ID: id

D. Product ID: 42

Solution

1. Step 1: Understand the route and parameter type

   The route expects an integer parameter named id, which matches 42 in the URL.

2. Step 2: Check the function return value

   The function returns a string with the id value inserted, so it returns "Product ID: 42".

3. Final Answer:

   Product ID: 42 -> Option D

4. Quick Check:

   Dynamic int parameter outputs value [OK]

Hint: Dynamic int parameter passes number as function argument [OK]

Common Mistakes:

• Expecting the literal string instead of value
• Confusing parameter name with string
• Assuming route returns error for valid int

4. Identify the error in this Flask route definition:

@app.route('/item/')
def item(item):
    return f"Item {item_id}"

medium

A. Route parameter type int is invalid.

B. Function parameter name does not match route parameter name.

C. Missing return statement in function.

D. Route URL should not have dynamic parameters.

Solution

1. Step 1: Compare route parameter and function argument names

   The route defines <int:item_id> but the function uses parameter named item, which is inconsistent.

2. Step 2: Understand how Flask matches parameters

   Flask passes the URL part as argument named item_id, so function must accept item_id to receive it correctly.

3. Final Answer:

   Function parameter name does not match route parameter name. -> Option B

4. Quick Check:

   Parameter names must match [OK]

Hint: Function argument must match route parameter name exactly [OK]

Common Mistakes:

• Using different names for route and function parameters
• Thinking type int is invalid syntax
• Forgetting to return a value

5. You want a Flask route that accepts a username (string) and an optional integer page number with default 1. Which route and function definition is correct?

hard

A. @app.route('/profile/<username>/')
def profile(username, page=1):
return f"User: {username}, Page: {page}"

B. @app.route('/profile/<username>/<page>')
def profile(username, page=1):
return f"User: {username}, Page: {page}"

C. @app.route('/profile/<username>')
def profile(username, page=1):
return f"User: {username}, Page: {page}"

D. @app.route('/profile/<username>/')
def profile(username, page):
return f"User: {username}, Page: {page}"

Solution

1. Step 1: Understand optional parameters in Flask routes

   Flask routes do not support optional URL parts directly; optional parameters must be handled with defaults in function and route without that part.

2. Step 2: Check which route allows optional page parameter

   Route with only <username> works, and function uses default page=1 if not provided.

3. Final Answer:

   @app.route('/profile/<username>')\ndef profile(username, page=1):\n return f"User: {username}, Page: {page}" -> Option C

4. Quick Check:

   Optional params handled by function defaults, not route [OK]

Hint: Optional URL parts need separate routes or defaults in function [OK]

Common Mistakes:

• Assuming Flask supports optional URL parts in one route
• Using default values with required route parameters
• Mismatching parameter types in route and function