Shulou(Shulou.com)05/31 Report--

This article mainly explains "what are the flask-related knowledge points of Python". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what are the flask-related knowledge points of Python"?

1. Flask

Flask is a micro framework developed based on Python and relies on jinja2 templates and Werkzeug WSGI services. For Werkzeug, it is essentially a Socket server, which is used to receive and preprocess http requests, and then trigger the Flask framework. The developer processes the request based on the functions provided by the Flask framework and returns it to the user. If you want to return the complex content to the user, you need to use the jinja2 template to process the template. That is, render the template and data, and return the rendered string to the user's browser

B. "micro" doesn't mean you need to cram the entire Web application into a single Python file (although you can), nor does it mean that Flask is lacking in functionality. The "micro" in the microframework means that Flask is designed to keep the core simple and easy to extend. Flask won't make too many decisions for you-- such as which database to use. What Flask chooses-- such as which template engine to use-- is easy to replace. Everything else is up to you. In this way, Flask can be a perfect match with you.

By default, Flask does not include database abstraction layers, form validation, or any other functionality that is already available in multiple libraries. However, Flask supports adding these functions to applications with extensions, as if it were implemented by Flask itself. Many extensions provide functions such as database integration, form verification, upload processing, a variety of open authentication technologies and so on. Flask may be "tiny", but it is ready to be put into use in a production environment with complex requirements.

D, video explanation

II. Installation

A. Installation: pip3 install flask

Video explanation

III. Virtual environment

A. Install: pip3 install virtualenv b, # create virtual environment virtualenv env1 c, # enter virtual environment Scripts/activate d, # exit virtual environment Scripts/deactivate

IV. Flask framework

A, introduction: lightweight framework Django: no socket, middleware, routing system, view (CBV,FBV), template, ORM, cookie, Session, Admin, Form, cache, signal, serialization. Flask: no socket, middleware (extension), routing system, view (CBV), third-party template (jinja2), cookie, Session is weak b, what is wsgi? Web service network management interface, protocol. C. Flask relies on a module that implements the WSGI protocol: werkzeug

5. Flask

A,-dependent on wsgi module: wsgiref,werkzeug Wsgi b,-instantiate Flask object-static file prefix / xxx-static file directory-template path c, add routing relationship-add Rule (url and view functions) to the url_map field of Flask object-two ways to add route d, Request-request.form-request.args

VI. Basic use

From flask import Flask# instantiates the Flask object app = Flask (_ _ name__) # to generate routing relationships And save the relationship somewhere, in the url_map field of the app object @ app.route ('/ xxxx') # @ decoratordef index (): return "Index" # def index (): # return "Index" # app.add_url_rule ('/ xxx', "N1", index) if _ _ name__ = ='_ _ main__': # start the program and listen for the user request # once the request arrives Execute app.__call__ method # encapsulate user request # for route matching app.run ()

Save the session data to the browser,-advantages: reduce the pressure on the server-disadvantages: not secure

B. Routing system:

App.route ('/ post/path:path') @ app.route ('/ login', methods= ['GET',' POST']) @ app.route ('/ user/') @ app.route ('/ post/int:post_id') @ app.route ('/ post/float:post_id')

7. Routing system a,-can pass in parameters

@ app.route ('/ user/') @ qpp.route ('/ post/',methods= ['GET','POST'], endpoint='fff')

B. Reverse generation of URL:url_for

C. Extend Flask's routing system to support regularization:

From flask import Flask Url_for app = Flask (_ _ name__) # defines the transformed class from werkzeug.routing import BaseConverter class RegexConverter (BaseConverter): "Custom URL matches regular expressions" def _ _ init__ (self, map) " Regex): super (RegexConverter, self). _ _ init__ (map) self.regex = regex def to_python (self, value): "" when the route matches The value passed to the parameter in the view function after a successful match: param value:: return: "" return int (value) def to_url (self) Value): when using url_for to generate URL in reverse The passed parameters are processed by this method. The returned value is used to generate the parameter in URL: param value:: return: "" val = super (RegexConverter) Self) .to_url (value) return val # add to converts app.url_map.converters ['xxx'] = RegexConverter # to use @ app.route (' / index/',endpoint='xx') def index (nid): url_for ('xx') Nid=123) return "Index" if _ _ name__ = ='_ main__': app.run ()

VIII. Request response

From flask import Flask from flask import request from flask import render_template from flask import redirect from flask import make_response app = Flask (_ _ name__) @ app.route ('/ login.html', methods= ['GET') "POST"]) def login (): # request related information # request.method # request.args # request.form # request.values # request.cookies # request.headers # request.path # request.full_path # request.script_root # request.url # request.base_url # request.url_root # request.host_url # request.host # request.files # obj = request.files ['the_file_name'] # obj.save (' / var/www/uploads/' + secure_filename (f.filename)) # response # return "string" # return render_template ('html template path') * * {}) # return redirect ('/ index.html') # response = make_response (render_template ('index.html')) # response is the flask.wrappers.Response type # response.delete_cookie (' key') # response.set_cookie ('key') 'value') # response.headers [' Xcopyright installation'] ='A value' # return response return "content" if _ name__ = ='_ main__': app.run () "

