Getting started with the Python Flask framework

Python Flask Framework Getting Started Tutorial

Flask is a simple and easy-to-use Python Web framework that pays more attention to flexibility and lightweight, allowing programmers to build according to their own preferences. This article will introduce you to the basic concepts, installation and use of Flask, and use a simple example to demonstrate how to use Flask to build a web application.

1. What is Flask?

Flask is a lightweight web application framework based on Python. It does not require the use of any special tools or libraries and only relies on Python itself to complete construction and deployment. At the same time, Flask also provides a flexible set of tools to easily build web applications that meet your needs. Therefore, Flask is widely used in small and medium-sized web application development.

2. Install Flask

Before we start using Flask, we need to install Flask first. First open the terminal and enter the following command:

pip install flask

This command will automatically download and install Flask from the Python software repository. After waiting for a few minutes, Flask will be installed. You can enter the following command to check whether Flask has been installed successfully:

import flask

If no error is reported, it means that Flask has been installed successfully.

3. Basic concepts of Flask

When developing Flask applications, you need to understand some basic concepts:

• Application object (Application Object): The entry point of the Flask application, responsible for starting the response HTTP service.
• Routing: Define the mapping relationship between URL paths and processing functions.
• View Function: It is the function that handles requests in the Flask application.
• Request Context: Flask provides a context for each request so that the request can easily access relevant information related to the request.
• Application Context: Flask provides a context for each application. This context will save the application's global variables and some configuration information throughout the application's life cycle.

4. Python Flask Web Application Example

Below, we create a simple Flask Web application:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

In the above code , we first imported the Flask module and created a Flask object. Then, use the app.route() decorator to define a route that needs to match the URL '/'. Define another hello_world() view function to process the request, and finally use the app.run() method to start the application.

After running this script, a web server will be created locally. You can enter http://localhost:5000/ in the browser to view the results. The displayed result should be Hello, World!.

5. Routing in Flask

Routing in Flask is defined using the app.route() decorator. app.route()The parameter in the decorator is the route URL, which can be defined using a string or regular expression. The following is an example to illustrate how to define different route URLs:

@app.route('/')
def index():
    return 'Index Page'

@app.route('/hello')
def hello():
    return 'Hello, World!'

@app.route('/user/<username>')
def show_user_profile(username):
    return f'User {username}'

@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f'Post {post_id}'

In the above code, we define four different routes. '/' and '/hello' respectively define two fixed URLs, which return Index Page and Hello, World!## respectively. #. '/user/' and '/post/' are dynamic routes with variable values, which can match different URLs. Used to display different content.

Template in Flask

In many web applications, different content needs to be displayed dynamically according to different user requests. In this case, you need to use the template in Flask. template. In Flask, the Jinja2 template engine is used by default.

Templates in Flask need to be placed in the

templates directory of the application. Next, let's look at a simple template usage example:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/hello/<name>')
def hello(name=None):
    return render_template('hello.html', name=name)

if __name__ == '__main__':
    app.run()

In the above code, we use the

render_template() function to call the template. The name of the template file is hello.html, and it needs to render a variable name. We use the second parameter of the render_template() function to pass the variable value to the template. In the template file, output variable values ​​by using the {{ }} syntax.

Static files in Flask

In Flask, static files usually refer to files such as JavaScript, CSS, and images. These static files generally do not need dynamic processing, so they do not need to be updated frequently. Static files in Flask need to be placed in the

static directory of the application.

Here is a simple example:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/hello')
def hello():
    return render_template('hello.html')

if __name__ == '__main__':
    app.run()

In the above example, we use the

url_for() function to load static files. In the template file, when using the url_for() function, you need to call it as follows:

{{ url_for('static', filename='style.css') }}

Among them,

'static' represents the name of the static file directory, 'filename' is the name of the static file. In the actual environment, 'style.css' should be replaced with the name of the static file we need.

At this point, we have learned about the basic concepts, installation, routing, templates and static files of the Python Flask framework. I hope that through the introduction of this article, you can quickly get started using the Flask framework and develop your own Python web applications.

The above is the detailed content of Getting started with the Python Flask framework. For more information, please follow other related articles on the PHP Chinese website!