G object for request-scoped data in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Flask route using g?

Consider this Flask route that uses the g object to store data during a request. What will be the output when accessing /show?

Flask

from flask import Flask, g
app = Flask(__name__)

@app.before_request
def before():
    g.user = 'Alice'

@app.route('/show')
def show():
    return f"User is {g.user}"

A User is Alice

B AttributeError: 'g' object has no attribute 'user'

C KeyError: 'user'

D User is None

💡 Hint

Remember that g is used to store data during a request and is reset for each request.

The g object is a special Flask object used to store data during a request. Here, g.user is set to 'Alice' before the request, so the route returns 'User is Alice'.

❓ state_output

intermediate

What happens to g data across multiple requests?

If you set g.value = 10 in one request, what will g.value be in the next request if not set again?

Flask

from flask import Flask, g
app = Flask(__name__)

@app.route('/set')
def set_value():
    g.value = 10
    return 'Value set'

@app.route('/get')
def get_value():
    return str(getattr(g, 'value', 'No value'))

A No value

B AttributeError

C 10

D 0

💡 Hint

Think about how Flask handles the g object for each request.

The g object is unique to each request. Data set in one request is not saved for the next. So, g.value is not set in the second request and returns 'No value'.

🔧 Debug

advanced

Why does this code raise RuntimeError when accessing g?

This Flask app tries to access g.user outside a request context. What causes the error?

Flask

from flask import Flask, g
app = Flask(__name__)

def get_user():
    return g.user

print(get_user())

A Because <code>g</code> is a global variable accessible anytime

B Because <code>g.user</code> was never set

C Because <code>g</code> is only available during a request context

D Because Flask app is not running

💡 Hint

Think about when Flask creates the g object.

The g object exists only during an active request context. Accessing it outside a request (like in global code) raises a RuntimeError.

🧠 Conceptual

advanced

What is the main purpose of Flask's g object?

Choose the best description of what the g object is used for in Flask.

A To store data that lasts across multiple requests and users

B To manage database connections globally

C To store configuration settings for the Flask app

D To store data during a single request, accessible across functions

💡 Hint

Think about the lifespan of data stored in g.

The g object is designed to hold data during one request only. It helps share information between functions during that request.

📝 Syntax

expert

Which option correctly sets and accesses g data in Flask?

Select the option that correctly sets g.user in a before_request function and accesses it in a route.

A

from flask import Flask, g
app = Flask(__name__)

def before():
    g.user = 'Bob'

@app.route('/')
def index():
    return f"User: {g.user}"

B

from flask import Flask, g
app = Flask(__name__)

@app.before_request
def before():
    g.user = 'Bob'

@app.route('/')
def index():
    return f"User: {g.user}"

C

from flask import Flask, g
app = Flask(__name__)

@app.before_request
def before():
    user = 'Bob'

@app.route('/')
def index():
    return f"User: {g.user}"

D

from flask import Flask, g
app = Flask(__name__)

@app.before_request
def before():
    g.user = 'Bob'

@app.route('/')
def index():
    return f"User: {user}"

💡 Hint

Remember to use the @app.before_request decorator and access g.user properly.

Option B correctly sets g.user in a function decorated with @app.before_request and accesses it in the route. Other options either miss the decorator or use undefined variables.

Practice

1. What is the main purpose of the g object in Flask?

easy

A. To store data temporarily during a single request

B. To store data permanently across all requests

C. To manage database connections globally

D. To handle user sessions across multiple requests

Solution

1. Step 1: Understand the scope of g

   The g object is designed to hold data only during the life of one request.

2. Step 2: Compare with other storage options

   Unlike session or global variables, g does not persist data beyond the current request.

3. Final Answer:

   To store data temporarily during a single request -> Option A

4. Quick Check:

   g = request-scoped storage [OK]

Hint: Remember: g lasts only for one request [OK]

Common Mistakes:

• Thinking g stores data across requests
• Confusing g with session or global variables
• Assuming g manages database connections automatically

2. Which of the following is the correct way to store a value in the g object inside a Flask view function?

easy

