一图看懂 flask 模块：一个 Python 微型框架，资料整理+笔记（大全）

本文由 大侠(AhcaoZhu)原创，转载请声明。
链接: https://blog.youkuaiyun.com/Ahcao2008

🧊摘要

• 全文介绍python的 flask 模块（一个 Python 微型框架）、函数、类及类的方法和属性。
• 它通过代码抓取并经AI智能翻译和人工校对。
• 是一部不可多得的权威字典类工具书。它是系列集的一部分。后续陆续发布、敬请关注。【原创：AhcaoZhu大侠】

注：从本文起，采用改版后的智能翻译了。

🧊模块图

flask
	flask.globals
	flask.json
		flask.json.provider
		flask.json.tag
	flask.signals
	flask.helpers
	flask.cli
	flask.typing
	flask.config
	flask.ctx
		◆contextvars
	flask.logging
	flask.templating
	flask.scaffold
	flask.sessions
	flask.wrappers
	flask.app
	flask.blueprints

🧊类关系图

◆object
	◆click.core.BaseCommand
		◆click.core.Command
			◆click.core.MultiCommand
				◆click.core.Group
					flask.cli.AppGroup
						flask.cli.FlaskGroup
	◆click.types.ParamType
		◆click.types.Path
			flask.cli.SeparatedPathType
		flask.cli.CertParamType
	◆collections.abc.Container
		◆collections.abc.Iterable
			◆collections.abc.Sized
				◆collections.abc.Collection
					◆collections.abc.Mapping
						◆collections.abc.MutableMapping
							flask.sessions.SessionMixin
								◆dict
									flask.config.Config
									◆werkzeug.datastructures.UpdateDictMixin
										◆werkzeug.datastructures.CallbackDict
											flask.sessions.SecureCookieSession
												flask.sessions.NullSession
	flask.blueprints.BlueprintSetupState
	flask.cli.ScriptInfo
	flask.config.ConfigAttribute
	flask.ctx.AppContext
	flask.ctx.RequestContext
	flask.ctx._AppCtxGlobals
	flask.globals._FakeStack
	flask.json.provider.JSONProvider
		flask.json.provider.DefaultJSONProvider
	flask.json.tag.JSONTag
		flask.json.tag.PassDict
		flask.json.tag.PassList
		flask.json.tag.TagBytes
		flask.json.tag.TagDateTime
		flask.json.tag.TagDict
		flask.json.tag.TagMarkup
		flask.json.tag.TagTuple
		flask.json.tag.TagUUID
	flask.json.tag.TaggedJSONSerializer
	flask.scaffold.Scaffold
		flask.app.Flask
		flask.blueprints.Blueprint
	flask.sessions.SessionInterface
		flask.sessions.SecureCookieSessionInterface
	flask.signals.Namespace
	flask.signals._FakeSignal
	◆jinja2.environment.Environment
		flask.templating.Environment
	◆jinja2.loaders.BaseLoader
		flask.templating.DispatchingJinjaLoader
	◆json.decoder.JSONDecoder
		flask.json.JSONDecoder
	◆json.encoder.JSONEncoder
		flask.json.JSONEncoder
	logging.BufferingFormatter
	logging.Filter
	logging.Filterer
		logging.Handler
			logging.NullHandler
			logging.StreamHandler
				logging.FileHandler
				logging._StderrHandler
		logging.Logger
			logging.RootLogger
	logging.Formatter
	logging.LogRecord
	logging.LoggerAdapter
	logging.Manager
	logging.PercentStyle
		logging.StrFormatStyle
		logging.StringTemplateStyle
	logging.PlaceHolder
	◆property
		◆werkzeug.utils.cached_property
			flask.helpers.locked_cached_property
	◆type
		typing.NamedTupleMeta
		typing._ProtocolMeta
	typing.Generic
		typing.IO
			typing.BinaryIO
			typing.TextIO
		typing._Protocol
			typing.SupportsAbs
			typing.SupportsBytes
			typing.SupportsComplex
			typing.SupportsFloat
			typing.SupportsInt
			typing.SupportsRound
	typing.NamedTuple
	typing._Final
		typing.ForwardRef
		typing.TypeVar
		typing._GenericAlias
			typing._VariadicGenericAlias
		typing._SpecialForm
	typing._Immutable
		typing._Final
	typing._TypingEllipsis
	typing._TypingEmpty
	typing.io
	typing.re
	◆werkzeug.sansio.request.Request
		◆werkzeug.wrappers.request.Request
			flask.wrappers.Request
	◆werkzeug.sansio.response.Response
		◆werkzeug.wrappers.response.Response
			flask.wrappers.Response

🧊模块全展开

☘️【flask】

flask, fullname=flask, file=flask_init_.py

🔵统计

序号	类别	数量
2	bool	1
4	str	5
6	list	1
8	dict	1
9	module	15
10	class	6
11	function	20
12	builtin_function_or_method	1
13	residual	17
14	system	11
16	all	67

🔵常量

🌿bool

1 signals_available False

🔵模块

🌿2 flask.globals

globals, fullname=flask.globals, file=flask\globals.py

🌿3 flask.json

json, fullname=flask.json, file=flask\json_init_.py

🌿4 flask.signals

signals, fullname=flask.signals, file=flask\signals.py

🌿5 flask.helpers

helpers, fullname=flask.helpers, file=flask\helpers.py

🌿6 flask.cli

cli, fullname=flask.cli, file=flask\cli.py

🌿7 flask.typing

typing, fullname=flask.typing, file=flask\typing.py

🌿8 flask.config

config, fullname=flask.config, file=flask\config.py

🌿9 flask.ctx

ctx, fullname=flask.ctx, file=flask\ctx.py

🌿10 flask.logging

logging, fullname=flask.logging, file=flask\logging.py

🌿11 flask.templating

templating, fullname=flask.templating, file=flask\templating.py

🌿12 flask.scaffold

scaffold, fullname=flask.scaffold, file=flask\scaffold.py

🌿13 flask.sessions

sessions, fullname=flask.sessions, file=flask\sessions.py

🌿14 flask.wrappers

wrappers, fullname=flask.wrappers, file=flask\wrappers.py

🌿15 flask.app

app, fullname=flask.app, file=flask\app.py

🌿16 flask.blueprints

blueprints, fullname=flask.blueprints, file=flask\blueprints.py

🔵函数

🌿17 after_this_request(f: Union[Callable[[~ResponseClass], ~ResponseClass], Callable[[~ResponseClass], Awaitable[~ResponseClass]]]) -> Union[Callable[[~ResponseClass],

~ResponseClass], Callable[[~ResponseClass], Awaitable[~ResponseClass]]]

after_this_request(f: Union[Callable[[~ResponseClass], ~ResponseClass], Callable[[~ResponseClass], Awaitable[~ResponseClass]]]) -> Union[Callable[[~ResponseClass], ~ResponseClass],
Callable[[~ResponseClass], Awaitable[~ResponseClass]]], module=flask.ctx, line:113 at site-packages\flask\ctx.py

	在此请求之后执行一个函数。这对于修改响应对象很有用。该函数被传递给响应对象，并且必须返回相同的对象或新的对象。
	举例：

        @app.route('/')
        def index():
            @after_this_request
            def add_header(response):
                response.headers['X-Foo'] = 'Parachute'
                return response
            return 'Hello World!'

	如果视图函数以外的函数想要修改响应，这将更加有用。例如，考虑一个想要添加一些头而不将返回值转换为响应对象的装饰器。
	版本变更： 0.9

🌿18 copy_current_request_context(f: Callable) -> Callable

copy_current_request_context(f: Callable) -> Callable, module=flask.ctx, line:146 at site-packages\flask\ctx.py

	修饰函数以保留当前请求上下文的辅助函数。这在使用greenlet时非常有用。
	在修饰函数的那一刻，创建了请求上下文的副本，然后在调用函数时推送。当前会话也包含在复制的请求上下文中。
	举例：

        import gevent
        from flask import copy_current_request_context

        @app.route('/')
        def index():
            @copy_current_request_context
            def do_some_work():
                # do some work here, it can access flask.request or
                # flask.session like you would otherwise in the view function.
                ...
            gevent.spawn(do_some_work)
            return 'Regular response'

	版本变更： 0.10

🌿19 has_app_context() -> bool

has_app_context() -> bool, module=flask.ctx, line:219 at site-packages\flask\ctx.py

	类似于 :func:`has_request_context`，但适用于应用程序上下文。
	您也可以对 :data:`current_app`对象进行布尔检查。
	版本变更： 0.9

🌿20 has_request_context() -> bool

has_request_context() -> bool, module=flask.ctx, line:187 at site-packages\flask\ctx.py

	如果您的代码想要测试请求上下文是否存在，则可以使用此函数。
	例如，如果请求对象可用，您可能希望利用请求信息，但如果请求对象不可用，则静默失败。
	
        class User(db.Model):

            def __init__(self, username, remote_addr=None):
                self.username = username
                if remote_addr is None and has_request_context():
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr

	或者，您也可以只测试任何上下文绑定对象(例如 :class:`request`或 :class:`g`)的真实性::
        class User(db.Model):

            def __init__(self, username, remote_addr=None):
                self.username = username
                if remote_addr is None and request:
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr

	版本变更： 0.7

🌿21 abort(code: Union[int, ForwardRef(‘BaseResponse’)], *args: Any, **kwargs: Any) -> ‘te.NoReturn’

abort(code: Union[int, ForwardRef(‘BaseResponse’)], *args: Any, **kwargs: Any) -> ‘te.NoReturn’, module=flask.helpers, line:290 at site-packages\flask\helpers.py

	为给定的状态码引发 :exc:`~werkzeug.exceptions.HTTPException`。
	如果 :data:`~flask.current_app`可用，它将调用它的 :attr:`~flask.Flask.aborter`对象，否则它将使用 :func:`werkzeug.exceptions.abort`。
	:param code: 		异常的状态码，必须在 ``app.aborter``中注册。
	:param args: 		传递给异常。
	:param kwargs: 		传递给异常。

	版本变更： 2.2	如果可用，调用 ``current_app.aborter``，而不是始终使用Werkzeug的默认 ``abort``。

🌿22 flash(message: str, category: str = ‘message’) -> None

flash(message: str, category: str = ‘message’) -> None, module=flask.helpers, line:337 at site-packages\flask\helpers.py

	向下一个请求闪烁一条消息。为了从会话中删除闪过的消息并将其显示给用户，模板必须调用 :func:`get_flashed_messages`。
	版本变更： 0.3	添加 `category`参数。
	:param message: 		要闪现的信息。
	:param category: 		消息的类别。建议设置如下值: 
	                            ``'message'``表示任何类型的消息， 
	                            ``'error'``表示错误， 
	                            ``'info'``表示提示消息， 
	                            ``'warning'``表示警告。
                            然而，任何类型的字符串都可以用作类别。

🌿23 get_flashed_messages(with_categories: bool = False, category_filter: Iterable[str] = ()) -> Union[List[str], List[Tuple[str, str]]]

get_flashed_messages(with_categories: bool = False, category_filter: Iterable[str] = ()) -> Union[List[str], List[Tuple[str, str]]], module=flask.helpers, line:369 at site-packages\flask\helpers.py

	从会话中提取所有闪现的消息并返回它们，在同一请求中对该函数的进一步调用将返回相同的消息。
	默认情况下，只返回消息，但是当 `with_categories`设置为 ``True``时，返回值将是 ``(category, message)``形式的元组列表。
	通过在 `category_filter`中提供这些类别，将闪现的消息筛选到一个或多个类别。这允许在单独的html块中呈现类别。 
	`with_categories`和 `category_filter`参数是不同的:
        * `with_categories`控制类别是否与消息文本一起返回( ``True``给出一个元组，其中 ``False``只给出消息文本)
        * `category_filter`将消息过滤到仅匹配所提供类别的消息。
	示例请参见 :doc:`/patterns/flashing`。
	版本变更： 0.3	添加 `with_categories`参数。
	版本变更： 0.9	添加 `category_filter`参数。
	:param with_categories: 		设置为 ``True``也可以接收类别。
	:param category_filter: 		筛选类别以限制返回值。只返回列表中的类别。

🌿24 get_template_attribute(template_name: str, attribute: str) -> Any

get_template_attribute(template_name: str, attribute: str) -> Any, module=flask.helpers, line:315 at site-packages\flask\helpers.py

	加载模板导出的宏(或变量)。这可以用于从Python代码中调用宏。例如，如果你有一个名为 :file:`_cider.html`的模板，其中包含以下内容:
    .. sourcecode:: html+jinja

	{%宏hello(name) %} hello {{name}}!{% endmacro %}。
	你可以像这样从Python代码中访问它::
        hello = get_template_attribute('_cider.html', 'hello')
        return hello('World')

	版本变更： 0.2
	:param template_name: 		模板的名称。
	:param attribute: 		要访问的宏的变量名。

🌿25 make_response(*args: Any) -> ‘Response’

make_response(*args: Any) -> ‘Response’, module=flask.helpers, line:163 at site-packages\flask\helpers.py

	有时需要在视图中设置额外的标头。因为视图不必返回响应对象，但可以返回由Flask本身转换为响应对象的值，所以在其中添加头信息会变得很棘手。
	这个函数可以被调用，而不是使用return，你会得到一个响应对象，你可以用它来附加标头。
	如果视图看起来像这样，你想添加一个新的标题::
        def index():
            return render_template('index.html', foo=42)

	你现在可以这样做::
        def index():
            response = make_response(render_template('index.html', foo=42))
            response.headers['X-Parachutes'] = 'parachutes are cool'
            return response

	这个函数接受与视图函数返回的参数完全相同的参数。例如，这将创建一个带有404错误代码的响应::
        response = make_response(render_template('not_found.html'), 404)

	这个函数的另一个用例是将视图函数的返回值强制转换为响应，这对视图装饰器很有帮助::
        response = make_response(view_function())
        response.headers['X-Parachutes'] = 'parachutes are cool'

	在内部，这个函数做以下事情:
	-如果没有传递参数，则创建一个新的响应参数-如果传递了一个参数，则调用 :meth:`flask.Flask.make_response`-如果传递了多个参数，则将参数作为元组传递给 :meth:`flask.Flask.make_response`函数。
	版本变更： 0.6

🌿26 redirect(location: str, code: int = 302, Response: Union[Type[ForwardRef(‘BaseResponse’)], NoneType] = None) -> ‘BaseResponse’

redirect(location: str, code: int = 302, Response: Union[Type[ForwardRef(‘BaseResponse’)], NoneType] = None) -> ‘BaseResponse’, module=flask.helpers, line:266 at site-packages\flask\helpers.py

	创建一个重定向响应对象。
	如果 :data:`~flask.current_app`可用，它将使用它的 :meth:`~flask.Flask.redirect`方法，否则将使用 :func:`werkzeug.utils.redirect`。
	:param location: 		要重定向到的URL。
	:param code: 		重定向的状态码。Response:要使用的响应类。当 ``current_app``是活动的，它使用 ``app.response_class``时不使用。

	版本变更： 2.2	如果可用，调用 ``current_app.redirect``，而不是始终使用Werkzeug的默认 ``redirect``。

🌿27 send_file(path_or_file: Union[os.PathLike, str, BinaryIO], mimetype: Union[str, NoneType] = None, as_attachment: bool = False,

download_name: Union[str, NoneType] = None, conditional: bool = True, etag: Union[bool, str] = True,
last_modified: Union[datetime.datetime, int, float, NoneType] = None, max_age: Union[int, Callable[[Union[str, NoneType]], Union[int, NoneType]], NoneType] = None) -> ‘Response’

