How to build API functions using Python Flask?

1. Overview

Python Flask is a lightweight web framework that provides an easy-to-use API to create web applications. In Flask, we can use Python functions to define routes and handlers for our web application.

2. Explanation of common functions

The following are some common Python Flask API functions:

1) Flask() function

This function is a Flask application The core of the program, used to create a new Flask instance.

from flask import Flask
app = Flask(__name__)

2) route() function

This function is used to specify routing and request methods. Multiple route() functions can be used to define multiple routes.

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

3) jsonify() function

This function can convert a Python object into a response object in JSON format.

from flask import jsonify
@app.route('/users')
def get_users():
    users = [
        {'name': 'Alice', 'age': 25},
        {'name': 'Bob', 'age': 30},
        {'name': 'Charlie', 'age': 35}
    ]
    return jsonify(users)

4) render_template() function

This function is used to render the template and return the HTML response object. Template engines can be used to dynamically generate HTML.

from flask import render_template
@app.route('/profile/')
def profile(username):
    return render_template('profile.html', name=username)

5) redirect() function

This function can redirect the request to another URL.

from flask import redirect
@app.route('/redirect')
def redirect_to_home():
    return redirect('/')

6) url_for() function

This function is used to generate URLs and can use the name of the view function as a parameter.

from flask import url_for
@app.route('/profile/')
def profile(username):
    return f'Hello, {username}! Your profile URL is {url_for("profile", username=username)}.'

7) before_request() function

This function is used to register a function to be executed before each request.

@app.before_request
def before_request():
    if 'user_id' not in session and request.endpoint not in ['login', 'static']:
        return redirect(url_for('login'))

8) after_request() function

This function is used to register a function to be executed after each request.

@app.after_request
def after_request(response):
    response.headers['X-Frame-Options'] = 'SAMEORIGIN'
    return response

9) abort() function

This function is used to raise an exception in the view function and return an error response.

from flask import abort
@app.route('/users/')
def get_user(user_id):
    user = User.query.get(user_id)
    if user is None:
        abort(404)
    return jsonify(user.to_dict())

10) send_file() function

This function is used to send a file as a response. The file can be sent as a byte stream or file path.

from flask import send_file
@app.route('/download')
def download_file():
    file_path = '/path/to/file'
    return send_file(file_path, as_attachment=True)

3. Explanation of common objects

1) request object

This object represents the request issued by the client, including request headers, request bodies and other information. You can use the request object to obtain the data sent by the client.

from flask import request
@app.route('/login', methods=['POST'])
def login():
    username = request.form['username']
    password = request.form['password']
    return f'Hello, {username}! Your password is {password}.'

2) session object

This object can be used to store user session data, such as user ID, etc.

from flask import session
@app.route('/login', methods=['POST'])
def login():
    username = request.form['username']
    password = request.form['password']
    if username == 'admin' and password == 'password':
        session['user_id'] = 1
        return redirect('/')
    else:
        return 'Invalid username or password.'

4. Cookies and sessions in Flask

1) Introduction and differences between cookies and sessions

In Flask, cookies and sessions are used to track user status Mechanisms.

Cookie is a small piece of text data. When a user visits your website, the server can store some data on the user's computer by setting cookie. When the user visits the website again, the browser sends cookie data to the server so that the server can use the data to identify the user. Flask uses Flask-Cookie to handle cookies, which can be used to set, get and delete cookies.

Session is a kind of state data stored on the server side. Unlike Cookie, Session data is not stored on the user's computer. , but stored on the server side. When a user visits your website, the server creates a unique Session ID for the user, stores the ID in a cookie, and then The server uses this Session ID to identify the user. Flask uses Flask-Session to handle Session, which can be used to set, get and delete Session data.

Generally speaking, Session is more secure because the data is stored on the server side and users cannot directly modify the data. Cookie The advantage is that it can store large amounts of data and can be shared between different pages. In actual use, developers can choose to use Cookie or Session as needed.

The following is an example of using Cookies and Session in Flask:

2) Example explanation

1. Use Flask-Cookie to set Cookie

from flask import Flask, make_response
app = Flask(__name__)
@app.route('/')
def index():
    response = make_response('Hello, World!')
    response.set_cookie('name', 'value')
    return response
if __name__ == '__main__':
    app.run()

In In the above example, we use Flask's make_response function to create a response object, and then use the set_cookie method to set a # named name with a value of value ##cookie.

2. Use Flask-Cookie to obtain Cookie

from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def index():
    name = request.cookies.get('name')
    return f'Hello, {name}!'
if __name__ == '__main__':
    app.run()

In the above example, we use Flask’s

request object to obtain a cookie named name The value of cookie and then returns it to the user.

3. Use Flask-Session to set and get Session

from flask import Flask, session
app = Flask(__name__)
app.config['SECRET_KEY'] = 'your_secret_key'
@app.route('/')
def index():
    session['name'] = 'value'
    name = session.get('name')
    return f'Hello, {name}!'
if __name__ == '__main__':
    app.run()

In the above example, we use Flask's session object to set up a Session named name with value value, and use The get method obtains the value of the Session and returns it to the user.

It should be noted that in order to use

Flask-Session, a SECRET_KEY needs to be set in the application. This key is used to encrypt Session data to ensure that the data is not tampered with.

The above is the detailed content of How to build API functions using Python Flask?. For more information, please follow other related articles on the PHP Chinese website!