A. g.user = 'Alice'

B. g.add('user', 'Alice')

C. g.set('user', 'Alice')

D. g['user'] = Alice

Solution

1. Step 1: Recall how to assign attributes in g

   g acts like a simple object where you assign attributes using dot notation.

2. Step 2: Check each option's syntax

   g.user = 'Alice' uses g.user = 'Alice', which is the correct way. g['user'] = Alice uses dictionary style which is invalid. Options B and C use methods that g does not have.

3. Final Answer:

   g.user = 'Alice' -> Option A

4. Quick Check:

   Use dot notation to set g attributes [OK]

Hint: Use dot notation: g.attribute = value [OK]

Common Mistakes:

• Using dictionary syntax like g['key']
• Trying to call non-existent methods on g
• Confusing g with Flask's session object

3. Consider this Flask code snippet:

from flask import Flask, g
app = Flask(__name__)

@app.before_request
def before():
    g.value = 10

@app.route('/')
def index():
    g.value += 5
    return str(g.value)

What will be the output when you visit the '/' route?

medium

A. 10

B. 5

C. 15

D. Error: AttributeError

Solution

1. Step 1: Understand the before_request function

   Before each request, g.value is set to 10.

2. Step 2: Analyze the index function

   It adds 5 to g.value, making it 15, then returns it as a string.

3. Final Answer:

   15 -> Option C

4. Quick Check:

   g.value starts 10, adds 5 = 15 [OK]

Hint: Remember g resets each request; additions apply after setup [OK]

Common Mistakes:

• Assuming g.value keeps old values between requests
• Forgetting before_request runs before route
• Expecting an error due to missing attribute

4. What is wrong with this Flask code using g?

from flask import Flask, g
app = Flask(__name__)

@app.route('/')
def index():
    if not hasattr(g, 'counter'):
        g.counter = 0
    g.counter += 1
    return str(g.counter)

medium

A. It will raise an error because g cannot have new attributes

B. The code will cause a syntax error due to missing import

C. The counter will increase across requests, causing unexpected results

D. The counter resets on every request, so it always returns 1

Solution

1. Step 1: Understand g scope

   g is reset for each request, so counter does not persist between requests.

2. Step 2: Analyze the counter behavior

   Each request starts fresh, so counter is set to 0 then incremented to 1 every time.

3. Final Answer:

   The counter resets on every request, so it always returns 1 -> Option D

4. Quick Check:

   g data is request-scoped, no persistence [OK]

Hint: Remember g resets each request; no data persists [OK]

Common Mistakes:

• Expecting g.counter to keep increasing across requests
• Thinking g forbids new attributes
• Confusing g with session or global variables

5. You want to share a database connection during a single Flask request using g. Which code snippet correctly opens the connection once per request and reuses it in multiple functions?

from flask import Flask, g
app = Flask(__name__)

def get_db():
    if not hasattr(g, 'db'):
        g.db = open_database_connection()
    return g.db

@app.route('/')
def index():
    db = get_db()
    # use db
    return 'OK'

What is the main benefit of this pattern?

hard

A. It opens a new database connection on every function call

B. It shares one connection per request, avoiding multiple opens

C. It stores the connection globally for all requests

D. It closes the connection automatically after each function

Solution

1. Step 1: Analyze the get_db function

   It checks if g.db exists; if not, it opens the connection and saves it to g.

2. Step 2: Understand request scope of g

   The connection is stored only for the current request, so multiple calls reuse the same connection.

3. Step 3: Compare options

   It shares one connection per request, avoiding multiple opens correctly describes this behavior. It opens a new database connection on every function call is wrong because it avoids multiple opens. It stores the connection globally for all requests is wrong because g is not global. It closes the connection automatically after each function is incorrect; closing is not automatic here.

4. Final Answer:

   It shares one connection per request, avoiding multiple opens -> Option B

5. Quick Check:

   Use g to cache per-request resources [OK]

Hint: Cache resources in g to reuse during request [OK]

Common Mistakes:

• Thinking g stores data globally across requests
• Opening new connections on every function call
• Assuming g auto-closes resources