forked from AFPy/python-docs-fr
1395 lines
50 KiB
Plaintext
1395 lines
50 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3.6\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2019-09-04 11:33+0200\n"
|
||
"PO-Revision-Date: 2019-02-26 12:09+0100\n"
|
||
"Last-Translator: \n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 2.0.6\n"
|
||
|
||
#: ../Doc/library/pickle.rst:2
|
||
msgid ":mod:`pickle` --- Python object serialization"
|
||
msgstr ":mod:`pickle` --- Module de sérialisation d'objets Python"
|
||
|
||
#: ../Doc/library/pickle.rst:10
|
||
msgid "**Source code:** :source:`Lib/pickle.py`"
|
||
msgstr "**Code source :** :source:`Lib/pickle.py`"
|
||
|
||
#: ../Doc/library/pickle.rst:22
|
||
msgid ""
|
||
"The :mod:`pickle` module implements binary protocols for serializing and de-"
|
||
"serializing a Python object structure. *\"Pickling\"* is the process "
|
||
"whereby a Python object hierarchy is converted into a byte stream, and *"
|
||
"\"unpickling\"* is the inverse operation, whereby a byte stream (from a :"
|
||
"term:`binary file` or :term:`bytes-like object`) is converted back into an "
|
||
"object hierarchy. Pickling (and unpickling) is alternatively known as "
|
||
"\"serialization\", \"marshalling,\" [#]_ or \"flattening\"; however, to "
|
||
"avoid confusion, the terms used here are \"pickling\" and \"unpickling\"."
|
||
msgstr ""
|
||
"Le module :mod:`pickle` implémente des protocoles binaires de sérialisation "
|
||
"et dé-sérialisation d'objets Python. Le *pickling* est le procédé par lequel "
|
||
"une hiérarchie d'objets Python est convertie en flux d'octets. *unpickling* "
|
||
"est l'opération inverse, par laquelle un flux d'octets (à partir d'un :term:"
|
||
"`binary file` ou :term:`bytes-like object`) est converti en hiérarchie "
|
||
"d'objets. *Pickling* (et *unpickling*) sont alternativement connus sous les "
|
||
"termes de \"sérialisation\", de \"*marshalling*\" [#]_ ou encore de "
|
||
"\"*flattening*\". Cependant pour éviter la confusion les termes utilisés ici "
|
||
"sont *pickling* et *unpickling*."
|
||
|
||
#: ../Doc/library/pickle.rst:33
|
||
msgid "The ``pickle`` module **is not secure**. Only unpickle data you trust."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:35
|
||
msgid ""
|
||
"It is possible to construct malicious pickle data which will **execute "
|
||
"arbitrary code during unpickling**. Never unpickle data that could have come "
|
||
"from an untrusted source, or that could have been tampered with."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:39
|
||
msgid ""
|
||
"Consider signing data with :mod:`hmac` if you need to ensure that it has not "
|
||
"been tampered with."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:42
|
||
msgid ""
|
||
"Safer serialization formats such as :mod:`json` may be more appropriate if "
|
||
"you are processing untrusted data. See :ref:`comparison-with-json`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:47
|
||
msgid "Relationship to other Python modules"
|
||
msgstr "Relations aux autres modules python"
|
||
|
||
#: ../Doc/library/pickle.rst:50
|
||
msgid "Comparison with ``marshal``"
|
||
msgstr "Comparaison avec ``marshal``"
|
||
|
||
#: ../Doc/library/pickle.rst:52
|
||
msgid ""
|
||
"Python has a more primitive serialization module called :mod:`marshal`, but "
|
||
"in general :mod:`pickle` should always be the preferred way to serialize "
|
||
"Python objects. :mod:`marshal` exists primarily to support Python's :file:`."
|
||
"pyc` files."
|
||
msgstr ""
|
||
"Python possède un module de bas niveau en sérialisation appelé :mod:"
|
||
"`marshal`, mais en général il est préférable d'utiliser :mod:`pickle` pour "
|
||
"sérialiser des objets Python. :mod:`marshal` existe principalement pour "
|
||
"gérer les fichiers Python en :file:`.pyc`."
|
||
|
||
#: ../Doc/library/pickle.rst:57
|
||
msgid ""
|
||
"The :mod:`pickle` module differs from :mod:`marshal` in several significant "
|
||
"ways:"
|
||
msgstr ""
|
||
"Le module :mod:`pickle` diffère du module :mod:`marshal` sur plusieurs "
|
||
"aspects :"
|
||
|
||
#: ../Doc/library/pickle.rst:59
|
||
msgid ""
|
||
"The :mod:`pickle` module keeps track of the objects it has already "
|
||
"serialized, so that later references to the same object won't be serialized "
|
||
"again. :mod:`marshal` doesn't do this."
|
||
msgstr ""
|
||
"Le module :mod:`pickle` garde la trace des objets qu'il a déjà sérialisés, "
|
||
"pour faire en sorte que les prochaines références à cet objet ne soient pas "
|
||
"sérialisées à nouveau. :mod:`marshal` ne le fait pas."
|
||
|
||
#: ../Doc/library/pickle.rst:63
|
||
msgid ""
|
||
"This has implications both for recursive objects and object sharing. "
|
||
"Recursive objects are objects that contain references to themselves. These "
|
||
"are not handled by marshal, and in fact, attempting to marshal recursive "
|
||
"objects will crash your Python interpreter. Object sharing happens when "
|
||
"there are multiple references to the same object in different places in the "
|
||
"object hierarchy being serialized. :mod:`pickle` stores such objects only "
|
||
"once, and ensures that all other references point to the master copy. "
|
||
"Shared objects remain shared, which can be very important for mutable "
|
||
"objects."
|
||
msgstr ""
|
||
"Ça a des implications sur les objets partagés et les objets récursifs. Les "
|
||
"objets récursifs sont des objets qui contiennent des références à eux-mêmes. "
|
||
"Ceux-ci ne sont pas gérées par marshal : lui donner un objet récursif va le "
|
||
"faire planter. Un objet est partagé lorsque que plusieurs références "
|
||
"pointent dessus, depuis différents endroits dans la hiérarchie sérialisée. "
|
||
"Le module :mod:`pickle` repère ces partages et ne stocke ces objets qu'une "
|
||
"seule fois. Les objets partagés restent ainsi partagés, ce qui peut être "
|
||
"très important pour les objets muables."
|
||
|
||
#: ../Doc/library/pickle.rst:72
|
||
msgid ""
|
||
":mod:`marshal` cannot be used to serialize user-defined classes and their "
|
||
"instances. :mod:`pickle` can save and restore class instances "
|
||
"transparently, however the class definition must be importable and live in "
|
||
"the same module as when the object was stored."
|
||
msgstr ""
|
||
":mod:`marshal` ne peut être utilisé pour la sérialisation et l'instanciation "
|
||
"de classes définies par les utilisateurs. :mod:`pickle` peut sauvegarder et "
|
||
"restaurer les instances de classes de manière transparente. Cependant la "
|
||
"définition de classe doit être importable et lancée dans le même module et "
|
||
"de la même manière que lors de son importation."
|
||
|
||
#: ../Doc/library/pickle.rst:77
|
||
msgid ""
|
||
"The :mod:`marshal` serialization format is not guaranteed to be portable "
|
||
"across Python versions. Because its primary job in life is to support :file:"
|
||
"`.pyc` files, the Python implementers reserve the right to change the "
|
||
"serialization format in non-backwards compatible ways should the need arise. "
|
||
"The :mod:`pickle` serialization format is guaranteed to be backwards "
|
||
"compatible across Python releases provided a compatible pickle protocol is "
|
||
"chosen and pickling and unpickling code deals with Python 2 to Python 3 type "
|
||
"differences if your data is crossing that unique breaking change language "
|
||
"boundary."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:90
|
||
msgid "Comparison with ``json``"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:92
|
||
msgid ""
|
||
"There are fundamental differences between the pickle protocols and `JSON "
|
||
"(JavaScript Object Notation) <http://json.org>`_:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:95
|
||
msgid ""
|
||
"JSON is a text serialization format (it outputs unicode text, although most "
|
||
"of the time it is then encoded to ``utf-8``), while pickle is a binary "
|
||
"serialization format;"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:99
|
||
msgid "JSON is human-readable, while pickle is not;"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:101
|
||
msgid ""
|
||
"JSON is interoperable and widely used outside of the Python ecosystem, while "
|
||
"pickle is Python-specific;"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:104
|
||
msgid ""
|
||
"JSON, by default, can only represent a subset of the Python built-in types, "
|
||
"and no custom classes; pickle can represent an extremely large number of "
|
||
"Python types (many of them automatically, by clever usage of Python's "
|
||
"introspection facilities; complex cases can be tackled by implementing :ref:"
|
||
"`specific object APIs <pickle-inst>`);"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:110
|
||
msgid ""
|
||
"Unlike pickle, deserializing untrusted JSON does not in itself create an "
|
||
"arbitrary code execution vulnerability."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:114
|
||
msgid ""
|
||
"The :mod:`json` module: a standard library module allowing JSON "
|
||
"serialization and deserialization."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:121
|
||
msgid "Data stream format"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:126
|
||
msgid ""
|
||
"The data format used by :mod:`pickle` is Python-specific. This has the "
|
||
"advantage that there are no restrictions imposed by external standards such "
|
||
"as JSON or XDR (which can't represent pointer sharing); however it means "
|
||
"that non-Python programs may not be able to reconstruct pickled Python "
|
||
"objects."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:131
|
||
msgid ""
|
||
"By default, the :mod:`pickle` data format uses a relatively compact binary "
|
||
"representation. If you need optimal size characteristics, you can "
|
||
"efficiently :doc:`compress <archiving>` pickled data."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:135
|
||
msgid ""
|
||
"The module :mod:`pickletools` contains tools for analyzing data streams "
|
||
"generated by :mod:`pickle`. :mod:`pickletools` source code has extensive "
|
||
"comments about opcodes used by pickle protocols."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:139
|
||
msgid ""
|
||
"There are currently 5 different protocols which can be used for pickling. "
|
||
"The higher the protocol used, the more recent the version of Python needed "
|
||
"to read the pickle produced."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:143
|
||
msgid ""
|
||
"Protocol version 0 is the original \"human-readable\" protocol and is "
|
||
"backwards compatible with earlier versions of Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:146
|
||
msgid ""
|
||
"Protocol version 1 is an old binary format which is also compatible with "
|
||
"earlier versions of Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:149
|
||
msgid ""
|
||
"Protocol version 2 was introduced in Python 2.3. It provides much more "
|
||
"efficient pickling of :term:`new-style class`\\es. Refer to :pep:`307` for "
|
||
"information about improvements brought by protocol 2."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:153
|
||
msgid ""
|
||
"Protocol version 3 was added in Python 3.0. It has explicit support for :"
|
||
"class:`bytes` objects and cannot be unpickled by Python 2.x. This was the "
|
||
"default protocol in Python 3.0--3.7."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:157
|
||
msgid ""
|
||
"Protocol version 4 was added in Python 3.4. It adds support for very large "
|
||
"objects, pickling more kinds of objects, and some data format "
|
||
"optimizations. It is the default protocol starting with Python 3.8. Refer "
|
||
"to :pep:`3154` for information about improvements brought by protocol 4."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:164
|
||
msgid ""
|
||
"Serialization is a more primitive notion than persistence; although :mod:"
|
||
"`pickle` reads and writes file objects, it does not handle the issue of "
|
||
"naming persistent objects, nor the (even more complicated) issue of "
|
||
"concurrent access to persistent objects. The :mod:`pickle` module can "
|
||
"transform a complex object into a byte stream and it can transform the byte "
|
||
"stream into an object with the same internal structure. Perhaps the most "
|
||
"obvious thing to do with these byte streams is to write them onto a file, "
|
||
"but it is also conceivable to send them across a network or store them in a "
|
||
"database. The :mod:`shelve` module provides a simple interface to pickle "
|
||
"and unpickle objects on DBM-style database files."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:177
|
||
msgid "Module Interface"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:179
|
||
msgid ""
|
||
"To serialize an object hierarchy, you simply call the :func:`dumps` "
|
||
"function. Similarly, to de-serialize a data stream, you call the :func:"
|
||
"`loads` function. However, if you want more control over serialization and "
|
||
"de-serialization, you can create a :class:`Pickler` or an :class:`Unpickler` "
|
||
"object, respectively."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:184
|
||
msgid "The :mod:`pickle` module provides the following constants:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:189
|
||
msgid ""
|
||
"An integer, the highest :ref:`protocol version <pickle-protocols>` "
|
||
"available. This value can be passed as a *protocol* value to functions :"
|
||
"func:`dump` and :func:`dumps` as well as the :class:`Pickler` constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:196
|
||
msgid ""
|
||
"An integer, the default :ref:`protocol version <pickle-protocols>` used for "
|
||
"pickling. May be less than :data:`HIGHEST_PROTOCOL`. Currently the default "
|
||
"protocol is 4, first introduced in Python 3.4 and incompatible with previous "
|
||
"versions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:203
|
||
msgid "The default protocol is 3."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:207
|
||
msgid "The default protocol is 4."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:209
|
||
msgid ""
|
||
"The :mod:`pickle` module provides the following functions to make the "
|
||
"pickling process more convenient:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:214
|
||
msgid ""
|
||
"Write a pickled representation of *obj* to the open :term:`file object` "
|
||
"*file*. This is equivalent to ``Pickler(file, protocol).dump(obj)``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:217
|
||
msgid ""
|
||
"Arguments *file*, *protocol*, *fix_imports* and *buffer_callback* have the "
|
||
"same meaning as in the :class:`Pickler` constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:220 ../Doc/library/pickle.rst:231
|
||
#: ../Doc/library/pickle.rst:323
|
||
msgid "The *buffer_callback* argument was added."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:225
|
||
msgid ""
|
||
"Return the pickled representation of the object as a :class:`bytes` object, "
|
||
"instead of writing it to a file."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:228
|
||
msgid ""
|
||
"Arguments *protocol*, *fix_imports* and *buffer_callback* have the same "
|
||
"meaning as in the :class:`Pickler` constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:236
|
||
msgid ""
|
||
"Read a pickled object representation from the open :term:`file object` "
|
||
"*file* and return the reconstituted object hierarchy specified therein. This "
|
||
"is equivalent to ``Unpickler(file).load()``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:240 ../Doc/library/pickle.rst:255
|
||
msgid ""
|
||
"The protocol version of the pickle is detected automatically, so no protocol "
|
||
"argument is needed. Bytes past the pickled object's representation are "
|
||
"ignored."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:244 ../Doc/library/pickle.rst:259
|
||
msgid ""
|
||
"Arguments *file*, *fix_imports*, *encoding*, *errors*, *strict* and "
|
||
"*buffers* have the same meaning as in the :class:`Unpickler` constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:247 ../Doc/library/pickle.rst:262
|
||
#: ../Doc/library/pickle.rst:424
|
||
msgid "The *buffers* argument was added."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:252
|
||
msgid ""
|
||
"Read a pickled object hierarchy from a :class:`bytes` object and return the "
|
||
"reconstituted object hierarchy specified therein."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:266
|
||
msgid "The :mod:`pickle` module defines three exceptions:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:270
|
||
msgid ""
|
||
"Common base class for the other pickling exceptions. It inherits :exc:"
|
||
"`Exception`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:275
|
||
msgid ""
|
||
"Error raised when an unpicklable object is encountered by :class:`Pickler`. "
|
||
"It inherits :exc:`PickleError`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:278
|
||
msgid ""
|
||
"Refer to :ref:`pickle-picklable` to learn what kinds of objects can be "
|
||
"pickled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:283
|
||
msgid ""
|
||
"Error raised when there is a problem unpickling an object, such as a data "
|
||
"corruption or a security violation. It inherits :exc:`PickleError`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:286
|
||
msgid ""
|
||
"Note that other exceptions may also be raised during unpickling, including "
|
||
"(but not necessarily limited to) AttributeError, EOFError, ImportError, and "
|
||
"IndexError."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:291
|
||
msgid ""
|
||
"The :mod:`pickle` module exports three classes, :class:`Pickler`, :class:"
|
||
"`Unpickler` and :class:`PickleBuffer`:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:296
|
||
msgid "This takes a binary file for writing a pickle data stream."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:298
|
||
msgid ""
|
||
"The optional *protocol* argument, an integer, tells the pickler to use the "
|
||
"given protocol; supported protocols are 0 to :data:`HIGHEST_PROTOCOL`. If "
|
||
"not specified, the default is :data:`DEFAULT_PROTOCOL`. If a negative "
|
||
"number is specified, :data:`HIGHEST_PROTOCOL` is selected."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:303
|
||
msgid ""
|
||
"The *file* argument must have a write() method that accepts a single bytes "
|
||
"argument. It can thus be an on-disk file opened for binary writing, an :"
|
||
"class:`io.BytesIO` instance, or any other custom object that meets this "
|
||
"interface."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:308
|
||
msgid ""
|
||
"If *fix_imports* is true and *protocol* is less than 3, pickle will try to "
|
||
"map the new Python 3 names to the old module names used in Python 2, so that "
|
||
"the pickle data stream is readable with Python 2."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:312
|
||
msgid ""
|
||
"If *buffer_callback* is None (the default), buffer views are serialized into "
|
||
"*file* as part of the pickle stream."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:315
|
||
msgid ""
|
||
"If *buffer_callback* is not None, then it can be called any number of times "
|
||
"with a buffer view. If the callback returns a false value (such as None), "
|
||
"the given buffer is :ref:`out-of-band <pickle-oob>`; otherwise the buffer is "
|
||
"serialized in-band, i.e. inside the pickle stream."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:320
|
||
msgid ""
|
||
"It is an error if *buffer_callback* is not None and *protocol* is None or "
|
||
"smaller than 5."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:328
|
||
msgid ""
|
||
"Write a pickled representation of *obj* to the open file object given in the "
|
||
"constructor."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:333
|
||
msgid "Do nothing by default. This exists so a subclass can override it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:335
|
||
msgid ""
|
||
"If :meth:`persistent_id` returns ``None``, *obj* is pickled as usual. Any "
|
||
"other value causes :class:`Pickler` to emit the returned value as a "
|
||
"persistent ID for *obj*. The meaning of this persistent ID should be "
|
||
"defined by :meth:`Unpickler.persistent_load`. Note that the value returned "
|
||
"by :meth:`persistent_id` cannot itself have a persistent ID."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:341 ../Doc/library/pickle.rst:441
|
||
msgid "See :ref:`pickle-persistent` for details and examples of uses."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:345
|
||
msgid ""
|
||
"A pickler object's dispatch table is a registry of *reduction functions* of "
|
||
"the kind which can be declared using :func:`copyreg.pickle`. It is a "
|
||
"mapping whose keys are classes and whose values are reduction functions. A "
|
||
"reduction function takes a single argument of the associated class and "
|
||
"should conform to the same interface as a :meth:`__reduce__` method."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:353
|
||
msgid ""
|
||
"By default, a pickler object will not have a :attr:`dispatch_table` "
|
||
"attribute, and it will instead use the global dispatch table managed by the :"
|
||
"mod:`copyreg` module. However, to customize the pickling for a specific "
|
||
"pickler object one can set the :attr:`dispatch_table` attribute to a dict-"
|
||
"like object. Alternatively, if a subclass of :class:`Pickler` has a :attr:"
|
||
"`dispatch_table` attribute then this will be used as the default dispatch "
|
||
"table for instances of that class."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:362
|
||
msgid "See :ref:`pickle-dispatch` for usage examples."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:368
|
||
msgid ""
|
||
"Special reducer that can be defined in :class:`Pickler` subclasses. This "
|
||
"method has priority over any reducer in the :attr:`dispatch_table`. It "
|
||
"should conform to the same interface as a :meth:`__reduce__` method, and can "
|
||
"optionally return ``NotImplemented`` to fallback on :attr:`dispatch_table`-"
|
||
"registered reducers to pickle ``obj``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:374
|
||
msgid "For a detailed example, see :ref:`reducer_override`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:380
|
||
msgid ""
|
||
"Deprecated. Enable fast mode if set to a true value. The fast mode disables "
|
||
"the usage of memo, therefore speeding the pickling process by not generating "
|
||
"superfluous PUT opcodes. It should not be used with self-referential "
|
||
"objects, doing otherwise will cause :class:`Pickler` to recurse infinitely."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:386
|
||
msgid "Use :func:`pickletools.optimize` if you need more compact pickles."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:391
|
||
msgid "This takes a binary file for reading a pickle data stream."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:393
|
||
msgid ""
|
||
"The protocol version of the pickle is detected automatically, so no protocol "
|
||
"argument is needed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:396
|
||
msgid ""
|
||
"The argument *file* must have three methods, a read() method that takes an "
|
||
"integer argument, a readinto() method that takes a buffer argument and a "
|
||
"readline() method that requires no arguments, as in the :class:`io."
|
||
"BufferedIOBase` interface. Thus *file* can be an on-disk file opened for "
|
||
"binary reading, an :class:`io.BytesIO` object, or any other custom object "
|
||
"that meets this interface."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:403
|
||
msgid ""
|
||
"The optional arguments *fix_imports*, *encoding* and *errors* are used to "
|
||
"control compatibility support for pickle stream generated by Python 2. If "
|
||
"*fix_imports* is true, pickle will try to map the old Python 2 names to the "
|
||
"new names used in Python 3. The *encoding* and *errors* tell pickle how to "
|
||
"decode 8-bit string instances pickled by Python 2; these default to 'ASCII' "
|
||
"and 'strict', respectively. The *encoding* can be 'bytes' to read these 8-"
|
||
"bit string instances as bytes objects. Using ``encoding='latin1'`` is "
|
||
"required for unpickling NumPy arrays and instances of :class:`~datetime."
|
||
"datetime`, :class:`~datetime.date` and :class:`~datetime.time` pickled by "
|
||
"Python 2."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:414
|
||
msgid ""
|
||
"If *buffers* is None (the default), then all data necessary for "
|
||
"deserialization must be contained in the pickle stream. This means that the "
|
||
"*buffer_callback* argument was None when a :class:`Pickler` was instantiated "
|
||
"(or when :func:`dump` or :func:`dumps` was called)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:419
|
||
msgid ""
|
||
"If *buffers* is not None, it should be an iterable of buffer-enabled objects "
|
||
"that is consumed each time the pickle stream references an :ref:`out-of-band "
|
||
"<pickle-oob>` buffer view. Such buffers have been given in order to the "
|
||
"*buffer_callback* of a Pickler object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:429
|
||
msgid ""
|
||
"Read a pickled object representation from the open file object given in the "
|
||
"constructor, and return the reconstituted object hierarchy specified "
|
||
"therein. Bytes past the pickled object's representation are ignored."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:435
|
||
msgid "Raise an :exc:`UnpicklingError` by default."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:437
|
||
msgid ""
|
||
"If defined, :meth:`persistent_load` should return the object specified by "
|
||
"the persistent ID *pid*. If an invalid persistent ID is encountered, an :"
|
||
"exc:`UnpicklingError` should be raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:445
|
||
msgid ""
|
||
"Import *module* if necessary and return the object called *name* from it, "
|
||
"where the *module* and *name* arguments are :class:`str` objects. Note, "
|
||
"unlike its name suggests, :meth:`find_class` is also used for finding "
|
||
"functions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:450
|
||
msgid ""
|
||
"Subclasses may override this to gain control over what type of objects and "
|
||
"how they can be loaded, potentially reducing security risks. Refer to :ref:"
|
||
"`pickle-restrict` for details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:454
|
||
msgid ""
|
||
"Raises an :ref:`auditing event <auditing>` ``pickle.find_class`` with "
|
||
"arguments ``module``, ``name``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:458
|
||
msgid ""
|
||
"A wrapper for a buffer representing picklable data. *buffer* must be a :ref:"
|
||
"`buffer-providing <bufferobjects>` object, such as a :term:`bytes-like "
|
||
"object` or a N-dimensional array."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:462
|
||
msgid ""
|
||
":class:`PickleBuffer` is itself a buffer provider, therefore it is possible "
|
||
"to pass it to other APIs expecting a buffer-providing object, such as :class:"
|
||
"`memoryview`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:466
|
||
msgid ""
|
||
":class:`PickleBuffer` objects can only be serialized using pickle protocol 5 "
|
||
"or higher. They are eligible for :ref:`out-of-band serialization <pickle-"
|
||
"oob>`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:474
|
||
msgid ""
|
||
"Return a :class:`memoryview` of the memory area underlying this buffer. The "
|
||
"returned object is a one-dimensional, C-contiguous memoryview with format "
|
||
"``B`` (unsigned bytes). :exc:`BufferError` is raised if the buffer is "
|
||
"neither C- nor Fortran-contiguous."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:481
|
||
msgid "Release the underlying buffer exposed by the PickleBuffer object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:487
|
||
msgid "What can be pickled and unpickled?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:489
|
||
msgid "The following types can be pickled:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:491
|
||
msgid "``None``, ``True``, and ``False``"
|
||
msgstr "``None``, ``True``, and ``False``"
|
||
|
||
#: ../Doc/library/pickle.rst:493
|
||
msgid "integers, floating point numbers, complex numbers"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:495
|
||
msgid "strings, bytes, bytearrays"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:497
|
||
msgid "tuples, lists, sets, and dictionaries containing only picklable objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:499
|
||
msgid ""
|
||
"functions defined at the top level of a module (using :keyword:`def`, not :"
|
||
"keyword:`lambda`)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:502
|
||
msgid "built-in functions defined at the top level of a module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:504
|
||
msgid "classes that are defined at the top level of a module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:506
|
||
msgid ""
|
||
"instances of such classes whose :attr:`~object.__dict__` or the result of "
|
||
"calling :meth:`__getstate__` is picklable (see section :ref:`pickle-inst` "
|
||
"for details)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:510
|
||
msgid ""
|
||
"Attempts to pickle unpicklable objects will raise the :exc:`PicklingError` "
|
||
"exception; when this happens, an unspecified number of bytes may have "
|
||
"already been written to the underlying file. Trying to pickle a highly "
|
||
"recursive data structure may exceed the maximum recursion depth, a :exc:"
|
||
"`RecursionError` will be raised in this case. You can carefully raise this "
|
||
"limit with :func:`sys.setrecursionlimit`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:517
|
||
msgid ""
|
||
"Note that functions (built-in and user-defined) are pickled by \"fully "
|
||
"qualified\" name reference, not by value. [#]_ This means that only the "
|
||
"function name is pickled, along with the name of the module the function is "
|
||
"defined in. Neither the function's code, nor any of its function attributes "
|
||
"are pickled. Thus the defining module must be importable in the unpickling "
|
||
"environment, and the module must contain the named object, otherwise an "
|
||
"exception will be raised. [#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:524
|
||
msgid ""
|
||
"Similarly, classes are pickled by named reference, so the same restrictions "
|
||
"in the unpickling environment apply. Note that none of the class's code or "
|
||
"data is pickled, so in the following example the class attribute ``attr`` is "
|
||
"not restored in the unpickling environment::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:534
|
||
msgid ""
|
||
"These restrictions are why picklable functions and classes must be defined "
|
||
"in the top level of a module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:537
|
||
msgid ""
|
||
"Similarly, when class instances are pickled, their class's code and data are "
|
||
"not pickled along with them. Only the instance data are pickled. This is "
|
||
"done on purpose, so you can fix bugs in a class or add methods to the class "
|
||
"and still load objects that were created with an earlier version of the "
|
||
"class. If you plan to have long-lived objects that will see many versions "
|
||
"of a class, it may be worthwhile to put a version number in the objects so "
|
||
"that suitable conversions can be made by the class's :meth:`__setstate__` "
|
||
"method."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:549
|
||
msgid "Pickling Class Instances"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:553
|
||
msgid ""
|
||
"In this section, we describe the general mechanisms available to you to "
|
||
"define, customize, and control how class instances are pickled and unpickled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:556
|
||
msgid ""
|
||
"In most cases, no additional code is needed to make instances picklable. By "
|
||
"default, pickle will retrieve the class and the attributes of an instance "
|
||
"via introspection. When a class instance is unpickled, its :meth:`__init__` "
|
||
"method is usually *not* invoked. The default behaviour first creates an "
|
||
"uninitialized instance and then restores the saved attributes. The "
|
||
"following code shows an implementation of this behaviour::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:571
|
||
msgid ""
|
||
"Classes can alter the default behaviour by providing one or several special "
|
||
"methods:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:576
|
||
msgid ""
|
||
"In protocols 2 and newer, classes that implements the :meth:"
|
||
"`__getnewargs_ex__` method can dictate the values passed to the :meth:"
|
||
"`__new__` method upon unpickling. The method must return a pair ``(args, "
|
||
"kwargs)`` where *args* is a tuple of positional arguments and *kwargs* a "
|
||
"dictionary of named arguments for constructing the object. Those will be "
|
||
"passed to the :meth:`__new__` method upon unpickling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:584
|
||
msgid ""
|
||
"You should implement this method if the :meth:`__new__` method of your class "
|
||
"requires keyword-only arguments. Otherwise, it is recommended for "
|
||
"compatibility to implement :meth:`__getnewargs__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:588
|
||
msgid ":meth:`__getnewargs_ex__` is now used in protocols 2 and 3."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:594
|
||
msgid ""
|
||
"This method serves a similar purpose as :meth:`__getnewargs_ex__`, but "
|
||
"supports only positional arguments. It must return a tuple of arguments "
|
||
"``args`` which will be passed to the :meth:`__new__` method upon unpickling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:598
|
||
msgid ""
|
||
":meth:`__getnewargs__` will not be called if :meth:`__getnewargs_ex__` is "
|
||
"defined."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:601
|
||
msgid ""
|
||
"Before Python 3.6, :meth:`__getnewargs__` was called instead of :meth:"
|
||
"`__getnewargs_ex__` in protocols 2 and 3."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:608
|
||
msgid ""
|
||
"Classes can further influence how their instances are pickled; if the class "
|
||
"defines the method :meth:`__getstate__`, it is called and the returned "
|
||
"object is pickled as the contents for the instance, instead of the contents "
|
||
"of the instance's dictionary. If the :meth:`__getstate__` method is absent, "
|
||
"the instance's :attr:`~object.__dict__` is pickled as usual."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:617
|
||
msgid ""
|
||
"Upon unpickling, if the class defines :meth:`__setstate__`, it is called "
|
||
"with the unpickled state. In that case, there is no requirement for the "
|
||
"state object to be a dictionary. Otherwise, the pickled state must be a "
|
||
"dictionary and its items are assigned to the new instance's dictionary."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:624
|
||
msgid ""
|
||
"If :meth:`__getstate__` returns a false value, the :meth:`__setstate__` "
|
||
"method will not be called upon unpickling."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:628
|
||
msgid ""
|
||
"Refer to the section :ref:`pickle-state` for more information about how to "
|
||
"use the methods :meth:`__getstate__` and :meth:`__setstate__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:633
|
||
msgid ""
|
||
"At unpickling time, some methods like :meth:`__getattr__`, :meth:"
|
||
"`__getattribute__`, or :meth:`__setattr__` may be called upon the instance. "
|
||
"In case those methods rely on some internal invariant being true, the type "
|
||
"should implement :meth:`__getnewargs__` or :meth:`__getnewargs_ex__` to "
|
||
"establish such an invariant; otherwise, neither :meth:`__new__` nor :meth:"
|
||
"`__init__` will be called."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:642
|
||
msgid ""
|
||
"As we shall see, pickle does not use directly the methods described above. "
|
||
"In fact, these methods are part of the copy protocol which implements the :"
|
||
"meth:`__reduce__` special method. The copy protocol provides a unified "
|
||
"interface for retrieving the data necessary for pickling and copying "
|
||
"objects. [#]_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:648
|
||
msgid ""
|
||
"Although powerful, implementing :meth:`__reduce__` directly in your classes "
|
||
"is error prone. For this reason, class designers should use the high-level "
|
||
"interface (i.e., :meth:`__getnewargs_ex__`, :meth:`__getstate__` and :meth:"
|
||
"`__setstate__`) whenever possible. We will show, however, cases where "
|
||
"using :meth:`__reduce__` is the only option or leads to more efficient "
|
||
"pickling or both."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:657
|
||
msgid ""
|
||
"The interface is currently defined as follows. The :meth:`__reduce__` "
|
||
"method takes no argument and shall return either a string or preferably a "
|
||
"tuple (the returned object is often referred to as the \"reduce value\")."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:661
|
||
msgid ""
|
||
"If a string is returned, the string should be interpreted as the name of a "
|
||
"global variable. It should be the object's local name relative to its "
|
||
"module; the pickle module searches the module namespace to determine the "
|
||
"object's module. This behaviour is typically useful for singletons."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:666
|
||
msgid ""
|
||
"When a tuple is returned, it must be between two and six items long. "
|
||
"Optional items can either be omitted, or ``None`` can be provided as their "
|
||
"value. The semantics of each item are in order:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:672
|
||
msgid ""
|
||
"A callable object that will be called to create the initial version of the "
|
||
"object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:675
|
||
msgid ""
|
||
"A tuple of arguments for the callable object. An empty tuple must be given "
|
||
"if the callable does not accept any argument."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:678
|
||
msgid ""
|
||
"Optionally, the object's state, which will be passed to the object's :meth:"
|
||
"`__setstate__` method as previously described. If the object has no such "
|
||
"method then, the value must be a dictionary and it will be added to the "
|
||
"object's :attr:`~object.__dict__` attribute."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:683
|
||
msgid ""
|
||
"Optionally, an iterator (and not a sequence) yielding successive items. "
|
||
"These items will be appended to the object either using ``obj.append(item)`` "
|
||
"or, in batch, using ``obj.extend(list_of_items)``. This is primarily used "
|
||
"for list subclasses, but may be used by other classes as long as they have :"
|
||
"meth:`append` and :meth:`extend` methods with the appropriate signature. "
|
||
"(Whether :meth:`append` or :meth:`extend` is used depends on which pickle "
|
||
"protocol version is used as well as the number of items to append, so both "
|
||
"must be supported.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:692
|
||
msgid ""
|
||
"Optionally, an iterator (not a sequence) yielding successive key-value "
|
||
"pairs. These items will be stored to the object using ``obj[key] = "
|
||
"value``. This is primarily used for dictionary subclasses, but may be used "
|
||
"by other classes as long as they implement :meth:`__setitem__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:697
|
||
msgid ""
|
||
"Optionally, a callable with a ``(obj, state)`` signature. This callable "
|
||
"allows the user to programmatically control the state-updating behavior of a "
|
||
"specific object, instead of using ``obj``'s static :meth:`__setstate__` "
|
||
"method. If not ``None``, this callable will have priority over ``obj``'s :"
|
||
"meth:`__setstate__`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:703
|
||
msgid "The optional sixth tuple item, ``(obj, state)``, was added."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:709
|
||
msgid ""
|
||
"Alternatively, a :meth:`__reduce_ex__` method may be defined. The only "
|
||
"difference is this method should take a single integer argument, the "
|
||
"protocol version. When defined, pickle will prefer it over the :meth:"
|
||
"`__reduce__` method. In addition, :meth:`__reduce__` automatically becomes "
|
||
"a synonym for the extended version. The main use for this method is to "
|
||
"provide backwards-compatible reduce values for older Python releases."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:721
|
||
msgid "Persistence of External Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:727
|
||
msgid ""
|
||
"For the benefit of object persistence, the :mod:`pickle` module supports the "
|
||
"notion of a reference to an object outside the pickled data stream. Such "
|
||
"objects are referenced by a persistent ID, which should be either a string "
|
||
"of alphanumeric characters (for protocol 0) [#]_ or just an arbitrary object "
|
||
"(for any newer protocol)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:733
|
||
msgid ""
|
||
"The resolution of such persistent IDs is not defined by the :mod:`pickle` "
|
||
"module; it will delegate this resolution to the user defined methods on the "
|
||
"pickler and unpickler, :meth:`~Pickler.persistent_id` and :meth:`~Unpickler."
|
||
"persistent_load` respectively."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:738
|
||
msgid ""
|
||
"To pickle objects that have an external persistent id, the pickler must have "
|
||
"a custom :meth:`~Pickler.persistent_id` method that takes an object as an "
|
||
"argument and returns either ``None`` or the persistent id for that object. "
|
||
"When ``None`` is returned, the pickler simply pickles the object as normal. "
|
||
"When a persistent ID string is returned, the pickler will pickle that "
|
||
"object, along with a marker so that the unpickler will recognize it as a "
|
||
"persistent ID."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:745
|
||
msgid ""
|
||
"To unpickle external objects, the unpickler must have a custom :meth:"
|
||
"`~Unpickler.persistent_load` method that takes a persistent ID object and "
|
||
"returns the referenced object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:749
|
||
msgid ""
|
||
"Here is a comprehensive example presenting how persistent ID can be used to "
|
||
"pickle external objects by reference."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:757
|
||
msgid "Dispatch Tables"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:759
|
||
msgid ""
|
||
"If one wants to customize pickling of some classes without disturbing any "
|
||
"other code which depends on pickling, then one can create a pickler with a "
|
||
"private dispatch table."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:763
|
||
msgid ""
|
||
"The global dispatch table managed by the :mod:`copyreg` module is available "
|
||
"as :data:`copyreg.dispatch_table`. Therefore, one may choose to use a "
|
||
"modified copy of :data:`copyreg.dispatch_table` as a private dispatch table."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:768
|
||
msgid "For example ::"
|
||
msgstr "Par exemple ::"
|
||
|
||
#: ../Doc/library/pickle.rst:775
|
||
msgid ""
|
||
"creates an instance of :class:`pickle.Pickler` with a private dispatch table "
|
||
"which handles the ``SomeClass`` class specially. Alternatively, the code ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:785
|
||
msgid ""
|
||
"does the same, but all instances of ``MyPickler`` will by default share the "
|
||
"same dispatch table. The equivalent code using the :mod:`copyreg` module "
|
||
"is ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:796
|
||
msgid "Handling Stateful Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:802
|
||
msgid ""
|
||
"Here's an example that shows how to modify pickling behavior for a class. "
|
||
"The :class:`TextReader` class opens a text file, and returns the line number "
|
||
"and line contents each time its :meth:`!readline` method is called. If a :"
|
||
"class:`TextReader` instance is pickled, all attributes *except* the file "
|
||
"object member are saved. When the instance is unpickled, the file is "
|
||
"reopened, and reading resumes from the last location. The :meth:"
|
||
"`__setstate__` and :meth:`__getstate__` methods are used to implement this "
|
||
"behavior. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:848
|
||
msgid "A sample usage might be something like this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:862
|
||
msgid "Custom Reduction for Types, Functions, and Other Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:866
|
||
msgid ""
|
||
"Sometimes, :attr:`~Pickler.dispatch_table` may not be flexible enough. In "
|
||
"particular we may want to customize pickling based on another criterion than "
|
||
"the object's type, or we may want to customize the pickling of functions and "
|
||
"classes."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:871
|
||
msgid ""
|
||
"For those cases, it is possible to subclass from the :class:`Pickler` class "
|
||
"and implement a :meth:`~Pickler.reducer_override` method. This method can "
|
||
"return an arbitrary reduction tuple (see :meth:`__reduce__`). It can "
|
||
"alternatively return ``NotImplemented`` to fallback to the traditional "
|
||
"behavior."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:876
|
||
msgid ""
|
||
"If both the :attr:`~Pickler.dispatch_table` and :meth:`~Pickler."
|
||
"reducer_override` are defined, then :meth:`~Pickler.reducer_override` method "
|
||
"takes priority."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:881
|
||
msgid ""
|
||
"For performance reasons, :meth:`~Pickler.reducer_override` may not be called "
|
||
"for the following objects: ``None``, ``True``, ``False``, and exact "
|
||
"instances of :class:`int`, :class:`float`, :class:`bytes`, :class:`str`, :"
|
||
"class:`dict`, :class:`set`, :class:`frozenset`, :class:`list` and :class:"
|
||
"`tuple`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:887
|
||
msgid ""
|
||
"Here is a simple example where we allow pickling and reconstructing a given "
|
||
"class::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:922
|
||
msgid "Out-of-band Buffers"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:926
|
||
msgid ""
|
||
"In some contexts, the :mod:`pickle` module is used to transfer massive "
|
||
"amounts of data. Therefore, it can be important to minimize the number of "
|
||
"memory copies, to preserve performance and resource consumption. However, "
|
||
"normal operation of the :mod:`pickle` module, as it transforms a graph-like "
|
||
"structure of objects into a sequential stream of bytes, intrinsically "
|
||
"involves copying data to and from the pickle stream."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:933
|
||
msgid ""
|
||
"This constraint can be eschewed if both the *provider* (the implementation "
|
||
"of the object types to be transferred) and the *consumer* (the "
|
||
"implementation of the communications system) support the out-of-band "
|
||
"transfer facilities provided by pickle protocol 5 and higher."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:939
|
||
msgid "Provider API"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:941
|
||
msgid ""
|
||
"The large data objects to be pickled must implement a :meth:`__reduce_ex__` "
|
||
"method specialized for protocol 5 and higher, which returns a :class:"
|
||
"`PickleBuffer` instance (instead of e.g. a :class:`bytes` object) for any "
|
||
"large data."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:946
|
||
msgid ""
|
||
"A :class:`PickleBuffer` object *signals* that the underlying buffer is "
|
||
"eligible for out-of-band data transfer. Those objects remain compatible "
|
||
"with normal usage of the :mod:`pickle` module. However, consumers can also "
|
||
"opt-in to tell :mod:`pickle` that they will handle those buffers by "
|
||
"themselves."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:953
|
||
msgid "Consumer API"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:955
|
||
msgid ""
|
||
"A communications system can enable custom handling of the :class:"
|
||
"`PickleBuffer` objects generated when serializing an object graph."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:958
|
||
msgid ""
|
||
"On the sending side, it needs to pass a *buffer_callback* argument to :class:"
|
||
"`Pickler` (or to the :func:`dump` or :func:`dumps` function), which will be "
|
||
"called with each :class:`PickleBuffer` generated while pickling the object "
|
||
"graph. Buffers accumulated by the *buffer_callback* will not see their data "
|
||
"copied into the pickle stream, only a cheap marker will be inserted."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:965
|
||
msgid ""
|
||
"On the receiving side, it needs to pass a *buffers* argument to :class:"
|
||
"`Unpickler` (or to the :func:`load` or :func:`loads` function), which is an "
|
||
"iterable of the buffers which were passed to *buffer_callback*. That "
|
||
"iterable should produce buffers in the same order as they were passed to "
|
||
"*buffer_callback*. Those buffers will provide the data expected by the "
|
||
"reconstructors of the objects whose pickling produced the original :class:"
|
||
"`PickleBuffer` objects."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:973
|
||
msgid ""
|
||
"Between the sending side and the receiving side, the communications system "
|
||
"is free to implement its own transfer mechanism for out-of-band buffers. "
|
||
"Potential optimizations include the use of shared memory or datatype-"
|
||
"dependent compression."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:979
|
||
#, fuzzy
|
||
msgid "Example"
|
||
msgstr "Exemples"
|
||
|
||
#: ../Doc/library/pickle.rst:981
|
||
msgid ""
|
||
"Here is a trivial example where we implement a :class:`bytearray` subclass "
|
||
"able to participate in out-of-band buffer pickling::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1005
|
||
msgid ""
|
||
"The reconstructor (the ``_reconstruct`` class method) returns the buffer's "
|
||
"providing object if it has the right type. This is an easy way to simulate "
|
||
"zero-copy behaviour on this toy example."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1009
|
||
msgid ""
|
||
"On the consumer side, we can pickle those objects the usual way, which when "
|
||
"unserialized will give us a copy of the original object::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1018
|
||
msgid ""
|
||
"But if we pass a *buffer_callback* and then give back the accumulated "
|
||
"buffers when unserializing, we are able to get back the original object::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1028
|
||
msgid ""
|
||
"This example is limited by the fact that :class:`bytearray` allocates its "
|
||
"own memory: you cannot create a :class:`bytearray` instance that is backed "
|
||
"by another object's memory. However, third-party datatypes such as NumPy "
|
||
"arrays do not have this limitation, and allow use of zero-copy pickling (or "
|
||
"making as few copies as possible) when transferring between distinct "
|
||
"processes or systems."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1035
|
||
msgid ":pep:`574` -- Pickle protocol 5 with out-of-band data"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1041
|
||
msgid "Restricting Globals"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1046
|
||
msgid ""
|
||
"By default, unpickling will import any class or function that it finds in "
|
||
"the pickle data. For many applications, this behaviour is unacceptable as "
|
||
"it permits the unpickler to import and invoke arbitrary code. Just consider "
|
||
"what this hand-crafted pickle data stream does when loaded::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1056
|
||
msgid ""
|
||
"In this example, the unpickler imports the :func:`os.system` function and "
|
||
"then apply the string argument \"echo hello world\". Although this example "
|
||
"is inoffensive, it is not difficult to imagine one that could damage your "
|
||
"system."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1060
|
||
msgid ""
|
||
"For this reason, you may want to control what gets unpickled by customizing :"
|
||
"meth:`Unpickler.find_class`. Unlike its name suggests, :meth:`Unpickler."
|
||
"find_class` is called whenever a global (i.e., a class or a function) is "
|
||
"requested. Thus it is possible to either completely forbid globals or "
|
||
"restrict them to a safe subset."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1066
|
||
msgid ""
|
||
"Here is an example of an unpickler allowing only few safe classes from the :"
|
||
"mod:`builtins` module to be loaded::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1095
|
||
msgid "A sample usage of our unpickler working has intended::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1114
|
||
msgid ""
|
||
"As our examples shows, you have to be careful with what you allow to be "
|
||
"unpickled. Therefore if security is a concern, you may want to consider "
|
||
"alternatives such as the marshalling API in :mod:`xmlrpc.client` or third-"
|
||
"party solutions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1121
|
||
msgid "Performance"
|
||
msgstr "Performances"
|
||
|
||
#: ../Doc/library/pickle.rst:1123
|
||
msgid ""
|
||
"Recent versions of the pickle protocol (from protocol 2 and upwards) feature "
|
||
"efficient binary encodings for several common features and built-in types. "
|
||
"Also, the :mod:`pickle` module has a transparent optimizer written in C."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1131
|
||
msgid "Examples"
|
||
msgstr "Exemples"
|
||
|
||
#: ../Doc/library/pickle.rst:1133
|
||
msgid ""
|
||
"For the simplest code, use the :func:`dump` and :func:`load` functions. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1149
|
||
msgid "The following example reads the resulting pickled data. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1166
|
||
msgid "Module :mod:`copyreg`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1166
|
||
msgid "Pickle interface constructor registration for extension types."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1169
|
||
msgid "Module :mod:`pickletools`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1169
|
||
msgid "Tools for working with and analyzing pickled data."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1172
|
||
msgid "Module :mod:`shelve`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1172
|
||
msgid "Indexed databases of objects; uses :mod:`pickle`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1175
|
||
msgid "Module :mod:`copy`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1175
|
||
msgid "Shallow and deep object copying."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1177
|
||
msgid "Module :mod:`marshal`"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1178
|
||
msgid "High-performance serialization of built-in types."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1182
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: ../Doc/library/pickle.rst:1183
|
||
msgid "Don't confuse this with the :mod:`marshal` module"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1185
|
||
msgid ""
|
||
"This is why :keyword:`lambda` functions cannot be pickled: all :keyword:`!"
|
||
"lambda` functions share the same name: ``<lambda>``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1188
|
||
msgid ""
|
||
"The exception raised will likely be an :exc:`ImportError` or an :exc:"
|
||
"`AttributeError` but it could be something else."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1191
|
||
msgid ""
|
||
"The :mod:`copy` module uses this protocol for shallow and deep copying "
|
||
"operations."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/pickle.rst:1194
|
||
msgid ""
|
||
"The limitation on alphanumeric characters is due to the fact the persistent "
|
||
"IDs, in protocol 0, are delimited by the newline character. Therefore if "
|
||
"any kind of newline characters occurs in persistent IDs, the resulting "
|
||
"pickle will become unreadable."
|
||
msgstr ""
|
||
|
||
#~ msgid ""
|
||
#~ "The :mod:`pickle` module is not secure against erroneous or maliciously "
|
||
#~ "constructed data. Never unpickle data received from an untrusted or "
|
||
#~ "unauthenticated source."
|
||
#~ msgstr ""
|
||
#~ "Le module :mod:`pickle` n'est pas sécurisé contre les données erronées et "
|
||
#~ "malicieusement construites. Ne jamais *unpickle* la donnée reçue à partir "
|
||
#~ "d'une source non fiable ou non authentifiée."
|