python框架☞Flask

flask文档：   https://flask.palletsprojects.com/en/1.1.x/

 

flask程序两种启动方式：
1. 通过开发工具启动
2. Windows环境在终端启动
    set FLASK_APP = flask_application.py
    set FLASK_ENV = development   #设置为debug模式
    set FALSK_DEBUG = 1  # 设置为debug模式（跟上面方法可以任选一种）
    python -m flask run   # 启动flask程序
    python -m flask run --host=0.0.0.0  #设置所以机器都可访问flask程序

　

python routing

from markupsafe import escape

@app.route('/user/<username>') 
def show_user_profile(username): 
　　# show the user profile for that user 
　　return 'User %s' % escape(username) 

@app.route('/post/<int:post_id>') 
def show_post(post_id):
　　pass

@app.route('/path/<path:subpath>') 
def show_subpath(subpath):  
　　return 'Subpath %s' % escape(subpath)

　　

Converter types:

string	(default) accepts any text without a slash
int	accepts positive integers
float	accepts positive floating point values
path	like string but also accepts slashes
uuid	accepts UUID strings

 

Unique URLs / Redirection Behavior

 

@app.route('/projects/')
def projects():
    return 'The project page'

@app.route('/about')
def about():
    return 'The about page'

　　

 

 

 

 

作用：通过视图函数，给响应请求附加请求头

函数：make_response(*args)

函数内部执行操作：
-   if no arguments are passed, it creates a new response argument
-   if one argument is passed, :meth:`flask.Flask.make_response`
        is invoked with it.
-   if more than one argument is passed, the arguments are passed
        to the :meth:`flask.Flask.make_response` function as tuple.

实战：
使用方式一：
def index():
            response = make_response(render_template('index.html', foo=42))
            response.headers['X-Parachutes'] = 'parachutes are cool'
            return response

使用方式二：
response = make_response(render_template('not_found.html'), 404)

使用方式三：
response = make_response(view_function())
        response.headers['X-Parachutes'] = 'parachutes are cool'

 

 

 

导入：from flask import jsonify

作用：将response以json格式返回

定义：jsonify(*args, **kwargs)

注意事项：
the JSON serialization behavior has the following differences
    from :func:`dumps`:

1. Single argument: Passed straight through to :func:`dumps`.
2. Multiple arguments: Converted to an array before being passed to:func:`dumps`.
3. Multiple keyword arguments: Converted to a dict before being passed to:func:`dumps`.
4. Both args and kwargs: Behavior undefined and will throw an exception.
特别提醒：不支持同时传关键字参数和位置参数

实战：
Example usage::
Example usage::

from flask import jsonify

@app.route('/_get_current_user')
def get_current_user():
    return jsonify(username=g.user.username,
                   email=g.user.email,
                   id=g.user.id)

This will send a JSON response like this to the browser::

{
    "username": "admin",
    "email": "admin@localhost",
    "id": 42
}

response以json格式输出的前置条件：
``JSONIFY_PRETTYPRINT_REGULAR`` config parameter is set to True or the Flask app is running in debug mode

 

from flask import Flask, flash, get_flashed_messages

闪现：基于session实现

def flash(message, category='message'):
    """Flashes a message to the next request.  In order to remove the
    flashed message from the session and to display it to the user,
    the template has to call :func:`get_flashed_messages`.

    .. versionchanged:: 0.3
       `category` parameter added.

    :param message: the message to be flashed.
    :param category: the category for the message.  The following values
                     are recommended: ``'message'`` for any kind of message,
                     ``'error'`` for errors, ``'info'`` for information
                     messages and ``'warning'`` for warnings.  However any
                     kind of string can be used as category.
    """
    # Original implementation:
    #
    #     session.setdefault('_flashes', []).append((category, message))
    #
    # This assumed that changes made to mutable structures in the session are
    # are always in sync with the session object, which is not true for session
    # implementations that use external storage for keeping their keys/values.
    flashes = session.get('_flashes', [])
    flashes.append((category, message))
    session['_flashes'] = flashes
    message_flashed.send(current_app._get_current_object(),
                         message=message, category=category)


