Flask is not only a free web framework, but also a young and dynamic small framework. It has complete development documents, high community activity and many supporters. The design goal of flask is to implement a WSGI micro framework, and its core code is very simple.
Introduction to flash framework
The share of flash framework in small and medium-sized enterprises is relatively high. Web framework is generally used to develop lightweight web applications. In terms of market share, flash framework also ranks high. This paper mainly introduces the basic knowledge of Flask framework, including its basic structure and its comparison with Django framework.
Basic structure of flash framework
The Flask framework mainly relies on two libraries: werkzeug and jinja2.
werkzeug: is a WSGI toolset that is a standard python interface between web applications and multiple servers.
The basic structure diagram of Flask framework is as follows:
In order to improve development efficiency and reduce redundant code, the Flask framework will spare time for the common part of Web development so that it can be used multiple times in different pages. When the client wants to obtain some information data from the Web server, it will launch an HTTP request (for example, we usually enter a URL in the browser). The Web application will carry out corresponding business processing in the background (for example, reading the database or doing some calculations), and then read the data required by the user to generate the corresponding HTTP response. If you are accessing static resources, you can directly return the resources without business operations.
Here I suggest that readers install anaconda to create virtual environments and install third-party libraries.
Installing flash on Windows systems
pip install flask
First knowledge of flash web program
The following is a program to demonstrate the process of developing web programs with the flash framework
from json.tool import main import flask # Import falsk module app = flask.Flask(__name__) #Instantiate flash @app.route('/') # Decorator operation to realize URL address def hello(): # Define business processing function (Hello) return "This is our first one flask program" if __name__ == '__main__': app.run() # Run program
Analyze the basic structure of web program
The function of the above code is to call run() in the flash class method to run the current flash web program on the local server. The name of the current flash web program is app. The prototype of the run method is as follows:
(method) run: (host: str | None = None, port: int | None = None, debug: bool | None = None, load_dotenv: bool = True, **options: Any) -> None
Three of the parameters are commonly used, but they are optional.
- Host: the host name of the current flash program. The default value is 127.0.0.1 or localhost
- Port: the port number corresponding to the host running the current flash program. The default value is 5000
- debug: set whether to display debugging information. The default value is False. If it is set to True, debugging information will be displayed. It is suggested that readers can open debugging information during program development.
The purpose of debugging is that if the code changes during debugging, the server will automatically restart and run the flash web program, so as to improve the effect of program operation. If it is not set to debug mode, you need to manually restart the program every time, which is quite troublesome.
At present, in the field of web development, the mainstream third-party framework mainly uses URL routing technology to access a specific page. In the flash web program, the client (browser) sends the access request to the web server, and the web server sends the request to the flash web program. The flask framework maps routes to python functions.
Flash framework supports three routing technologies
(1) Use route method ()
In the Flask framework, an ordinary hash number is associated with a specific URL by using the routing function route(). When the Web server receives the URL request, it will call the function associated with route () and return the function response content.
@app.route('/hello') def hello(): return "Hello, I'm python"
Enter in the browser http://127.0.0.1:5000/hello , the response content will appear.
(2) Routing method add_url_rule()
def hello(): return "Hello, I'm python" app.add_url_rule('/hello', 'hello', hello)
(3) Map different URL s to the same function
In flash web, you can use multiple different URL s to map to multiple functions at the same time. Only two decorators need to be set.
@app.route('/') @app.route('/hello') def hello(): # Define business processing function (Hello) return "This is our first one flask program"
Processing URL parameters
In a web program, the URL is not necessarily static, but may be dynamic. It is necessary to declare the variable name in the list parameter in the corresponding processing function.
from unicodedata import name from flask import Flask app = Flask(__name__) @app.route('/hello/<name>') def hello(name): return 'Hello %s' % name if __name__ == '__main__': app.run(debug=True)
The parameter name in the URL is a variable. If you enter it in the browser
Then "jack" will be passed to the hello() function as a parameter. Therefore, the running result is as follows:
In the URL of the Flask framework, in addition to the string type parameters, the following parameters can also be used:
- int: indicates an integer parameter, such as "/ hello/1"
- float: indicates a floating-point parameter, such as "hello/1.1"
from tkinter import N from flask import Flask app = Flask(__name__) @app.route('/blog/<int:ID>') def show_age(ID): return 'My age is:%d' % ID + 'year' @app.route('/rev/<float:No>') def show_money(No): return 'My height is%f' % No + 'cm' if __name__ == '__main__': app.run()
After running the above code, enter the following URL in the browser:
http://127.0.0.1:5000/blog / integer parameter http://127.0.0.1:5000/rev / floating point parameters
Deliver HTTP request
In computer applications, HTTP protocol is the basis of data communication in the Internet. Readers need to be familiar with only two HTTP methods: GET and POST. In the Flask framework, the default method is the GET method. By using the URL decorator to pass the "method type" parameter, the same URL can process two request methods at the same time.
from flask import Flask, request html_txt = """<html> <body> <h2>If so get request</h2> <form method='post'> <input type='submit' value='Press I send post request' /> </form> </body> </html> """ app = Flask(__name__) @app.route('/hello', methods=['GET', 'POST']) def hello(): if request.method == 'GET': return html_txt else: return '<h2>I've received it post request</h2>' if __name__ == '__main__': app.run(debug=True)
The above procedures implement POST requests and GET requests in the same URL. In addition, the Flask framework can use URLs_ For() to specify the URL.
Method url_for() can pass two parameters:
- endpoint: indicates the name of the function to be passed
- **values: keyword parameters, that is, there are multiple formal parameters of key=value, corresponding to the variable part in the URL.
from flask import Flask, redirect, url_for app = Flask(__name__) @app.route('/admin') def hello_admin(): return 'Hello, administrator' @app.route('/guest/<guest>') def hello_guest(guest): return 'Hello%s,Are you a tourist' % guest @app.route('/user/<name>') def hello_user(name): if name == 'admin': return redirect(url_for('hello_admin')) else: return redirect(url_for('hello_guest', guest=name)) if __name__ == '__main__': app.run(debug=True)
In the above code, enter in the browser http://127.0.0.1:5000/user/admin , the URL will be redirected to http://127.0.0.1:5000/admin , execute the function hello_ The function of admin(); If the received parameter is not admin, the URL will be redirected to http://127.0.0.1:5000/guest/ Parameter, execute function hello_ The function of guest().
Simulate user login system
Write the form login HTML, the function is to realize the static HTML form. The name can be entered in the form. After clicking the submit button, the data in the form will be sent to the specified URL using the POST method: http://127.0.0.1:5000/login .
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> </head> <body> <form action="http://127.0.0.1:5000/login" method="post"> <p>Please output naming</p> <p><input type="text" name="username" /></p> <p><input type="submit" value="Sign in"></p> </form> </body> </html>
Next, write login Py, because when the form is submitted, it will be mapped to the login() function. Because the server receives data through the POST method, you can obtain the value of the passed parameter username form through the following code.
Server code, as follows:
from flask import Flask, redirect, request, url_for app = Flask(__name__) @app.route('/success/<name>') def success(name): return 'welcome%s' % name + 'Log in to this system' @app.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'POST': user = request.form.get('username') print(user) return redirect(url_for('success', name=user)) else: # return 'Please Login' user = request.form['username'] return redirect(url_for('success', name=user)) if __name__ == '__main__': app.run(debug=True)
After clicking login, codings will be passed as a parameter to the parameter name after / success /.