send_file(path_or_file: Union[os.PathLike, str, BinaryIO], mimetype: Union[str, NoneType] = None,
as_attachment: bool = False, download_name: Union[str, NoneType] = None, conditional: bool = True, etag: Union[bool, str] = True,
last_modified: Union[datetime.datetime, int, float, NoneType] = None,
max_age: Union[int, Callable[[Union[str, NoneType]], Union[int, NoneType]], NoneType] = None) -> ‘Response’, module=flask.helpers, line:424 at site-packages\flask\helpers.py

	将文件的内容发送到客户端。
	第一个参数可以是文件路径或类文件对象。在大多数情况下，路径是首选，因为Werkzeug可以管理文件并从路径获取额外信息。
	传递一个类文件对象要求文件以二进制模式打开，并且在使用 :class:`io.BytesIO`在内存中构建文件时非常有用。
	永远不要传递用户提供的文件路径。假定该路径是可信的，因此用户可以创建一个路径来访问您不希望访问的文件。使用 :func:`send_from_directory`可以安全地从目录中提供用户请求的路径。
	如果WSGI服务器在 ``environ``中设置了 ``file_wrapper``，则使用它，否则使用Werkzeug的内置包装器。或者，如果HTTP服务器支持 ``X-Sendfile``，用 ``USE_X_SENDFILE = True``配置Flask会告诉服务器发送给定的路径，这比在Python中读取要高效得多。
	:param path_or_file: 		要发送的文件的路径，如果给出了相对路径，则相对于当前工作目录。或者，以二进制模式打开的类文件对象。确保将文件指针查找到数据的开头。
	:param mimetype: 		要为文件发送的MIME类型。如果没有提供，它将尝试从文件名检测它。
	:param as_attachment: 		向浏览器指示它应该提供保存文件而不是显示它。
	:param download_name: 		浏览器在保存文件时使用的默认名称。默认为传递的文件名。
	:param conditional: 		基于请求头启用条件响应和范围响应。要求传递文件路径和 ``environ``。
	:param etag: 		计算文件的ETag，这需要传递一个文件路径。也可以是要使用的字符串。
	:param last_modified: 		为文件发送的最后一次修改时间，以秒为单位。如果没有提供，它将尝试从文件路径中检测它。
	:param max_age: 		客户端应该缓存文件多长时间，以秒为单位。如果设置， ``Cache-Control``将为 ``public``，否则将为 ``no-cache``，以优先选择条件缓存。

	版本变更： 2.0	``download_name``替换 ``attachment_filename``参数。如果是 ``as_attachment=False``，则传递 ``Content-Disposition: inline``。
	版本变更： 2.0	``max_age``替换 ``cache_timeout``参数 ``conditional``已启用，默认情况下未设置 ``max_age``。
	版本变更： 2.0	``etag``替换 ``add_etags``参数。它可以是要使用的字符串，而不是生成一个字符串。
	版本变更： 2.0	传递继承自 :class:`~io.TextIOBase`的类文件对象将引发 :exc:`ValueError`，而不是发送空文件。
	版本变更： 2.0	将实现移至Werkzeug。这现在是一个包装器，用于传递一些特定于flask的参数。
	版本变更： 1.1	``filename``可以是一个 :class:`~os.PathLike`对象。
	版本变更： 1.1	传递 :class:`~io.BytesIO`对象支持范围请求。
	版本变更： 1.0.3	文件名用ASCII而不是Latin-1编码，以便与WSGI服务器更广泛地兼容。
	版本变更： 1.0	支持 :rfc:`2231`中指定的UTF-8文件名。
	版本变更： 0.12	不再自动从文件对象推断文件名。如果要使用自动MIME和etag支持，请通过 ``filename_or_fp``或 ``attachment_filename``传递文件名。
	版本变更： 0.12	``attachment_filename``优先于 ``filename``进行MIME检测。
	版本变更： 0.9	``cache_timeout``默认为 :meth:`Flask.get_send_file_max_age`。
	版本变更： 0.7	对类文件对象的MIME猜测和etag支持已弃用，因为它不可靠。如果可以，传递一个文件名，否则自己附加一个标签。
	版本变更： 0.5	新增 ``add_etags``、 ``cache_timeout``和 ``conditional``参数。默认行为是添加标签。
	版本变更： 0.2

🌿28 send_from_directory(directory: Union[os.PathLike, str], path: Union[os.PathLike, str], **kwargs: Any) -> ‘Response’

send_from_directory(directory: Union[os.PathLike, str], path: Union[os.PathLike, str], **kwargs: Any) -> ‘Response’, module=flask.helpers, line:552 at site-packages\flask\helpers.py

	使用 :func:`send_file`从目录内发送文件。
	代码块： python
        @app.route("/uploads/<path:name>")
        def download_file(name):
            return send_from_directory(
                app.config['UPLOAD_FOLDER'], name, as_attachment=True
            )

	这是一种从文件夹中提供文件的安全方式，例如静态文件或上传文件。使用 :func:`~werkzeug.security.safe_join`确保来自客户端的路径不会被恶意制作为指向指定目录之外的路径。
	如果最终路径没有指向现有的常规文件，则引发404 :exc:`~werkzeug.exceptions.NotFound`错误。
	:param directory: 		``path``必须位于的目录，相对于当前应用程序的根路径。
	:param path: 		要发送的文件的路径，相对于 ``directory``。
	:param kwargs: 		传递给 :func:`send_file`的参数。

	版本变更： 2.0	``path``替换 ``filename``参数。
	版本变更： 2.0	将实现移至Werkzeug。这现在是一个包装器，用于传递一些特定于flask的参数。
	版本变更： 0.5

🌿29 stream_with_context(generator_or_function: Union[Iterator[~AnyStr], Callable[…, Iterator[~AnyStr]]]) -> Iterator[~AnyStr]

stream_with_context(generator_or_function: Union[Iterator[~AnyStr], Callable[…, Iterator[~AnyStr]]]) -> Iterator[~AnyStr], module=flask.helpers, line:84 at site-packages\flask\helpers.py

	当响应在服务器上启动时，请求上下文就会消失。这样做是出于效率的考虑，并使编写糟糕的WSGI中间件不太可能遇到内存泄漏。缺点是，如果使用流响应，则生成器无法再访问请求绑定信息。
	然而，这个函数可以帮助您将上下文保存更长时间::
        from flask import stream_with_context, request, Response

        @app.route('/stream')
        def streamed_response():
            @stream_with_context
            def generate():
                yield 'Hello '
                yield request.args['name']
                yield '!'
            return Response(generate())

	或者，它也可以在特定的生成器周围使用::
        from flask import stream_with_context, request, Response

        @app.route('/stream')
        def streamed_response():
            def generate():
                yield 'Hello '
                yield request.args['name']
                yield '!'
            return Response(stream_with_context(generate()))

	版本变更： 0.9

🌿30 url_for(endpoint: str, *, _anchor: Union[str, NoneType] = None, _method: Union[str, NoneType] = None,

_scheme: Union[str, NoneType] = None, _external: Union[bool, NoneType] = None, **values: Any) -> str

url_for(endpoint: str, *, _anchor: Union[str, NoneType] = None, _method: Union[str, NoneType] = None, _scheme: Union[str, NoneType] = None,
_external: Union[bool, NoneType] = None, **values: Any) -> str, module=flask.helpers, line:212 at site-packages\flask\helpers.py

	用给定的值生成到给定端点的URL。
	这需要一个活动请求或应用程序上下文，并调用:meth: `current_app.url_for() <flask.Flask.url_for>`。有关完整文档，请参阅该方法。
	:param endpoint: 		与要生成的URL相关联的端点名称。如果以 ``.``开头，则使用当前蓝图名称(如果有的话)。
	:param _anchor: 		如果给定，将其作为 ``#anchor``附加到URL。
	:param _method: 		如果给定，则为端点生成与此方法关联的URL。
	:param _scheme: 		如果给定，则URL将具有此模式，如果它是外部的。
	:param _external: 		如果给出，希望URL是内部的(False)或要求它是外部的(True)。外部url包括方案和域。当不在活动请求中时，url默认情况下是外部的。
	:param values: 		值，用于URL规则的可变部分。未知键作为查询字符串参数追加，如 ``?a=b&c=d``。

	版本变更： 2.2	调用 ``current_app.url_for``，允许应用重写该行为。
	版本变更： 0.10	添加 ``_scheme``参数。
	版本变更： 0.9	添加 ``_anchor``和 ``_method``参数。
	版本变更： 0.9	生成错误时调用 ``app.handle_url_build_error``。

🌿31 jsonify(*args: ‘t.Any’, **kwargs: ‘t.Any’) -> ‘Response’

jsonify(*args: ‘t.Any’, **kwargs: ‘t.Any’) -> ‘Response’, module=flask.json, line:310 at site-packages\flask\json_init_.py

	将给定的参数序列化为JSON，并返回一个 ``application/json``mime类型的 :class:`~flask.Response`对象。从视图返回的字典或列表将自动转换为JSON响应，而不需要调用它。
	这需要一个活动请求或应用程序上下文，并调用:meth: `app.json.response() <flask.json.provider.JSONProvider.response>`。
	在调试模式下，输出使用缩进格式化，以使其更易于阅读。这也可以由提供商控制。
	可以给出位置参数或关键字参数，但不能同时给出两个参数。如果没有给出参数，则序列化 ``None``。
	:param args: 		要序列化的单个值，或将多个值视为要序列化的列表。
	:param kwargs: 		将其视为要序列化的字典。

	版本变更： 2.2	调用 ``current_app.json.response``，允许应用重写该行为。
	版本变更： 2.0.2	:class:`decimal.Decimal`通过转换为字符串来支持。
	版本变更： 0.11	增加了对序列化顶级数组的支持。这在古代浏览器中是一个安全风险。参见 :ref:`security-json`。
	版本变更： 0.2

🌿32 render_template(template_name_or_list: Union[str, jinja2.environment.Template, List[Union[str, jinja2.environment.Template]]], **context: Any) -> str

render_template(template_name_or_list: Union[str, jinja2.environment.Template, List[Union[str, jinja2.environment.Template]]], **context: Any) -> str,
module=flask.templating, line:135 at site-packages\flask\templating.py

	使用给定的上下文按名称呈现模板。
	:param template_name_or_list: 		要呈现的模板的名称。如果给出了列表，将呈现存在的第一个名称。
	:param context: 		要在模板中可用的变量。

🌿33 render_template_string(source: str, **context: Any) -> str

render_template_string(source: str, **context: Any) -> str, module=flask.templating, line:150 at site-packages\flask\templating.py

	用给定的上下文呈现来自给定源字符串的模板。
	:param source: 		要呈现的模板的源代码。
	:param context: 		要在模板中可用的变量。

🌿34 stream_template(template_name_or_list: Union[str, jinja2.environment.Template, List[Union[str, jinja2.environment.Template]]], **context: Any) -> Iterator[str]

stream_template(template_name_or_list: Union[str, jinja2.environment.Template, List[Union[str, jinja2.environment.Template]]], **context: Any) -> Iterator[str],
module=flask.templating, line:181 at site-packages\flask\templating.py

	这将返回一个字符串迭代器，它可以用作来自视图的流响应。
	:param template_name_or_list: 		要呈现的模板的名称。如果给出了列表，将呈现存在的第一个名称。
	:param context: 		要在模板中可用的变量。

	版本变更： 2.2

🌿35 stream_template_string(source: str, **context: Any) -> Iterator[str]

stream_template_string(source: str, **context: Any) -> Iterator[str], module=flask.templating, line:200 at site-packages\flask\templating.py

	将来自给定源字符串的模板与给定上下文作为流呈现。这将返回一个字符串迭代器，它可以用作来自视图的流响应。
	:param source: 		要呈现的模板的源代码。
	:param context: 		要在模板中可用的变量。

	版本变更： 2.2

🔵类

🌿36 markupsafe.Markup

Markup, markupsafe.Markup, module=markupsafe, line:0 at

	可以安全地插入到HTML或XML文档中的字符串，因为它已被转义或标记为安全。
	将对象传递给构造函数将其转换为文本并对其进行包装以标记为安全而不进行转义。若要转义文本，请改用 :meth:`escape`类方法。
    >>> Markup("Hello, <em>World</em>!")
    Markup('Hello, <em>World</em>!')
    >>> Markup(42)
    Markup('42')
    >>> Markup.escape("Hello, <em>World</em>!")
    Markup('Hello &lt;em>World&lt;/em>!')

	这实现了一些框架使用的 ``__html__()``接口。传递一个实现 ``__html__()``的对象将包装该方法的输出，将其标记为安全。
    >>> class Foo:
    ...     def __html__(self):
    ...         return '<a href="/foo">foo</a>'
    ...
    >>> Markup(Foo())
    Markup('<a href="/foo">foo</a>')

	这是 :class:`str`的子类。它具有相同的方法，但转义了它们的参数并返回一个 ``Markup``实例。
    >>> Markup("<em>%s</em>") % ("foo & bar",)
    Markup('<em>foo &amp; bar</em>')
    >>> Markup("<em>Hello</em> ") + "<foo>"
    Markup('<em>Hello</em> &lt;foo>')

method

1 capitalize()

kind=method class=Markup objtype=function

	返回字符串的大写版本。
	更具体地说，使第一个字符大写，其余字符小写。

2 center()

kind=method class=Markup objtype=function

	返回长度为width的居中字符串。
	填充使用指定的填充字符完成(默认是一个空格)。

3 expandtabs()

kind=method class=Markup objtype=function

	返回一个副本，其中所有制表符都使用空格展开。
	如果没有给出tabsize，则假设tabsize为8个字符。

4 format()

kind=method class=Markup objtype=function

5 join()

kind=method class=Markup objtype=function

	连接任意数量的字符串。
	。
	例如:“。”。Join (['ab'， 'pq'， 'rs']) -> 'ab.pq.rs'。

6 ljust()

kind=method class=Markup objtype=function

	返回长度为width的左对齐字符串。
	填充使用指定的填充字符完成(默认是一个空格)。

7 lower()

kind=method class=Markup objtype=function

	返回转换为小写的字符串副本。

8 lstrip()

kind=method class=Markup objtype=function

	返回删除前导空格的字符串副本。
	如果给出了chars而不是None，则删除chars中的字符。

9 partition()

kind=method class=Markup objtype=function

10 replace()

kind=method class=Markup objtype=function

	返回一个副本，其中所有出现的子字符串old都被new替换。
	count替换的最大出现次数-1(默认值)表示替换所有的出现次数。
	如果给出了可选参数count，则只替换第一个count出现。

11 rjust()

kind=method class=Markup objtype=function

	返回长度为width的右对齐字符串。
	填充使用指定的填充字符完成(默认是一个空格)。

12 rpartition()

kind=method class=Markup objtype=function

13 rsplit()

kind=method class=Markup objtype=function

	返回字符串中单词的列表，使用sep作为分隔符字符串。
	sep分割字符串的分隔符None(默认值)表示根据任何空格进行分割，并从结果中丢弃空字符串maxsplit进行分割的最大次数-1(默认值)表示没有限制。
	分割是从字符串的末尾开始，一直到前面。

14 rstrip()

kind=method class=Markup objtype=function

	返回字符串的副本，删除末尾的空格。
	如果给出了chars而不是None，则删除chars中的字符。

15 split()

kind=method class=Markup objtype=function

	返回字符串中单词的列表，使用sep作为分隔符字符串。
	sep分割字符串的分隔符None(默认值)表示根据任何空格进行分割，并从结果中丢弃空字符串maxsplit进行分割的最大次数-1(默认值)表示没有限制。

16 splitlines()

kind=method class=Markup objtype=function

	返回字符串中的行列表，在行边界处中断。
	换行符不包括在结果列表中，除非给出了keepends并且为真。

17 strip()

kind=method class=Markup objtype=function

	返回字符串的副本，去掉前导和尾部的空白。
	如果给出了chars而不是None，则删除chars中的字符。

18 striptags()

kind=method class=Markup objtype=function

	:meth:`unescape`标记，删除标记，并将空白规范化为单个空格。
        >>> Markup("Main &raquo;	<em>About</em>").striptags()
        'Main » About'

19 swapcase()

kind=method class=Markup objtype=function

	将大写字符转换为小写字符，小写字符转换为大写字符。

20 title()

kind=method class=Markup objtype=function

	返回字符串的一个版本，其中每个单词都加了标题。
	更具体地说，单词以大写字符开头，其余所有大小写字符都是小写。

21 translate()

kind=method class=Markup objtype=function

	使用给定的翻译表替换字符串中的每个字符。
	table转换表，它必须是Unicode序数到Unicode序数、字符串或None的映射。
	表必须通过getiitem实现查找/索引，例如字典或列表。如果此操作引发LookupError，则保持字符不变。映射到None的字符将被删除。

22 unescape()

kind=method class=Markup objtype=function

	将转义的标记转换回文本字符串。这将用它们所表示的字符替换HTML实体。
        >>> Markup("Main &raquo; <em>About</em>").unescape()
        'Main » <em>About</em>'

