In Flask, a route is a mapping between a URL and a Python function. When a user requests a specific URL, Flask matches the URL to the corresponding route and invokes the associated function, which is referred to as a view. Views are responsible for processing a user’s request and returning a response, which can be an HTML template, a JSON object, or any other type of data.
To define a route in Flask, you use the @app.route decorator to associate a URL pattern with a view function. For example, the following code creates a route that maps to the root URL (/):
@app.route("/")
def index():
return "Hello, World!"In this example, the view function index returns a simple string, “Hello, World!”, which will be displayed in the user’s browser when they request the root URL.
In addition to the root URL, you can create routes for other URL patterns by specifying the desired pattern as an argument to the @app.route decorator. For example, the following code creates a route that maps to the URL /hello/<name>:
@app.route("/hello/<name>")
def hello(name):
return "Hello, " + name + "!"In this example, the <name> component of the URL is treated as a variable, and Flask will pass the value of the name variable to the view function as an argument. This allows you to create dynamic routes that can respond to different inputs.
To pass data from a view to a template, you can use the render_template function from the Flask render_template module. This function takes a template file and a set of variables, and returns a string containing the rendered HTML. For example, the following code creates a view that returns a template with a variable name:
@app.route("/hello/<name>")
def hello(name):
return render_template("hello.html", name=name)In this example, the render_template function takes the hello.html template file and the name variable, and returns a string containing the rendered HTML. The hello.html file could contain something like the following:
<html>
<head>
<title>Hello, {{ name }}!</title>
</head>
<body>
<h1>Hello, {{ name }}!</h1>
</body>
</html>In this example, the double curly braces {{ }} indicate a template variable. When the template is rendered, Flask will replace these variables with the values passed to the render_template function.
In addition to handling incoming requests and returning responses, views can also perform other tasks, such as accessing databases, processing form submissions, and more. To perform these tasks, you can use the tools and libraries provided by Flask and the Python ecosystem, such as SQLAlchemy for database access and WTForms for form processing.
In conclusion, Flask routes and views form the core of a Flask application, allowing you to define the behavior of your application in response to incoming requests. By defining routes and views, you can create dynamic, interactive web applications that respond to user inputs and provide useful information to users.