python-docs-fr/library/pickle.po

# 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: 2018-12-21 09:48+0100\n"
"PO-Revision-Date: 2018-12-06 22:27+0100\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"
"Last-Translator: \n"
"X-Generator: Poedit 2.0.6\n"

#: ../Doc/library/pickle.rst:2
msgid ":mod:`pickle` --- Python object serialization"
msgstr ":mod:`pickle` --- Module Python de sérialisation en objet"

#: ../Doc/library/pickle.rst:10
msgid "**Source code:** :source:`Lib/pickle.py`"
msgstr "**Source code:** :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 protocole binaires pour permettre la "
"sérialisation et la dé-sérialisation de la structure d'un objet Python. *"
"\"Pickling\"* est le procédé par lequel la hiérarchie d'un objet python est "
"convertie en flux d'octets. *\"unpickling\"* est l'opération inverse, par "
"laquelle un flux d'octet (à partir d'un :term:`binary file` ou :term:`bytes-"
"like object`) est converti en retour en hiérarchie d'objet. *Pickling* (et "
"*unpickling*) sont alternativement connu sous le terme de \"sérialisation\" "
"ou de \"marshalling\". Cependant pour éviter la confusion les termes "
"utilisés ici sont \"pickling\" et \"unpickling\"."

#: ../Doc/library/pickle.rst:33
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 reconnue ou non authentique."

#: ../Doc/library/pickle.rst:39
msgid "Relationship to other Python modules"
msgstr "Relation par rapport aux autres modules python"

#: ../Doc/library/pickle.rst:42
msgid "Comparison with ``marshal``"
msgstr "Comparaison avec ``marshal``"

#: ../Doc/library/pickle.rst:44
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 "
"supporter les fichiers Python  finissant en :file:`.pyc`."

#: ../Doc/library/pickle.rst:49
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:51
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é,  "
"pour faire en sorte que les prochaines références à cet objet ne soient plus "
"sérialisé à nouveau. :mod:`marshal` lui ne le fait pas. "

#: ../Doc/library/pickle.rst:55
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 provoque des implications à la fois sur le partage d'objet et sur les "
"objets récursifs. Les objets récursifs sont des objets qui contiennent des "
"auto références. Celles-ci ne sont pas gérées par marshal. Essayer de lancer "
"des objets récursifs sur marshall va faire crasher votre interpréteur "
"python. Le partage d'objet s'effectue lorsque qu'il y a plusieurs références "
"au même objet à différents endroits dans la hiérarchie de l'objet en "
"sérialisation. Le module  :mod:`pickle`récupères ce type d'objet seulement "
"une fois, et fait en sorte que toutes les prochaines références soient "
"dirigées en direction de la copie master. Les objets partagés restent "
"partagés, ce qui peut être très important pour les objets muables."

#: ../Doc/library/pickle.rst:64
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:69
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:79
msgid "Comparison with ``json``"
msgstr ""

#: ../Doc/library/pickle.rst:81
msgid ""
"There are fundamental differences between the pickle protocols and `JSON "
"(JavaScript Object Notation) <http://json.org>`_:"
msgstr ""

#: ../Doc/library/pickle.rst:84
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:88
msgid "JSON is human-readable, while pickle is not;"
msgstr ""

#: ../Doc/library/pickle.rst:90
msgid ""
"JSON is interoperable and widely used outside of the Python ecosystem, while "
"pickle is Python-specific;"
msgstr ""

#: ../Doc/library/pickle.rst:93
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:100
msgid ""
"The :mod:`json` module: a standard library module allowing JSON "
"serialization and deserialization."
msgstr ""

#: ../Doc/library/pickle.rst:107
msgid "Data stream format"
msgstr ""

#: ../Doc/library/pickle.rst:112
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:117
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:121
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:125
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:129
msgid ""
"Protocol version 0 is the original \"human-readable\" protocol and is "
"backwards compatible with earlier versions of Python."
msgstr ""

#: ../Doc/library/pickle.rst:132
msgid ""
"Protocol version 1 is an old binary format which is also compatible with "
"earlier versions of Python."
msgstr ""

#: ../Doc/library/pickle.rst:135
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:139
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 is the "
"default protocol, and the recommended protocol when compatibility with other "
"Python 3 versions is required."
msgstr ""

#: ../Doc/library/pickle.rst:144
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.  Refer to :pep:`3154` for information about improvements "
"brought by protocol 4."
msgstr ""

#: ../Doc/library/pickle.rst:150
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:163
msgid "Module Interface"
msgstr ""

#: ../Doc/library/pickle.rst:165
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:170
msgid "The :mod:`pickle` module provides the following constants:"
msgstr ""

#: ../Doc/library/pickle.rst:175
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:182
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 3, a new protocol designed for Python 3."
msgstr ""

#: ../Doc/library/pickle.rst:187
msgid ""
"The :mod:`pickle` module provides the following functions to make the "
"pickling process more convenient:"
msgstr ""