23 upper()

kind=method class=Markup objtype=function

	返回转换为大写的字符串副本。

24 zfill()

kind=method class=Markup objtype=function

	在左边填充一个带零的数字字符串，以填充给定宽度的字段。
	该字符串永远不会被截断。

class method

25 escape()

kind=class method class=Markup objtype=classmethod

classmethod(function) -> method

	将函数转换为类方法。
	类方法接收类作为隐式的第一个参数，就像实例方法接收实例一样。要声明一个类方法，使用这种习惯用法:
  class C:
      @classmethod
      def f(cls, arg1, arg2, ...):
          ...

	它可以在类(例如C.f())上调用，也可以在实例(例如C().f())上调用。如果为派生类调用类方法，则将派生类对象作为隐含的第一个参数传递。
	类方法不同于c++或Java的静态方法。如果您需要这些方法，请参阅内置的staticmethod。

🌿37 flask.app.Flask

Flask, flask.app.Flask, module=flask.app, line:110 at site-packages\flask\app.py

	flask对象实现了一个WSGI应用程序，并充当中心对象。它被传递给应用程序的模块或包的名称。一旦创建完成，它将作为视图函数、URL规则、模板配置等的中心注册中心。
	包的名称用于从包或包含模块的文件夹中解析资源，具体取决于包参数是解析为实际的python包(包含 :file:`__init__.py`文件的文件夹)还是标准模块(仅包含 ``.py``文件)。
	有关资源加载的详细信息，请参见 :func:`open_resource`。
	通常你在主模块或包的 :file:`__init__.py`文件中创建一个 :class:`Flask`实例，如下所示::
        from flask import Flask
        app = Flask(__name__)

	警告： About the First Parameter
	第一个参数的目的是让Flask了解什么属于您的应用程序。这个名称用于查找文件系统上的资源，扩展可以使用它来改进调试信息等等。
	所以你在那里提供什么很重要。如果使用单个模块， `__name__`始终是正确的值。但是，如果您正在使用一个包，通常建议在那里硬编码您的包的名称。
	例如，如果你的应用程序是在 :file:`yourapplication/app.py`中定义的，你应该使用下面两个版本之一来创建它::
            app = Flask('yourapplication')
            app = Flask(__name__.split('.')[0])

	为什么呢?由于资源的查找方式，应用程序甚至可以使用 `__name__`。然而，这将使调试更加痛苦。某些扩展可以根据应用程序的导入名称做出假设。
	例如，Flask-SQLAlchemy扩展将在调试模式下查找应用程序中触发SQL查询的代码。如果没有正确设置导入名称，则该调试信息将丢失。
	(例如，它只会选择 `yourapplication.app`而不是 `yourapplication.views.frontend`中的SQL查询)。
	版本变更： 0.7	新增 `static_url_path`、 `static_folder`和 `template_folder`参数。
	版本变更： 0.8	添加 `instance_path`和 `instance_relative_config`参数。
	版本变更： 0.11	添加 `root_path`参数。
	版本变更： 1.0	添加 ``host_matching``和 ``static_host``参数。
	版本变更： 1.0	添加 ``subdomain_matching``参数。现在需要手动启用子域匹配。设置 :data:`SERVER_NAME`不会隐式启用它。
	:param import_name: 		应用程序包的名称。
	:param static_url_path: 		可用于为web上的静态文件指定不同的路径。默认为 `static_folder`文件夹的名称。
	:param static_folder: 		包含在 ``static_url_path``处提供的静态文件的文件夹。相对于应用程序 ``root_path``或绝对路径。默认为 ``'static'``。
	:param static_host: 		添加静态路由时使用的主机。默认为None。使用 ``host_matching=True``并配置 ``static_folder``时必需。
	:param host_matching: 		设置 ``url_map.host_matching``属性。默认为False。
	:param subdomain_matching: 		匹配路由时考虑相对于 :data:`SERVER_NAME`的子域。默认为False。
	:param template_folder: 		包含应用程序应使用的模板的文件夹。默认为应用程序根路径中的 ``'templates'``文件夹。
	:param instance_path: 		应用程序的可选实例路径。默认情况下，包或模块旁边的文件夹 ``'instance'``被认为是实例路径。
	:param instance_relative_config: 		如果设置为 ``True``，则假定加载配置的相对文件名相对于实例路径而不是应用程序根。
	:param root_path: 		应用程序文件根目录的路径。只有在无法自动检测时才应该手动设置，比如对于命名空间包。

data

1 aborter_class=<class ‘werkzeug.exceptions.Aborter’> kind:data type:type class:<class ‘flask.app.Flask’>
2 app_ctx_globals_class=<class ‘flask.ctx._AppCtxGlobals’> kind:data type:type class:<class ‘flask.app.Flask’>
3 config_class=<class ‘flask.config.Config’> kind:data type:type class:<class ‘flask.app.Flask’>
4 default_config=ImmutableDict({‘ENV’: None, ‘DEBUG’: None, ‘TESTING’: False, ‘PROPAGATE_EXCEPTIONS’: None, ‘SECRET_KEY’: None, ‘PERMANENT_SESSION_LIFETIME’: datetime.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’: None, ‘TRAP_BAD_REQUEST_ERRORS’: None, ‘TRAP_HTTP_EXCEPTIONS’: False, ‘EXPLAIN_TEMPLATE_LOADING’: False, ‘PREFERRED_URL_SCHEME’: ‘http’,
‘JSON_AS_ASCII’: None, ‘JSON_SORT_KEYS’: None, ‘JSONIFY_PRETTYPRINT_REGULAR’: None, ‘JSONIFY_MIMETYPE’: None, ‘TEMPLATES_AUTO_RELOAD’: None,
‘MAX_COOKIE_SIZE’: 4093}) kind:data type:ImmutableDict class:<class ‘flask.app.Flask’>
5 jinja_environment=<class ‘flask.templating.Environment’> kind:data type:type class:<class ‘flask.app.Flask’>
6 jinja_options={} kind:data type:dict class:<class ‘flask.app.Flask’>
7 json_provider_class=<class ‘flask.json.provider.DefaultJSONProvider’> kind:data type:type class:<class ‘flask.app.Flask’>
8 permanent_session_lifetime=<flask.config.ConfigAttribute object at 0x00000210C1EF3EC8> kind:data type:ConfigAttribute class:<class ‘flask.app.Flask’>
9 request_class=<class ‘flask.wrappers.Request’> kind:data type:type class:<class ‘flask.app.Flask’>
10 response_class=<class ‘flask.wrappers.Response’> kind:data type:type class:<class ‘flask.app.Flask’>
11 secret_key=<flask.config.ConfigAttribute object at 0x00000210C1EC3788> kind:data type:ConfigAttribute class:<class ‘flask.app.Flask’>
12 session_interface=<flask.sessions.SecureCookieSessionInterface object at 0x00000210C1F01788> kind:data type:SecureCookieSessionInterface class:<class ‘flask.app.Flask’>
13 test_cli_runner_class=None kind:data type:NoneType class:<class ‘flask.app.Flask’>
14 test_client_class=None kind:data type:NoneType class:<class ‘flask.app.Flask’>
15 testing=<flask.config.ConfigAttribute object at 0x00000210C1DB9308> kind:data type:ConfigAttribute class:<class ‘flask.app.Flask’>
16 url_map_class=<class ‘werkzeug.routing.map.Map’> kind:data type:type class:<class ‘flask.app.Flask’>
17 url_rule_class=<class ‘werkzeug.routing.rules.Rule’> kind:data type:type class:<class ‘flask.app.Flask’>

property

18 debug=<property object at 0x00000210C1F03DB8> kind:property type:property class:<class ‘flask.app.Flask’>
19 env=<property object at 0x00000210C1F03CC8> kind:property type:property class:<class ‘flask.app.Flask’>
20 got_first_request=<property object at 0x00000210C1F037C8> kind:property type:property class:<class ‘flask.app.Flask’>
21 jinja_env=<flask.helpers.locked_cached_property object at 0x00000210C1EEC888> kind:property type:locked_cached_property class:<class ‘flask.app.Flask’>
22 json_decoder=<property object at 0x00000210C1F03228> kind:property type:property class:<class ‘flask.app.Flask’>
23 json_encoder=<property object at 0x00000210C1F03138> kind:property type:property class:<class ‘flask.app.Flask’>
24 logger=<flask.helpers.locked_cached_property object at 0x00000210C1EEC828> kind:property type:locked_cached_property class:<class ‘flask.app.Flask’>
25 name=<flask.helpers.locked_cached_property object at 0x00000210C1EEC7C8> kind:property type:locked_cached_property class:<class ‘flask.app.Flask’>
26 propagate_exceptions=<property object at 0x00000210C1F03318> kind:property type:property class:<class ‘flask.app.Flask’>
27 send_file_max_age_default=<property object at 0x00000210C1EFFEF8> kind:property type:property class:<class ‘flask.app.Flask’>
28 session_cookie_name=<property object at 0x00000210C1EFFCC8> kind:property type:property class:<class ‘flask.app.Flask’>
29 templates_auto_reload=<property object at 0x00000210C1F03A48> kind:property type:property class:<class ‘flask.app.Flask’>
30 use_x_sendfile=<property object at 0x00000210C1F03048> kind:property type:property class:<class ‘flask.app.Flask’>

method

