# Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. # msgid "" msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-15 22:33+0100\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: library/weakref.rst:4 msgid ":mod:`weakref` --- Weak references" msgstr "" #: library/weakref.rst:14 msgid "**Source code:** :source:`Lib/weakref.py`" msgstr "**Code source :** :source:`Lib/weakref.py`" #: library/weakref.rst:18 msgid "" "The :mod:`weakref` module allows the Python programmer to create :dfn:`weak " "references` to objects." msgstr "" #: library/weakref.rst:24 msgid "" "In the following, the term :dfn:`referent` means the object which is " "referred to by a weak reference." msgstr "" #: library/weakref.rst:27 msgid "" "A weak reference to an object is not enough to keep the object alive: when " "the only remaining references to a referent are weak references, :term:" "`garbage collection` is free to destroy the referent and reuse its memory " "for something else. However, until the object is actually destroyed the " "weak reference may return the object even if there are no strong references " "to it." msgstr "" #: library/weakref.rst:33 msgid "" "A primary use for weak references is to implement caches or mappings holding " "large objects, where it's desired that a large object not be kept alive " "solely because it appears in a cache or mapping." msgstr "" #: library/weakref.rst:37 msgid "" "For example, if you have a number of large binary image objects, you may " "wish to associate a name with each. If you used a Python dictionary to map " "names to images, or images to names, the image objects would remain alive " "just because they appeared as values or keys in the dictionaries. The :" "class:`WeakKeyDictionary` and :class:`WeakValueDictionary` classes supplied " "by the :mod:`weakref` module are an alternative, using weak references to " "construct mappings that don't keep objects alive solely because they appear " "in the mapping objects. If, for example, an image object is a value in a :" "class:`WeakValueDictionary`, then when the last remaining references to that " "image object are the weak references held by weak mappings, garbage " "collection can reclaim the object, and its corresponding entries in weak " "mappings are simply deleted." msgstr "" #: library/weakref.rst:50 msgid "" ":class:`WeakKeyDictionary` and :class:`WeakValueDictionary` use weak " "references in their implementation, setting up callback functions on the " "weak references that notify the weak dictionaries when a key or value has " "been reclaimed by garbage collection. :class:`WeakSet` implements the :" "class:`set` interface, but keeps weak references to its elements, just like " "a :class:`WeakKeyDictionary` does." msgstr "" #: library/weakref.rst:57 msgid "" ":class:`finalize` provides a straight forward way to register a cleanup " "function to be called when an object is garbage collected. This is simpler " "to use than setting up a callback function on a raw weak reference, since " "the module automatically ensures that the finalizer remains alive until the " "object is collected." msgstr "" #: library/weakref.rst:63 msgid "" "Most programs should find that using one of these weak container types or :" "class:`finalize` is all they need -- it's not usually necessary to create " "your own weak references directly. The low-level machinery is exposed by " "the :mod:`weakref` module for the benefit of advanced uses." msgstr "" #: library/weakref.rst:68 msgid "" "Not all objects can be weakly referenced. Objects which support weak " "references include class instances, functions written in Python (but not in " "C), instance methods, sets, frozensets, some :term:`file objects `, :term:`generators `, type objects, sockets, arrays, " "deques, regular expression pattern objects, and code objects." msgstr "" #: library/weakref.rst:74 msgid "Added support for thread.lock, threading.Lock, and code objects." msgstr "" #: library/weakref.rst:77 msgid "" "Several built-in types such as :class:`list` and :class:`dict` do not " "directly support weak references but can add support through subclassing::" msgstr "" #: library/weakref.rst:87 msgid "" "Other built-in types such as :class:`tuple` and :class:`int` do not support " "weak references even when subclassed." msgstr "" #: library/weakref.rst:90 msgid "" "Extension types can easily be made to support weak references; see :ref:" "`weakref-support`." msgstr "" #: library/weakref.rst:93 msgid "" "When ``__slots__`` are defined for a given type, weak reference support is " "disabled unless a ``'__weakref__'`` string is also present in the sequence " "of strings in the ``__slots__`` declaration. See :ref:`__slots__ " "documentation ` for details." msgstr "" #: library/weakref.rst:100 msgid "" "Return a weak reference to *object*. The original object can be retrieved " "by calling the reference object if the referent is still alive; if the " "referent is no longer alive, calling the reference object will cause :const:" "`None` to be returned. If *callback* is provided and not :const:`None`, and " "the returned weakref object is still alive, the callback will be called when " "the object is about to be finalized; the weak reference object will be " "passed as the only parameter to the callback; the referent will no longer be " "available." msgstr "" #: library/weakref.rst:108 msgid "" "It is allowable for many weak references to be constructed for the same " "object. Callbacks registered for each weak reference will be called from the " "most recently registered callback to the oldest registered callback." msgstr "" #: library/weakref.rst:112 msgid "" "Exceptions raised by the callback will be noted on the standard error " "output, but cannot be propagated; they are handled in exactly the same way " "as exceptions raised from an object's :meth:`__del__` method." msgstr "" #: library/weakref.rst:116 msgid "" "Weak references are :term:`hashable` if the *object* is hashable. They will " "maintain their hash value even after the *object* was deleted. If :func:" "`hash` is called the first time only after the *object* was deleted, the " "call will raise :exc:`TypeError`." msgstr "" #: library/weakref.rst:121 msgid "" "Weak references support tests for equality, but not ordering. If the " "referents are still alive, two references have the same equality " "relationship as their referents (regardless of the *callback*). If either " "referent has been deleted, the references are equal only if the reference " "objects are the same object." msgstr "" #: library/weakref.rst:126 msgid "This is a subclassable type rather than a factory function." msgstr "" #: library/weakref.rst:130 msgid "" "This read-only attribute returns the callback currently associated to the " "weakref. If there is no callback or if the referent of the weakref is no " "longer alive then this attribute will have value ``None``." msgstr "" #: library/weakref.rst:134 msgid "Added the :attr:`__callback__` attribute." msgstr "" #: library/weakref.rst:140 msgid "" "Return a proxy to *object* which uses a weak reference. This supports use " "of the proxy in most contexts instead of requiring the explicit " "dereferencing used with weak reference objects. The returned object will " "have a type of either ``ProxyType`` or ``CallableProxyType``, depending on " "whether *object* is callable. Proxy objects are not :term:`hashable` " "regardless of the referent; this avoids a number of problems related to " "their fundamentally mutable nature, and prevents their use as dictionary " "keys. *callback* is the same as the parameter of the same name to the :func:" "`ref` function." msgstr "" #: library/weakref.rst:149 msgid "" "Accessing an attribute of the proxy object after the referent is garbage " "collected raises :exc:`ReferenceError`." msgstr "" #: library/weakref.rst:152 msgid "" "Extended the operator support on proxy objects to include the matrix " "multiplication operators ``@`` and ``@=``." msgstr "" #: library/weakref.rst:159 msgid "" "Return the number of weak references and proxies which refer to *object*." msgstr "" #: library/weakref.rst:164 msgid "" "Return a list of all weak reference and proxy objects which refer to " "*object*." msgstr "" #: library/weakref.rst:169 msgid "" "Mapping class that references keys weakly. Entries in the dictionary will " "be discarded when there is no longer a strong reference to the key. This " "can be used to associate additional data with an object owned by other parts " "of an application without adding attributes to those objects. This can be " "especially useful with objects that override attribute accesses." msgstr "" #: library/weakref.rst:175 msgid "" "Note that when a key with equal value to an existing key (but not equal " "identity) is inserted into the dictionary, it replaces the value but does " "not replace the existing key. Due to this, when the reference to the " "original key is deleted, it also deletes the entry in the dictionary::" msgstr "" #: library/weakref.rst:188 msgid "A workaround would be to remove the key prior to reassignment::" msgstr "" #: library/weakref.rst:199 msgid "Added support for ``|`` and ``|=`` operators, specified in :pep:`584`." msgstr "" "Ajout de la gestion des opérateurs ``|`` et ``|=`` tels que définis dans :" "pep:`584`." #: library/weakref.rst:202 msgid "" ":class:`WeakKeyDictionary` objects have an additional method that exposes " "the internal references directly. The references are not guaranteed to be " "\"live\" at the time they are used, so the result of calling the references " "needs to be checked before being used. This can be used to avoid creating " "references that will cause the garbage collector to keep the keys around " "longer than needed." msgstr "" #: library/weakref.rst:212 msgid "Return an iterable of the weak references to the keys." msgstr "" #: library/weakref.rst:217 msgid "" "Mapping class that references values weakly. Entries in the dictionary will " "be discarded when no strong reference to the value exists any more." msgstr "" #: library/weakref.rst:220 msgid "" "Added support for ``|`` and ``|=`` operators, as specified in :pep:`584`." msgstr "" #: library/weakref.rst:223 msgid "" ":class:`WeakValueDictionary` objects have an additional method that has the " "same issues as the :meth:`keyrefs` method of :class:`WeakKeyDictionary` " "objects." msgstr "" #: library/weakref.rst:230 msgid "Return an iterable of the weak references to the values." msgstr "" #: library/weakref.rst:235 msgid "" "Set class that keeps weak references to its elements. An element will be " "discarded when no strong reference to it exists any more." msgstr "" #: library/weakref.rst:241 msgid "" "A custom :class:`ref` subclass which simulates a weak reference to a bound " "method (i.e., a method defined on a class and looked up on an instance). " "Since a bound method is ephemeral, a standard weak reference cannot keep " "hold of it. :class:`WeakMethod` has special code to recreate the bound " "method until either the object or the original function dies::" msgstr "" #: library/weakref.rst:265 msgid "" "*callback* is the same as the parameter of the same name to the :func:`ref` " "function." msgstr "" #: library/weakref.rst:271 msgid "" "Return a callable finalizer object which will be called when *obj* is " "garbage collected. Unlike an ordinary weak reference, a finalizer will " "always survive until the reference object is collected, greatly simplifying " "lifecycle management." msgstr "" #: library/weakref.rst:276 msgid "" "A finalizer is considered *alive* until it is called (either explicitly or " "at garbage collection), and after that it is *dead*. Calling a live " "finalizer returns the result of evaluating ``func(*arg, **kwargs)``, whereas " "calling a dead finalizer returns :const:`None`." msgstr "" #: library/weakref.rst:281 msgid "" "Exceptions raised by finalizer callbacks during garbage collection will be " "shown on the standard error output, but cannot be propagated. They are " "handled in the same way as exceptions raised from an object's :meth:" "`__del__` method or a weak reference's callback." msgstr "" #: library/weakref.rst:287 msgid "" "When the program exits, each remaining live finalizer is called unless its :" "attr:`atexit` attribute has been set to false. They are called in reverse " "order of creation." msgstr "" #: library/weakref.rst:291 msgid "" "A finalizer will never invoke its callback during the later part of the :" "term:`interpreter shutdown` when module globals are liable to have been " "replaced by :const:`None`." msgstr "" #: library/weakref.rst:297 msgid "" "If *self* is alive then mark it as dead and return the result of calling " "``func(*args, **kwargs)``. If *self* is dead then return :const:`None`." msgstr "" #: library/weakref.rst:303 msgid "" "If *self* is alive then mark it as dead and return the tuple ``(obj, func, " "args, kwargs)``. If *self* is dead then return :const:`None`." msgstr "" #: library/weakref.rst:309 msgid "" "If *self* is alive then return the tuple ``(obj, func, args, kwargs)``. If " "*self* is dead then return :const:`None`." msgstr "" #: library/weakref.rst:314 msgid "Property which is true if the finalizer is alive, false otherwise." msgstr "" #: library/weakref.rst:318 msgid "" "A writable boolean property which by default is true. When the program " "exits, it calls all remaining live finalizers for which :attr:`.atexit` is " "true. They are called in reverse order of creation." msgstr "" #: library/weakref.rst:325 msgid "" "It is important to ensure that *func*, *args* and *kwargs* do not own any " "references to *obj*, either directly or indirectly, since otherwise *obj* " "will never be garbage collected. In particular, *func* should not be a " "bound method of *obj*." msgstr "" #: library/weakref.rst:335 msgid "The type object for weak references objects." msgstr "" #: library/weakref.rst:340 msgid "The type object for proxies of objects which are not callable." msgstr "" #: library/weakref.rst:345 msgid "The type object for proxies of callable objects." msgstr "" #: library/weakref.rst:350 msgid "" "Sequence containing all the type objects for proxies. This can make it " "simpler to test if an object is a proxy without being dependent on naming " "both proxy types." msgstr "" #: library/weakref.rst:358 msgid ":pep:`205` - Weak References" msgstr "" #: library/weakref.rst:358 msgid "" "The proposal and rationale for this feature, including links to earlier " "implementations and information about similar features in other languages." msgstr "" #: library/weakref.rst:365 msgid "Weak Reference Objects" msgstr "Objets à références faibles" #: library/weakref.rst:367 msgid "" "Weak reference objects have no methods and no attributes besides :attr:`ref." "__callback__`. A weak reference object allows the referent to be obtained, " "if it still exists, by calling it:" msgstr "" #: library/weakref.rst:381 msgid "" "If the referent no longer exists, calling the reference object returns :" "const:`None`:" msgstr "" #: library/weakref.rst:388 msgid "" "Testing that a weak reference object is still live should be done using the " "expression ``ref() is not None``. Normally, application code that needs to " "use a reference object should follow this pattern::" msgstr "" #: library/weakref.rst:401 msgid "" "Using a separate test for \"liveness\" creates race conditions in threaded " "applications; another thread can cause a weak reference to become " "invalidated before the weak reference is called; the idiom shown above is " "safe in threaded applications as well as single-threaded applications." msgstr "" #: library/weakref.rst:406 msgid "" "Specialized versions of :class:`ref` objects can be created through " "subclassing. This is used in the implementation of the :class:" "`WeakValueDictionary` to reduce the memory overhead for each entry in the " "mapping. This may be most useful to associate additional information with a " "reference, but could also be used to insert additional processing on calls " "to retrieve the referent." msgstr "" #: library/weakref.rst:412 msgid "" "This example shows how a subclass of :class:`ref` can be used to store " "additional information about an object and affect the value that's returned " "when the referent is accessed::" msgstr "" #: library/weakref.rst:439 msgid "Example" msgstr "Exemple" #: library/weakref.rst:441 msgid "" "This simple example shows how an application can use object IDs to retrieve " "objects that it has seen before. The IDs of the objects can then be used in " "other data structures without forcing the objects to remain alive, but the " "objects can still be retrieved by ID if they do." msgstr "" #: library/weakref.rst:466 msgid "Finalizer Objects" msgstr "" #: library/weakref.rst:468 msgid "" "The main benefit of using :class:`finalize` is that it makes it simple to " "register a callback without needing to preserve the returned finalizer " "object. For instance" msgstr "" #: library/weakref.rst:482 msgid "" "The finalizer can be called directly as well. However the finalizer will " "invoke the callback at most once." msgstr "" #: library/weakref.rst:498 msgid "" "You can unregister a finalizer using its :meth:`~finalize.detach` method. " "This kills the finalizer and returns the arguments passed to the constructor " "when it was created." msgstr "" #: library/weakref.rst:512 msgid "" "Unless you set the :attr:`~finalize.atexit` attribute to :const:`False`, a " "finalizer will be called when the program exits if it is still alive. For " "instance" msgstr "" #: library/weakref.rst:527 msgid "Comparing finalizers with :meth:`__del__` methods" msgstr "" #: library/weakref.rst:529 msgid "" "Suppose we want to create a class whose instances represent temporary " "directories. The directories should be deleted with their contents when the " "first of the following events occurs:" msgstr "" #: library/weakref.rst:533 msgid "the object is garbage collected," msgstr "" #: library/weakref.rst:534 msgid "the object's :meth:`remove` method is called, or" msgstr "" #: library/weakref.rst:535 msgid "the program exits." msgstr "" #: library/weakref.rst:537 msgid "" "We might try to implement the class using a :meth:`__del__` method as " "follows::" msgstr "" #: library/weakref.rst:556 msgid "" "Starting with Python 3.4, :meth:`__del__` methods no longer prevent " "reference cycles from being garbage collected, and module globals are no " "longer forced to :const:`None` during :term:`interpreter shutdown`. So this " "code should work without any issues on CPython." msgstr "" #: library/weakref.rst:561 msgid "" "However, handling of :meth:`__del__` methods is notoriously implementation " "specific, since it depends on internal details of the interpreter's garbage " "collector implementation." msgstr "" #: library/weakref.rst:565 msgid "" "A more robust alternative can be to define a finalizer which only references " "the specific functions and objects that it needs, rather than having access " "to the full state of the object::" msgstr "" #: library/weakref.rst:581 msgid "" "Defined like this, our finalizer only receives a reference to the details it " "needs to clean up the directory appropriately. If the object never gets " "garbage collected the finalizer will still be called at exit." msgstr "" #: library/weakref.rst:585 msgid "" "The other advantage of weakref based finalizers is that they can be used to " "register finalizers for classes where the definition is controlled by a " "third party, such as running code when a module is unloaded::" msgstr "" #: library/weakref.rst:597 msgid "" "If you create a finalizer object in a daemonic thread just as the program " "exits then there is the possibility that the finalizer does not get called " "at exit. However, in a daemonic thread :func:`atexit.register`, ``try: ... " "finally: ...`` and ``with: ...`` do not guarantee that cleanup occurs either." msgstr ""