Python 会话究竟返回了什么对象。_get_current_object（）？

我正在使用Flask，努力了解会话如何工作的细节，我正在使用：

• Python 3.6.1
• 烧瓶0.12.2

烧瓶文件（粗体是我的）：

session对象的工作原理与普通dict非常相似，具有 区别在于它跟踪修改

这是一个代理

提到（同样，粗体是我的）：

如果您需要访问 对于代理的基础对象，可以使用 方法

因此，对于请求或线程，底层对象（

session.\u get\u current\u object（）

）必须保持不变。尽管如此，它既不持久，也不在请求内部，也不在线程内部

下面是一个演示代码：

import threading

    from flask import (
    Flask,
    session,
    )

    app = Flask(__name__)
    app.secret_key = 'some random secret key'

    @app.route('/')
    def index():
        print("session ID is: {}".format(id(session)))
        print("session._get_current_object() ID is: {}".format(id(session._get_current_object())))
        print("threading.current_thread().ident is: {}".format(threading.current_thread().ident))
        print('________________________________')
        return 'Check the console! ;-)'

如果您运行上面的Flask应用程序，并反复转到

会话返回的
/
-id.\u get\u current\u object（）

会偶尔更改，而

线程。current\u thread（）.ident

不会更改

这使我提出以下问题：

会话究竟返回了什么。\u获取\u当前\u对象（）

我知道它是一个位于

session

proxy底层的对象，但是这个底层对象绑定到什么（如果它不是一个请求，也不是一个线程，如果我希望它永远不会改变，对于上面的简单应用程序）

会话究竟返回了什么。\u获取\u当前\u对象（）

从技术上讲，它是名为的实例中最顶层元素的

会话

属性中引用的对象。
该堆栈最顶层的元素是在中实例化的，每个HTTP请求都会调用该元素。
RequestContext实现方法将

和
pop
自身推送到本地堆栈
\u request\u ctx\u堆栈
。
push
方法还负责上下文

此会话在
会话
代理中可用；已初始化
RequestContext
的请求通过
request
代理可用。这两个代理仅在请求上下文中可用，即在处理活动HTTP请求时可用

我知道它是会话代理的底层对象，但这是什么
基础对象绑定到（如果它不是请求也不是
线程，如果有什么我会期待它永远不会改变，为简单
以上的申请

如上所述，由
会话
本地代理代理的请求上下文会话属于
请求上下文
。每一个请求都在改变。如中所述，为每个请求创建一个新的上下文，并在每次执行
push
时创建一个新会话。

session.\u get\u current\u object（）
的id在连续请求之间保持不变，这可能是因为新会话对象是在与前一个请求中的旧会话对象占用的内存地址相同的内存地址中创建的

另请参见：烧瓶文档的一节

会话究竟返回了什么。\u获取\u当前\u对象（）

从技术上讲，它是名为的实例中最顶层元素的
会话
属性中引用的对象。

该堆栈最顶层的元素是在中实例化的，每个HTTP请求都会调用该元素。
RequestContext

实现方法将

和
pop
自身推送到本地堆栈
\u request\u ctx\u堆栈
。
push
方法还负责上下文

此会话在
会话
代理中可用；已初始化
RequestContext
的请求通过
request
代理可用。这两个代理仅在请求上下文中可用，即在处理活动HTTP请求时可用

我知道它是会话代理的底层对象，但这是什么
基础对象绑定到（如果它不是请求也不是
线程，如果有什么我会期待它永远不会改变，为简单
以上的申请

如上所述，由
会话
本地代理代理的请求上下文会话属于
请求上下文
。每一个请求都在改变。如中所述，为每个请求创建一个新的上下文，并在每次执行
push
时创建一个新会话。

session.\u get\u current\u object（）
的id在连续请求之间保持不变，这可能是因为新会话对象是在与前一个请求中的旧会话对象占用的内存地址相同的内存地址中创建的

另请参见：Flask文档的一节。
这里是一个经过修改的代码片段，通过

导入线程
从烧瓶进口(
瓶子
一场
要求
)
app=烧瓶（名称）
app.secret\u key='一些随机密钥'
@应用程序路径（“/”）
def index（）：
打印（“>>>会话请求线程这里是一个修改过的代码片段，通过

导入线程
从烧瓶进口(
瓶子
一场
要求
)
app=烧瓶（名称）
app.secret\u key='一些随机密钥'
@应用程序路径（“/”）
def index（）：
打印（“>>>会话请求线程我感谢如此详尽的解释！我感谢如此详尽的解释！中给出了对该问题的良好解释。中给出了对该问题的良好解释。
import threading

from flask import (
Flask,
session,
request
)

app = Flask(__name__)
app.secret_key = 'some random secret key'

@app.route('/')
def index():
    print(">>> session <<<")
    session_id = id(session)
    session_object_id = id(session._get_current_object())
    print("ID: {}".format(session_id),
          "Same as previous: {}".format(session.get('prev_sess_id', '') == session_id))
    print("_get_current_object() ID: {}".format(session_object_id),
          "Same as previous: {}".format(session.get('prev_sess_obj_id', '') == session_object_id))
    session['prev_sess_id'] = session_id
    session['prev_sess_obj_id'] = session_object_id

    print("\n>>> request <<<")
    request_id = id(request)
    request_object_id = id(request._get_current_object())
    print("request ID is: {}".format(request_id),
          "Same as previous: {}".format(session.get('prev_request_id', '') == request_id))
    print("request._get_current_object() ID is: {}".format(id(request._get_current_object())),
          "Same as previous: {}".format(session.get('prev_request_obj_id', '') == request_object_id))
    session['prev_request_id'] = request_id
    session['prev_request_obj_id'] = request_object_id

    print("\n>>> thread <<<")
    thread_id = threading.current_thread().ident
    print("threading.current_thread().ident is: {}".format(threading.current_thread().ident),
          "Same as previous: {}".format(session.get('prev_thread', '') == thread_id))
    session['prev_thread'] = thread_id
    print('-' * 100)
    return 'Check the console! ;-)'