#: ../Doc/library/pickle.rst:192
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:195 ../Doc/library/pickle.rst:297
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:200 ../Doc/library/pickle.rst:302
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:205 ../Doc/library/pickle.rst:307
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:211
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:214
msgid ""
"Arguments *protocol* and *fix_imports* have the same meaning as in :func:"
"`dump`."
msgstr ""

#: ../Doc/library/pickle.rst:219
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:223 ../Doc/library/pickle.rst:249
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:227
msgid ""
"The argument *file* must have two methods, a read() method that takes an "
"integer argument, and a readline() method that requires no arguments.  Both "
"methods should return bytes.  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:233 ../Doc/library/pickle.rst:253
msgid ""
"Optional keyword arguments are *fix_imports*, *encoding* and *errors*, which "
"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:246
msgid ""
"Read a pickled object hierarchy from a :class:`bytes` object and return the "
"reconstituted object hierarchy specified therein."
msgstr ""

#: ../Doc/library/pickle.rst:265
msgid "The :mod:`pickle` module defines three exceptions:"
msgstr ""

#: ../Doc/library/pickle.rst:269
msgid ""
"Common base class for the other pickling exceptions.  It inherits :exc:"
"`Exception`."
msgstr ""

#: ../Doc/library/pickle.rst:274
msgid ""
"Error raised when an unpicklable object is encountered by :class:`Pickler`. "
"It inherits :exc:`PickleError`."
msgstr ""

#: ../Doc/library/pickle.rst:277
msgid ""
"Refer to :ref:`pickle-picklable` to learn what kinds of objects can be "
"pickled."
msgstr ""

#: ../Doc/library/pickle.rst:282
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:285
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:290
msgid ""
"The :mod:`pickle` module exports two classes, :class:`Pickler` and :class:"
"`Unpickler`:"
msgstr ""

#: ../Doc/library/pickle.rst:295
msgid "This takes a binary file for writing a pickle data stream."
msgstr ""

#: ../Doc/library/pickle.rst:313
msgid ""
"Write a pickled representation of *obj* to the open file object given in the "
"constructor."
msgstr ""

#: ../Doc/library/pickle.rst:318
msgid "Do nothing by default.  This exists so a subclass can override it."
msgstr ""

#: ../Doc/library/pickle.rst:320
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:326 ../Doc/library/pickle.rst:397
msgid "See :ref:`pickle-persistent` for details and examples of uses."
msgstr ""

#: ../Doc/library/pickle.rst:330
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:338
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:347
msgid "See :ref:`pickle-dispatch` for usage examples."
msgstr ""

#: ../Doc/library/pickle.rst:353
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:359
msgid "Use :func:`pickletools.optimize` if you need more compact pickles."
msgstr ""

#: ../Doc/library/pickle.rst:364
msgid "This takes a binary file for reading a pickle data stream."
msgstr ""

#: ../Doc/library/pickle.rst:366
msgid ""
"The protocol version of the pickle is detected automatically, so no protocol "
"argument is needed."
msgstr ""

#: ../Doc/library/pickle.rst:369
msgid ""
"The argument *file* must have two methods, a read() method that takes an "
"integer argument, and a readline() method that requires no arguments.  Both "
"methods should return bytes.  Thus *file* can be an on-disk file object "
"opened for binary reading, an :class:`io.BytesIO` object, or any other "
"custom object that meets this interface."
msgstr ""

#: ../Doc/library/pickle.rst:375
msgid ""
"Optional keyword arguments are *fix_imports*, *encoding* and *errors*, which "
"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."
msgstr ""

#: ../Doc/library/pickle.rst:385
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:391
msgid "Raise an :exc:`UnpicklingError` by default."
msgstr ""

#: ../Doc/library/pickle.rst:393
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:401
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:406
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:414
msgid "What can be pickled and unpickled?"
msgstr ""

#: ../Doc/library/pickle.rst:416
msgid "The following types can be pickled:"
msgstr ""

#: ../Doc/library/pickle.rst:418
msgid "``None``, ``True``, and ``False``"
msgstr "``None``, ``True``, and ``False``"

#: ../Doc/library/pickle.rst:420
msgid "integers, floating point numbers, complex numbers"
msgstr ""

#: ../Doc/library/pickle.rst:422
msgid "strings, bytes, bytearrays"
msgstr ""

#: ../Doc/library/pickle.rst:424
msgid "tuples, lists, sets, and dictionaries containing only picklable objects"
msgstr ""

#: ../Doc/library/pickle.rst:426
msgid ""
"functions defined at the top level of a module (using :keyword:`def`, not :"
"keyword:`lambda`)"
msgstr ""

#: ../Doc/library/pickle.rst:429
msgid "built-in functions defined at the top level of a module"
msgstr ""

#: ../Doc/library/pickle.rst:431
msgid "classes that are defined at the top level of a module"
msgstr ""