A. Use make_safe in django and make_response in Flask

IX. Template language

A. Flask uses the Jinja2 template, so its syntax is no different from Django. The custom template method in Flask is similar to Bottle. Create a function and pass it into render_template in the form of parameters.

10. Session

A,-session, is there any other way? -it is the same as the dictionary method b. How to set the session timeout: app.config ['SESSION_COOKIE_NAME'] =' session_lvning' "" 'SESSION_COOKIE_NAME':' session', 'SESSION_COOKIE_DOMAIN': None,' SESSION_COOKIE_PATH': None 'SESSION_COOKIE_HTTPONLY': True, 'SESSION_COOKIE_SECURE': False,' SESSION_REFRESH_EACH_REQUEST': True, 'PERMANENT_SESSION_LIFETIME': timedelta (days=31)

In addition to the request object, there is also a session object. It allows you to store specific user information between different requests. It is implemented on the basis of Cookies, and to sign a key for Cookies to use a session, you need to set a key.

Setting: session ['username'] =' xxx'

Delete: session.pop ('username', None)

11. Flash (flash)

A, session take once the data saved by session from a dictionary on the server side, it will still have. Flash is created based on session, and flash supports putting values in it. As long as you take a value in it, it will not have it. Flash is b, on the basis of session, put its value really on session, when removing it, not only take its value away, but also get rid of session things.

XII. Blueprints

A. Blueprints are used to provide directory partition for applications.

Blueprint URL prefix: xxx = Blueprint ('account', name,url_prefix='/xxx') Blueprint subdomain: xxx = Blueprint (' account', name,subdomain='admin')

The prerequisite is to configure SERVER_NAME: app.config ['SERVER_NAME'] =' wupeiqi.com:5000'

When visiting: admin.wupeiqi.com:5000/login.html

XIII. DBUtils

