Python uses flask as a web server code implementation

1. Introduction to flash lightweight web framework

The Python Flask Framework is a lightweight web framework that is simple and easy to use, flexible and flexible, and is ideal for building small to medium-sized web applications. The following is a detailed introduction to the Flask framework:

1. Basic concepts

Flask is a Python-based micro web development framework, mainly aimed at small applications and projects with simple initial development needs. Compared to a heavyweight framework like Django, Flask is lighter and easier to use and deploy. It provides basic core features of web development such as routing, template rendering, error handling, etc., but maintains sufficient flexibility to allow developers to select and add other libraries to extend functionality as needed.

2. Main features

Lightweight: Flask keeps core features simple, easy to understand and use. This makes Flask a very suitable framework for rapid development and iteration.
Flexibility: Flask does not force the use of specific libraries or tools, and developers can choose the appropriate components according to their needs. For example, different databases, template engines, etc. can be used.
Scalability: Although Flask itself is simple, it provides rich extension interfaces. Developers can add various functions by installing Flask extensions, such as database support, form processing, security, etc.
Strong Community Support: Flask has an active community that provides a large number of tutorials, sample code, and third-party libraries. This allows developers to quickly find solutions when they encounter problems.

3. Core components

Routing system: Flask through the decorator@()Define routing rules and map URLs to corresponding processing functions. This makes the definition of routing very intuitive and concise.
Template Engine: Flask uses the Jinja2 template engine to render HTML by default. Jinja2 provides a wealth of template tags and filters, making dynamically generating HTML pages simple and efficient.
Request context: Flask handles HTTP requests through the request context. Developers can obtain request data from the request context, such as query parameters, form data, etc.
Response Object: Flask allows developers to customize HTTP responses through response object. You can set status code, response header, response body and other contents.
Error handling: Flask provides a powerful error handling mechanism. Developers can define error handlers to handle different types of HTTP errors, such as 404 (page not found) and 500 (server internal error), etc.
Session Management: Flask supports cookie-based session management. Developers can easily store and retrieve data in sessions, enabling tracking and managing user status.

4. Expansion and Ecology

Flask has a very rich ecosystem with a large number of third-party extensions to choose from. Here are some commonly used Flask extensions:

Flask-SQLAlchemy: provides ORM (object relational mapping) support for Flask, allowing developers to operate databases more conveniently.
Flask-WTF: Provides form processing functions, including form verification, CSRF protection, etc.
Flask-Login: used to handle user login and permission verification.
Flask-Migrate: Provides database migration function to facilitate management of database schema changes.
Flask-Mail: Used to send emails.
Flask-Babel: supports internationalization, allowing developers to easily implement multilingual applications.

5. Summary

Known for its lightweight, flexibility and scalability, the Flask framework is ideal for building small to medium-sized web applications. It provides basic web development capabilities and allows developers to select and add additional libraries to extend functionality as needed. Flask's strong community support and rich ecosystem make it easy for developers to find solutions and tools to solve problems.

2. Use code examples

Here is a simple code example for a Flask application that covers basic routing, template rendering, and simple form processing.

First, make sure you have Flask installed. If not, install by running the following command:

pip install Flask

You can then create a simple Flask application like this:

# Import Flask classfrom flask import Flask, render_template, request

# Create Flask application instanceapp = Flask(__name__)

# Define a simple routing and processing function@('/')
def hello_world():
    return 'Hello, World!'

# Define a route with parameters@('/greet/&lt;name&gt;')
def greet(name):
    return f'Hello, {name}!'

# Define a route for processing POST requests to receive form data@('/submit', methods=['GET', 'POST'])
def submit():
    if  == 'POST':
        name = ('name')
        return f'Hello, {name}! Your form has been submitted.'
    return render_template('')

# If your application has a folder called 'templates' and has a '' file in it,# Flask will automatically load templates from this folder.
# Start Flask development server, default port 5000# You can add parameters to specify the portif __name__ == '__main__':
    (debug=True)
    # (debug=True, port=8088)

Next, create atemplatesfolder and create a folder calledThe HTML template file, with the following content:

<!DOCTYPE html>
<html>
<head>
    <title>Flask Form Example</title>
</head>
<body>
    <h1>Submit Your Name</h1>
    <form method="POST" action="/submit">
        <input type="text" name="name" placeholder="Your name">
        <input type="submit" value="Submit">
    </form>