#: ../Doc/library/pickle.rst:433
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:437
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:444
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:451
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:461
msgid ""
"These restrictions are why picklable functions and classes must be defined "
"in the top level of a module."
msgstr ""

#: ../Doc/library/pickle.rst:464
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:476
msgid "Pickling Class Instances"
msgstr ""

#: ../Doc/library/pickle.rst:480
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:483
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:498
msgid ""
"Classes can alter the default behaviour by providing one or several special "
"methods:"
msgstr ""

#: ../Doc/library/pickle.rst:503
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:511
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:515
msgid ":meth:`__getnewargs_ex__` is now used in protocols 2 and 3."
msgstr ""

#: ../Doc/library/pickle.rst:521
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:525
msgid ""
":meth:`__getnewargs__` will not be called if :meth:`__getnewargs_ex__` is "
"defined."
msgstr ""

#: ../Doc/library/pickle.rst:528
msgid ""
"Before Python 3.6, :meth:`__getnewargs__` was called instead of :meth:"
"`__getnewargs_ex__` in protocols 2 and 3."
msgstr ""

#: ../Doc/library/pickle.rst:535
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:544
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:551
msgid ""
"If :meth:`__getstate__` returns a false value, the :meth:`__setstate__` "
"method will not be called upon unpickling."
msgstr ""

#: ../Doc/library/pickle.rst:555
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:560
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:569
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:575
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:584
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:588
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:593
msgid ""
"When a tuple is returned, it must be between two and five 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:599
msgid ""
"A callable object that will be called to create the initial version of the "
"object."
msgstr ""

#: ../Doc/library/pickle.rst:602
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:605
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:610
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:619
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:627
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:639
msgid "Persistence of External Objects"
msgstr ""

#: ../Doc/library/pickle.rst:645
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:651
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:656
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:663
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:667
msgid ""
"Here is a comprehensive example presenting how persistent ID can be used to "
"pickle external objects by reference."
msgstr ""

#: ../Doc/library/pickle.rst:675
msgid "Dispatch Tables"
msgstr ""

#: ../Doc/library/pickle.rst:677
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:681
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:686
msgid "For example ::"
msgstr "Par exemple ::"

#: ../Doc/library/pickle.rst:693
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:703
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:714
msgid "Handling Stateful Objects"
msgstr ""

#: ../Doc/library/pickle.rst:720
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:766
msgid "A sample usage might be something like this::"
msgstr ""

#: ../Doc/library/pickle.rst:781
msgid "Restricting Globals"
msgstr ""

#: ../Doc/library/pickle.rst:786
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:796
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:800
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:806
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:835
msgid "A sample usage of our unpickler working has intended::"
msgstr ""

#: ../Doc/library/pickle.rst:854
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:861
msgid "Performance"
msgstr ""

#: ../Doc/library/pickle.rst:863
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:871
msgid "Examples"
msgstr "Exemples"

#: ../Doc/library/pickle.rst:873
msgid ""
"For the simplest code, use the :func:`dump` and :func:`load` functions. ::"
msgstr ""

#: ../Doc/library/pickle.rst:889
msgid "The following example reads the resulting pickled data. ::"
msgstr ""

#: ../Doc/library/pickle.rst:906
msgid "Module :mod:`copyreg`"
msgstr ""

#: ../Doc/library/pickle.rst:906
msgid "Pickle interface constructor registration for extension types."
msgstr ""

#: ../Doc/library/pickle.rst:909
msgid "Module :mod:`pickletools`"
msgstr ""

#: ../Doc/library/pickle.rst:909
msgid "Tools for working with and analyzing pickled data."
msgstr ""

#: ../Doc/library/pickle.rst:912
msgid "Module :mod:`shelve`"
msgstr ""

#: ../Doc/library/pickle.rst:912
msgid "Indexed databases of objects; uses :mod:`pickle`."
msgstr ""

#: ../Doc/library/pickle.rst:915
msgid "Module :mod:`copy`"
msgstr ""

#: ../Doc/library/pickle.rst:915
msgid "Shallow and deep object copying."
msgstr ""

#: ../Doc/library/pickle.rst:917
msgid "Module :mod:`marshal`"
msgstr ""

#: ../Doc/library/pickle.rst:918
msgid "High-performance serialization of built-in types."
msgstr ""

#: ../Doc/library/pickle.rst:922
msgid "Footnotes"
msgstr "Notes"

#: ../Doc/library/pickle.rst:923
msgid "Don't confuse this with the :mod:`marshal` module"
msgstr ""

#: ../Doc/library/pickle.rst:925
msgid ""
"This is why :keyword:`lambda` functions cannot be pickled:  all :keyword:`!"
"lambda` functions share the same name:  ``<lambda>``."
msgstr ""

#: ../Doc/library/pickle.rst:928
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:931
msgid ""
"The :mod:`copy` module uses this protocol for shallow and deep copying "
"operations."
msgstr ""

#: ../Doc/library/pickle.rst:934
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 ""