Google Code offered in: 中文 - English - Português - Pусский - Español - 日本語
The Python runtime environment caches imported modules between requests on a single web server, similar to how a standalone Python application loads a module only once even if the module is imported by multiple files. If a handler script provides a main()
routine, the runtime environment also caches the script. Otherwise, the handler script is loaded for every request.
App caching provides a significant benefit in response time. We recommend that all applications use a main()
routine, as described below.
For efficiency, the web server keeps imported modules in memory and does not re-load or re-evaluate them on subsequent requests to the same application on the same server. Most modules do not initialize any global data or have other side effects when they are imported, so caching them does not change the behavior of the application.
If your application imports a module that depends on the module being evaluated for every request, the application must accommodate this caching behavior.
The following example demonstrates how an imported module is cached. Because mymodule
is only imported once for a single web server, the global mymodule.counter
is only initialized to 0
on the first request served by the server. Subsequent requests use the value from the previous request.
### mymodule.py counter = 0 def increment(): global counter counter += 1 return counter ### myhandler.py import mymodule print "Content-Type: text/plain" print "" print "My number: " + str(mymodule.increment())
This outputs My number: #
where #
is the number of times this handler has been called by the web server that handled the request.
You can tell App Engine to cache the handler script itself, in addition to imported modules. If the handler script defines a function named main()
, then the script and its global environment will be cached like an imported module. The first request for the script on a given web server evaluates the script normally. For subsequent requests, App Engine calls the main()
function in the cached environment.
To cache a handler script, App Engine must be able to call main()
with no arguments. If the handler script does not define a main()
function, or the main()
function requires arguments (that don't have defaults), then App Engine loads and evaluates the entire script for every request.
Keeping the parsed Python code in memory saves time and allows for faster responses. Caching the global environment has other potential uses as well:
The following example does the same thing as the previous example, using caching of the handler script's global environment:
### myhandler.py # A global variable, cached between requests on this web server. counter = 0 def main(): global counter counter += 1 print "Content-Type: text/plain" print "" print "My number: " + str(counter) if __name__ == "__main__": main()
Note: Be careful to not "leak" user-specific information between requests. Avoid global variables unless caching is desired, and always initialize request-specific data inside the main()
routine.
App caching with main()
provides a significant improvement in your application's response time. We recommend it for all applications.