def get_flashed_messages(with_categories=False, category_filter=[]):
    """Pulls all flashed messages from the session and returns them.
    Further calls in the same request to the function will return
    the same messages.  By default just the messages are returned,
    but when `with_categories` is set to ``True``, the return value will
    be a list of tuples in the form ``(category, message)`` instead.

    Filter the flashed messages to one or more categories by providing those
    categories in `category_filter`.  This allows rendering categories in
    separate html blocks.  The `with_categories` and `category_filter`
    arguments are distinct:

    * `with_categories` controls whether categories are returned with message
      text (``True`` gives a tuple, where ``False`` gives just the message text).
    * `category_filter` filters the messages down to only those matching the
      provided categories.

    See :ref:`message-flashing-pattern` for examples.

    .. versionchanged:: 0.3
       `with_categories` parameter added.

    .. versionchanged:: 0.9
        `category_filter` parameter added.

    :param with_categories: set to ``True`` to also receive categories.
    :param category_filter: whitelist of categories to limit return values
    """
    flashes = _request_ctx_stack.top.flashes
    if flashes is None:
        _request_ctx_stack.top.flashes = flashes = session.pop('_flashes') \
            if '_flashes' in session else []
    if category_filter:
        flashes = list(filter(lambda f: f[0] in category_filter, flashes))
    if not with_categories:
        return [x[1] for x in flashes]
    return flashes

 

导入：from flask import url_for

作用：反向生成url， 配合endpoint一起使用

定义：url_for(endpoint, **values)

 

Flask定义路由绑定关系有两种方式

from flask import Flask

app = Flask(__name__)

方式1：装饰器
@app.route('/user', endpoint='info')
def get_current_user():
    return jsonify('hello', 12, '男')

方式2：通过add_url_rule method
def get_file_name():
    return 'ok'

app.add_url_rule('/file', 'f', get_file_name)

说明：装饰器方法内部也是通过add_url_rule 方法来实现的

 

flask的配置文件是一个flask.config.Config对象，默认配置：
default_config = ImmutableDict({
        'ENV':                                  None,
        'DEBUG':                                None,
        'TESTING':                              False,
        'PROPAGATE_EXCEPTIONS':                 None,
        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
        'SECRET_KEY':                           None,
        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
        'USE_X_SENDFILE':                       False,
        'SERVER_NAME':                          None,
        'APPLICATION_ROOT':                     '/',
        'SESSION_COOKIE_NAME':                  'session',
        'SESSION_COOKIE_DOMAIN':                None,
        'SESSION_COOKIE_PATH':                  None,
        'SESSION_COOKIE_HTTPONLY':              True,
        'SESSION_COOKIE_SECURE':                False,
        'SESSION_COOKIE_SAMESITE':              None,
        'SESSION_REFRESH_EACH_REQUEST':         True,
        'MAX_CONTENT_LENGTH':                   None,
        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
        'TRAP_BAD_REQUEST_ERRORS':              None,
        'TRAP_HTTP_EXCEPTIONS':                 False,
        'EXPLAIN_TEMPLATE_LOADING':             False,
        'PREFERRED_URL_SCHEME':                 'http',
        'JSON_AS_ASCII':                        True,
        'JSON_SORT_KEYS':                       True,
        'JSONIFY_PRETTYPRINT_REGULAR':          False,
        'JSONIFY_MIMETYPE':                     'application/json',
        'TEMPLATES_AUTO_RELOAD':                None,
        'MAX_COOKIE_SIZE': 4093,
    })


实际使用过程中，flask常用导入配置项有三种方式：
方式1：app.config.from_pyfile('yourconfig.cfg')
注意：yourconfig.cfg 文件一般是放在程序根路径下面
    如：
            settings.py
                DEBUG = True
                TESTING = True
 
            app.config.from_pyfile("settings.py")

方式2：app.config.from_object()
官方解释： provide an import path to a module that should be loaded.  It is also possible to tell it to use the same module and with that provide the configuration values just before the call
使用from_object方式导入配置项，有两种方式
      1：
        DEBUG = True
        SECRET_KEY = 'development key'
        app.config.from_object(__name__)
      
      2：
         app.config.from_object('test_flask.settings.TestConfig')
 
        settings.py

    class BaseConfig:
        DEBUG = False
        TESTING = False
        DATABASE_URI = 'sqlite://:memory:'

    class ProConfig(BaseConfig):
        DATABASE_URI = 'mysql://user@localhost/foo'

    class DevConfig(BaseConfig):
        DEBUG = True

    class TestConfig(BaseConfig):
        TESTING = True
    


