Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "Flask context example Analysis". Many people will encounter such a dilemma in the operation of actual cases, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1. The concept of context

Context, to put it bluntly, is the so-called context, that is, the language environment. For example, to pick out a sentence of an article alone, we may not be able to understand its meaning, but through the language environment of this sentence, combined with the sentence before and after it, we can easily understand it.

We can think of the context as a snapshot of the current environment, an object used to save state. At some point in the execution of the code, according to the code logic of the context, you can decide which environment variables to use at the current time, and so on.

2. Context in Flask

There are two contexts in Flask, application context (application context) and request context (request context):

Application: refers to the Flask object created by calling app = Flask (_ _ name__)

Request: refers to the Request object created inside the Flask object each time a HTTP request occurs

2.1 request context

When processing a request in Flask, the application will generate a "request context" object and save the relevant data information of the current request. The whole processing of the request will be carried out in this context object to ensure that the processing of the request is independent and undisturbed.

The request context objects are: request and session. Let's take request as an example.

As we mentioned in the previous article on the implementation of Flask request hooks, there are four common request hooks in Flask: before_first_request, before_request, after_request, and teardown_request.

App.before_first_requestdef before_first_request (): print (request.url) print ('before_first_request') @ app.before_requestdef before_request (): print (request.url) print (' before_request') @ app.after_requestdef after_request (response): print (request.url) print ('after_request') return response@app.teardown_requestdef teardown_request (e): print (request. Url) print ('teardown_request') @ app.route (' / test') def test (): print (request.url) return 'test'

Through the request, we find that in each handler decorated with the request hook, we can access the request object directly. Moreover, in other ordinary functions, the request object cannot be accessed, indicating that the request object is not a true global variable, but can be accessed during the life cycle of the request context, and cannot be accessed without the request life cycle. The handler decorated with the request hook above is executed at different stages of request processing, and naturally the request object can also be accessed internally.

2.2 Application context

It is said above that the request context is related to the request, and the request context object stores the relevant data information of the request. Let's talk about the application context. The so-called application context is related to the current application. The application context object contains information related to the current application.

The application context objects are: current_app and g.

We have learned that each request has a request object corresponding to the view function, which can be understood as the current request (current request), and the program will have multiple instances. In order to get the corresponding program instance, rather than a fixed program instance, we need to use the current_app variable.

From flask import Flask, current_appapp = Flask ("tigeriaf_app") @ app.route ('/') def index (): return 'Hello, {}!' .format (current_app.name)

Current_app is a local proxy, its type is werkzeug.local.LocalProxy, and what it proxies is the app object, that is, current_app = = LocalProxy (app). So you can get the name of the current application, tigeriaf_app, through current_app.name. Current_app is used because it is also a ThreadLocal variable, and changes to it will not affect other threads. We can get the app object through the current_app._get_current_object () method. You can also store some custom variables in current_app.

Current_app exists only within the request thread, and its life cycle is in the application context. Current_app cannot be used without the application context.

The g object is a global temporary variable of the Flask program and acts as an intermediary. We can pass some data through it. G holds the global variable of the current request, and each request resets this value. We usually use it in combination with the request hook to save the global variables needed before each request is processed, such as the user object currently logged in, database connection, and so on. For example, if you use the g object to save the requested token, you can directly use g.name to get the corresponding value in the view function.

From flask import g@app.before_requestdef get_token (): g.name = request.headers.get ("token") "Flask context example Analysis" ends here. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.