The gc module is only available if the interpreter was built
with the optional cyclic garbage detector (enabled by default). If
this was not enabled, an ImportError is raised by attempts
to import this module.
This module provides an interface to the optional garbage collector. It
provides the ability to disable the collector, tune the collection
frequency, and set debugging options. It also provides access to
unreachable objects that the collector found but cannot free. Since the
collector supplements the reference counting already used in Python, you
can disable the collector if you are sure your program does not create
reference cycles. Automatic collection can be disabled by calling
gc.disable(). To debug a leaking program call
gc.set_debug(gc.DEBUG_LEAK).
The gc module provides the following functions:
- enable()
-
Enable automatic garbage collection.
- disable()
-
Disable automatic garbage collection.
- isenabled()
-
Returns true if automatic collection is enabled.
- collect()
-
Run a full collection. All generations are examined and the
number of unreachable objects found is returned.
- set_debug(flags)
-
Set the garbage collection debugging flags.
Debugging information will be written to
sys.stderr. See below
for a list of debugging flags which can be combined using bit
operations to control debugging.
- get_debug()
-
Return the debugging flags currently set.
- set_threshold(threshold0[,
threshold1[, threshold2]])
-
Set the garbage collection thresholds (the collection frequency).
Setting threshold0 to zero disables collection.
The GC classifies objects into three generations depending on how many
collection sweeps they have survived. New objects are placed in the
youngest generation (generation 0). If an object survives a
collection it is moved into the next older generation. Since
generation 2 is the oldest generation, objects in that
generation remain there after a collection. In order to decide when
to run, the collector keeps track of the number object allocations and
deallocations since the last collection. When the number of
allocations minus the number of deallocations exceeds
threshold0, collection starts. Initially only generation
0 is examined. If generation 0 has been examined more
than threshold1 times since generation 1 has been
examined, then generation 1 is examined as well. Similarly,
threshold2 controls the number of collections of generation
1 before collecting generation 2.
- get_threshold()
-
Return the current collection thresholds as a tuple of
(threshold0, threshold1, threshold2).
- get_referrers(*objs)
-
Return the list of objects that directly refer to any of objs. This
function will only locate those containers which support garbage
collection; extension types which do refer to other objects but do not
support garbage collection will not be found.
New in version 2.2.
The following variable is provided for read-only access (you can
mutate its value but should not rebind it):
- garbage
-
A list of objects which the collector found to be unreachable
but could not be freed (uncollectable objects). By default, this list
contains only objects with __del__() methods.3.1Objects that have
__del__() methods and are part of a reference cycle cause
the entire reference cycle to be uncollectable, including objects
not necessarily in the cycle but reachable only from it. Python doesn't
collect such cycles automatically because, in general, it isn't possible
for Python to guess a safe order in which to run the __del__()
methods. If you know a safe order, you can force the issue by examining
the garbage list, and explicitly breaking cycles due to your
objects within the list. Note that these objects are kept alive even
so by virtue of being in the garbage list, so they should be
removed from garbage too. For example, after breaking cycles, do
del gc.garbage[:] to empty the list. It's generally better
to avoid the issue by not creating cycles containing objects with
__del__() methods, and garbage can be examined in that
case to verify that no such cycles are being created.
If DEBUG_SAVEALL is set, then all unreachable objects will
be added to this list rather than freed.
The following constants are provided for use with
set_debug():
- DEBUG_STATS
-
Print statistics during collection. This information can
be useful when tuning the collection frequency.
- DEBUG_COLLECTABLE
-
Print information on collectable objects found.
- DEBUG_UNCOLLECTABLE
-
Print information of uncollectable objects found (objects which are
not reachable but cannot be freed by the collector). These objects
will be added to the
garbage list.
- DEBUG_INSTANCES
-
When DEBUG_COLLECTABLE or DEBUG_UNCOLLECTABLE is
set, print information about instance objects found.
- DEBUG_OBJECTS
-
When DEBUG_COLLECTABLE or DEBUG_UNCOLLECTABLE is
set, print information about objects other than instance objects found.
- DEBUG_SAVEALL
-
When set, all unreachable objects found will be appended to
garbage rather than being freed. This can be useful for debugging
a leaking program.
- DEBUG_LEAK
-
The debugging flags necessary for the collector to print
information about a leaking program (equal to
DEBUG_COLLECTABLE |
DEBUG_UNCOLLECTABLE | DEBUG_INSTANCES | DEBUG_OBJECTS | DEBUG_SAVEALL).
Footnotes
- ... methods.3.1
- Prior to
Python 2.2, the list contained all instance objects in unreachable
cycles, not only those with __del__() methods.
See About this document... for information on suggesting changes.