对于上面两种方式导入配置文件，配置文件中的配置项必须大写（In both cases (loading from any Python file or loading from modules),
only uppercase keys are added to the config.  This makes it possible to use lowercase values in the config file for temporary values that are not added to the config or to define the config keys in the same file that implements  the application.）

方式3：app.config.from_envvar('YOURAPPLICATION_SETTINGS')
第三种方式官方解释：In this case before launching the application you have to set this environment variable to the file you want to use.  On Linux and OS X
 use the export statement::
 export YOURAPPLICATION_SETTINGS='/path/to/config/file'

On windows use `set` instead.



        

 

# 请求相关信息
# request.method
# request.access_route
# request.args
# request.form
# request.data
# request.values
# request.cookies
# request.headers
# request.path
# request.view_args
# request.full_path  
# request.query_string 
# request.url  
# request.base_url
# request.url_root
# request.host_url  
# request.host  
# request.files
# obj = request.files['upload_file_name']
# obj.save('/opt/files/' + secure_filename(f.filename))

# 响应相关信息
# return "字符串"
# return render_template('html模板路径',**{})
# return redirect('/index.html')

# response = make_response(render_template('index.html'))
# response.delete_cookie('key')
# response.set_cookie('key', 'value')
# response.headers['X-Something'] = 'A value'
# return response

#return jsonify(username=g.user.username,
                           email=g.user.email,
                           id=g.user.id)

 

from flask import Flask, views
app = Flask(__name__)


def superuser_required(func):
    def inner(*args, **kwargs):
        print('before request')
        result = func(*args, **kwargs)
        print('after request')
        return result

    return inner


class CountAPI(views.MethodView):
    methods = ['GET', 'POST']
    decorators = [superuser_required]

    def get(self):
        print('request runing')
        return "Hello GET request"

    def post(self):
        pass


app.add_url_rule('/count', view_func=CountAPI.as_view('api'))


if __name__ == '__main__':
    app.run()

 

作用：请求分发、自定义静态文件路径

定义蓝图：
from flask import Blueprint
sales = Blueprint('c2', __name__, url_prefix='/sales')

BluePrint构造函数：
    def __init__(self, name, import_name, static_folder=None,
                 static_url_path=None, template_folder=None,
                 url_prefix=None, subdomain=None, url_defaults=None,
                 root_path=None):
        _PackageBoundObject.__init__(self, import_name, template_folder,
                                     root_path=root_path)
        self.name = name
        self.url_prefix = url_prefix
        self.subdomain = subdomain
        self.static_folder = static_folder
        self.static_url_path = static_url_path
        self.deferred_functions = []
        if url_defaults is None:
            url_defaults = {}
        self.url_values_defaults = url_defaults

注册蓝图：
app = Flask(__name__)
app.register_blueprint(sales)

 

from flask import Flask
app = Flask(__name__)

@app.before_first_request   # 程序程序后，只有第一次请求进来会执行一次
def before_first():
    print('before_first')


@app.before_request   #
def before_request():
    print('before_request')


@app.after_request
def after_request(response):
    print('after request')
    return response


@app.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404

 

from flask import Flask

app = Flask(__name__)


class MiddleWare:
    def __init__(self, wsgi_app):
        self.wsgi = wsgi_app
    
    def __call__(self, environ, start_response):
        print('request coming')
        obj = self.wsgi(environ, start_response)
        print('request end')
        return obj

if __name__ == '__main__':
    app.wsgi_app = MiddleWare(app.wsgi_app)
    app.run()

 

 

pipreqs ：自动发现项目依赖模块&版本
    安装: pip install pipreqs
    生成依赖文件: pipreqs .   会自动生成一个文件（requirements.txt）
    安装依赖文件：pip3 install -r requirements.txt #会自动安装requirements.txt 中的package

 

 

flask插件：http://flask.pocoo.org/extensions/