</body>
</html>

This simple Flask application does the following:

When a user accesses the root URL (/) , it returns a simple "Hello, World!" string.
When the user visits/greet/<name>When URL, it returns a personalized greeting, where<name>It is a name provided by the user.
When the user visits/submitWhen URL, if it is a GET request, it displays an HTML page containing the form. Users can enter their name into the form and submit the form. If it is a POST request (i.e. the user submits a form), it reads the name in the form and returns a greeting containing the name.

To run this application, save the above Python code as(or other file name you like), and then run the following command in the command line:

python

This will start Flask's development server and listen for the default127.0.0.1:5000address. You can access it through your browserhttp://127.0.0.1:5000/Come to view the application.

3. Use jsonify make_response to return json data

jsonify and make_response are both tools in the Flask framework for creating HTTP responses, but they have some differences in usage and functionality.

jsonify

jsonify is a convenient function specifically used to generate JSON responses. Using jsonify is very convenient when you need to return data to the client in JSON format. It automatically converts the data to JSON format and sets the correct Content-Type to application/json. Additionally, jsonify allows you to add additional HTTP headers or status codes.

Example:

from flask import Flask, jsonify

app = Flask(__name__)

@('/data', methods=['GET'])
def get_data():
    data = {'key': 'value'}
    return jsonify(data), 200  # Return JSON response and status code 200

make_response

make_response is a more general function to create a response object. You can use it to create any kind of response, not just JSON. Through make_response, you can set response body, status code, header information, etc. If you need more control or need to create non-JSON responses, make_response is a good choice.

Example:

from flask import Flask, make_response

app = Flask(__name__)
# By default, Flask will look for template files in the templates folder of the application# You can add parameters to specify the template directory# app = Flask(__name__, template_folder='my_templates')

@('/text', methods=['GET'])
def get_text():
    response = make_response('Hello, World!')
    ['Content-Type'] = 'text/plain'
    return response

Summary of the difference

Specialization and versatility：jsonifySpecially used to create JSON responses, andmake_responseCan be used to create any type of HTTP response.
Convenience: When you need to quickly return a JSON response,jsonifyProvides a more concise syntax. andmake_responseYou need to manually set the response body and header information.
Automatic conversion：jsonifyThe data will be automatically converted to JSON format and set the correct oneContent-TypeHead. and usemake_responseWhen you need to handle these conversions and settings yourself.
flexibility:AlthoughjsonifyVery convenient when handling JSON responses, but if you need to create other types of responses or need more control (such as custom headers, setting cookies, etc.),make_responseWill be more flexible.

Select to usejsonifystillmake_responseWhen considering your specific needs and response types. If you just need to return a simple JSON response, thenjsonifyUsually a better choice. If you need more customization or control, or need to return a non-JSON response, thenmake_responseIt would be more suitable.

4. Log printing

In Flask, it is a preconfigured logger that you can use to log applications. By default, logs are output to the console. If you want to log the logs to a file, you need to configure the log handler and formatter.

Here is an example showing how to log a log into a file in a Flask application:

from flask import Flask
import logging
from  import RotatingFileHandler

app = Flask(__name__)

# Configure the loggerhandler = RotatingFileHandler('', maxBytes=1024 * 1024, backupCount=5)  # Create a log file, up to 1MB, backup 5()  # Set the log level to INFOformatter = ('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  # Set log format(formatter)  # Set up a formatter for the processor
(handler)  # Add the processor to Flask's logger()  # Set the level of Flask logger to INFO
@('/')
def index():
    ('This is an info message')
    ('This is a warning message')
    return 'Hello, World!'

if __name__ == '__main__':
    (debug=True)

In this example, we use the RotatingFileHandler, which logs the logs into a file and will automatically split and back up when the file reaches a certain size. We set the maximum size of the log file to 1MB and keep 5 backup files. The log level is set to INFO, which means that logs at INFO level and above will be logged. We also define a log format that includes timestamps, logger names, log levels, and log messages. Finally, we added this processor to Flask's logger and set the log level.

Now, when you run the Flask application and access the root route, you should see the corresponding logging in the log file named .

The above is the detailed content of Python's code implementation using flask as a web server. For more information about Python flask as a web server, please pay attention to my other related articles!