Unzip Yearly Subscription_@mapkey注解

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

原文：http://werkzeug.pocoo.org/docs/0.12/local/#werkzeug.local.LocalProxy

Sooner or later you have some things you want to have in every single view or helper function or whatever. In PHP the way to go are global variables. However, that isn’t possible in WSGI applications without a major drawback: As soon as you operate on the global namespace your application isn’t thread-safe any longer.

The Python standard library has a concept called “thread locals” (or thread-local data). A thread local is a global object in which you can put stuff in and get back later in a thread-safe and thread-specific way. That means that whenever you set or get a value on a thread local object, the thread local object checks in which thread you are and retrieves the value corresponding to your thread (if one exists). So, you won’t accidentally get another thread’s data.


Python标准库有一个名为“本地线程”的概念(或本地线程数据)。本地线程是一个全局对象，您可以用特定、安全的线程形式将其放入并于稍后将其返回。这意味着当您给本地线程对象上设置或获取值时，本地线程对象检查您所在的线程，并检索与您的线程对应的值(如果存在)。所以，你不会不小心得到另一个线程的数据。

This approach, however, has a few disadvantages. For example, besides threads, there are other types of concurrency in Python. A very popular one is greenlets. Also, whether every request gets its own thread is not guaranteed in WSGI. It could be that a request is reusing a thread from a previous request, and hence data is left over in the thread local object.
然而，这种方法有一些缺点。例如，除了线程之外，Python中还有其他类型的并发。其中一个非常受欢迎的是greenlets。同样，在WSGI中，每个请求都有自己的线程是无法保证的。有可能该请求正在重用以前请求的线程，因此在本地线程对象中保留了数据。

Werkzeug provides its own implementation of local data storage called werkzeug.local. This approach provides a similar functionality to thread locals but also works with greenlets.

Werkzeug提供了自己的本地数据存储的实现，称为Werkzeug . local。这种方法提供了一种类似于本地线程的功能，但也适用于greenlets。

Here’s a simple example of how one could use werkzeug.local:

from werkzeug.local import Local, LocalManager

local = Local()
local_manager = LocalManager([local])

def application(environ, start_response):
    local.request = request = Request(environ)
    ...

application = local_manager.make_middleware(application)

This binds the request to local.request. Every other piece of code executed after this assignment in the same context can safely access local.request and will get the same request object. Themake_middleware method on the local manager ensures that all references to the local objects are cleared up after the request.

这将请求绑定到local. request。在同一环境下执行此任务后执行的所有其他代码都可以安全地访问本地，并且将得到相同的请求对象。本地管理器上的make_middleware方法确保在请求之后，所有引用本地对象的内容都会被清除。

The same context means the same greenlet (if you’re using greenlets) in the same thread and same process.

在相同的线程和协程中，相同的环境意味着相同的greenlet(如果您正在使用greenlets)。

If a request object is not yet set on the local object and you try to access it, you will get anAttributeError. You can use getattr to avoid that:

如果一个请求对象还没有设置在本地对象上，并且您尝试访问它，那么您将得到一个AttributeError。你可以使用getattr来避免:

def get_request():
    return getattr(local, 'request', None)

This will try to get the request or return None if the request is not (yet?) available.

这将尝试获得请求，如果请求不存在则返回None。

Note that local objects cannot manage themselves, for that you need a local manager. You can pass a local manager multiple locals or add additionals later by appending them tomanager.locals and every time the manager cleans up it will clean up all the data left in the locals for this context.

注意，本地对象不能管理自己，因此您需要一个本地管理器。您可以把多个区域变量传递给本地管理器，或在稍后通过appending的方式把额外的东西添加到管理器。每当管理器清空，会把这个环境下的所有区域变量的数据清空。

werkzeug.local.
release_local
(
local
)

Releases the contents of the local for the current context.This makes it possible to use locals without a manager.

为当前环境释放本地内容。这使得在没有管理器的情况下使用区域变量成为可能。

Example:

>>> loc = Local()
>>> loc.foo = 42
>>> release_local(loc)
>>> hasattr(loc, 'foo')
False

With this function one can release Local objects as well as LocalStack objects. However it is not possible to release data held by proxies that way, one always has to retain a reference to the underlying local object in order to be able to release it.

使用这个函数，可以释放本地对象和LocalStack对象。但是，不能通过这种方式释放代理所持有的数据，因此，始终必须保留对底层本地对象的引用，以便能够释放它。

New in version 0.6.1.

class
werkzeug.local.
LocalManager
(
locals=None,
ident_func=None
)

Local objects cannot manage themselves. For that you need a local manager. You can pass a local manager multiple locals or add them later by appending them tomanager.locals. Every time the manager cleans up,it will clean up all the data left in the locals for this context.

本地对象不能管理自己，因此您需要一个本地管理器。您可以把多个区域变量传递给本地管理器，或在稍后通过appending的方式把额外的东西添加到管理器。每当管理器清空，会把这个环境下的所有区域变量的数据清空。

The ident_func parameter can be added to override the default ident function for the wrapped locals.

可以添加ident_func参数来重写包装好的本地函数中的默认ident函数。

cleanup
(
)

Manually clean up the data in the locals for this context. Call this at the end of the request or usemake_middleware().

手动清除当前环境下的区域变量数据。在请求的最后调用这个或者使用make_middleware()。

    get_ident
(
)

             Return the context identifier the local objects use internally for this context. You cannot override this method to change the behavior but use it to link other                      context local objects (such as SQLAlchemy’s scoped sessions) to the Werkzeug locals.

                         
返回本地对象在当前环境内存下使用的环境标识符。您不能重写这个方法来改变这个行为，而是用它来连接其他环境下的本地对象（例如           SQLAlchemy                            的scoped sessions）和Werkzeug locals。

make_middleware
(
app
)

Wrap a WSGI application so that cleaning up happens afterrequest end.

封装一个WSGI应用程序，以便在请求结束后进行清理。

    middleware
(
func
)

          Like make_middleware but for decorating functions.

          make_middleware的装饰函数形式。

          Example usage:

 @manager.middleware
 def application(environ, start_response):
        ...

          The difference to
make_middleware is that the function passed will have all the arguments copied from the inner application(name, docstring, module).

          与make_middleware不同的是，传递的函数将包含从内部应用程序复制的所有参数(name、docstring、module)。

class
werkzeug.local.
LocalStack

>>> ls = LocalStack()
>>> ls.push(42)
>>> ls.top
42
>>> ls.push(23)
>>> ls.top
23
>>> ls.pop()
23
>>> ls.top
42

class
werkzeug.local.
LocalProxy
(
local,
name=None
)

from werkzeug.local import Local
l = Local()

# these are proxies
request = l('request')
user = l('user')


from werkzeug.local import LocalStack
_response_local = LocalStack()

# this is a proxy
response = _response_local()

session = LocalProxy(lambda: get_current_request().session)

>>> from werkzeug.local import LocalProxy
>>> isinstance(request, LocalProxy)
True

from werkzeug.local import Local, LocalProxy
local = Local()
request = LocalProxy(local, 'request')