A, DBUtils is a module of Python to implement database connection pool. B, three modes of connection pooling: (1), the first mode: its disadvantages: creating links to the database repeatedly with each request. Too many links (2), second mode: its disadvantages: cannot support concurrency (3), third mode: it implements database connection pool based on DBUtils-create a link for each thread, when the thread shuts down It is not really closed, when this thread calls again, it still uses the original created link, and the database link is not closed until the thread terminates-create a connection pool (10 links) and provide links for all threads. get it when you're done, and put it back into the connection pool again when you're done. C. Application of DBUtils: import timeimport pymysqlimport threadingfrom DBUtils.PooledDB import PooledDB, SharedDBConnectionPOOL = PooledDB (creator=pymysql, # use the module maxconnections=6 of the linked database, # maximum number of connections allowed in the connection pool, 0 and None indicate unlimited number of connections mincached=2, # initialization, at least free links created in the link pool, 0 means no creation of maxcached=5, # the most idle links in the link pool 0 and None do not limit maxshared=3, the maximum number of links shared in the # link pool, and 0 and None means all are shared. PS: useless, because modules such as pymysql and MySQLdb have a threadsafety of 1, and no matter how many values are set, _ maxcached is always 0, so all links are always shared. Blocking=True, whether to block waiting if no connection is available in the connection pool. True, wait; False, do not wait and then report an error maxusage=None, # the maximum number of times a link is reused, and None represents an unlimited setsession= [], # list of commands executed before starting the session. For example, ["set datestyle to...", "set time zone..."] Ping=0, # ping MySQL server, check whether the service is available. # such as: 0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always host='127.0.0.1', port=3306, user='root', password='123', database='pooldb', charset='utf8')

14. Session

A, the principle and difference between session and cookie: cookie is the key-value pair stored on the browser, session is the key-value pair that exists in the server (session on the server is a big dictionary, which is a random string in the dictionary) (session is the same as request principle) (session principle is also related to context) session depends on cookie to exist b, session process when the request comes in for the first time Generate a random string-send it to the user cookie-call stark to put the random string and the corresponding value into the local view function when saving to the session dictionary-import top (it takes session) session=LocalProxy (partile (_ lookup_req_object) when in use ('session')) request is processed: after memory is processed Persist session (session to database, to Redis, to encrypted cookie)

15. Session source code parsing

First, execute the _ _ call__ method of Flask, and call out wsgi_app. It first completes the context of request, and the request has just entered the push. It first processes the data related to the request from request, and then adds it to the local.

B, then process session (add the RequestContext object (request,session) to the local), request (encapsulate the request information into the Request (environ) object and copy it to the requestContext object), and then get the random string in the cookie to check whether it exists or not. Get the value saved by the server session according to the random string. Put session in memory

C. Execute the view function under the wsgi_app method. After executing the view function, it returns to the full_dispatch_requesthong and triggers the decorator that executes only once (triggers the Flask signal)

D. After executing the decorator, execute the following special decorator. If these special decorators do not return a value, then rv=None, if there is a return value, the return value is displayed on the page.

E. if there is no return value, trigger the execution of that view function to get the return value. After the request is returned, finalize_request is called to encapsulate its return value.

Sixteen. The difference between Flask and Django

A. Request-related data-Django: parameters-Flask: based on Local,LocalStark object b, multiple requests will not be confused-single-thread-multi-thread-co-program solution: from greenlet import getcurrent as get_ident

Flask signal

A. The signal in Flask framework is based on blinker.

B. Installation: pip3 install blinker

C, ten signals

1. 10 built-in signals: 2. Request_started = _ signals.signal ('request-started') # execute before the request arrives. Request_finished = _ signals.signal (' request-finished') # execute 3. Before_render_ after the request ends Template = _ signals.signal ('before-render-template') # template execution before rendering 4. Template_rendered = _ signals.signal (' template-rendered') # after template rendering, execute got_request_exception = _ signals.signal ('got-request-exception') # request to execute Execute 6. Request_tearing_down = _ signals.signal ('request-tearing-down') # automatically after the request is executed (whether successful or not) 7. Appcontext_tearing_down = _ signals.signal (' appcontext-tearing-down') # automatic execution after the context of the request is executed (regardless of success or not) 1. Appcontext_pushed = _ signals.signal ('appcontext-pushed') # execute when requesting app context push. Appcontext_popped = _ signals.signal (' appcontext-popped') # execute when requesting context pop Message_flashed = _ signals.signal ('message-flashed') # when calling flask to add data to it Automatic trigger

D, flask signals do not have their own, using someone else's, and these signals can all be replaced by decorators, but there is something special in Django that those model operations do not have decorators at all, that is, they are completed with built-in signals.

Eighteen, django built-in signal

Before the Request/response signals request_started # request arrives, after automatically triggering the request_finished # request, after automatically triggering the got_request_exception # request exception Automatically triggers the modal of Model signals pre_init # django to execute its constructor, and automatically triggers the modal of post_init # django to execute its constructor Automatically triggers pre_save # django's modal object before saving, automatically triggers post_save # django's modal object to save, and automatically triggers pre_delete # django's modal object to be deleted before After automatically triggering the deletion of the modal object of post_delete # django, it automatically triggers the operation of the third table (add,remove,clear) using the M2m field in the modal of m2m_changed # django. Automatically trigger class_prepared # when the program starts, detect the modal class in the registered app, and for each class, automatically trigger Management signals pre_migrate # before executing the migrate command Automatically triggers post_migrate # when executing migrate commands, automatically triggers Test signals setting_changed # when modifying configuration files using test tests, automatically triggers template_rendered # when using test test rendering templates Automatically triggers Database Wrappers connection_created # when creating a database connection

19. Wtform

A, WTForms is a form component that supports multiple web frameworks, which is mainly used to verify the data requested by users.

B. Installation: pip3 install wtform

C. Purpose:

1. Users log in and register

When the user logs in, the user name and password submitted by the user need to be verified in multiple formats. Such as:

Users cannot be empty; user length must be greater than 6; password must not be empty; password length must be greater than 12; password must contain letters, numbers, special characters, etc. (custom regular); app.py login

20. SQLALchemy

A. Introduction:

SQLALchemy is an ORM framework based on Python implementation. The framework is based on DB API and uses relational object mapping for database operations. In a nutshell, it converts classes and objects into SQL, and then uses data API to execute SQL and get the results.

B. Installation: pip3 install SQLALchemy

C, components

Engine, framework engine Connection Pooling, database connection pool Dialect, select DB API type Schema / Types for linked database, schema and type SQL Exprression Language SQL expression language

D, SQLALcheam the province can not operate the database, it must come to pymysql and other third-party plug-ins, Dialect is used for the exchange of data API, according to the configuration file

Call different database API to realize the operation of the database.

MySQL-Python mysql+mysqldb://:@ [:] / pymysql mysql+pymysql://:@/ [?] MySQL-Connector mysql+mysqlconnector://:@ [:] / cx_Oracle oracle+cx_oracle://user:pass@host:port/dbname [? key=value&key=value...] More: http://docs.sqlalchemy.org/en/latest/dialects/index.html thank you for reading, the above is "what are the flask-related knowledge points of Python?" after the study of this article, I believe you have a deeper understanding of what the flask-related knowledge points of Python have, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.