31 add_template_filter(

kind=method class=Flask objtype=function line:1390 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	注册一个自定义模板过滤器。与 :meth:`template_filter`装饰器完全相同。
	:param name: 		过滤器的可选名称，否则将使用函数名。

32 add_template_global(

kind=method class=Flask objtype=function line:1469 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	注册一个自定义模板全局函数。与 :meth:`template_global`装饰器完全相同。
	版本变更： 0.10
	:param name: 		全局函数的可选名称，否则将使用函数名。

33 add_template_test(

kind=method class=Flask objtype=function line:1431 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	注册一个自定义模板测试。与 :meth:`template_test`装饰器完全相同。
	版本变更： 0.10
	:param name: 		测试例的可选名称，否则将使用函数名。

34 add_url_rule(

kind=method class=Flask objtype=function line:1309 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

35 app_context(self) -> AppContext:

kind=method class=Flask objtype=function line:2405 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	创建一个 :class:`~flask.ctx.AppContext`。作为 ``with``块来推送上下文，这将使 :data:`current_app`指向此应用程序。
	当处理请求和运行CLI命令时，应用程序上下文由:meth: `RequestContext.push() <flask.ctx.RequestContext.push>`自动推送。使用它可以在这些情况之外手动创建上下文。
	
	使用app.app context(): init db()。
	参见 :doc:`/appcontext`。
	版本变更： 0.9

36 async_to_sync(

kind=method class=Flask objtype=function line:1894 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	返回将运行协程函数的同步函数。
	代码块： python
            result = app.async_to_sync(func)(*args, **kwargs)

	重写此方法以更改应用程序将异步代码转换为可同步调用的方式。
	版本变更： 2.0

37 auto_find_instance_path(self) -> str:

kind=method class=Flask objtype=function line:846 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	如果没有提供给应用程序类的构造函数，则尝试定位实例路径。它基本上会计算主文件或包旁边一个名为 ``instance``的文件夹的路径。
	版本变更： 0.8

38 before_first_request(self, f: T_before_first_request) -> T_before_first_request:

kind=method class=Flask objtype=function line:1483 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	注册要在向应用程序的此实例发出第一个请求之前运行的函数。
	该函数将在不带任何参数的情况下被调用，其返回值将被忽略。
	弃用： 2.2	将在Flask 2.3中删除。而是在创建应用程序时运行安装代码。
	版本变更： 0.8

39 create_global_jinja_loader(self) -> DispatchingJinjaLoader:

kind=method class=Flask objtype=function line:947 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	为Jinja2环境创建加载器。可以用来覆盖加载器，保持其余部分不变。不建议重写这个函数。相反，应该重写 :meth:`jinja_loader`函数。
	全局加载器在应用程序的加载器和各个蓝图之间进行分派。
	版本变更： 0.7

40 create_jinja_environment(self) -> Environment:

kind=method class=Flask objtype=function line:907 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	基于 :attr:`jinja_options`和应用程序中各种与Jinja相关的方法创建Jinja环境。在此之后更改 :attr:`jinja_options`将不会产生任何影响。还将flask相关的全局变量和过滤器添加到环境中。
	版本变更： 0.11	``Environment.auto_reload``根据 ``TEMPLATES_AUTO_RELOAD``配置选项设置。
	版本变更： 0.5

41 create_url_adapter(

kind=method class=Flask objtype=function line:2195 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	为给定请求创建URL适配器。URL适配器是在请求上下文尚未设置的地方创建的，因此请求是显式传递的。
	版本变更： 0.6
	版本变更： 0.9	当为应用程序上下文创建URL适配器时，现在也可以在没有请求对象的情况下调用它。
	版本变更： 1.0	:data:`SERVER_NAME`不再隐式启用子域匹配。使用 :attr:`subdomain_matching`代替。

42 dispatch_request(self) -> ft.ResponseReturnValue:

kind=method class=Flask objtype=function line:1776 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	执行请求调度。匹配URL并返回视图或错误处理程序的返回值。这不一定是响应对象。要将返回值转换为适当的响应对象，请调用 :func:`make_response`。
	版本变更： 0.7	这不再进行异常处理，此代码被移动到新的 :meth:`full_dispatch_request`。

43 do_teardown_appcontext(

kind=method class=Flask objtype=function line:2380 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	在应用程序上下文弹出之前调用。
	在处理请求时，应用程序上下文在请求上下文之后弹出。参见 :meth:`do_teardown_request`。
	这将调用所有以 :meth:`teardown_appcontext`装饰的函数。然后发送 :data:`appcontext_tearing_down`信号。
	调用方法:meth: `AppContext.pop() <flask.ctx.AppContext.pop>`。
	版本变更： 0.9

44 do_teardown_request(

kind=method class=Flask objtype=function line:2347 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	在请求被分派并返回响应之后调用，就在弹出请求上下文之前。
	这将调用所有以 :meth:`teardown_request`装饰的函数，如果蓝图处理了请求，则调用 :meth:`Blueprint.teardown_request`装饰的函数。最后，发送 :data:`request_tearing_down`信号。
	它由:meth: `RequestContext.pop() <flask.ctx.RequestContext.pop>`调用，在测试期间可能会延迟调用以保持对资源的访问。
	:param exc: 		在调度请求时引发的未处理异常。如果未传递，则从当前异常信息中检测到。传递给每个拆卸函数。

	版本变更： 0.9	增加了 ``exc``参数。

45 ensure_sync(self, func: t.Callable) -> t.Callable:

kind=method class=Flask objtype=function line:1880 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	确保函数对WSGI worker是同步的。Plain ``def``函数按原样返回。 ``async def``函数被包装以运行并等待响应。
	重写此方法以更改应用程序运行异步视图的方式。
	版本变更： 2.0

46 finalize_request(

kind=method class=Flask objtype=function line:1828 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	给定视图函数的返回值，这将通过将请求转换为响应并调用后处理函数来完成请求。对于普通请求调度和错误处理程序都调用此方法。
	因为这意味着它可能会因故障而被调用，所以可以使用 `from_error_handler`标志启用特殊的安全模式。如果启用，响应处理中的失败将被记录，否则将被忽略。
	。

47 full_dispatch_request(self) -> Response:

kind=method class=Flask objtype=function line:1801 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	调度请求，并在此基础上执行请求预处理和后处理，以及HTTP异常捕获和错误处理。
	版本变更： 0.7

48 handle_exception(self, e: Exception) -> Response:

kind=method class=Flask objtype=function line:1678 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	处理没有与之关联的错误处理程序或从错误处理程序引发的异常。这总是导致500  ``InternalServerError``。
	总是发送 :data:`got_request_exception`信号。
	如果 :attr:`propagate_exceptions`为 ``True``，例如在调试模式下，错误将被重新引发，以便调试器可以显示它。否则，将记录原始异常，并返回 :exc:`~werkzeug.exceptions.InternalServerError`。
	如果为 ``InternalServerError``或 ``500``注册了错误处理程序，则将使用它。为了保持一致性，处理程序将始终接收 ``InternalServerError``。原始的未处理异常为 ``e.original_exception``。
	版本变更： 1.1.0	始终将 ``InternalServerError``实例传递给处理程序，将 ``original_exception``设置为未处理的错误。
	版本变更： 1.1.0	``after_request``函数和其他最终化即使在没有处理程序的情况下也会为默认的500响应完成。
	版本变更： 0.3

49 handle_http_exception(

kind=method class=Flask objtype=function line:1576 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	处理HTTP异常。默认情况下，这将调用已注册的错误处理程序，并返回异常作为响应。
	版本变更： 1.0.3	``RoutingException``在内部用于路由期间的斜杠重定向等操作，不会传递给错误处理程序。
	版本变更： 1.0	异常由代码*和MRO *查找，因此 ``HTTPException``子类可以使用基 ``HTTPException``的全捕获处理程序来处理。
	版本变更： 0.3

50 handle_url_build_error(

kind=method class=Flask objtype=function line:2258 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	如果引发 :exc:`~werkzeug.routing.BuildError`，则由 :meth:`.url_for`调用。如果这返回一个值，它将由 ``url_for``返回，否则将重新引发错误。
	:attr:`url_build_error_handlers`中的每个函数都用 ``error``、 ``endpoint``和 ``values``调用。如果函数返回 ``None``或引发 ``BuildError``，则跳过它。否则，它的返回值由 ``url_for``返回。
	:param error: 		正在处理的活动 ``BuildError``。
	:param endpoint: 		正在构建的端点。
	:param values: 		传递给 ``url_for``的关键字参数。

51 handle_user_exception(

kind=method class=Flask objtype=function line:1646 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	每当发生应该处理的异常时，就调用此方法。一个特殊的例子是:class:`~werkzeug .exceptions。HTTPException’，它被转发给 :meth:`handle_http_exception`方法。这个函数要么返回一个响应值，要么用相同的回溯方法重新引发异常。
	版本变更： 1.0	从请求数据(如 ``form``)引发的键错误显示调试模式下的坏键，而不是一般的错误请求消息。
	版本变更： 0.7

52 inject_url_defaults(self, endpoint: str, values: dict) -> None:

kind=method class=Flask objtype=function line:2237 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	将给定端点的URL默认值直接注入传递的值字典中。这在内部使用，并在URL构建时自动调用。
	版本变更： 0.7

53 iter_blueprints(self) -> t.ValuesView[“Blueprint”]:

kind=method class=Flask objtype=function line:1301 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	按照注册的顺序遍历所有蓝图。
	版本变更： 0.11

54 log_exception(

kind=method class=Flask objtype=function line:1731 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	记录异常。如果在调用处理程序之前禁用调试，则由 :meth:`handle_exception`调用。默认实现将异常记录为 :attr:`logger`上的错误。
	版本变更： 0.8

55 make_aborter(self) -> Aborter:

kind=method class=Flask objtype=function line:834 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	创建要分配给 :attr:`aborter`的对象。该对象由 :func:`flask.abort`调用以引发HTTP错误，也可以直接调用。
	默认情况下，这会创建一个 :attr:`aborter_class`的实例，该实例默认为 :class:`werkzeug.exceptions.Aborter`。
	版本变更： 2.2

56 make_config(self, instance_relative: bool = False) -> Config:

kind=method class=Flask objtype=function line:817 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	`instance_relative`参数从Flask的构造函数(命名为 `instance_relative_config`)传入，并指示该配置应该相对于应用程序的实例路径还是根路径。
	版本变更： 0.8

57 make_default_options_response(self) -> Response:

kind=method class=Flask objtype=function line:1857 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	调用此方法来创建默认的 ``OPTIONS``响应。可以通过子类化来更改 ``OPTIONS``响应的默认行为。
	版本变更： 0.7

58 make_response(self, rv: ft.ResponseReturnValue) -> Response:

kind=method class=Flask objtype=function line:2055 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	将视图函数的返回值转换为 :attr:`response_class`的实例。
	:param rv: 		视图函数的返回值。视图函数必须返回一个响应。不允许返回 ``None``，或者视图不返回而结束。 ``view_rv``允许使用以下类型:

	``str``以编码为UTF-8的字符串作为主体创建响应对象。
	``bytes``以字节为主体创建响应对象。
	``dict``在返回之前将被json化的字典。
	``list``在返回之前将被json化的列表。
	``generator``或 ``iterator``返回 ``str``或 ``bytes``作为响应流的生成器。
	``tuple`` ``(body, status, headers)``， ``(body, status)``或 ``(body, headers)``，其中 ``body``是这里允许的任何其他类型， 
	``status``是字符串或整数， 
	``headers``是一个字典或 ``(key, value)``元组列表。
	如果 ``body``是 :attr:`response_class`实例，则 ``status``覆盖现有值，并扩展 ``headers``。
	:attr:`response_class`返回对象不变。
	其他 :class:`~werkzeug.wrappers.Response`类对象被强制为 :attr:`response_class`。
	:func:`callable`该函数作为WSGI应用程序调用。结果用于创建响应对象。
	版本变更： 2.2	生成器将被转换为流响应，列表将被转换为JSON响应。
	版本变更： 1.1	字典将被转换为JSON响应。
	版本变更： 0.9	以前，元组被解释为响应对象的参数。

59 make_shell_context(self) -> dict:

kind=method class=Flask objtype=function line:1001 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	返回此应用程序的交互式shell的shell上下文。这将运行所有已注册的shell上下文处理器。
	版本变更： 0.11

60 open_instance_resource(self, resource: str, mode: str = “rb”) -> t.IO[t.AnyStr]:

kind=method class=Flask objtype=function line:859 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	从应用程序的实例文件夹( :attr:`instance_path`)打开资源。其他类似于 :meth:`open_resource`。实例资源也可以为写入打开。
	:param resource: 		资源的名称。要访问子文件夹中的资源，请使用正斜杠作为分隔符。
	:param mode: 		资源文件打开模式，默认为'rb'。

61 preprocess_request(self) -> t.Optional[ft.ResponseReturnValue]:

kind=method class=Flask objtype=function line:2292 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	在请求被分派之前调用。调用在应用程序和当前蓝图(如果有)中注册的 :attr:`url_value_preprocessors`。然后调用在应用和蓝图中注册的 :attr:`before_request_funcs`。
	如果任何 :meth:`before_request`处理程序返回非none值，则将该值作为视图的返回值进行处理，并停止进一步的请求处理。

62 process_response(self, response: Response) -> Response:

kind=method class=Flask objtype=function line:2319 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	可以重写，以便在响应对象发送到WSGI服务器之前修改它。默认情况下，这将调用所有 :meth:`after_request`装饰函数。
	版本变更： 0.5	从Flask 0.5开始，在请求执行后注册的函数以注册的相反顺序调用。
	:param response: 		一个 :attr:`response_class`对象。
	:return: 		新的响应对象或相同的响应对象必须是 :attr:`response_class`的实例。

63 raise_routing_exception(self, request: Request) -> “te.NoReturn”:

kind=method class=Flask objtype=function line:1748 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	拦截路由异常，并可能执行其他操作。
	在调试模式下，拦截路由重定向，如果主体将被丢弃，则将其替换为错误。
	在现代的Werkzeug中，这种情况不应该发生，因为它现在使用308状态来告诉浏览器重新发送方法和主体。
	版本变更： 2.1	不要拦截307和308重定向。
	:meta private::internal:

64 redirect(self, location: str, code: int = 302) -> BaseResponse:

kind=method class=Flask objtype=function line:2041 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	创建一个重定向响应对象。
	它由 :func:`flask.redirect`调用，也可以直接调用。
	:param location: 		要重定向到的URL。
	:param code: 		重定向的状态码。

	版本变更： 2.2	从 ``flask.redirect``移来，它调用此方法。

65 register_blueprint(self, blueprint: “Blueprint”, **options: t.Any) -> None:

kind=method class=Flask objtype=function line:1274 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	在应用程序上注册一个 :class:`~flask.Blueprint`。传递给此方法的关键字参数将覆盖蓝图上设置的默认值。
	在应用程序的 :attr:`blueprints`中记录蓝图后，调用蓝图的 :meth:`~flask.Blueprint.register`方法。
	:param blueprint: 		蓝图注册。
	:param url_prefix: 		蓝图路由将以this作为前缀。
	:param subdomain: 		蓝图路由将在此子域上匹配。
	:param url_defaults: 		Blueprint路由将使用这些默认值作为视图参数。
	:param options: 		其他关键字参数传递给 :class:`~flask.blueprints.BlueprintSetupState`。它们可以在 :meth:`~flask.Blueprint.record`回调中访问。

	版本变更： 2.0.1	``name``选项可用于更改蓝图注册的名称(前置点)。这允许同一个蓝图以唯一的名称 ``url_for``被注册多次。
	版本变更： 0.7

66 request_context(self, environ: dict) -> RequestContext:

kind=method class=Flask objtype=function line:2426 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	创建一个代表WSGI环境的 :class:`~flask.ctx.RequestContext`。使用 ``with``块来推送上下文，这将使 :data:`request`指向此请求。
	参见 :doc:`/reqcontext`。
	通常不应该从自己的代码中调用它。在处理请求时，请求上下文由 :meth:`wsgi_app`自动推送。使用 :meth:`test_request_context`来创建环境和上下文，而不是此方法。
	:param environ: 		WSGI环境。

67 run(

kind=method class=Flask objtype=function line:1067 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	在本地开发服务器上运行应用程序。
	不要在生产设置中使用 ``run()``。它不打算满足生产服务器的安全和性能要求，相反，请参阅 :doc:`/deploying/index`获取WSGI服务器建议。
	如果设置了 :attr:`debug`标志，服务器将自动重新加载代码更改，并在发生异常时显示调试器。
	如果要在调试模式下运行应用程序，但在交互式调试器上禁用代码执行，则可以将 ``use_evalex=False``作为参数传递。这将使调试器的回溯屏幕保持活动状态，但禁用代码执行。
	不建议将此函数用于自动重新加载的开发，因为它不支持。相反，您应该使用 :command:`flask`命令行脚本的 ``run``支持。
	警告： Keep in Mind
	除非处于调试模式，否则Flask会用通用错误页面来抑制任何服务器错误。因此，为了只启用交互式调试器而不重新加载代码，
	您必须使用 ``debug=True``和 ``use_reloader=False``调用 :meth:`run`，将 ``use_debugger``设置为 ``True``而不处于调试模式将不会捕获任何异常，因为不会捕获任何异常。
	:param host: 		要监听的主机名。将其设置为 ``'0.0.0.0'``以使服务器也可以从外部使用。默认为 ``'127.0.0.1'``或 ``SERVER_NAME``配置变量中的主机(如果存在)。
	:param port: 		web服务器的端口。默认为 ``5000``或在 ``SERVER_NAME``配置变量中定义的端口(如果存在)。
	:param debug: 		如果给出，启用或禁用调试模式。 :attr:`debug`。
	:param load_dotenv: 		加载最近的 :file:`.env`和 :file:`.flaskenv`文件来设置环境变量。还将工作目录更改为包含找到的第一个文件的目录。
	:param options: 		要转发到底层Werkzeug服务器的选项。有关详细信息，请参见 :func:`werkzeug.serving.run_simple`。

	版本变更： 1.0	如果安装了，python-dotenv将用于从 :file:`.env`和 :file:`.flaskenv`文件中加载环境变量。
	:envvar:`FLASK_DEBUG`环境变量将覆盖 :attr:`debug`。
	默认情况下，线程模式是启用的。
	版本变更： 0.10	现在从 ``SERVER_NAME``变量中选择默认端口。

68 select_jinja_autoescape(self, filename: str) -> bool:

kind=method class=Flask objtype=function line:960 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	如果自动转义应该为给定模板名激活，则返回 ``True``。如果没有给出模板名，则返回 `True`。
	版本变更： 2.2	现在默认情况下为 ``.svg``文件启用自动转义。
	版本变更： 0.5

69 shell_context_processor(

kind=method class=Flask objtype=function line:1543 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	注册一个shell上下文处理器函数。
	版本变更： 0.11

70 should_ignore_error(self, error: t.Optional[BaseException]) -> bool:

kind=method class=Flask objtype=function line:1870 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	调用这个函数是为了确定一个错误是否应该被忽略，就拆卸系统而言。如果此函数返回 ``True``，则不会将错误传递给teardown处理程序。
	版本变更： 0.10

71 teardown_appcontext(self, f: T_teardown) -> T_teardown:

kind=method class=Flask objtype=function line:1509 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	注册一个函数，以便在弹出应用程序上下文时调用。应用程序上下文通常在每个请求的请求上下文之后、CLI命令结束时或手动推送上下文结束后弹出。
	代码块： python
	使用app.app context():…。
	当 ``with``块退出(或调用 ``ctx.pop()``)时，在应用上下文处于非活动状态之前调用teardown函数。由于请求上下文通常也管理应用程序上下文，因此在弹出请求上下文时也会调用它。
	当由于未处理的异常而调用teardown函数时，它将被传递一个错误对象。如果注册了 :meth:`errorhandler`，它将处理异常，而teardown将不会接收到异常。
	拆解函数必须避免引发异常。如果它们执行可能失败的代码，它们必须用 ``try``/ ``except``块包围该代码并记录任何错误。
	拆除函数的返回值将被忽略。
	版本变更： 0.9

72 template_filter(

kind=method class=Flask objtype=function line:1368 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	一个用于注册自定义模板过滤器的装饰器。你可以为过滤器指定一个名称，否则将使用函数名。例如::
          @app.template_filter()
          def reverse(s):
              return s[::-1]

	:param name: 		过滤器的可选名称，否则将使用函数名。

73 template_global(

kind=method class=Flask objtype=function line:1445 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	一个用于注册自定义模板全局函数的装饰器。你可以为全局函数指定一个名称，否则将使用函数名。例如::
            @app.template_global()
            def double(n):
                return 2 * n

	版本变更： 0.10
	:param name: 		全局函数的可选名称，否则将使用函数名。

74 template_test(

kind=method class=Flask objtype=function line:1402 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	你可以为测试指定一个名称，否则将使用函数名。例如::
          @app.template_test()
          def is_prime(n):
              if n == 2:
                  return True
              for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
                  if n % i == 0:
                      return False
              return True

	版本变更： 0.10
	:param name: 		测试例的可选名称，否则将使用函数名。

75 test_cli_runner(self, **kwargs: t.Any) -> “FlaskCliRunner”:

kind=method class=Flask objtype=function line:1256 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	创建用于测试CLI命令的CLI运行器请参见 :ref:`testing-cli`。
	返回 :attr:`test_cli_runner_class`的实例，默认为 :class:`~flask.testing.FlaskCliRunner`。Flask应用对象作为第一个参数传递。
	版本变更： 1.0

76 test_client(self, use_cookies: bool = True, **kwargs: t.Any) -> “FlaskClient”:

kind=method class=Flask objtype=function line:1198 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	为此应用程序创建一个测试客户端。有关单元测试的信息，请转到 :doc:`/testing`。
	注意，如果要测试应用程序代码中的断言或异常，则必须设置 ``app.testing = True``，以便将异常传播到测试客户端。
	否则，异常将由应用程序处理(对测试客户端不可见)，AssertionError或其他异常的唯一指示将是对测试客户端的500状态码响应。
	参见 :attr:`testing`属性。例如::
            app.testing = True
            client = app.test_client()

	测试客户端可以在 ``with``块中使用，以延迟上下文的关闭，直到 ``with``块结束。如果你想要访问上下文局部变量进行测试，这是很有用的::
	使用app.test client()作为c: rv = c.get('/?vodka=42')断言请求。Args ['vodka'] = '42'。
	另外，你可以传递可选的关键字参数，这些参数将被传递给应用程序的 :attr:`test_client_class`构造函数，例如::
	从烧瓶。导入FlaskClient。
            class CustomClient(FlaskClient):
                def __init__(self, *args, **kwargs):
                    self._authentication = kwargs.pop("authentication")
                    super(CustomClient,self).__init__( *args, **kwargs)

            app.test_client_class = CustomClient
            client = app.test_client(authentication='Basic ....')

	有关详细信息，请参见 :class:`~flask.testing.FlaskClient`。
	版本变更： 0.4	增加了对客户端 ``with``块使用的支持。
	版本变更： 0.7	添加了 `use_cookies`参数以及通过设置 :attr:`test_client_class`属性来覆盖要使用的客户端的能力。
	版本变更： 0.11	增加了 `**kwargs`以支持向 :attr:`test_client_class`的构造函数传递额外的关键字参数。

77 test_request_context(self, *args: t.Any, **kwargs: t.Any) -> RequestContext:

kind=method class=Flask objtype=function line:2442 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	为从给定值创建的WSGI环境创建一个 :class:`~flask.ctx.RequestContext`。这在测试期间非常有用，因为您可能希望运行一个使用请求数据而不调度完整请求的函数。
	参见 :doc:`/reqcontext`。
	使用 ``with``块来推送上下文，这将使 :data:`request`指向对所创建环境的请求。：:
	使用测试请求上下文(…):生成报告()。
	在使用shell时，手动推送和弹出上下文以避免缩进可能更容易。：:
            ctx = app.test_request_context(...)
            ctx.push()
            ...
            ctx.pop()

	接受与Werkzeug的 :class:`~werkzeug.test.EnvironBuilder`相同的参数，并使用应用程序的一些默认值。请参阅链接的Werkzeug文档，了解大多数可用的参数。这里列出了特定于烧瓶的行为。
	:param path: 		正在请求的URL路径。
	:param base_url: 		正在服务应用程序的基础URL， ``path``是相对于它的。如果没有给出，则从 :data:`PREFERRED_URL_SCHEME`， ``subdomain``， :data:`SERVER_NAME`和 :data:`APPLICATION_ROOT`构建。
	:param subdomain: 		要附加到 :data:`SERVER_NAME`的子域名。
	:param url_scheme: 		替代 :data:`PREFERRED_URL_SCHEME`使用的模式。
	:param data: 		请求体，可以是字符串，也可以是表单键和值的字典。
	:param json: 		如果给定，它将被序列化为JSON并作为 ``data``传递。默认 ``content_type``为 ``application/json``。
	:param args: 		传递给 :class:`~werkzeug.test.EnvironBuilder`的其他位置参数。
	:param kwargs: 		传递给 :class:`~werkzeug.test.EnvironBuilder`的其他关键字参数。

78 trap_http_exception(self, e: Exception) -> bool:

kind=method class=Flask objtype=function line:1611 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	检查HTTP异常是否应该被捕获。默认情况下，如果 ``TRAP_BAD_REQUEST_ERRORS``设置为 ``True``，则除了错误的请求键错误外，所有异常都将返回 ``False``。如果 ``TRAP_HTTP_EXCEPTIONS``被设置为 ``True``，它也返回 ``True``。
	如果它对任何异常返回 ``True``，则不会调用此异常的错误处理程序，并且在回溯中显示为常规异常。这有助于调试隐式引发的HTTP异常。
	版本变更： 1.0	默认情况下，在调试模式下不会捕获错误请求错误。
	版本变更： 0.8

79 update_template_context(self, context: dict) -> None:

kind=method class=Flask objtype=function line:973 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	这会将request、session、config和g注入到模板上下文中，以及模板上下文处理器想要注入的所有内容。请注意，在Flask 0.6中，如果上下文处理器决定返回具有相同键的值，上下文中的原始值将不会被覆盖。
	:param context: 		上下文作为一个字典，在适当的地方更新以添加额外的变量。

80 url_for(

kind=method class=Flask objtype=function line:1917 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	用给定的值生成到给定端点的URL。
	它由 :func:`flask.url_for`调用，也可以直接调用。
	*endpoint*是URL规则的名称，通常与:meth: `@app.route() <route>`一起添加，通常与视图函数的名称相同。在 :class:`~flask.Blueprint`中定义的路由将把蓝图的名称以 ``.``分隔到端点。
	在某些情况下，例如电子邮件消息，您希望url包含方案和域，如 ``https://example.com/hello``。当不在活动请求中时，url默认是外部的，但这需要设置 :data:`SERVER_NAME`，以便Flask知道使用哪个域。 
	:data:`APPLICATION_ROOT`和 :data:`PREFERRED_URL_SCHEME`也应该根据需要进行配置。此配置仅在非活动请求时使用。
	可以用 :meth:`url_defaults`装饰函数，以便在构建URL之前修改关键字参数。
	如果构建由于某些原因失败，例如未知的端点或不正确的值，则调用应用程序的 :meth:`handle_url_build_error`方法。如果返回一个字符串，则返回该字符串，否则引发 :exc:`~werkzeug.routing.BuildError`。
	:param endpoint: 		与要生成的URL相关联的端点名称。如果以 ``.``开头，则使用当前蓝图名称(如果有的话)。
	:param _anchor: 		如果给定，将其作为 ``#anchor``附加到URL。
	:param _method: 		如果给定，则为端点生成与此方法关联的URL。
	:param _scheme: 		如果给定，则URL将具有此模式，如果它是外部的。
	:param _external: 		如果给出，希望URL是内部的(False)或要求它是外部的(True)。外部url包括方案和域。当不在活动请求中时，url默认情况下是外部的。
	:param values: 		值，用于URL规则的可变部分。未知键作为查询字符串参数追加，如 ``?a=b&c=d``。

	版本变更： 2.2	从 ``flask.url_for``移来，它调用此方法。

81 wsgi_app(self, environ: dict, start_response: t.Callable) -> t.Any:

kind=method class=Flask objtype=function line:2498 at D:\Programs\Python\Python37\lib\site-packages\flask\app.py

	实际的WSGI应用程序。这在 :meth:`__call__`中没有实现，因此可以在不丢失对app对象的引用的情况下应用中间件。而不是这样做::
            app = MyMiddleware(app)

	这样做会更好::
            app.wsgi_app = MyMiddleware(app.wsgi_app)

	然后，您仍然拥有原始的应用程序对象，并且可以继续在其上调用方法。
	版本变更： 0.7	即使发生未处理的错误，也会调用请求和应用上下文的Teardown事件。其他事件可能不会被调用，具体取决于调度期间发生错误的时间参见 :ref:`callbacks-and-errors`。
	:param environ: 		一个WSGI环境。
	:param start_response: 		一个可调用对象，接受一个状态码、一个标头列表和一个可选的异常上下文来启动响应。

🌿38 flask.wrappers.Request

Request, flask.wrappers.Request, module=flask.wrappers, line:15 at site-packages\flask\wrappers.py

	Flask中默认使用的request对象。记住匹配的端点和视图参数。
	它就是最后的 :class:`~flask.request`。如果你想替换使用的请求对象，你可以继承这个，并设置 :attr:`~flask.Flask.request_class`为你的子类。
	request对象是一个 :class:`~werkzeug.wrappers.Request`子类，提供了Werkzeug定义的所有属性以及一些Flask特有的属性。

data

1 json_module=<module ‘flask.json’ from ‘D:\Programs\Python\Python37\lib\site-packages\flask\json\init.py’> kind:data type:module class:<class ‘flask.wrappers.Request’>
2 routing_exception=None kind:data type:NoneType class:<class ‘flask.wrappers.Request’>
3 url_rule=None kind:data type:NoneType class:<class ‘flask.wrappers.Request’>
4 view_args=None kind:data type:NoneType class:<class ‘flask.wrappers.Request’>

property

5 blueprint=<property object at 0x00000210C1EFF4F8> kind:property type:property class:<class ‘flask.wrappers.Request’>
6 blueprints=<property object at 0x00000210C1EFF598> kind:property type:property class:<class ‘flask.wrappers.Request’>
7 endpoint=<property object at 0x00000210C1EFF458> kind:property type:property class:<class ‘flask.wrappers.Request’>
8 max_content_length=<property object at 0x00000210C1EFF3B8> kind:property type:property class:<class ‘flask.wrappers.Request’>

method

9 on_json_loading_failed(self, e: t.Optional[ValueError]) -> t.Any:

kind=method class=Request objtype=function line:126 at D:\Programs\Python\Python37\lib\site-packages\flask\wrappers.py

🌿39 flask.wrappers.Response

Response, flask.wrappers.Response, module=flask.wrappers, line:136 at site-packages\flask\wrappers.py

	在Flask中默认使用的响应对象。工作方式类似于Werkzeug中的响应对象，但默认情况下被设置为具有HTML mime类型。通常您不必自己创建这个对象，因为 :meth:`~flask.Flask.make_response`会为您处理这个问题。
	如果你想替换使用的响应对象，你可以继承这个，并将 :attr:`~flask.Flask.response_class`设置为你的子类。
	版本变更： 1.0	JSON支持被添加到响应中，就像请求一样。这在测试以JSON形式获取测试客户端响应数据时非常有用。
	版本变更： 1.0
	添加了 :attr:`max_cookie_size`。

data

1 autocorrect_location_header=False kind:data type:bool class:<class ‘flask.wrappers.Response’>
2 default_mimetype=text/html kind:data type:str class:<class ‘flask.wrappers.Response’>
3 json_module=<module ‘flask.json’ from ‘D:\Programs\Python\Python37\lib\site-packages\flask\json\init.py’> kind:data type:module class:<class ‘flask.wrappers.Response’>

property

4 max_cookie_size=<property object at 0x00000210C1EFF818> kind:property type:property class:<class ‘flask.wrappers.Response’>

🌿40 flask.blueprints.Blueprint

Blueprint, flask.blueprints.Blueprint, module=flask.blueprints, line:36 at site-packages\flask\blueprints.py

	表示一个蓝图、一组路由和其他与应用相关的功能，这些功能可以在以后的实际应用中注册。
	蓝图是一个对象，它允许定义应用程序功能，而不需要提前使用应用程序对象。它使用与 :class:`~flask.Flask`相同的装饰器，但通过记录它们以供以后注册来推迟对应用程序的需要。
	用蓝图装饰函数会创建一个延迟函数，该函数在蓝图注册到应用程序时使用 :class:`~flask.blueprints.BlueprintSetupState`调用。
	有关详细信息，请参见 :doc:`/blueprints`。
	:param name: 		蓝图的名称。将添加到每个端点名称之前。
	:param import_name: 		蓝图包的名称，通常为 ``__name__``。这有助于定位蓝图的 ``root_path``。
	:param static_folder: 		包含静态文件的文件夹，应该由蓝图的静态路由提供服务。该路径是相对于蓝图的根路径的。默认情况下，蓝图静态文件是禁用的。
	:param static_url_path: 		提供静态文件的url。默认为 ``static_folder``。如果蓝图没有 ``url_prefix``，应用的静态路由将优先，蓝图的静态文件将无法访问。
	:param template_folder: 		一个包含模板的文件夹，应该添加到应用的模板搜索路径中。该路径是相对于蓝图的根路径的。默认情况下，蓝图模板是禁用的。蓝图模板的优先级低于应用模板文件夹中的模板。
	:param url_prefix: 		在蓝图的所有url前添加一个路径，使它们区别于应用的其他路由。
	:param subdomain: 		默认情况下蓝图路由将匹配的子域。
	:param url_defaults: 		蓝图路由将在默认情况下接收的默认值字典。
	:param root_path: 		默认情况下，蓝图将根据 ``import_name``自动设置此值。在某些情况下，这种自动检测可能会失败，因此可以手动指定路径。

	版本变更： 1.1.0	蓝图有一个 ``cli``组来注册嵌套的CLI命令。 ``cli_group``参数控制 ``flask``命令下的组的名称。
	版本变更： 0.7

property

1 json_decoder=<property object at 0x00000210C1F1A048> kind:property type:property class:<class ‘flask.blueprints.Blueprint’>
2 json_encoder=<property object at 0x00000210C1F15EF8> kind:property type:property class:<class ‘flask.blueprints.Blueprint’>

method

3 add_app_template_filter(

kind=method class=Blueprint objtype=function line:521 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个模板过滤器，可以在应用程序呈现的任何模板中使用。像 :meth:`app_template_filter`装饰器一样工作。相当于 :meth:`.Flask.add_template_filter`。
	:param name: 		过滤器的可选名称，否则将使用函数名。

4 add_app_template_global(

kind=method class=Blueprint objtype=function line:595 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个全局模板，可以在应用程序呈现的任何模板中使用。像 :meth:`app_template_global`装饰器一样工作。相当于 :meth:`.Flask.add_template_global`。
	版本变更： 0.10
	:param name: 		全局变量的可选名称，否则将使用函数名。

5 add_app_template_test(

kind=method class=Blueprint objtype=function line:557 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个模板测试，可以在应用程序呈现的任何模板中使用。像 :meth:`app_template_test`装饰器一样工作。相当于 :meth:`.Flask.add_template_test`。
	版本变更： 0.10
	:param name: 		测试例的可选名称，否则将使用函数名。

6 add_url_rule(

kind=method class=Blueprint objtype=function line:89 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	在蓝图中注册一个URL规则。有关完整文档，请参阅 :meth:`.Flask.add_url_rule`。
	URL规则的前缀是蓝图的URL前缀。端点名称(与 :func:`url_for`一起使用)以蓝图名称为前缀。

7 after_app_request(self, f: T_after_request) -> T_after_request:

kind=method class=Blueprint objtype=function line:647 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	像 :meth:`after_request`一样，但是在每个请求之后，不仅仅是那些由蓝图处理的请求。相当于 :meth:`.Flask.after_request`。

8 app_context_processor(

kind=method class=Blueprint objtype=function line:667 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	类似于 :meth:`context_processor`，但适用于每个视图呈现的模板，而不仅仅是蓝图呈现的模板。相当于 :meth:`.Flask.context_processor`。

9 app_errorhandler(

kind=method class=Blueprint objtype=function line:679 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	像 :meth:`errorhandler`一样，但是对于每个请求，不仅仅是那些由蓝图处理的请求。相当于 :meth:`.Flask.errorhandler`。

10 app_template_filter(

kind=method class=Blueprint objtype=function line:504 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个模板过滤器，可以在应用程序呈现的任何模板中使用。相当于 :meth:`.Flask.template_filter`。
	:param name: 		过滤器的可选名称，否则将使用函数名。

11 app_template_global(

kind=method class=Blueprint objtype=function line:576 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个全局模板，可以在应用程序呈现的任何模板中使用。相当于 :meth:`.Flask.template_global`。
	版本变更： 0.10
	:param name: 		全局变量的可选名称，否则将使用函数名。

12 app_template_test(

kind=method class=Blueprint objtype=function line:538 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个模板测试，可以在应用程序呈现的任何模板中使用。相当于 :meth:`.Flask.template_test`。
	版本变更： 0.10
	:param name: 		测试例的可选名称，否则将使用函数名。

13 app_url_defaults(self, f: T_url_defaults) -> T_url_defaults:

kind=method class=Blueprint objtype=function line:705 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	像 :meth:`url_defaults`一样，但是对于每个请求，不仅仅是那些由蓝图处理的请求。相当于 :meth:`.Flask.url_defaults`。

14 app_url_value_preprocessor(

kind=method class=Blueprint objtype=function line:693 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	像 :meth:`url_value_preprocessor`一样，但是对于每个请求，不仅仅是那些由蓝图处理的请求。相当于 :meth:`.Flask.url_value_preprocessor`。

15 before_app_first_request(

kind=method class=Blueprint objtype=function line:624 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册一个函数，在worker处理对应用程序的第一个请求之前运行。相当于 :meth:`.Flask.before_first_request`。
	弃用： 2.2	将在Flask 2.3中删除。而是在创建应用程序时运行安装代码。

16 before_app_request(self, f: T_before_request) -> T_before_request:

kind=method class=Blueprint objtype=function line:614 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	像 :meth:`before_request`一样，但是在每个请求之前，不仅仅是那些由蓝图处理的请求。相当于 :meth:`.Flask.before_request`。

17 make_setup_state(

kind=method class=Blueprint objtype=function line:323 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	创建一个 :meth:`~flask.blueprints.BlueprintSetupState`对象的实例，该实例稍后传递给注册回调函数。子类可以重写此实例以返回设置状态的子类。

18 record(self, func: t.Callable) -> None:

kind=method class=Blueprint objtype=function line:301 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	注册在应用程序上注册蓝图时调用的函数。这个函数是用 :meth:`make_setup_state`方法返回的状态作为参数调用的。

19 record_once(self, func: t.Callable) -> None:

kind=method class=Blueprint objtype=function line:310 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	工作方式类似于 :meth:`record`，但将函数包装在另一个函数中，以确保该函数只被调用一次。如果在应用程序上第二次注册蓝图，则不会调用传递的函数。

20 register(self, app: “Flask”, options: dict) -> None:

kind=method class=Blueprint objtype=function line:350 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	由 :meth:`Flask.register_blueprint`调用，将蓝图上注册的所有视图和回调函数注册到应用程序中。创建 :class:`.BlueprintSetupState`并使用它调用每个 :meth:`record`回调。
	:param app: 		正在注册此蓝图的应用程序。
	:param options: 		从 :meth:`~Flask.register_blueprint`转发的关键字参数。

	版本变更： 2.0.1	嵌套蓝图以其带点的名称注册，这允许在不同位置嵌套具有相同名称的不同蓝图。
	版本变更： 2.0.1	``name``选项可用于更改蓝图注册的名称(前置点)。这允许同一个蓝图以唯一的名称 ``url_for``被注册多次。
	版本变更： 2.0.1	多次使用相同的名称注册同一个蓝图是不赞成的，这将在Flask 2.1中成为一个错误。

21 register_blueprint(self, blueprint: “Blueprint”, **options: t.Any) -> None:

kind=method class=Blueprint objtype=function line:333 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	在此蓝图上注册一个 :class:`~flask.Blueprint`。传递给此方法的关键字参数将覆盖蓝图上设置的默认值。
	版本变更： 2.0.1	``name``选项可用于更改蓝图注册的名称(前置点)。这允许同一个蓝图以唯一的名称 ``url_for``被注册多次。
	版本变更： 2.0

22 teardown_app_request(self, f: T_teardown) -> T_teardown:

kind=method class=Blueprint objtype=function line:657 at D:\Programs\Python\Python37\lib\site-packages\flask\blueprints.py

	像 :meth:`teardown_request`一样，但是在每个请求之后，不仅仅是那些由蓝图处理的请求。相当于 :meth:`.Flask.teardown_request`。

🌿41 flask.config.Config

Config, flask.config.Config, module=flask.config, line:10 at site-packages\flask\config.py

	工作原理与字典完全相同，但提供了从文件或特殊字典填充它的方法。有两种常见的模式来填充配置。
	你可以从配置文件中填写配置::
        app.config.from_pyfile('yourconfig.cfg')

	或者，您也可以在调用 :meth:`from_object`的模块中定义配置选项，或者为应该加载的模块提供导入路径。也可以告诉它使用相同的模块，并在调用之前提供配置值::
        DEBUG = True
        SECRET_KEY = 'development key'
        app.config.from_object(__name__)

	在这两种情况下(从任何Python文件加载或从模块加载)，只有大写键被添加到配置中。这使得可以在配置文件中使用小写值来表示未添加到配置中的临时值，或者在实现应用程序的同一文件中定义配置键。
	加载配置的最有趣的方式可能是从一个指向文件的环境变量::
        app.config.from_envvar('YOURAPPLICATION_SETTINGS')

	在这种情况下，在启动应用程序之前，必须将该环境变量设置为要使用的文件。在Linux和OS X上使用export语句::
	导出你的应用程序设置='/path/to/config/file'。
	在windows上使用 `set`代替。
	:param root_path: 		读取文件的相对路径。当配置对象由应用程序创建时，这是应用程序的 :attr:`~flask.Flask.root_path`。
	:param defaults: 		默认值的可选字典。

method

1 from_envvar(self, variable_name: str, silent: bool = False) -> bool:

kind=method class=Config objtype=function line:77 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	从指向配置文件的环境变量加载配置。这基本上只是这行代码的一个快捷方式，有更好的错误信息::
            app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])

	:param variable_name: 		环境变量的名称。
	:param silent: 		如果您希望丢失的文件静默失败，请设置为 ``True``。
	:return: 		``True``表示文件已成功加载。

2 from_file(

kind=method class=Config objtype=function line:232 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	从使用 ``load``参数加载的文件更新配置中的值。加载的数据被传递给 :meth:`from_mapping`方法。
	代码块： python
            import json
            app.config.from_file("config.json", load=json.load)

            import toml
            app.config.from_file("config.toml", load=toml.load)

	:param filename: 		数据文件的路径。这可以是绝对路径，也可以是相对于配置根路径的路径。
	:param load: 		一个可调用函数，它接受一个文件句柄并返回从文件加载的数据的映射。
	:type load: 		``Callable[[Reader], Mapping]``，其中 ``Reader``实现 ``read``方法。
	:param silent: 		如果该文件不存在，则忽略它。
	:return: 		``True``表示文件已成功加载。

	版本变更： 2.0

3 from_mapping(

kind=method class=Config objtype=function line:275 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	更新配置，如 :meth:`update`忽略非上键项。
	:return: 		总是返回 ``True``。

	版本变更： 0.11

4 from_object(self, obj: t.Union[object, str]) -> None:

kind=method class=Config objtype=function line:194 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	更新给定对象的值。对象可以是以下两种类型之一:
	-一个字符串:在这种情况下，具有该名称的对象将被导入-一个实际的对象引用:该对象被直接使用。
	对象通常是模块或类。 :meth:`from_object`只加载模块/类的大写属性。 ``dict``对象不能与 :meth:`from_object`一起工作，因为 ``dict``的键不是 ``dict``类的属性。
	基于模块的配置示例::
            app.config.from_object('yourapplication.default_config')
            from yourapplication import default_config
            app.config.from_object(default_config)

	在加载之前不会对对象做任何操作。如果对象是一个类并且具有 ``@property``属性，则需要在传递给此方法之前对其进行实例化。
	您不应该使用这个函数来加载实际配置，而应该使用默认配置。实际的配置应该用 :meth:`from_pyfile`加载，理想情况下应该从包内以外的位置加载，因为包可能是在系统范围内安装的。
	有关使用 :meth:`from_object`进行基于类配置的示例，请参阅 :ref:`config-dev-prod`。
	:param obj: 		导入名称或对象。

5 from_prefixed_env(

kind=method class=Config objtype=function line:101 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	加载任何以 ``FLASK_``开头的环境变量，从env键中删除配置键的前缀。值通过加载函数传递，以尝试将它们转换为比字符串更具体的类型。
	键按 :func:`sorted`顺序加载。
	默认加载函数尝试将值解析为任何有效的JSON类型，包括字典和列表。
	可以通过用双下划线( ``__``)分隔键来设置嵌套字典中的特定项。如果中间键不存在，则将其初始化为空字典。
	:param prefix: 		加载以该前缀开头，用下划线( ``_``)分隔的环境变量。
	:param loads: 		将每个字符串值传递给此函数，并使用返回值作为配置值。如果引发任何错误，则忽略它，并且值仍然是字符串。默认值为 :func:`json.loads`。

	版本变更： 2.1

6 from_pyfile(self, filename: str, silent: bool = False) -> bool:

kind=method class=Config objtype=function line:165 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	从Python文件更新配置中的值。这个函数的行为就好像文件是用 :meth:`from_object`函数作为模块导入的。
	:param filename: 		配置文件的文件名。它可以是绝对文件名，也可以是相对于根路径的文件名。
	:param silent: 		如果您希望丢失的文件静默失败，请设置为 ``True``。
	:return: 		``True``表示文件已成功加载。

	版本变更： 0.7	`silent`参数。

7 get_namespace(

kind=method class=Config objtype=function line:294 at D:\Programs\Python\Python37\lib\site-packages\flask\config.py

	返回一个字典，其中包含与指定命名空间/前缀匹配的配置选项子集。用法:例子:
            app.config['IMAGE_STORE_TYPE'] = 'fs'
            app.config['IMAGE_STORE_PATH'] = '/var/app/images'
            app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
            image_store_config = app.config.get_namespace('IMAGE_STORE_')

	生成的字典 `image_store_config`看起来像::
	{“类型”:“f”,“路径”:“/ var / app /图片”,“基url”:“http://img.website.com”}。
	当配置选项直接映射到函数或类构造函数中的关键字参数时，这通常很有用。
	:param namespace: 		配置名称空间。
	:param lowercase: 		一个标志，指示结果字典的键是否应该是小写的。
	:param trim_namespace: 		一个标志，指示结果字典的键是否不应包含名称空间。

	版本变更： 0.11

🔵内嵌函数或方法

42 escape

🔵剩余

43 doc
44 loader <_frozen_importlib_external.SourceFileLoader object at 0x00000210C10B2648>
45 spec ModuleSpec(name=‘flask’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x00000210C10B2648>,
origin=‘D:\Programs\Python\Python37\lib\site-packages\flask\init.py’, submodule_search_locations=[‘D:\Programs\Python\Python37\lib\site-packages\flask’])
46 current_app
47 g
48 request
49 session
50 appcontext_popped <flask.signals._FakeSignal object at 0x00000210C1E8D648>
51 appcontext_pushed <flask.signals._FakeSignal object at 0x00000210C1E8D608>
52 appcontext_tearing_down <flask.signals._FakeSignal object at 0x00000210C1E8D5C8>
53 before_render_template <flask.signals._FakeSignal object at 0x00000210C1E8D3C8>
54 got_request_exception <flask.signals._FakeSignal object at 0x00000210C1E8D588>
55 message_flashed <flask.signals._FakeSignal object at 0x00000210C1E8D688>
56 request_finished <flask.signals._FakeSignal object at 0x00000210C1E8D508>
57 request_started <flask.signals._FakeSignal object at 0x00000210C1E8D4C8>
58 request_tearing_down <flask.signals._FakeSignal object at 0x00000210C1E8D548>
59 template_rendered <flask.signals._FakeSignal object at 0x00000210C1E8D408>

☘️【flask.globals】

globals, fullname=flask.globals, file=flask\globals.py

☘️【flask.json】

json, fullname=flask.json, file=flask\json_init_.py

☘️【flask.signals】

signals, fullname=flask.signals, file=flask\signals.py

☘️【flask.helpers】

helpers, fullname=flask.helpers, file=flask\helpers.py

☘️【flask.cli】

cli, fullname=flask.cli, file=flask\cli.py

☘️【flask.typing】

typing, fullname=flask.typing, file=flask\typing.py

☘️【flask.config】

config, fullname=flask.config, file=flask\config.py

☘️【flask.ctx】

ctx, fullname=flask.ctx, file=flask\ctx.py

☘️【flask.logging】

logging, fullname=flask.logging, file=flask\logging.py

☘️【flask.templating】

templating, fullname=flask.templating, file=flask\templating.py

☘️【flask.scaffold】

scaffold, fullname=flask.scaffold, file=flask\scaffold.py

☘️【flask.sessions】

sessions, fullname=flask.sessions, file=flask\sessions.py

☘️【flask.wrappers】

wrappers, fullname=flask.wrappers, file=flask\wrappers.py

☘️【flask.app】

app, fullname=flask.app, file=flask\app.py

☘️【flask.blueprints】

blueprints, fullname=flask.blueprints, file=flask\blueprints.py

☘️【typing】

typing, fullname=typing, file=typing.py

☘️【json】

json, fullname=json, file=json_init_.py

☘️【flask.json.provider】

provider, fullname=flask.json.provider, file=flask\json\provider.py

🔵统计

序号	类别	数量
4	str	4
8	dict	1
9	module	6
10	class	3
11	function	2
13	residual	5
14	system	8
15	private	1
16	all	21

🔵模块

🌿1 dataclasses

dataclasses, fullname=dataclasses, file=dataclasses.py

🌿2 decimal

decimal, fullname=decimal, file=decimal.py

🌿3 json

json, fullname=json, file=json_init_.py

🌿4 typing

typing, fullname=typing, file=typing.py

🌿5 uuid

uuid, fullname=uuid, file=uuid.py

🌿6 weakref

weakref, fullname=weakref, file=weakref.py

🔵函数

🌿7 http_date(timestamp: Union[datetime.datetime, datetime.date, int, float, time.struct_time, NoneType] = None) -> str

http_date(timestamp: Union[datetime.datetime, datetime.date, int, float, time.struct_time, NoneType] = None) -> str, module=werkzeug.http, line:960 at site-packages\werkzeug\http.py

	将datetime对象或时间戳格式化为 :rfc:`2822`日期字符串。
	这是 :func:`email.utils.format_datetime`的包装器。它假设朴素datetime对象是UTC格式的，而不是引发异常。
	:param timestamp: 		要格式化的日期时间或时间戳。默认为当前时间。

	版本变更： 2.0	使用 ``email.utils.format_datetime``。接受 ``date``对象。

🌿8 _default(o: ‘t.Any’) -> ‘t.Any’

_default(o: ‘t.Any’) -> ‘t.Any’, module=flask.json.provider, line:109 at site-packages\flask\json\provider.py

🔵类

🌿9 datetime.date

date, datetime.date, module=datetime, line:0 at

date(year, month, day) --> date object

🌿10 flask.json.provider.JSONProvider

JSONProvider, flask.json.provider.JSONProvider, module=flask.json.provider, line:20 at site-packages\flask\json\provider.py

	应用程序的一组标准JSON操作。它的子类可用于自定义JSON行为或使用不同的JSON库。
	若要实现特定库的提供程序，请继承此基类并至少实现 :meth:`dumps`和 :meth:`loads`。所有其他方法都有默认实现。
	要使用不同的提供程序，可以将子类 ``Flask``和 :attr:`~flask.Flask.json_provider_class`设置为提供程序类，或者将:attr: `app.json <flask.Flask.json>`设置为该类的实例。
	:param app: 		应用实例。这将被存储为 :attr:`_app`属性中的 :class:`weakref.proxy`。

	版本变更： 2.2

method

1 dump(self, obj: t.Any, fp: t.IO[str], **kwargs: t.Any) -> None:

kind=method class=JSONProvider objtype=function line:50 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将数据序列化为JSON并写入文件。
	:param obj: 		要序列化的数据。
	:param fp: 		为编写文本而打开的文件。应该使用UTF-8编码才能成为有效的JSON。
	:param kwargs: 		可以传递给底层JSON库。

2 dumps(self, obj: t.Any, **kwargs: t.Any) -> str:

kind=method class=JSONProvider objtype=function line:42 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将数据序列化为JSON。
	:param obj: 		要序列化的数据。
	:param kwargs: 		可以传递给底层JSON库。

3 load(self, fp: t.IO[t.AnyStr], **kwargs: t.Any) -> t.Any:

kind=method class=JSONProvider objtype=function line:68 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将数据反序列化为从文件读取的JSON。
	:param fp: 		为读取文本或UTF-8字节而打开的文件。
	:param kwargs: 		可以传递给底层JSON库。

4 loads(self, s: str | bytes, **kwargs: t.Any) -> t.Any:

kind=method class=JSONProvider objtype=function line:60 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将数据反序列化为JSON。
	:param s: 		文本或UTF-8字节。
	:param kwargs: 		可以传递给底层JSON库。

5 response(self, *args: t.Any, **kwargs: t.Any) -> Response:

kind=method class=JSONProvider objtype=function line:90 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将给定的参数序列化为JSON，并返回一个 ``application/json``mime类型的 :class:`~flask.Response`对象。
	:func:`~flask.json.jsonify`函数为当前应用程序调用此方法。
	可以给出位置参数或关键字参数，但不能同时给出两个参数。如果没有给出参数，则序列化 ``None``。
	:param args: 		要序列化的单个值，或将多个值视为要序列化的列表。
	:param kwargs: 		将其视为要序列化的字典。

🌿11 flask.json.provider.DefaultJSONProvider

DefaultJSONProvider, flask.json.provider.DefaultJSONProvider, module=flask.json.provider, line:125 at site-packages\flask\json\provider.py

	使用Python内置的 :mod:`json`库提供JSON操作。序列化以下附加数据类型:
        - :class:`datetime.datetime`和 :class:`datetime.date`被序列化为 :rfc:`822`字符串。这与HTTP日期格式相同
        - :class:`uuid.UUID`被序列化为字符串
        - :class:`dataclasses.dataclass`被传递给 :func:`dataclasses.asdict`
        - :class:`~markupsafe.Markup`(或任何具有 ``__html__``方法的对象)将调用 ``__html__``方法来获取字符串。

data

1 compact=None kind:data type:NoneType class:<class ‘flask.json.provider.DefaultJSONProvider’>
2 ensure_ascii=True kind:data type:bool class:<class ‘flask.json.provider.DefaultJSONProvider’>
3 mimetype=application/json kind:data type:str class:<class ‘flask.json.provider.DefaultJSONProvider’>
4 sort_keys=True kind:data type:bool class:<class ‘flask.json.provider.DefaultJSONProvider’>

method

5 dumps(self, obj: t.Any, **kwargs: t.Any) -> str:

kind=method class=DefaultJSONProvider objtype=function line:169 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将数据作为JSON序列化为字符串。
	关键字参数传递给 :func:`json.dumps`。从 :attr:`default`、 :attr:`ensure_ascii`和 :attr:`sort_keys`属性设置一些参数默认值。
	:param obj: 		要序列化的数据。
	:param kwargs: 		传递给 :func:`json.dumps`。

6 loads(self, s: str | bytes, **kwargs: t.Any) -> t.Any:

kind=method class=DefaultJSONProvider objtype=function line:232 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将数据从字符串或字节反序列化为JSON。
	:param s: 		文本或UTF-8字节。
	:param kwargs: 		传递给 :func:`json.loads`。

7 response(self, *args: t.Any, **kwargs: t.Any) -> Response:

kind=method class=DefaultJSONProvider objtype=function line:257 at D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py

	将给定的参数序列化为JSON，并返回一个 :class:`~flask.Response`对象。响应mime类型将是"application/json"，可以用 :attr:`mimetype`修改。
	如果 :attr:`compact`为 ``False``或启用了调试模式，则输出将被格式化以方便阅读。
	可以给出位置参数或关键字参数，但不能同时给出两个参数。如果没有给出参数，则序列化 ``None``。
	:param args: 		要序列化的单个值，或将多个值视为要序列化的列表。
	:param kwargs: 		将其视为要序列化的字典。

static method

8 default()

kind=static method class=DefaultJSONProvider objtype=staticmethod

staticmethod(function) -> method

	将函数转换为静态方法。
	静态方法不接受隐式的第一个参数。要声明静态方法，请使用以下习惯用法:
     class C:
         @staticmethod
         def f(arg1, arg2, ...):
             ...

	它可以在类(例如C.f())上调用，也可以在实例(例如C().f())上调用。除了它的类之外，实例被忽略。
	Python中的静态方法类似于Java或c++中的静态方法。要了解更高级的概念，请参阅内置的类方法。

🔵私有或局部

12 _default <function _default at 0x00000210C1CF5678>

🔵剩余

13 doc
14 loader <_frozen_importlib_external.SourceFileLoader object at 0x00000210C1CF8308>
15 spec ModuleSpec(name=‘flask.json.provider’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x00000210C1CF8308>,
origin=‘D:\Programs\Python\Python37\lib\site-packages\flask\json\provider.py’)
16 annotations _Feature((3, 7, 0, ‘beta’, 1), (4, 0, 0, ‘alpha’, 0), 1048576)
17 request

☘️【flask.json.tag】

tag, fullname=flask.json.tag, file=flask\json\tag.py

	标记JSON ~~~~~~~~~~~。
	非标准JSON类型无损序列化的紧凑表示。 :class:`~flask.sessions.SecureCookieSessionInterface`使用它来序列化会话数据，但它可能在其他地方很有用。
	它可以扩展以支持其他类型。
	自动类： TaggedJSONSerializer	。
	自动类： JSONTag	。
	
	让我们看一个增加对 :class:`~collections.OrderedDict`支持的示例。
	字典在JSON中没有顺序，所以为了处理这个问题，我们将把条目转储为一个 ``[key, value]``对的列表。
	子类 :class:`JSONTag`并给它一个新的键 ``' od'``来识别类型。
	会话序列化器首先处理字典，因此在顺序的前面插入新标记，因为 ``OrderedDict``必须在 ``dict``之前处理。
	
	代码块： python
	from flask.json.tag import JSONTag
    class TagOrderedDict(JSONTag):
        __slots__ = ('serializer',)
        key = ' od'

        def check(self, value):
            return isinstance(value, OrderedDict)

        def to_json(self, value):
            return [[k, self.serializer.tag(v)] for k, v in iteritems(value)]

        def to_python(self, value):
            return OrderedDict(value)

    app.session_interface.serializer.register(TagOrderedDict, index=0)

🔵统计

序号	类别	数量
4	str	5
8	dict	1
9	module	1
10	class	13
11	function	6
13	residual	2
14	system	8
16	all	28

🔵模块

🌿1 typing

typing, fullname=typing, file=typing.py

🔵函数

🌿2 b64decode(s, altchars=None, validate=False)

b64decode(s, altchars=None, validate=False), module=base64, line:65 at base64.py

	解码Base64编码的类字节对象或ASCII字符串s。
	可选altchars必须是bytes-like object或长度为2的ASCII字符串，指定替代'+'和'/'字符的替代字母表。
	结果以bytes对象的形式返回。binascii。如果s被错误填充，将引发错误。
	如果validate为False(默认值)，则在填充检查之前丢弃既不在标准base-64字母表中也不在替代字母表中的字符。如果validate为True，则输入中的这些非字母字符将产生binascii。错误。

🌿3 b64encode(s, altchars=None)

b64encode(s, altchars=None), module=base64, line:51 at base64.py

	使用Base64对类字节对象s进行编码并返回一个bytes对象。
	可选altchars应该是一个长度为2的字节字符串，它指定'+'和'/'字符的替代字母表。这允许应用程序生成url或文件系统安全的Base64字符串。

🌿4 http_date(timestamp: Union[datetime.datetime, datetime.date, int, float, time.struct_time, NoneType] = None) -> str

http_date(timestamp: Union[datetime.datetime, datetime.date, int, float, time.struct_time, NoneType] = None) -> str, module=werkzeug.http, line:960 at site-packages\werkzeug\http.py

	将datetime对象或时间戳格式化为 :rfc:`2822`日期字符串。
	这是 :func:`email.utils.format_datetime`的包装器。它假设朴素datetime对象是UTC格式的，而不是引发异常。
	:param timestamp: 		要格式化的日期时间或时间戳。默认为当前时间。

	版本变更： 2.0	使用 ``email.utils.format_datetime``。接受 ``date``对象。

🌿5 parse_date(value: Union[str, NoneType]) -> Union[datetime.datetime, NoneType]

parse_date(value: Union[str, NoneType]) -> Union[datetime.datetime, NoneType], module=werkzeug.http, line:931 at site-packages\werkzeug\http.py

	将 :rfc:`2822`日期解析为具有时区意识的 :class:`datetime.datetime`对象，如果解析失败则解析为 ``None``。
	这是 :func:`email.utils.parsedate_to_datetime`的包装器。如果解析失败，它将返回 ``None``，而不是引发异常，并且始终返回一个具有时区意识的datetime对象。如果字符串没有时区信息，则假定为UTC。
	:param value: 		支持日期格式的字符串。

	版本变更： 2.0	返回一个支持时区的datetime对象。使用 ``email.utils.parsedate_to_datetime``。

🌿6 dumps(obj: ‘t.Any’, *, app: ‘Flask | None’ = None, **kwargs: ‘t.Any’) -> ‘str’

dumps(obj: ‘t.Any’, *, app: ‘Flask | None’ = None, **kwargs: ‘t.Any’) -> ‘str’, module=flask.json, line:84 at site-packages\flask\json_init_.py

	将数据序列化为JSON。
	如果 :data:`~flask.current_app`可用，它将使用它的:meth: `app.json.dumps() <flask.json.provider.JSONProvider.dumps>`方法，否则它将使用 :func:`json.dumps`。
	:param obj: 		要序列化的数据。
	:param kwargs: 		传递给 ``dumps``实现的参数。

	版本变更： 2.2	调用 ``current_app.json.dumps``，允许应用重写该行为。
	版本变更： 2.2	``app``参数将在Flask 2.3中删除。
	版本变更： 2.0.2	:class:`decimal.Decimal`通过转换为字符串来支持。
	版本变更： 2.0	``encoding``将在Flask 2.1中移除。
	版本变更： 1.0.3	``app``可以直接传递，而不需要应用上下文进行配置。

🌿7 loads(s: ‘str | bytes’, *, app: ‘Flask | None’ = None, **kwargs: ‘t.Any’) -> ‘t.Any’

loads(s: ‘str | bytes’, *, app: ‘Flask | None’ = None, **kwargs: ‘t.Any’) -> ‘t.Any’, module=flask.json, line:174 at site-packages\flask\json_init_.py

	将数据反序列化为JSON。
	如果 :data:`~flask.current_app`可用，它将使用它的:meth: `app.json.loads() <flask.json.provider.JSONProvider.loads>`方法，否则它将使用 :func:`json.loads`。
	:param s: 		文本或UTF-8字节。
	:param kwargs: 		传递给 ``loads``实现的参数。

	版本变更： 2.2	调用 ``current_app.json.loads``，允许应用重写该行为。
	版本变更： 2.2	``app``参数将在Flask 2.3中删除。
	版本变更： 2.0	``encoding``将在Flask 2.1中移除。数据必须是字符串或UTF-8字节。
	版本变更： 1.0.3	``app``可以直接传递，而不需要应用上下文进行配置。

🔵类

🌿8 datetime.datetime

datetime, datetime.datetime, module=datetime, line:0 at

datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])

	需要年、月和日参数。tzinfo可以是None，或者是tzinfo子类的一个实例。剩下的参数可以是整型。

🌿9 uuid.UUID

UUID, uuid.UUID, module=uuid, line:0 at

	UUID类的实例表示RFC 4122中指定的UUID
    UUID对象是不可变的、可哈希的，并且可用作字典键。使用str()将UUID转换为字符串会产生类似'12345678-1234-1234-1234-123456789abc'的结果。

🌿10 markupsafe.Markup

Markup, markupsafe.Markup, module=markupsafe, line:0 at

🌿10 flask.json.tag.JSONTag

JSONTag, flask.json.tag.JSONTag, module=flask.json.tag, line:57 at site-packages\flask\json\tag.py

	为 :class:`TaggedJSONSerializer`定义类型标记的基类。

data

1 key=None kind:data type:NoneType class:<class ‘flask.json.tag.JSONTag’>
2 serializer=<member ‘serializer’ of ‘JSONTag’ objects> kind:data type:member_descriptor class:<class ‘flask.json.tag.JSONTag’>

method

3 check(self, value: t.Any) -> bool:

kind=method class=JSONTag objtype=function line:70 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	检查给定的值是否应该被这个标签所标记。

4 tag(self, value: t.Any) -> t.Any:

kind=method class=JSONTag objtype=function line:84 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	将值转换为有效的JSON类型，并在其周围添加标记结构。

5 to_json(self, value: t.Any) -> t.Any:

kind=method class=JSONTag objtype=function line:74 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	将Python对象转换为有效JSON类型的对象。标记将在稍后添加。

6 to_python(self, value: t.Any) -> t.Any:

kind=method class=JSONTag objtype=function line:79 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	将JSON表示转换回正确的类型。标签已经被移除。

🌿11 flask.json.tag.TagDict

TagDict, flask.json.tag.TagDict, module=flask.json.tag, line:90 at site-packages\flask\json\tag.py

	标记，用于唯一键与注册标记匹配的1项字典。
	在内部，字典键以 `__`作为后缀，并且在反序列化时删除该后缀。

data

1 key= di kind:data type:str class:<class ‘flask.json.tag.TagDict’>

method

2 check(self, value: t.Any) -> bool:

kind=method class=TagDict objtype=function line:100 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=TagDict objtype=function line:107 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

4 to_python(self, value: t.Any) -> t.Any:

kind=method class=TagDict objtype=function line:111 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿12 flask.json.tag.PassDict

PassDict, flask.json.tag.PassDict, module=flask.json.tag, line:116 at site-packages\flask\json\tag.py

method

1 check(self, value: t.Any) -> bool:

kind=method class=PassDict objtype=function line:119 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

2 tag(self, value: t.Any) -> t.Dict[str, t.Any]:

kind=method class=PassDict objtype=function line:286 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=PassDict objtype=function line:122 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿13 flask.json.tag.TagTuple

TagTuple, flask.json.tag.TagTuple, module=flask.json.tag, line:130 at site-packages\flask\json\tag.py

data

1 key= t kind:data type:str class:<class ‘flask.json.tag.TagTuple’>

method

2 check(self, value: t.Any) -> bool:

kind=method class=TagTuple objtype=function line:134 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=TagTuple objtype=function line:137 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

4 to_python(self, value: t.Any) -> t.Any:

kind=method class=TagTuple objtype=function line:140 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿14 flask.json.tag.PassList

PassList, flask.json.tag.PassList, module=flask.json.tag, line:144 at site-packages\flask\json\tag.py

method

1 check(self, value: t.Any) -> bool:

kind=method class=PassList objtype=function line:147 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

2 tag(self, value: t.Any) -> t.Dict[str, t.Any]:

kind=method class=PassList objtype=function line:286 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=PassList objtype=function line:150 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿15 flask.json.tag.TagBytes

TagBytes, flask.json.tag.TagBytes, module=flask.json.tag, line:156 at site-packages\flask\json\tag.py

data

1 key= b kind:data type:str class:<class ‘flask.json.tag.TagBytes’>

method

2 check(self, value: t.Any) -> bool:

kind=method class=TagBytes objtype=function line:160 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=TagBytes objtype=function line:163 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

4 to_python(self, value: t.Any) -> t.Any:

kind=method class=TagBytes objtype=function line:166 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿16 flask.json.tag.TagMarkup

TagMarkup, flask.json.tag.TagMarkup, module=flask.json.tag, line:170 at site-packages\flask\json\tag.py

	序列化任何与 :class:`~markupsafe.Markup`API匹配的东西，方法是将 ``__html__``方法与该方法的结果关联起来。始终反序列化为 :class:`~markupsafe.Markup`的实例。

data

1 key= m kind:data type:str class:<class ‘flask.json.tag.TagMarkup’>

method

2 check(self, value: t.Any) -> bool:

kind=method class=TagMarkup objtype=function line:178 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=TagMarkup objtype=function line:181 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

4 to_python(self, value: t.Any) -> t.Any:

kind=method class=TagMarkup objtype=function line:184 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿17 flask.json.tag.TagUUID

TagUUID, flask.json.tag.TagUUID, module=flask.json.tag, line:188 at site-packages\flask\json\tag.py

data

1 key= u kind:data type:str class:<class ‘flask.json.tag.TagUUID’>

method

2 check(self, value: t.Any) -> bool:

kind=method class=TagUUID objtype=function line:192 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=TagUUID objtype=function line:195 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

4 to_python(self, value: t.Any) -> t.Any:

kind=method class=TagUUID objtype=function line:198 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿18 flask.json.tag.TagDateTime

TagDateTime, flask.json.tag.TagDateTime, module=flask.json.tag, line:202 at site-packages\flask\json\tag.py

data

1 key= d kind:data type:str class:<class ‘flask.json.tag.TagDateTime’>

method

2 check(self, value: t.Any) -> bool:

kind=method class=TagDateTime objtype=function line:206 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

3 to_json(self, value: t.Any) -> t.Any:

kind=method class=TagDateTime objtype=function line:209 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

4 to_python(self, value: t.Any) -> t.Any:

kind=method class=TagDateTime objtype=function line:212 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

🌿19 flask.json.tag.TaggedJSONSerializer

TaggedJSONSerializer, flask.json.tag.TaggedJSONSerializer, module=flask.json.tag, line:216 at site-packages\flask\json\tag.py

	序列化器，它使用标记系统紧凑地表示非JSON类型的对象。作为中间序列化器传递给 :class:`itsdangerous.Serializer`。
	支持以下额外类型:
        *  :class:`dict` 
        *  :class:`tuple` 
        *  :class:`bytes` 
        *  :class:`~markupsafe.Markup` 
        *  :class:`~uuid.UUID` 
        *  :class:`~datetime.datetime`

data

1 default_tags=[<class ‘flask.json.tag.TagDict’>, <class ‘flask.json.tag.PassDict’>, <class 'fl… kind:data type:list class:<class ‘flask.json.tag.TaggedJSONSerializer’>
2 order=<member ‘order’ of ‘TaggedJSONSerializer’ objects> kind:data type:member_descriptor class:<class ‘flask.json.tag.TaggedJSONSerializer’>
3 tags=<member ‘tags’ of ‘TaggedJSONSerializer’ objects> kind:data type:member_descriptor class:<class ‘flask.json.tag.TaggedJSONSerializer’>

method

4 dumps(self, value: t.Any) -> str:

kind=method class=TaggedJSONSerializer objtype=function line:306 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	标记该值并将其转储为一个紧凑的JSON字符串。

5 loads(self, value: str) -> t.Any:

kind=method class=TaggedJSONSerializer objtype=function line:310 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	从JSON字符串加载数据并对任何标记对象进行反序列化。

6 register(

kind=method class=TaggedJSONSerializer objtype=function line:253 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	用这个序列化器注册一个新标记。
	:param tag_class: 		要注册的标签类。将使用此序列化器实例实例化。
	:param force: 		覆盖现有标记。如果false(默认)，则引发 :exc:`KeyError`。
	:param index: 		索引以按标记顺序插入新标记。当新标记是现有标记的特殊情况时有用。如果 ``None``(默认)，则将标签附加到订单的末尾。

	:引发KeyError:如果标签密钥已经注册并且 ``force``不为真。

7 tag(self, value: t.Any) -> t.Dict[str, t.Any]:

kind=method class=TaggedJSONSerializer objtype=function line:286 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	必要时将值转换为带标记的表示形式。

8 untag(self, value: t.Dict[str, t.Any]) -> t.Any:

kind=method class=TaggedJSONSerializer objtype=function line:294 at D:\Programs\Python\Python37\lib\site-packages\flask\json\tag.py

	将标记的表示形式转换回原始类型。

☘️【os】

os, fullname=os, file=os.py

☘️【pkgutil】

pkgutil, fullname=pkgutil, file=pkgutil.py

☘️【socket】

socket, fullname=socket, file=socket.py

☘️【sys】

sys, fullname=sys, file=

☘️【werkzeug】

werkzeug, fullname=werkzeug, file=werkzeug_init_.py

🔵统计

序号	类别	数量
4	str	5
6	list	1
8	dict	1
9	module	16
10	class	3
11	function	1
13	residual	3
14	system	10
15	private	1
16	all	30

🔵模块

🌿1 werkzeug._internal

_internal, fullname=werkzeug._internal, file=werkzeug_internal.py

🌿2 werkzeug.exceptions

exceptions, fullname=werkzeug.exceptions, file=werkzeug\exceptions.py

	实现了许多可以在视图中引发的Python异常，以触发标准的HTTP非200响应。
	使用示例-。
	代码块： python
	从werkzeug导入请求。exception导入HTTPException, NotFound。
    def view(request):
        raise NotFound()

    @Request.application
    def application(request):
        try:
            return view(request)
        except HTTPException as e:
            return e

	从这个例子中可以看到，这些异常是可调用的WSGI应用程序。然而，它们不是Werkzeug响应对象。您可以通过在HTTP异常上调用 ``get_response()``来获得响应对象。
	请记住，您可能必须将环境(WSGI)或范围(ASGI)传递给 ``get_response()``，因为一些错误会获取与请求相关的额外信息。
	如果你想钩入一个不同的异常页面，比如404状态码，你可以添加第二个异常页面，除了一个特定的错误子类:
	代码块： python
    @Request.application
    def application(request):
        try:
            return view(request)
        except NotFound as e:
            return not_found(request)
        except HTTPException as e:
            return e

🌿3 werkzeug.urls

urls, fullname=werkzeug.urls, file=werkzeug\urls.py

	处理url的函数。
	包含 :mod:`urllib.parse`中处理字节和字符串的函数的实现。

🌿4 werkzeug.serving

serving, fullname=werkzeug.serving, file=werkzeug\serving.py

	仅在开发期间使用的WSGI和HTTP服务器。这个服务器使用起来很方便，但并不是特别稳定、安全或高效。在部署到生产环境时，使用专用的WSGI服务器和HTTP服务器。
	它提供了交互式调试和代码重载等特性。使用 ``run_simple``启动服务器。将其放入 ``run.py``脚本中:
	代码块： python
    from myapp import create_app
    from werkzeug import run_simple

🌿5 werkzeug.sansio

sansio, fullname=werkzeug.sansio, file=werkzeug\sansio_init_.py

🌿6 werkzeug.http

http, fullname=werkzeug.http, file=werkzeug\http.py

🌿7 werkzeug.datastructures

datastructures, fullname=werkzeug.datastructures, file=werkzeug\datastructures.py

🌿8 werkzeug.security

security, fullname=werkzeug.security, file=werkzeug\security.py

🌿9 werkzeug.wsgi

wsgi, fullname=werkzeug.wsgi, file=werkzeug\wsgi.py

🌿10 werkzeug.utils

utils, fullname=werkzeug.utils, file=werkzeug\utils.py

🌿11 werkzeug.formparser

formparser, fullname=werkzeug.formparser, file=werkzeug\formparser.py

🌿12 werkzeug.user_agent

user_agent, fullname=werkzeug.user_agent, file=werkzeug\user_agent.py

🌿13 werkzeug.wrappers

wrappers, fullname=werkzeug.wrappers, file=werkzeug\wrappers_init_.py

🌿14 werkzeug.test

test, fullname=werkzeug.test, file=werkzeug\test.py

🌿15 werkzeug.local

local, fullname=werkzeug.local, file=werkzeug\local.py

🌿16 werkzeug.routing

routing, fullname=werkzeug.routing, file=werkzeug\routing_init_.py

	当涉及到组合多个控制器或视图函数(无论您想如何调用它们)时，您需要调度程序。一种简单的方法是对 ``PATH_INFO``应用正则表达式测试，然后调用注册的回调函数返回值。
	这个模块实现了一个比简单的正则表达式匹配更强大的系统，因为它还可以转换url中的值并构建url。
	。
	代码块： python
    m = Map([
        # Static URLs
        Rule('/', endpoint='static/index'),
        Rule('/about', endpoint='static/about'),
        Rule('/help', endpoint='static/help'),
        # Knowledge Base
        Subdomain('kb', [
            Rule('/', endpoint='kb/index'),
            Rule('/browse/', endpoint='kb/browse'),
            Rule('/browse/<int:id>/', endpoint='kb/browse'),
            Rule('/browse/<int:id>/<int:page>', endpoint='kb/browse')
        ])
    ], default_subdomain='www')

	如果应用程序不使用子域，那么不设置默认子域和不使用 `Subdomain`规则工厂是完全可以的。规则中的端点可以是任何东西，例如导入路径或唯一标识符。
	WSGI应用程序可以使用这些端点来获取该URL的处理程序。它不需要是一个字符串，但建议这样做。
	现在可以为其中一个子域创建一个URL适配器并构建URL:
	代码块： python
    c = m.bind('example.com')

    c.build("kb/browse", dict(id=42))
    'http://kb.example.com/browse/42/'

    c.build("kb/browse", dict())
    'http://kb.example.com/browse/'

    c.build("kb/browse", dict(id=42, page=3))
    'http://kb.example.com/browse/42/3'

    c.build("static/about")
    '/about'

    c.build("static/index", force_external=True)
    'http://www.example.com/'

    c = m.bind('example.com', subdomain='kb')

    c.build("static/about")
    'http://www.example.com/about'

	要绑定的第一个参数是服务器名*不带子域*默认情况下，它会假设脚本挂载在根目录上，但通常情况下不是这样，所以你可以提供真正的挂载点作为第二个参数:
	代码块： python
    c = m.bind('example.com', '/applications/example')

	第三个参数可以是子域，如果没有给出，则使用默认子域。有关绑定的更多详细信息，请参阅 `MapAdapter`的文档。
	下面是如何匹配url:
	代码块： python
    c = m.bind('example.com')

    c.match("/")
    ('static/index', {})

    c.match("/about")
    ('static/about', {})

    c = m.bind('example.com', '/', 'kb')

    c.match("/")
    ('kb/index', {})

    c.match("/browse/42/23")
    ('kb/browse', {'id': 42, 'page': 23})

	如果匹配失败，你会得到一个 ``NotFound``异常，如果规则认为重定向是一个好主意(例如，因为URL被定义为在末尾有一个斜杠，但请求缺少这个斜杠)，
	它将引发一个 ``RequestRedirect``异常。它们都是 ``HTTPException``的子类，因此可以在应用程序中使用这些错误作为响应。
	如果匹配成功，但URL规则与给定方法不兼容(例如，只有 ``GET``和 ``HEAD``的规则，但路由试图匹配 ``POST``请求)，则引发 ``MethodNotAllowed``异常。

🔵函数

🌿17 run_simple(hostname: str, port: int, application: ‘WSGIApplication’, use_reloader: bool = False, use_debugger: bool = False,

use_evalex: bool = True, extra_files: Union[Iterable[str], NoneType] = None, exclude_patterns: Union[Iterable[str], NoneType] = None,
reloader_interval: int = 1, reloader_type: str = ‘auto’, threaded: bool = False, processes: int = 1,
request_handler: Union[Type[werkzeug.serving.WSGIRequestHandler], NoneType] = None, static_files: Union[Dict[str, Union[str, Tuple[str, str]]], NoneType] = None,
passthrough_errors: bool = False, ssl_context: Union[ForwardRef(‘ssl.SSLContext’), Tuple[str, Union[str, NoneType]], ForwardRef(“te.Literal[‘adhoc’]”), NoneType] = None) -> None

run_simple(hostname: str, port: int, application: ‘WSGIApplication’, use_reloader: bool = False, use_debugger: bool = False,
use_evalex: bool = True, extra_files: Union[Iterable[str], NoneType] = None, exclude_patterns: Union[Iterable[str], NoneType] = None,
reloader_interval: int = 1, reloader_type: str = ‘auto’, threaded: bool = False, processes: int = 1,
request_handler: Union[Type[werkzeug.serving.WSGIRequestHandler], NoneType] = None,
static_files: Union[Dict[str, Union[str, Tuple[str, str]]], NoneType] = None, passthrough_errors: bool = False,
ssl_context: Union[ForwardRef(‘ssl.SSLContext’), Tuple[str, Union[str, NoneType]], ForwardRef(“te.Literal[‘adhoc’]”), NoneType] = None) -> None,
module=werkzeug.serving, line:907 at site-packages\werkzeug\serving.py

	为WSGI应用程序启动一个开发服务器。可以启用各种可选功能。
	警告：
	    在部署到生产环境时不要使用开发服务器，它仅供本地开发期间使用。它的设计并不是特别高效、稳定或安全。
	:param hostname: 		    要绑定到的主机，例如 ``'localhost'``。Unix套接字可以是域名、IPv4或IPv6地址，也可以是以 ``unix://``开头的文件路径。
	:param port: 		        要绑定到的端口，例如 ``8080``。使用 ``0``告诉操作系统随机选择一个空闲端口。
	:param application: 		要运行的WSGI应用程序。
	:param use_reloader: 		当文件发生更改时，使用reloader进程重新启动服务器进程。
	:param use_debugger: 		使用Werkzeug的调试器，它将显示未处理异常的格式化跟踪。
	:param use_evalex: 		    使调试器具有交互性。可以为回溯中的任何帧打开Python终端。通过要求PIN提供了一些保护，但这绝不应该在公开可见的服务器上启用。
	:param extra_files: 		除了Python模块之外，重新加载器还会监视这些文件的更改。例如，查看配置文件。
	:param exclude_patterns: 	重新加载程序将忽略对匹配这些 :mod:`fnmatch`模式的任何文件的更改。例如，忽略缓存文件。
	:param reloader_interval: 	重新加载程序尝试检查更改的频率。
	:param reloader_type: 		要使用的重新加载器。 ``'stat'``重新加载程序是内置的，但可能需要大量CPU来查看文件。 ``'watchdog'``重新加载器更有效，但需要先安装 ``watchdog``包。
	:param threaded: 		    使用线程处理并发请求。不能与 ``processes``一起使用。
	:param processes: 		    处理并发请求时，最多使用此数量的进程。不能与 ``threaded``一起使用。
	:param request_handler: 	使用不同的 :class:`~BaseHTTPServer.BaseHTTPRequestHandler`子类来处理请求。
	:param static_files: 		将URL前缀映射到使用 :class:`~werkzeug.middleware.SharedDataMiddleware`提供静态文件的目录的字典。
	:param passthrough_errors: 	不要在服务器级别捕捉未处理的异常，而是让服务器崩溃。如果启用了 ``use_debugger``，调试器仍将捕获此类错误。
	:param ssl_context: 		配置TLS通过HTTPS提供服务。可以是一个 :class:`ssl.SSLContext`对象，
	                            一个 ``(cert_file, key_file)``元组来创建一个典型的上下文，或者字符串 ``'adhoc'``来生成一个临时的自签名证书。

	版本变更： 2.1	说明显示处理“地址已在使用中”错误。
	版本变更： 2.1	在 ``0.0.0.0``或 ``::``上运行显示的是除真实IP外的环回IP。
	版本变更： 2.1	删除命令行界面。
	版本变更： 2.0	在 ``0.0.0.0``或 ``::``上运行会显示绑定的真实IP地址，并警告不要在生产环境中运行开发服务器。
	版本变更： 2.0	添加 ``exclude_patterns``参数。
	版本变更： 0.15	通过传递以 ``unix://``开头的 ``hostname``绑定到Unix套接字。
	版本变更： 0.10	改进了重新加载程序，并添加了通过 ``reloader_type``参数更改后端的支持。
	版本变更： 0.9	增加命令行接口。
	版本变更： 0.8	``ssl_context``可以是证书和私钥文件路径的元组。
	版本变更： 0.6	添加 ``ssl_context``参数。
	版本变更： 0.5	添加 ``static_files``和 ``passthrough_errors``参数。

🔵类

🌿18 werkzeug.test.Client

Client, werkzeug.test.Client, module=werkzeug.test, line:0 at

	该类允许您向包装的应用程序发送请求。
	use cookies参数指示是否应该存储并为后续请求发送cookies。默认为True，但传入False将禁用此行为。
	如果您想请求应用程序的子域，您可以将 `allow_subdomain_redirects`设置为 `True`，因为不允许外部重定向。
	版本变更： 2.1	删除了将响应视为元组的弃用行为。所有数据都可以作为返回的响应对象的属性使用。
	版本变更： 2.0	``response_wrapper``始终是:class: ``TestResponse``的子类。
	版本变更： 0.5	增加了 ``use_cookies``参数。

🌿19 werkzeug.wrappers.request.Request

Request, werkzeug.wrappers.request.Request, module=werkzeug.wrappers.request, line:0 at

🌿19 werkzeug.wrappers.response.Response

Response, werkzeug.wrappers.response.Response, module=werkzeug.wrappers.response, line:0 at

🔵私有或局部

19 _internal <module ‘werkzeug._internal’ from ‘D:\Programs\Python\Python37\lib\site-packages\werkzeug\_internal.py’>

☘️【ast】

ast, fullname=ast, file=ast.py

☘️【inspect】

inspect, fullname=inspect, file=inspect.py

☘️【platform】

platform, fullname=platform, file=platform.py

☘️【re】

re, fullname=re, file=re.py

☘️【traceback】

traceback, fullname=traceback, file=traceback.py

☘️【click】

click, fullname=click, file=click_init_.py

	Click是一个简单的Python模块，受标准库optparse的启发，使编写命令行脚本变得有趣。与其他模块不同，它基于一个简单的API，没有太多的魔力，并且是可组合的。

☘️【errno】

errno, fullname=errno, file=

☘️【types】

types, fullname=types, file=types.py

☘️【contextvars】

contextvars, fullname=contextvars, file=contextvars.py

☘️【logging】

logging, fullname=logging, file=logging_init_.py

☘️【importlib】

importlib, fullname=importlib, file=importlib_init_.py

☘️【pathlib】

pathlib, fullname=pathlib, file=pathlib.py

☘️【hashlib】

hashlib, fullname=hashlib, file=hashlib.py

☘️【warnings】

warnings, fullname=warnings, file=warnings.py

☘️【functools】

functools, fullname=functools, file=functools.py

☘️【weakref】

weakref, fullname=weakref, file=weakref.py

☘️【dataclasses】

dataclasses, fullname=dataclasses, file=dataclasses.py

☘️【decimal】

decimal, fullname=decimal, file=decimal.py

☘️【uuid】

uuid, fullname=uuid, file=uuid.py