**Course Title:** Mastering Flask Framework: Building Modern Web Applications **Section Title:** Routing, Views, and Templates **Topic:** Passing data between routes and templates **Introduction** In the previous topics, we have explored how to define routes and create views in Flask. Now, we will delve into the concept of passing data between routes and templates. This is an essential aspect of building dynamic web applications, where you need to display data from your database or other sources on your web pages. In this topic, we will cover the different methods of passing data between routes and templates in Flask, along with examples and practical takeaways. **Passing Data from Routes to Templates** There are several ways to pass data from routes to templates in Flask. Here are a few common methods: ### 1. Using the render_template function The `render_template` function in Flask allows you to render a template and pass data to it. You can pass data as keyword arguments to the `render_template` function, and then access it in your template using Jinja2 syntax. ```python from flask import Flask, render_template app = Flask(__name__) @app.route('/') def home(): name = 'John Doe' age = 30 return render_template('home.html', name=name, age=age) ``` In your `home.html` template, you can access the `name` and `age` variables like this: ```html <h1>Hello, {{ name }}!</h1> <p>You are {{ age }} years old.</p> ``` ### 2. Using the g object The `g` object in Flask is a special object that is available in every request. You can use it to store data that you want to access in your templates. ```python from flask import Flask, g app = Flask(__name__) @app.route('/') def home(): g.name = 'John Doe' g.age = 30 return render_template('home.html') ``` In your `home.html` template, you can access the `name` and `age` variables like this: ```html <h1>Hello, {{ g.name }}!</h1> <p>You are {{ g.age }} years old.</p> ``` ### 3. Using context processors Context processors are functions that are executed before every request in Flask. You can use them to inject data into your templates. ```python from flask import Flask, g app = Flask(__name__) @app.context_processor def inject_data(): return {'name': 'John Doe', 'age': 30} @app.route('/') def home(): return render_template('home.html') ``` In your `home.html` template, you can access the `name` and `age` variables like this: ```html <h1>Hello, {{ name }}!</h1> <p>You are {{ age }} years old.</p> ``` **Passing Data from Templates to Routes** Passing data from templates to routes is a bit more complex in Flask. You can use forms and the `request` object to send data from your templates to your routes. ### 1. Using forms You can use forms in your templates to send data to your routes. In your template, you can create a form like this: ```html <form action="" method="post"> <input type="text" name="name"> <input type="submit" value="Submit"> </form> ``` In your route, you can access the form data like this: ```python from flask import Flask, request app = Flask(__name__) @app.route('/', methods=['GET', 'POST']) def home(): if request.method == 'POST': name = request.form['name'] # do something with the name variable return render_template('home.html') ``` ### 2. Using the request object You can also use the `request` object to send data from your templates to your routes. For example, you can send data in the query string: ```html <a href="/?name=John+Doe">Click me</a> ``` In your route, you can access the query string data like this: ```python from flask import Flask, request app = Flask(__name__) @app.route('/') def home(): name = request.args.get('name') # do something with the name variable return render_template('home.html') ``` **Conclusion** In this topic, we have explored the different methods of passing data between routes and templates in Flask. We have seen how to use the `render_template` function, the `g` object, and context processors to pass data from routes to templates. We have also seen how to use forms and the `request` object to pass data from templates to routes. **Key Takeaways** * Use the `render_template` function to pass data from routes to templates. * Use the `g` object to store data that you want to access in your templates. * Use context processors to inject data into your templates. * Use forms and the `request` object to pass data from templates to routes. **What's Next?** In the next topic, we will cover static files and assets management in Flask. We will see how to serve static files and how to manage assets in your Flask application. **Leave a comment or ask for help** If you have any questions or need further clarification on any of the concepts covered in this topic, please leave a comment below. We will be happy to help. **External Resources** * [Flask Documentation: Templates](https://flask.palletsprojects.com/en/2.0.x/templating/) * [Flask Documentation: Context Processors](https://flask.palletsprojects.com/en/2.0.x/templating/#context-processors) * [Flask Documentation: Forms](https://flask.palletsprojects.com/en/2.0.x/patterns/wtforms/)