2018-07-04 09:06:45 +00:00
|
|
|
|
# Copyright (C) 2001-2018, Python Software Foundation
|
2018-07-04 09:08:42 +00:00
|
|
|
|
# For licence information, see README file.
|
2016-10-30 09:46:26 +00:00
|
|
|
|
#
|
|
|
|
|
msgid ""
|
|
|
|
|
msgstr ""
|
2019-12-05 22:15:54 +00:00
|
|
|
|
"Project-Id-Version: Python 3\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2020-10-02 08:55:01 +00:00
|
|
|
|
"POT-Creation-Date: 2020-10-01 16:00+0200\n"
|
2021-12-16 18:51:49 +00:00
|
|
|
|
"PO-Revision-Date: 2021-12-11 11:45+0100\n"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\n"
|
2018-07-04 09:14:25 +00:00
|
|
|
|
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
2017-05-23 22:40:56 +00:00
|
|
|
|
"Language: fr\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"X-Generator: Poedit 2.4.1\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:2
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":mod:`pickle` --- Python object serialization"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr ":mod:`pickle` — Sérialisation d'objets Python"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:10
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "**Source code:** :source:`Lib/pickle.py`"
|
2019-02-26 10:31:07 +00:00
|
|
|
|
msgstr "**Code source :** :source:`Lib/pickle.py`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:22
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2019-02-26 10:31:07 +00:00
|
|
|
|
"Le module :mod:`pickle` implémente des protocoles binaires de sérialisation "
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"et dé-sérialisation d'objets Python. La sérialisation est le procédé par "
|
|
|
|
|
"lequel une hiérarchie d'objets Python est convertie en flux d'octets. La "
|
|
|
|
|
"désérialisation 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. Sérialisation (et *désérialisation*) sont aussi "
|
|
|
|
|
"connus sous les termes de *pickling*, de \"*marshalling*\" [#]_ ou encore de "
|
|
|
|
|
"\"*flattening*\"."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:33
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "The ``pickle`` module **is not secure**. Only unpickle data you trust."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module ``pickle`` **n'est pas sécurisé**. Ne désérialisez des objets qu'à "
|
|
|
|
|
"partir de sources fiables."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:35
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Il est possible de produire des données binaires qui **exécutent du code "
|
|
|
|
|
"arbitraire lors de leur désérialisation**. Ne désérialisez jamais des "
|
|
|
|
|
"données provenant d'une source non fiable, ou qui pourraient avoir été "
|
|
|
|
|
"modifiées."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:39
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Consider signing data with :mod:`hmac` if you need to ensure that it has not "
|
|
|
|
|
"been tampered with."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pensez au module :mod:`hmac` pour signer des données afin de s'assurer "
|
|
|
|
|
"qu'elles n'ont pas été modifiées."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:42
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Safer serialization formats such as :mod:`json` may be more appropriate if "
|
|
|
|
|
"you are processing untrusted data. See :ref:`comparison-with-json`."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Des formats de sérialisation plus sûrs, comme :mod:`json`, peuvent se "
|
|
|
|
|
"révéler plus adaptés si vous travaillez sur des données qui ne sont pas "
|
|
|
|
|
"fiables. Voir :ref:`comparison-with-json`."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:47
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Relationship to other Python modules"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Relations aux autres modules Python"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:50
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Comparison with ``marshal``"
|
2019-02-26 10:16:23 +00:00
|
|
|
|
msgstr "Comparaison avec ``marshal``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:52
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2019-05-26 15:47:42 +00:00
|
|
|
|
"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 "
|
2019-02-26 10:16:23 +00:00
|
|
|
|
"sérialiser des objets Python. :mod:`marshal` existe principalement pour "
|
2019-02-26 10:31:07 +00:00
|
|
|
|
"gérer les fichiers Python en :file:`.pyc`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:57
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :mod:`pickle` module differs from :mod:`marshal` in several significant "
|
|
|
|
|
"ways:"
|
|
|
|
|
msgstr ""
|
2019-02-26 10:31:07 +00:00
|
|
|
|
"Le module :mod:`pickle` diffère du module :mod:`marshal` sur plusieurs "
|
|
|
|
|
"aspects :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:59
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2019-05-26 15:47:42 +00:00
|
|
|
|
"Le module :mod:`pickle` garde la trace des objets qu'il a déjà sérialisés, "
|
2019-02-26 10:31:07 +00:00
|
|
|
|
"pour faire en sorte que les prochaines références à cet objet ne soient pas "
|
2019-05-26 15:47:42 +00:00
|
|
|
|
"sérialisées à nouveau. :mod:`marshal` ne le fait pas."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:63
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2019-02-26 10:31:07 +00:00
|
|
|
|
"Ç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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:72
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2019-02-26 10:16:23 +00:00
|
|
|
|
":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 "
|
2019-02-26 10:31:07 +00:00
|
|
|
|
"définition de classe doit être importable et lancée dans le même module et "
|
2019-02-26 10:16:23 +00:00
|
|
|
|
"de la même manière que lors de son importation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:77
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2018-12-24 13:20:55 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Aucune garantie n'est offerte sur la portabilité du format :mod:`marshal` "
|
|
|
|
|
"entre différentes versions de Python. Sa fonction première étant la gestion "
|
|
|
|
|
"des fichiers :file:`.pyc`, les développeurs se réservent le droit de changer "
|
|
|
|
|
"le format de sérialisation de manière non-rétrocompatible si besoin était. "
|
|
|
|
|
"Il est garanti que le format :mod:`pickle` restera compatible avec les "
|
|
|
|
|
"versions futures de Python, pourvu que vous choisissiez un protocole de "
|
|
|
|
|
"sérialisation adapté. De plus, il masque les différences entre les types "
|
|
|
|
|
"Python 2 et Python 3, pour le cas où il s'agit de désérialiser en Python 3 "
|
|
|
|
|
"des données sérialisées en Python 2."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:90
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Comparison with ``json``"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Comparaison avec ``json``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:92
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"There are fundamental differences between the pickle protocols and `JSON "
|
|
|
|
|
"(JavaScript Object Notation) <http://json.org>`_:"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Il existe des différences fondamentales entre les protocoles de "
|
|
|
|
|
"sérialisation définis par ce module et le format `JSON (JavaScript Object "
|
|
|
|
|
"Notation) <http://json.org>`_ :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:95
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"*pickle* est un format binaire, tandis que JSON est un format textuel "
|
|
|
|
|
"(constitué de caractères Unicode et généralement encodé en UTF-8) ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:99
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "JSON is human-readable, while pickle is not;"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "JSON peut être lu par une personne, contrairement à *pickle* ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:101
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"JSON is interoperable and widely used outside of the Python ecosystem, while "
|
|
|
|
|
"pickle is Python-specific;"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"JSON offre l'interopérabilité avec de nombreux outils en dehors de "
|
|
|
|
|
"l'écosystème Python, alors que *pickle* est propre à Python ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:104
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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:"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"`specific object APIs <pickle-inst>`);"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Par défaut, JSON n'est capable de sérialiser qu'un nombre limité de types "
|
|
|
|
|
"natifs Python, et ne prend pas en charge les classes définies par "
|
|
|
|
|
"l'utilisateur. Le format *pickle* peut représenter une multitude de types "
|
|
|
|
|
"d'objets, dont beaucoup automatiquement, grâce à une utilisation fine des "
|
|
|
|
|
"possibilités d'introspection de Python ; on peut traiter les cas les plus "
|
|
|
|
|
"complexes en implémentant des :ref:`méthodes de sérialisation propres à une "
|
|
|
|
|
"classe <pickle-inst>` ;"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:110
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Unlike pickle, deserializing untrusted JSON does not in itself create an "
|
|
|
|
|
"arbitrary code execution vulnerability."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Contrairement à *pickle*, la désérialisation de données JSON n'ouvre pas en "
|
|
|
|
|
"soi une vulnérabilité à l'exécution de code arbitraire."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:114
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :mod:`json` module: a standard library module allowing JSON "
|
|
|
|
|
"serialization and deserialization."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module :mod:`json` de la bibliothèque standard permet la sérialisation et "
|
|
|
|
|
"désérialisation au format JSON."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:121
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Data stream format"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Format du flux de données"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:126
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le format de données employé par :mod:`pickle` est propre à Python, avec "
|
|
|
|
|
"l'avantage qu'aucune restriction n'est imposée par des standards externes "
|
|
|
|
|
"comme JSON ou XDR (qui ne peuvent pas représenter le partage de références). "
|
|
|
|
|
"Cependant, cela signifie que des programmes écrits en d'autres langages que "
|
|
|
|
|
"Python peuvent échouer à reconstituer les objets sérialisés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:131
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le format binaire :mod:`pickle` est, par défaut, une représentation assez "
|
|
|
|
|
"compacte des objets. Il est possible de :doc:`compresser <archiving>` "
|
|
|
|
|
"efficacement les données sérialisées."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:135
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module :mod:`pickletools` contient des outils servant à analyser les flux "
|
|
|
|
|
"de données générés par :mod:`pickle`. Le code source de :mod:`pickletools` "
|
|
|
|
|
"contient des commentaires détaillés sur les *opcodes* employés par les "
|
|
|
|
|
"protocoles *pickle*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:139
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-11-15 22:57:16 +00:00
|
|
|
|
"There are currently 6 different protocols which can be used for pickling. "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"The higher the protocol used, the more recent the version of Python needed "
|
|
|
|
|
"to read the pickle produced."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Il existe actuellement 6 protocoles différents pour la sérialisation. Les "
|
|
|
|
|
"protocoles portant les numéros les plus grands sont les derniers ajoutés, et "
|
|
|
|
|
"nécessitent en conséquence des versions de Python plus récentes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:143
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Protocol version 0 is the original \"human-readable\" protocol and is "
|
|
|
|
|
"backwards compatible with earlier versions of Python."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le protocole 0 est le format originel, humainement lisible. Il est "
|
|
|
|
|
"rétrocompatible avec les versions les plus anciennes de Python."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:146
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Protocol version 1 is an old binary format which is also compatible with "
|
|
|
|
|
"earlier versions of Python."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le protocole 1 est un ancien format binaire, aussi compatible avec les "
|
|
|
|
|
"versions anciennes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:149
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le protocole 2, introduit en Python 2.3, offre une sérialisation bien plus "
|
|
|
|
|
"efficace des :term:`nouvelles classes <new-style class>`. Voir la :pep:`307` "
|
|
|
|
|
"au sujet des améliorations apportées par ce protocole."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:153
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Protocol version 3 was added in Python 3.0. It has explicit support for :"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"class:`bytes` objects and cannot be unpickled by Python 2.x. This was the "
|
|
|
|
|
"default protocol in Python 3.0--3.7."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le protocole 3 a été introduit en Python 3.0. Il gère les objets :class:"
|
|
|
|
|
"`bytes`, et ne permet pas la désérialisation par Python 2.x. Il fut le "
|
|
|
|
|
"protocole par défaut de Python 3.0 à Python 3.7."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:157
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"optimizations. It is the default protocol starting with Python 3.8. Refer "
|
|
|
|
|
"to :pep:`3154` for information about improvements brought by protocol 4."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le protocole 4 est apparu en Python 3.4. Il prend en charge les objets de "
|
|
|
|
|
"très grande taille ainsi que la sérialisation d'une plus grande variété "
|
|
|
|
|
"d'objets, et optimise le format. Il est le protocole par défaut depuis "
|
|
|
|
|
"Python 3.8. Voir la :pep:`3154` pour plus d'informations sur les "
|
|
|
|
|
"améliorations apportées par le protocole 4."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:163
|
2019-11-15 22:57:16 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Protocol version 5 was added in Python 3.8. It adds support for out-of-band "
|
|
|
|
|
"data and speedup for in-band data. Refer to :pep:`574` for information "
|
|
|
|
|
"about improvements brought by protocol 5."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le protocole 5 a été ajouté en Python 3.8 afin de permettre le transfert des "
|
|
|
|
|
"données en marge de la sérialisation elle-même. Il a également accéléré les "
|
|
|
|
|
"opérations sur les données à sérialiser. Reportez-vous à la :pep:`574` pour "
|
|
|
|
|
"les détails relatifs aux améliorations apportées par le protocole 5."
|
2019-11-15 22:57:16 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:168
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"La sérialisation est un problème plus simple que la persistance des données "
|
|
|
|
|
"en général. Le module :mod:`pickle` lit et écrit des objets fichiers-"
|
|
|
|
|
"compatibles, mais ne s'occupe pas du problème de donner un nom à des objets "
|
|
|
|
|
"persistants, ni de gérer l'accès par différents processus en parallèle à ces "
|
|
|
|
|
"objets. :mod:`pickle` se contente de transformer des objets complexes en "
|
|
|
|
|
"flux d'octets, et lire ces flux d'octets par la suite pour reconstruire des "
|
|
|
|
|
"objets avec la même structure. Si l'on peut bien sûr écrire les flux "
|
|
|
|
|
"d'octets dans un fichier, rien n'empêche de les transférer à travers un "
|
|
|
|
|
"réseau, ou bien de les stocker dans une base de données. Voir le module :mod:"
|
|
|
|
|
"`shelve` pour une interface simple qui sérialise et désérialise les objets "
|
|
|
|
|
"dans des bases de données de style DBM."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:181
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Module Interface"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Interface du module"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:183
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pour sérialiser un objet, contenant éventuellement d'autres objets, appelez "
|
|
|
|
|
"tout simplement la fonction :func:`dumps`. La fonction :func:`loads`, quant "
|
|
|
|
|
"à elle, désérialise un flux de données. Pour un contrôle plus fin des "
|
|
|
|
|
"opérations de sérialisation ou désérialisation, créez un objet :class:"
|
|
|
|
|
"`Pickler` ou :class:`Unpickler`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:188
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The :mod:`pickle` module provides the following constants:"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Le module :mod:`pickle` définit les constantes suivantes :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:193
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Entier qui donne la version du :ref:`protocole <pickle-protocols>` le plus "
|
|
|
|
|
"récent qui soit disponible. Ce nombre peut être passé comme paramètre "
|
|
|
|
|
"*protocol* aux fonctions :func:`dump` et :func:`dumps` ainsi qu'au "
|
|
|
|
|
"constructeur de la classe :class:`Pickler`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:200
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An integer, the default :ref:`protocol version <pickle-protocols>` used for "
|
|
|
|
|
"pickling. May be less than :data:`HIGHEST_PROTOCOL`. Currently the default "
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"protocol is 4, first introduced in Python 3.4 and incompatible with previous "
|
|
|
|
|
"versions."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Entier qui donne la version du :ref:`protocole <pickle-protocols>` employé "
|
|
|
|
|
"par défaut pour la sérialisation. Il peut être moindre que :data:"
|
|
|
|
|
"`HIGHEST_PROTOCOL`. La valeur actuelle est 4, sachant que le protocole "
|
|
|
|
|
"correspondant a été introduit en Python 3.4 et n'est pas compatible avec les "
|
|
|
|
|
"versions antérieures."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:207
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "The default protocol is 3."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Le protocole par défaut est devenu le protocole 3."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:211
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "The default protocol is 4."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Le protocole par défaut est devenu le protocole 4."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:213
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :mod:`pickle` module provides the following functions to make the "
|
|
|
|
|
"pickling process more convenient:"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module :mod:`pickle` contient quelques fonctions pour faciliter la "
|
|
|
|
|
"sérialisation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:218
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"Write the pickled representation of the object *obj* to the open :term:`file "
|
|
|
|
|
"object` *file*. This is equivalent to ``Pickler(file, protocol).dump(obj)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Écrit la représentation sérialisée de l'objet *obj* dans l'\\ :term:`objet "
|
|
|
|
|
"fichier-compatible <file object>` *file*, qui doit être ouvert. Ceci est "
|
|
|
|
|
"l'équivalent de ``Pickle(file, protocol).dump(obj)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:222
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"Arguments *file*, *protocol*, *fix_imports* and *buffer_callback* have the "
|
|
|
|
|
"same meaning as in the :class:`Pickler` constructor."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les arguments *file*, *protocol*, *fix_imports* et *buffer_callback* sont "
|
|
|
|
|
"identiques à ceux du constructeur de la classe :class:`Pickler`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-10-02 08:55:01 +00:00
|
|
|
|
#: library/pickle.rst:236 library/pickle.rst:328
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "The *buffer_callback* argument was added."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "ajout de l'argument *buffer_callback*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:230
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"Return the pickled representation of the object *obj* as a :class:`bytes` "
|
|
|
|
|
"object, instead of writing it to a file."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Renvoie la représentation sérialisée de *obj* sous forme de :class:`bytes`, "
|
|
|
|
|
"au lieu de l'écrire dans un fichier."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:233
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"Arguments *protocol*, *fix_imports* and *buffer_callback* have the same "
|
|
|
|
|
"meaning as in the :class:`Pickler` constructor."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les arguments *protocol*, *fix_imports* et *buffer_callback* sont identiques "
|
|
|
|
|
"à ceux du constructeur de la classe :class:`Pickler`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:241
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"Read the pickled representation of an object from the open :term:`file "
|
|
|
|
|
"object` *file* and return the reconstituted object hierarchy specified "
|
|
|
|
|
"therein. This is equivalent to ``Unpickler(file).load()``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Charge la représentation sérialisée d'un objet depuis l'\\ :term:`objet "
|
|
|
|
|
"fichier-compatible <file object>` ouvert *file*, et renvoie l'objet "
|
|
|
|
|
"reconstitué obtenu. Ceci est l'équivalent de ``Unpickler(file).load()``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-10-02 08:55:01 +00:00
|
|
|
|
#: library/pickle.rst:260
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The protocol version of the pickle is detected automatically, so no protocol "
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"argument is needed. Bytes past the pickled representation of the object are "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"ignored."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"La version du protocole utilisée pour la sérialisation est détectée "
|
|
|
|
|
"automatiquement, d'où l'absence d'un argument. Les octets situés après la "
|
|
|
|
|
"représentation sérialisée de l'objet sont ignorés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-10-02 08:55:01 +00:00
|
|
|
|
#: library/pickle.rst:264
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"Arguments *file*, *fix_imports*, *encoding*, *errors*, *strict* and "
|
|
|
|
|
"*buffers* have the same meaning as in the :class:`Unpickler` constructor."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les arguments *file*, *fix_imports*, *encoding*, *errors*, *strict* et "
|
|
|
|
|
"*buffers* sont identiques à ceux du constructeur de la classe :class:"
|
|
|
|
|
"`Unpickler`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-10-02 08:55:01 +00:00
|
|
|
|
#: library/pickle.rst:267 library/pickle.rst:429
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "The *buffers* argument was added."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Ajout de l'argument *buffers*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:257
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"Return the reconstituted object hierarchy of the pickled representation "
|
2020-05-24 14:31:50 +00:00
|
|
|
|
"*data* of an object. *data* must be a :term:`bytes-like object`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Renvoie l'objet reconstitué à partir de la représentation sérialisée *data*, "
|
|
|
|
|
"qui doit être fournie sous la forme d'un :term:`bytes-like object`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:271
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The :mod:`pickle` module defines three exceptions:"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Le module :mod:`pickle` définit trois types d'exceptions :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:275
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Common base class for the other pickling exceptions. It inherits :exc:"
|
|
|
|
|
"`Exception`."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Classe mère commune aux autres exceptions de sérialisation. Elle hérite de :"
|
|
|
|
|
"exc:`Exception`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:280
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Error raised when an unpicklable object is encountered by :class:`Pickler`. "
|
|
|
|
|
"It inherits :exc:`PickleError`."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Exception levée lorsqu'un objet impossible à sérialiser est rencontré par "
|
|
|
|
|
"un :class:`Pickler`. Elle hérite de :exc:`PickleError`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:283
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Refer to :ref:`pickle-picklable` to learn what kinds of objects can be "
|
|
|
|
|
"pickled."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lisez :ref:`pickle-picklable` pour en savoir plus sur les types d'objets qui "
|
|
|
|
|
"peuvent être sérialisés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:288
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Exception levée lorsqu'un flux binaire ne peut pas être désérialisé, par "
|
|
|
|
|
"exemple s'il est corrompu ou en cas de violation de la sécurité. Elle hérite "
|
|
|
|
|
"de :exc:`PickleError`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:291
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Note that other exceptions may also be raised during unpickling, including "
|
|
|
|
|
"(but not necessarily limited to) AttributeError, EOFError, ImportError, and "
|
|
|
|
|
"IndexError."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Veuillez noter que d'autres exceptions peuvent être levées durant la "
|
|
|
|
|
"désérialisation, comme ``AttributeError``, ``EOFError``, ``ImportError`` et "
|
|
|
|
|
"``IndexError`` (liste non-exhaustive)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:296
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"The :mod:`pickle` module exports three classes, :class:`Pickler`, :class:"
|
|
|
|
|
"`Unpickler` and :class:`PickleBuffer`:"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module :mod:`pickle` exporte trois classes : :class:`Pickler`, :class:"
|
|
|
|
|
"`Unpickler` et :class:`PickleBuffer`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:301
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "This takes a binary file for writing a pickle data stream."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Classe d'objets qui implémentent la sérialisation vers un flux binaire."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:303
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"L'argument optionnel *protocol* détermine la version du protocole de "
|
|
|
|
|
"sérialisation à employer, entre 0 et :data:`HIGHEST_PROTOCOL`. La valeur par "
|
|
|
|
|
"défaut est celle de :data:`DEFAULT_PROTOCOL`. Avec un nombre strictement "
|
|
|
|
|
"négatif, c'est :data:`HIGHEST_PROTOCOL` qui est utilisé."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:308
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"L'argument *file* peut être un fichier sur disque ouvert en mode binaire "
|
|
|
|
|
"pour l'écriture, une instance de la classe :class:`io.BytesIO`, ou plus "
|
|
|
|
|
"généralement un objet quelconque qui possède une méthode ``write()`` "
|
|
|
|
|
"acceptant d'être appelée sur un argument unique de type ``bytes``."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:313
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si *fix_imports* est vrai et *protocol* est inférieur ou égal à 2, les noms "
|
|
|
|
|
"des modules sont reliés par *pickle* aux anciens noms qui avaient cours en "
|
|
|
|
|
"Python 2, afin que le flux sérialisé soit lisible aussi bien par Python 2 "
|
|
|
|
|
"que Python 3."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:317
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If *buffer_callback* is None (the default), buffer views are serialized into "
|
|
|
|
|
"*file* as part of the pickle stream."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si *buffer_callback* vaut ``None`` (comme par défaut), les vues de tampon "
|
|
|
|
|
"sont sérialisées dans *file* avec le reste du flux."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:320
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans le cas où le *buffer_callback* n'est pas ``None``, il doit pouvoir être "
|
|
|
|
|
"appelé un nombre quelconque de fois avec une vue d'un tampon. S'il renvoie "
|
|
|
|
|
"une valeur évaluée comme fausse (telle que ``None``), le tampon est "
|
|
|
|
|
"considéré en marge de la sérialisation (ou « :ref:`hors-bande <pickle-"
|
|
|
|
|
"oob>` »), sinon il est sérialisé dans le flux binaire."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:325
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"It is an error if *buffer_callback* is not None and *protocol* is None or "
|
|
|
|
|
"smaller than 5."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Une erreur se produit si *buffer_callback* vaut autre chose que ``None`` et "
|
|
|
|
|
"*protocol* est 4 ou inférieur, ou ``None``."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:333
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"Write the pickled representation of *obj* to the open file object given in "
|
|
|
|
|
"the constructor."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Écrit la représentation sérialisée de l'objet *obj* dans le fichier ouvert "
|
|
|
|
|
"passé au constructeur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:338
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Do nothing by default. This exists so a subclass can override it."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Ne fait rien par défaut. Cette méthode est destinée à être implémentée par "
|
|
|
|
|
"une classe fille."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:340
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si :meth:`persistent_id` renvoie ``None``, *obj* est sérialisé normalement. "
|
|
|
|
|
"Toute autre valeur est reprise par le :class:`Pickler` comme ID persistant "
|
|
|
|
|
"pour *obj*. Le sens de cet ID persistant doit être défini par :meth:"
|
|
|
|
|
"`Unpickler.persistent_load`. Veuillez noter que la valeur renvoyée par :meth:"
|
|
|
|
|
"`persistent_id` ne peut pas porter elle-même d'ID persistant."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-10-02 08:55:01 +00:00
|
|
|
|
#: library/pickle.rst:447
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "See :ref:`pickle-persistent` for details and examples of uses."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "La section :ref:`pickle-persistent` donne des détails et exemples."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:350
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"La table de distribution d'un sérialiseur est un tableau associatif dont les "
|
|
|
|
|
"clés sont des classes et les valeurs, des fonctions de réduction. La manière "
|
|
|
|
|
"la plus directe de déclarer une fonction de réduction est la fonction :func:"
|
|
|
|
|
"`copyreg.pickle`. Une fonction de réduction prend un unique argument, qui "
|
|
|
|
|
"doit être de la classe en question, et obéit à la même interface qu'une "
|
|
|
|
|
"méthode :meth:`__reduce__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:358
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lorsqu'un sérialiseur ne possède pas l'attribut :attr:`dispatch_table`, "
|
|
|
|
|
"comme c'est le cas par défaut, il utilise le tableau global du module :mod:"
|
|
|
|
|
"`copyreg`. Afin de personnaliser l'opération de sérialisation pour un "
|
|
|
|
|
"sérialiseur particulier, on peut affecter à son attribut :attr:"
|
|
|
|
|
"`dispatch_table` un objet compatible avec les dictionnaires. Une autre "
|
|
|
|
|
"possibilité est de définir l'attribut :attr:`dispatch_table` dans une classe "
|
|
|
|
|
"fille de :class:`Pickler`. Sa valeur sera alors utilisée pour toutes les "
|
|
|
|
|
"instances de cette classe fille."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:367
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "See :ref:`pickle-dispatch` for usage examples."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Voir :ref:`pickle-dispatch` pour des exemples d'utilisation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:373
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Réducteur spécial, qui peut se définir dans une classe fille de :class:"
|
|
|
|
|
"`Pickler`. Cette méthode doit se conformer à l'interface des méthodes :meth:"
|
|
|
|
|
"`__reduce__`. Elle prend en général le pas sur les réducteurs contenus dans "
|
|
|
|
|
"l'attribut :attr:`dispatch_table`. Cependant, elle peut choisir de renvoyer "
|
|
|
|
|
"``NotImplemented`` pour que :attr:`dispatch_table` soit utilisé à la place."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:379
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "For a detailed example, see :ref:`reducer_override`."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Voir :ref:`reducer_override` pour un exemple détaillé."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:385
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Cet attribut est obsolète. Une valeur vraie (« mode rapide ») désactive la "
|
|
|
|
|
"mémorisation des objets au fur et à mesure de leur sérialisation, qui permet "
|
|
|
|
|
"habituellement de représenter les doublons par une unique référence. Cette "
|
|
|
|
|
"option accélère la sérialisation en évitant des *opcodes* PUT superflus. "
|
|
|
|
|
"Elle ne doit pas être utilisée sur un objet contenant une référence à lui-"
|
|
|
|
|
"même, car le :class:`Pickler` entre alors dans une récursion infinie."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:391
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Use :func:`pickletools.optimize` if you need more compact pickles."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Utilisez plutôt :func:`pickletools.optimize` pour obtenir des données "
|
|
|
|
|
"sérialisées plus compactes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:396
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "This takes a binary file for reading a pickle data stream."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les objets de cette classe sont des désérialiseurs, qui lisent un flux de "
|
|
|
|
|
"données pour le convertir en objet."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:398
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The protocol version of the pickle is detected automatically, so no protocol "
|
|
|
|
|
"argument is needed."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Il n'y a nul besoin d'argument *protocol*. La version du protocole avec "
|
|
|
|
|
"lequel sont encodées les données est déterminée automatiquement."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:401
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"L'argument *file* doit posséder trois méthodes qui proviennent de "
|
|
|
|
|
"l'interface de :class:`io.BufferedIOBase`. Ce sont : ``read()``, prenant un "
|
|
|
|
|
"entier, ``readinto()``, prenant un tampon, et ``readline()``, sans "
|
|
|
|
|
"arguments. *file* peut donc être aussi bien un fichier sur disque ouvert en "
|
|
|
|
|
"mode lecture binaire qu'un objet :class:`io.BytesIO`, ou un objet quelconque "
|
|
|
|
|
"vérifiant ces critères."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:408
|
2018-12-24 13:20:55 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"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."
|
2018-12-24 13:20:55 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les paramètres facultatifs *fix_imports*, *encoding* et *errors* sont dédiés "
|
|
|
|
|
"à la compatibilité de la désérialisation avec les flux binaires générés par "
|
|
|
|
|
"Python 2. Si *fix_imports* est vrai, *pickle* tente de modifier les anciens "
|
|
|
|
|
"noms des modules que l'on trouve en Python 2, pour les remplacer par ceux en "
|
|
|
|
|
"usage en Python 3. Les paramètres *encoding* et *errors* contrôlent la façon "
|
|
|
|
|
"de décoder les chaînes de caractères 8 bits. Leurs valeurs par défaut "
|
|
|
|
|
"respectives sont ``'ASCII'`` et ``'strict'``. *encoding* peut être mis à "
|
|
|
|
|
"``'bytes'`` pour lire des chaînes d'octets en tant que *bytes*. Il doit être "
|
|
|
|
|
"mis à ``'latin1'`` pour désérialiser des tableaux NumPy ou des instances de :"
|
|
|
|
|
"class:`~datetime.datetime`, :class:`~datetime.date` et :class:`~datetime."
|
|
|
|
|
"time` sérialisées par Python 2."
|
2018-12-24 13:20:55 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:419
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si *buffers* vaut None (comme par défaut), toutes les données nécessaires à "
|
|
|
|
|
"la désérialisation doivent être contenues dans le flux binaire. Ceci "
|
|
|
|
|
"signifie que l'argument *buffer_callback* valait None lors de la "
|
|
|
|
|
"construction du :class:`Pickler` (ou dans l'appel à :func:`dump` ou :func:"
|
|
|
|
|
"`dumps`)."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:424
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:434
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"Read the pickled representation of an object from the open file object given "
|
|
|
|
|
"in the constructor, and return the reconstituted object hierarchy specified "
|
|
|
|
|
"therein. Bytes past the pickled representation of the object are ignored."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lit la représentation sérialisée d'un objet depuis le fichier ouvert passé "
|
|
|
|
|
"au constructeur, et reconstitue l'objet qui y est stocké, avec tous les "
|
|
|
|
|
"objets qu'il contient. Les octets situés au-delà de la fin de la "
|
|
|
|
|
"représentation binaire sont ignorés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:441
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Raise an :exc:`UnpicklingError` by default."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Par défaut, cette méthode lève une exception :exc:`UnpicklingError`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:443
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si elle est définie autrement dans une sous-classe, :meth:`persistent_load` "
|
|
|
|
|
"doit renvoyer l'objet correspondant à l'ID persistant *pid*. Si celui-ci est "
|
|
|
|
|
"invalide, elle doit lever une exception :exc:`UnpicklingError`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:451
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Importe *module* si besoin, et renvoie l'objet du nom *name* qu'il contient. "
|
|
|
|
|
"*module* et *name* sont des chaînes de caractères (classe :class:`str`). "
|
|
|
|
|
"Contrairement à ce que son nom laisse penser, :meth:`find_class` est "
|
|
|
|
|
"également appelée pour trouver les fonctions."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:456
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les classes filles peuvent redéfinir cette méthode pour restreindre la "
|
|
|
|
|
"désérialisation à certains types d'objets ou à d'autres conditions, "
|
|
|
|
|
"notamment en vue de réduire les risques de sécurité. Voir :ref:`pickle-"
|
|
|
|
|
"restrict` pour plus de détails."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:460
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Raises an :ref:`auditing event <auditing>` ``pickle.find_class`` with "
|
|
|
|
|
"arguments ``module``, ``name``."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lève un :ref:`événement d'audit <auditing>` ``pickle.find_class`` avec les "
|
|
|
|
|
"arguments ``module`` et ``name``."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:464
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Encapsule un objet tampon contenant des données sérialisables. *buffer* doit "
|
|
|
|
|
"être un objet prenant en charge le :ref:`protocole tampon <bufferobjects>`, "
|
|
|
|
|
"comme un :term:`objet octet-compatible <bytes-like object>` ou un tableau n-"
|
|
|
|
|
"dimensionnel."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:468
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les objets :class:`PickleBuffer` savent gérer le protocole tampon. Il est "
|
|
|
|
|
"donc possible de les passer à d'autres API qui attendent un tampon, comme :"
|
|
|
|
|
"class:`memoryview`."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:472
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les objets :class:`PickleBuffer` ne peuvent être sérialisés qu'avec le "
|
|
|
|
|
"protocole 5 ou supérieur. Ils sont susceptibles d'être sérialisés :ref:`hors-"
|
|
|
|
|
"bande <pickle-oob>`."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:480
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Renvoie une :class:`memoryview` de l'espace mémoire sous-jacent à ce tampon. "
|
2021-12-16 18:51:49 +00:00
|
|
|
|
"La *memoryview* renvoyée est unidimensionnelle et C-contiguë. Elle a le "
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"format ``B`` (octets sans signe). :exc:`BufferError` est levée si le tampon "
|
|
|
|
|
"n'est ni C-contigu, ni Fortran-contigu."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:487
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "Release the underlying buffer exposed by the PickleBuffer object."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:493
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "What can be pickled and unpickled?"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Quels objets sont sérialisables ?"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:495
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The following types can be pickled:"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Les objets des types suivants peuvent être sérialisés :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:497
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "``None``, ``True``, and ``False``"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "``None``, ``True`` et ``False`` ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:499
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "integers, floating point numbers, complex numbers"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "les entiers, nombres à virgule flottante et nombres complexes ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:501
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "strings, bytes, bytearrays"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "les chaînes de caractères, *bytes* et *bytearrays* ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:503
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "tuples, lists, sets, and dictionaries containing only picklable objects"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"les *n*-uplets, listes, ensembles et dictionnaires, à condition que tous les "
|
|
|
|
|
"objets qu'ils contiennent soient sérialisables."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:505
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"functions defined at the top level of a module (using :keyword:`def`, not :"
|
|
|
|
|
"keyword:`lambda`)"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"les fonctions définies au niveau le plus haut dans un module (avec :keyword:"
|
|
|
|
|
"`def`, mais pas :keyword:`lambda`) ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:508
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "built-in functions defined at the top level of a module"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "les fonctions natives définies au plus haut niveau dans un module ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:510
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "classes that are defined at the top level of a module"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "les classes définies au plus haut niveau dans un module ;"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:512
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"les instances de telles classes, à condition que leur :attr:`~object."
|
|
|
|
|
"__dict__`, ou la valeur de retour de :meth:`__getstate__`, soit sérialisable "
|
|
|
|
|
"(voir :ref:`pickle-inst` pour plus d'informations)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:516
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si vous essayez de sérialiser un objet qui ne peut pas l'être, une exception "
|
|
|
|
|
"de type :exc:`PicklingError` est levée. Lorsque cela se produit, il est "
|
|
|
|
|
"possible qu'un certain nombre d'octets aient déjà été écrits dans le fichier "
|
|
|
|
|
"ou flux. La sérialisation d'une structure de donnée avec de nombreux niveaux "
|
|
|
|
|
"d'imbrication peut lever une exception :exc:`RecursionError`. Pour augmenter "
|
|
|
|
|
"la limite (avec précaution), voir :func:`sys.setrecursionlimit`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:523
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Veuillez noter que les fonctions, natives ou non, sont sérialisées par "
|
|
|
|
|
"référence à leur « nom complètement qualifié », et non pas par leur vraie "
|
|
|
|
|
"valeur [#]_. La seule information stockée est le nom de la fonction "
|
|
|
|
|
"accompagné du nom du module auquel elle appartient. Le code de la fonction "
|
|
|
|
|
"n'est pas sérialisé, les attributs de la fonction non plus. Ainsi, le module "
|
|
|
|
|
"qui définit la fonction sérialisée doit être disponible dans l'environnement "
|
|
|
|
|
"de désérialisation. Il doit contenir l'objet du nom spécifié, sans quoi une "
|
|
|
|
|
"exception sera levée [#]_."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:530
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"De même, les classes sont sérialisées par leur nom. Les mêmes prérequis sur "
|
|
|
|
|
"l'environnement de désérialisation s'appliquent. Le code de la classe et les "
|
|
|
|
|
"données qu'elle contient ne sont pas sérialisés. Par exemple, dans ce code, "
|
|
|
|
|
"l'attribut ``attr`` ne sera pas restauré à la désérialisation :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:540
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These restrictions are why picklable functions and classes must be defined "
|
|
|
|
|
"in the top level of a module."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Cette sérialisation par le nom est la raison pour laquelle les fonctions et "
|
|
|
|
|
"classes à sérialiser doivent impérativement être définies au plus haut "
|
|
|
|
|
"niveau dans un module."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:543
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"De même, lorsque les instances d'une certaine classe sont sérialisées, seuls "
|
|
|
|
|
"les attributs de l'instance sont inclus, mais pas le code de leur classe ni "
|
|
|
|
|
"les données qu'elle pourrait contenir. Ceci est intentionnel : vous pouvez "
|
|
|
|
|
"corriger des bogues dans une classe ou ajouter des méthodes, et désérialiser "
|
|
|
|
|
"malgré tout des objets instanciés avec une version plus ancienne de la "
|
|
|
|
|
"classe. Si vous stockez des objets destinés être conservés pendant "
|
|
|
|
|
"longtemps, et que leur classe est susceptible de connaître de nombreuses "
|
|
|
|
|
"évolutions, il peut s'avérer utile d'associer aux objets un numéro de "
|
|
|
|
|
"version afin que des conversions puissent être implémentées dans la méthode :"
|
|
|
|
|
"meth:`__setstate__` de la classe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:555
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Pickling Class Instances"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Sérialisation des instances d'une classe"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:559
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans cette section sont décrits les mécanismes généraux qui s'offrent à vous "
|
|
|
|
|
"pour définir, personnaliser et contrôler la manière dont les instances d'une "
|
|
|
|
|
"classe sont sérialisées et désérialisées."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:562
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans la plupart des cas, il n'y a besoin de rien pour que les instances "
|
|
|
|
|
"d'une classe puissent être sérialisées. Par défaut, *pickle* accède à la "
|
|
|
|
|
"classe et aux attributs de l'instance par introspection. Lorsqu'une instance "
|
|
|
|
|
"est désérialisée, sa méthode :meth:`__init__` n'est normalement *pas* "
|
|
|
|
|
"appelée. Une nouvelle instance est créée sans être initialisée, et ses "
|
|
|
|
|
"attributs sont simplement restaurés à partir des valeurs conservées. En "
|
|
|
|
|
"d'autres termes, les opérations sont celles qu'effectue le code suivant ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:577
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Classes can alter the default behaviour by providing one or several special "
|
|
|
|
|
"methods:"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les classes peuvent personnaliser le comportement par défaut en définissant "
|
|
|
|
|
"des méthodes spéciales :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:582
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans les protocoles 2 et suivants, les classes peuvent personnaliser les "
|
|
|
|
|
"valeurs passées à la méthode :meth:`__new__` lors de la désérialisation. "
|
|
|
|
|
"Elles le font en définissant une méthode :meth:`__getnewargs_ex__` qui "
|
|
|
|
|
"renvoie un couple ``(args, kwargs)``, où *args* est un *n*-uplet des "
|
|
|
|
|
"arguments positionnels et *kwargs* un dictionnaire des arguments nommés qui "
|
|
|
|
|
"seront passés à :meth:`__new__` — autrement dit, l'appel sera ``classe."
|
|
|
|
|
"__new__(*args, **kwargs)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:590
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Définissez cette méthode seulement si la méthode :meth:`__new__` de votre "
|
|
|
|
|
"classe demande des arguments nommés. Dans le cas contraire, mieux vaut "
|
|
|
|
|
"définir :meth:`__getnewargs__` pour préserver la compatibilité avec les "
|
|
|
|
|
"protocoles anciens."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:594
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":meth:`__getnewargs_ex__` is now used in protocols 2 and 3."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
":meth:`__getnewargs_ex__` est désormais appelée dans les protocoles 2 et 3."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:600
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-06-10 09:32:30 +00:00
|
|
|
|
"This method serves a similar purpose as :meth:`__getnewargs_ex__`, but "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"supports only positional arguments. It must return a tuple of arguments "
|
|
|
|
|
"``args`` which will be passed to the :meth:`__new__` method upon unpickling."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Comme :meth:`__getnewargs_ex__`, mais ne permet que les arguments "
|
|
|
|
|
"positionnels. Cette méthode doit renvoyer le *n*-uplet ``args`` des "
|
|
|
|
|
"arguments passés à :meth:`__new__` lors de la désérialisation : l'appel sera "
|
|
|
|
|
"``classe.__new__(*args)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:604
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`__getnewargs__` will not be called if :meth:`__getnewargs_ex__` is "
|
|
|
|
|
"defined."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si :meth:`__getnewargs_ex__` est définie, elle prend la priorité et :meth:"
|
|
|
|
|
"`__getnewargs__` n'est jamais appelée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:607
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Before Python 3.6, :meth:`__getnewargs__` was called instead of :meth:"
|
|
|
|
|
"`__getnewargs_ex__` in protocols 2 and 3."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Auparavant, :meth:`__getnewargs__` était appelée au lieu de :meth:"
|
|
|
|
|
"`__getnewargs_ex__` dans les protocoles 2 et 3."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:614
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Des personnalisations plus poussées de la sérialisation sont possibles à "
|
|
|
|
|
"l'aide de la méthode :meth:`__getstate__`. Lorsque :meth:`__getstate__` est "
|
|
|
|
|
"définie, l'objet qu'elle renvoie (état de l'instance) est sérialisé en lieu "
|
|
|
|
|
"et place du :attr:`~object.__dict__`, le dictionnaire des attributs de "
|
|
|
|
|
"l'instance."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:623
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lors de la désérialisation, l'état de l'instance est passé à la méthode :"
|
|
|
|
|
"meth:`__setstate__`, si elle est définie (l'objet *state* n'a pas besoin "
|
|
|
|
|
"d'être un dictionnaire). Si elle ne l'est pas, les attributs de l'objet sont "
|
|
|
|
|
"tirés de l'état, qui dans ce cas doit être obligatoirement un dictionnaire."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:630
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If :meth:`__getstate__` returns a false value, the :meth:`__setstate__` "
|
|
|
|
|
"method will not be called upon unpickling."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si :meth:`__getstate__` renvoie une valeur fausse, :meth:`__setstate__` ne "
|
|
|
|
|
"sera pas appelée à la désérialisation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:634
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Refer to the section :ref:`pickle-state` for more information about how to "
|
|
|
|
|
"use the methods :meth:`__getstate__` and :meth:`__setstate__`."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Voir :ref:`pickle-state` pour plus d'informations sur :meth:`__getstate__` "
|
|
|
|
|
"et :meth:`__setstate__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:639
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 "
|
2020-05-24 14:31:50 +00:00
|
|
|
|
"should implement :meth:`__new__` to establish such an invariant, as :meth:"
|
|
|
|
|
"`__init__` is not called when unpickling an instance."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lors de la désérialisation, des méthodes comme :meth:`__getattr__`, :meth:"
|
|
|
|
|
"`__getattribute__` et :meth:`__setattr__` sont susceptibles d'être appelées "
|
|
|
|
|
"sur l'instance. Si ces méthodes reposent sur des invariants internes à "
|
|
|
|
|
"l'objet, leur classe doit les initialiser dans la méthode :meth:`__new__`, "
|
|
|
|
|
"puisque la méthode :meth:`__init__` n'est pas appelée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:648
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Comme nous le verrons, *pickle* ne fait pas directement appel aux méthodes "
|
|
|
|
|
"ci-dessus. En réalité, elles font partie du protocole de copie, qui "
|
|
|
|
|
"implémente la méthode spéciale :meth:`__reduce__`. Ce protocole constitue "
|
|
|
|
|
"une interface unifiée pour l'accès aux données nécessaires à la "
|
|
|
|
|
"sérialisation comme à la copie [#]_."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:654
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Bien que la méthode :meth:`__reduce__` ouvre davantage de possibilités, elle "
|
|
|
|
|
"conduit plus facilement à des erreurs. C'est pourquoi les auteurs de classes "
|
|
|
|
|
"sont encouragés à utiliser lorsque c'est possible l'interface de plus haut "
|
|
|
|
|
"niveau avec :meth:`__getnewargs_ex__`, :meth:`__getstate__` et :meth:"
|
|
|
|
|
"`__state__`. Cependant, il existe des cas où l'on ne peut pas se passer de :"
|
|
|
|
|
"meth:`__reduce__`, ou bien elle permet une sérialisation plus efficace."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:663
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Voici l'interface de la méthode :meth:`__reduce__`. Elle ne prend aucun "
|
|
|
|
|
"argument et renvoie soit une chaîne de caractères, soit (c'est conseillé) un "
|
|
|
|
|
"*n*-uplet. On appelle souvent l'objet renvoyé « valeur de réduction »."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:667
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:672
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-09-04 09:35:23 +00:00
|
|
|
|
"When a tuple is returned, it must be between two and six items long. "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"Optional items can either be omitted, or ``None`` can be provided as their "
|
|
|
|
|
"value. The semantics of each item are in order:"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si c'est un *n*-uplet qui est renvoyé, ses éléments sont interprétés dans "
|
|
|
|
|
"l'ordre comme suit. Les deux premiers éléments sont obligatoires, les quatre "
|
|
|
|
|
"suivants sont facultatifs et peuvent être simplement omis, ou bien mis à "
|
|
|
|
|
"``None``. Les éléments sont, dans l'ordre :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:678
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A callable object that will be called to create the initial version of the "
|
|
|
|
|
"object."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Un objet appelable qui sera appelé pour créer l'objet initial."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:681
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A tuple of arguments for the callable object. An empty tuple must be given "
|
|
|
|
|
"if the callable does not accept any argument."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Un *n*-uplet d'arguments passés à cet objet appelable. Donnez un *n*-uplet "
|
|
|
|
|
"vide si l'objet appelable n'accepte pas d'arguments."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:684
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"L'état de l'objet, qui sera passé à la méthode :meth:`__setstate__` comme vu "
|
|
|
|
|
"précédemment. Si la méthode n'existe pas, cet élément doit être un "
|
|
|
|
|
"dictionnaire, et ses éléments compléteront l'attribut :attr:`~object."
|
|
|
|
|
"__dict__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:689
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Un itérateur (non pas une séquence). Les éléments qu'il fournit sont ajoutés "
|
|
|
|
|
"à l'objet un par un avec la méthode :meth:`append`, ou bien plusieurs à la "
|
|
|
|
|
"fois avec la méthode :meth:`extend`. Ceci est principalement utile aux les "
|
|
|
|
|
"classes héritant de ``list``, mais peut aussi servir sur d'autres classes, "
|
|
|
|
|
"la seule contrainte étant qu'elles implémentent :meth:`append` et :meth:"
|
|
|
|
|
"`extend` avec les bonnes signatures (l'une ou l'autre de ces méthodes est "
|
|
|
|
|
"utilisée selon la version du protocole *pickle* et le nombre d'éléments à "
|
|
|
|
|
"ajouter, c'est pourquoi elles doivent être définies toutes les deux)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:698
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Un itérateur (non pas une séquence). Les éléments qu'il fournit doivent être "
|
|
|
|
|
"des couples ``(clé, valeur)``. Ils sont ajoutés dans l'objet par affectation "
|
|
|
|
|
"aux clés : ``objet[clé] = valeur``. Ceci est principalement utile aux "
|
|
|
|
|
"classes héritant de ``dict``, mais peut servir à d'autres classes à la seule "
|
|
|
|
|
"condition qu'elles implémentent la méthode :meth:`__setitem__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:703
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Un objet appelable qui puisse recevoir en arguments l'objet et son état. "
|
|
|
|
|
"Ceci permet de redéfinir le processus de reconstruction des attributs pour "
|
|
|
|
|
"un objet en particulier, outrepassant la méthode :meth:`__setstate__`. Si "
|
|
|
|
|
"cet objet appelable est fourni, :meth:`__setstate__` n'est pas appelée."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:709
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "The optional sixth tuple item, ``(obj, state)``, was added."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "ajout du sixième élément."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:715
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Il est également possible de définir une méthode :meth:`__reduce_ex__`. La "
|
|
|
|
|
"seule différence est qu'elle prend la version du protocole en argument. Si "
|
|
|
|
|
"elle est définie, elle prend le pas sur :meth:`__reduce__`. De plus, :meth:"
|
|
|
|
|
"`__reduce__` devient automatiquement un alias pour sa version étendue. Cette "
|
|
|
|
|
"méthode est principalement destinée à renvoyer des valeurs de réduction "
|
|
|
|
|
"compatibles avec les versions anciennes de Python."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:727
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Persistence of External Objects"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Persistance d'objets externes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:733
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pour les besoins de la persistance, :mod:`pickle` permet des références à "
|
|
|
|
|
"des objets en dehors du flux sérialisé. Ils sont identifiés par un ID "
|
|
|
|
|
"persistant. Le protocole 0 requiert que cet ID soit une chaîne de caractères "
|
|
|
|
|
"alphanumériques [#]_. Les suivants autorisent un objet quelconque."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:739
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The resolution of such persistent IDs is not defined by the :mod:`pickle` "
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"module; it will delegate this resolution to the user-defined methods on the "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"pickler and unpickler, :meth:`~Pickler.persistent_id` and :meth:`~Unpickler."
|
|
|
|
|
"persistent_load` respectively."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
":mod:`pickle` délègue la résolution des ID à des méthodes définies par "
|
|
|
|
|
"l'utilisateur sur les objets sérialiseurs et désérialiseurs, à savoir :meth:"
|
|
|
|
|
"`~Pickler.persistent_id` et :meth:`~Unpickler.persistent_load`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:744
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"To pickle objects that have an external persistent ID, the pickler must have "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"a custom :meth:`~Pickler.persistent_id` method that takes an object as an "
|
2019-10-09 16:10:12 +00:00
|
|
|
|
"argument and returns either ``None`` or the persistent ID for that object. "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pour affecter à des objets leurs ID persistants provenant d'une source "
|
|
|
|
|
"externe, le sérialiseur doit posséder une méthode :meth:`~Pickler."
|
|
|
|
|
"persistent_id` qui prend un objet et renvoie soit ``None``, soit son ID. Si "
|
|
|
|
|
"cette méthode renvoie ``None``, l'objet est sérialisé de la manière "
|
|
|
|
|
"habituelle. Si un ID est renvoyé, sous forme de chaîne de caractères, c'est "
|
|
|
|
|
"cette chaîne qui est sérialisée et elle est marquée de manière spéciale pour "
|
|
|
|
|
"être reconnue comme un ID persistant."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:751
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pour désérialiser des objets identifiés par un ID externe, un désérialiseur "
|
|
|
|
|
"doit posséder une méthode :meth:`~Unpickler.persistent_load` qui prend un ID "
|
|
|
|
|
"et renvoie l'objet qu'il désigne."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:755
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here is a comprehensive example presenting how persistent ID can be used to "
|
|
|
|
|
"pickle external objects by reference."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Voici un exemple complet qui montre comment sérialiser des objets externes "
|
|
|
|
|
"en leur affectant des ID persistants."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:763
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Dispatch Tables"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Tables de distribution"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:765
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pour personnaliser la sérialisation d'une classe à un endroit particulier "
|
|
|
|
|
"sans affecter le reste du code, on peut créer un sérialiseur avec une table "
|
|
|
|
|
"de distribution spécifique."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:769
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"La table de distribution gérée par le module :mod:`copyreg` est disponible "
|
|
|
|
|
"sous le nom :data:`copyreg.dispatch_table`. On peut donc utiliser une copie "
|
|
|
|
|
"modifiée de :data:`copyreg.dispatch_table` comme table spécifique à un "
|
|
|
|
|
"sérialiseur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:774
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "For example ::"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Par exemple, le code :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:781
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"creates an instance of :class:`pickle.Pickler` with a private dispatch table "
|
|
|
|
|
"which handles the ``SomeClass`` class specially. Alternatively, the code ::"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"crée une instance de la classe :class:`pickle.Pickler` avec une table de "
|
|
|
|
|
"distribution propre qui traite la classe ``SomeClass`` de manière "
|
|
|
|
|
"spécifique. Le code :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:791
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"fait la même chose, mais toutes les instances de ``MyPickler`` partageront "
|
|
|
|
|
"par défaut la même table de distribution. L'équivalent avec :mod:`copyreg` "
|
|
|
|
|
"serait :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:802
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Handling Stateful Objects"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Traitement des objets à état"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:808
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"L'exemple suivant illustre comment modifier la sérialisation pour une "
|
|
|
|
|
"classe. La classe :class:`TextReader` ouvre un fichier de texte, et sa "
|
|
|
|
|
"méthode :meth:`!readline` renvoie le numéro de la ligne suivante et son "
|
|
|
|
|
"contenu chaque fois qu'elle est appelée. Si une instance de :class:"
|
|
|
|
|
"`TextReader` est sérialisée, tous les attributs *sauf* le fichier ouvert "
|
|
|
|
|
"sont enregistrés. Lorsque l'instance est désérialisée, le fichier est "
|
|
|
|
|
"rouvert et la lecture reprend là où elle s'était arrêtée. Ceci est "
|
|
|
|
|
"implémenté à travers les méthodes :meth:`__setstate__` et :meth:"
|
|
|
|
|
"`__getstate__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:854
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "A sample usage might be something like this::"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Voici un exemple d'utilisation :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:868
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "Custom Reduction for Types, Functions, and Other Objects"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Réduction personnalisée pour les types, fonctions et autres objets"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:872
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Parfois, la simple utilisation de :attr:`~Pickler.dispatch_table` n'offre "
|
|
|
|
|
"pas assez de flexibilité. On peut vouloir changer la méthode de "
|
|
|
|
|
"sérialisation selon d'autres critères que le type de l'objet, ou bien "
|
|
|
|
|
"personnaliser la sérialisation des fonctions et des classes."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:877
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans ces cas, il est possible d'écrire une méthode :meth:`~Pickler."
|
|
|
|
|
"reducer_override` dans une classe fille de :class:`Pickler`. Cette méthode "
|
|
|
|
|
"renvoie un *n*-uplet de réduction arbitraire (voir :meth:`__reduce__`). Elle "
|
|
|
|
|
"peut aussi renvoyer ``NotImplemented``, auquel cas la méthode habituelle de "
|
|
|
|
|
"réduction par table s'applique."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:882
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If both the :attr:`~Pickler.dispatch_table` and :meth:`~Pickler."
|
|
|
|
|
"reducer_override` are defined, then :meth:`~Pickler.reducer_override` method "
|
|
|
|
|
"takes priority."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Si :attr:`~Pickler.dispatch_table` et :meth:`~Pickler.reducer_override` sont "
|
|
|
|
|
"tous les deux définis, :meth:`~Pickler.reducer_override` a la priorité."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:887
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Pour des raisons de performance, la méthode :meth:`~Pickler."
|
|
|
|
|
"reducer_override` n'est jamais appelée sur ``None``, ``True``, ``False``, "
|
|
|
|
|
"ainsi que les instances exactes (pas dérivées) de :class:`int`, :class:"
|
|
|
|
|
"`float`, :class:`bytes`, :class:`str`, :class:`dict`, :class:`set`, :class:"
|
|
|
|
|
"`frozenset`, :class:`list` et :class:`tuple`."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:893
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here is a simple example where we allow pickling and reconstructing a given "
|
|
|
|
|
"class::"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Voici un exemple simple qui implémente la sérialisation d'une classe :"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:928
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "Out-of-band Buffers"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Tampons hors-bande"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:932
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module :mod:`pickle` est parfois utilisé pour transférer des quantités "
|
|
|
|
|
"énormes de données. Il peut devenir important de réduire les copies de "
|
|
|
|
|
"mémoire au minimum pour préserver la performance et diminuer l'usage des "
|
|
|
|
|
"ressources matérielles. Cependant, dans son contexte courant d'utilisation, "
|
|
|
|
|
"le module :mod:`pickle` effectue des copies depuis et vers le flux de "
|
|
|
|
|
"données pour les besoins de la conversion de structures d'objets semblables "
|
|
|
|
|
"à des graphes en flux séquentiels d'octets."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:939
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Cette contrainte peut être levée si le *producteur* (qui implémente les "
|
|
|
|
|
"types d'objets à transférer) et le *consommateur* (qui implémente le système "
|
|
|
|
|
"de communication) emploient les possibilités de transfert hors-bande "
|
|
|
|
|
"offertes par les protocoles 5 et suivants."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:945
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "Provider API"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "API des producteurs"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:947
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les objets de grande taille à sérialiser doivent posséder une méthode :meth:"
|
|
|
|
|
"`__reduce_ex__` qui, lorsqu'elle est appelée pour le protocole 5 ou plus, "
|
|
|
|
|
"renvoie un objet :class:`PickleBuffer` au lieu d'un objet :class:`bytes` dès "
|
|
|
|
|
"que la taille le justifie."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:952
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Les objets :class:`PickleBuffer` ne font que signaler que leur tampon permet "
|
|
|
|
|
"le transfert hors-bande. Ils demeurent compatibles avec l'utilisation "
|
|
|
|
|
"classique du module :mod:`pickle`. Cependant, les consommateurs peuvent "
|
|
|
|
|
"aussi choisir d'indiquer à :mod:`pickle` qu'ils gèrent eux-mêmes ces tampons."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:959
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "Consumer API"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "API des consommateurs"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:961
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A communications system can enable custom handling of the :class:"
|
|
|
|
|
"`PickleBuffer` objects generated when serializing an object graph."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Un système de communication peut gérer de manière spécifique les objets :"
|
|
|
|
|
"class:`PickleBuffer` générés lors de la sérialisation d'un réseau d'objets."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:964
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Du côté de l'expéditeur, il faut passer le paramètre *buffer_callback* à :"
|
|
|
|
|
"class:`Pickler` (ou à :func:`dump` ou :func:`dumps`). Le *buffer_callback* "
|
|
|
|
|
"sera appelé avec chaque :class:`PickleBuffer` généré lors de la "
|
|
|
|
|
"sérialisation du réseau d'objets. Les tampons accumulés par le "
|
|
|
|
|
"*buffer_callback* ne verront pas leurs données copiées dans le flux "
|
|
|
|
|
"sérialisé. Il leur sera substitué un marqueur léger."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:971
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Du côté du receveur, il faut passer l'argument *buffers* à :class:"
|
|
|
|
|
"`Unpickler` (ou :func:`load` ou bien :func:`loads`). *buffers* est un "
|
|
|
|
|
"itérable des tampons passés à *buffer_callback*. Il doit fournir les tampons "
|
|
|
|
|
"dans le même ordre que celui dans lequel ils ont été passés à "
|
|
|
|
|
"*buffer_callback*. Les tampons fournis constituent la source des données "
|
|
|
|
|
"qu'attendent les reconstructeurs des objets dont la sérialisation a abouti "
|
|
|
|
|
"aux objets :class:`PickleBuffer`."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:979
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Entre expéditeur et receveur, le système de communication peut implémenter "
|
|
|
|
|
"son propre mécanisme de transfert pour les tampons hors-bande. Parmi les "
|
|
|
|
|
"optimisations possibles se trouvent l'utilisation de mémoire partagée et la "
|
|
|
|
|
"compression spécifique au type de données."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:985
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid "Example"
|
2020-02-05 14:12:44 +00:00
|
|
|
|
msgstr "Exemple"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:987
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here is a trivial example where we implement a :class:`bytearray` subclass "
|
|
|
|
|
"able to participate in out-of-band buffer pickling::"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Voici un exemple trivial où est implémentée une classe fille de :class:"
|
|
|
|
|
"`bytearray` capable de sérialisation hors-bande."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1011
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Lorsqu'il rencontre le bon type, le reconstructeur (la méthode de classe "
|
|
|
|
|
"``_reconstruct``) renvoie directement le tampon original. Il s'agit d'une "
|
|
|
|
|
"manière simple de simuler l'absence de copie dans cet exemple simpliste."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1015
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"En tant que consommateur des objets, on peut les sérialiser de la manière "
|
|
|
|
|
"classique. La désérialisation conduit alors à une copie."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1024
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Mais en passant un *buffer_callback* et en donnant les tampons accumulés au "
|
|
|
|
|
"désérialiseur, il n'y a plus de copie."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1034
|
2019-09-04 09:35:23 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Cet exemple est limité par le fait que :class:`bytearray` effectue sa propre "
|
|
|
|
|
"allocation de mémoire. Il n'est pas possible de créer un :class:`bytearray` "
|
|
|
|
|
"sur la mémoire d'un autre objet. Cependant, certains types de données que "
|
|
|
|
|
"l'on trouve dans des bibliothèques externes, comme les tableaux NumPy, n'ont "
|
|
|
|
|
"pas cette limitation. Le passage hors-bande permet alors de n'effectuer "
|
|
|
|
|
"aucune copie (ou bien de minimiser le nombre de copies) lors du transfert de "
|
|
|
|
|
"données d'un système à l'autre ou d'un processus à l'autre."
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1041
|
2019-09-04 09:35:23 +00:00
|
|
|
|
msgid ":pep:`574` -- Pickle protocol 5 with out-of-band data"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr ":pep:`574` — Protocole *pickle* 5 avec données hors-bande"
|
2019-09-04 09:35:23 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1047
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Restricting Globals"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Restriction des noms dans l'espace de nommage global"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1052
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Par défaut, la désérialisation importe toutes les classes ou fonctions que "
|
|
|
|
|
"demande le flux de données. Dans bien des cas, ce comportement est "
|
|
|
|
|
"inacceptable, puisqu'il permet de faire exécuter du code arbitraire dans "
|
|
|
|
|
"l'environnement de désérialisation. Observez le résultat de ce flux de "
|
|
|
|
|
"données fait-main lorsqu'il est lu :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1062
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans cet exemple, le désérialiseur importe la fonction :func:`os.system` et "
|
|
|
|
|
"l'applique à la chaîne de caractères `\"echo hello world\"`. C'est "
|
|
|
|
|
"inoffensif, mais il n'est pas difficile d'imaginer des variantes qui "
|
|
|
|
|
"endommageraient le système."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1066
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"C'est pour cette raison qu'il s'avère parfois nécessaire de contrôler ce qui "
|
|
|
|
|
"peut être désérialisé. Cela est possible en redéfinissant la méthode :meth:"
|
|
|
|
|
"`Unpickler.find_class`. Contrairement à ce que son nom laisse penser, :meth:"
|
|
|
|
|
"`Unpickler.find_class` est appelée pour tous les noms à chercher dans "
|
|
|
|
|
"l'espace de nommage global, ce qui inclut les classes mais aussi les "
|
|
|
|
|
"fonctions. Par ce biais, il est possible d'interdire complètement la "
|
|
|
|
|
"résolution des noms globaux ou de la restreindre à un sous-ensemble que l'on "
|
|
|
|
|
"considère sûr."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1072
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here is an example of an unpickler allowing only few safe classes from the :"
|
|
|
|
|
"mod:`builtins` module to be loaded::"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Voici un exemple de désérialiseur qui permet seulement la désérialisation "
|
|
|
|
|
"d'un petit nombre de classes sûres du module :mod:`builtins`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1101
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "A sample usage of our unpickler working has intended::"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Et voici un exemple d'utilisation montrant que notre désérialiseur "
|
|
|
|
|
"fonctionne comme prévu :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1120
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Comme le montre l'exemple, il faut faire attention aux objets que l'on "
|
|
|
|
|
"autorise à être désérialisés. Si la sécurité est une priorité, il peut être "
|
|
|
|
|
"sage de se tourner vers des alternatives comme l'API du module :mod:`xmlrpc."
|
|
|
|
|
"client`, ou des bibliothèques tierces."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1127
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Performance"
|
2019-09-16 10:08:42 +00:00
|
|
|
|
msgstr "Performances"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1129
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1137
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Examples"
|
|
|
|
|
msgstr "Exemples"
|
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1139
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For the simplest code, use the :func:`dump` and :func:`load` functions. ::"
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Dans les cas les plus simples, utilisez les fonctions :func:`dump` et :func:"
|
|
|
|
|
"`load`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1155
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The following example reads the resulting pickled data. ::"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Le code suivant lit les données qui viennent d'être sérialisées :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1172
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Module :mod:`copyreg`"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Module :mod:`copyreg`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1172
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Pickle interface constructor registration for extension types."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Enregistre les fonctions de sérialisation pour les types définis par "
|
|
|
|
|
"l'utilisateur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1175
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Module :mod:`pickletools`"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Module :mod:`pickletools`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1175
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Tools for working with and analyzing pickled data."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Outils pour travailler sur les données sérialisées et les analyser."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1178
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Module :mod:`shelve`"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Module :mod:`shelve`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1178
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Indexed databases of objects; uses :mod:`pickle`."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Bases de données indexées (module fondé sur :mod:`pickle`)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1181
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Module :mod:`copy`"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Module :mod:`copy`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1181
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Shallow and deep object copying."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Copie superficielle ou récursive d'objets."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1183
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Module :mod:`marshal`"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Module :mod:`marshal`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1184
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "High-performance serialization of built-in types."
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "Sérialisation haute-performance des types natifs."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1188
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Footnotes"
|
|
|
|
|
msgstr "Notes"
|
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1189
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Don't confuse this with the :mod:`marshal` module"
|
2021-09-07 07:54:56 +00:00
|
|
|
|
msgstr "À ne pas confondre avec ce que fait le module :mod:`marshal`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1191
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-12-24 13:20:55 +00:00
|
|
|
|
"This is why :keyword:`lambda` functions cannot be pickled: all :keyword:`!"
|
|
|
|
|
"lambda` functions share the same name: ``<lambda>``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"C'est la raison pour laquelle les fonctions :keyword:`lambda` ne peuvent pas "
|
|
|
|
|
"être sérialisées : elles partagent toutes le même nom, à savoir ``<lambda>``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1194
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The exception raised will likely be an :exc:`ImportError` or an :exc:"
|
|
|
|
|
"`AttributeError` but it could be something else."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"L'exception levée est généralement de type :exc:`ImportError` ou :exc:"
|
|
|
|
|
"`AttributeError`, mais ce n'est pas systématique."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1197
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :mod:`copy` module uses this protocol for shallow and deep copying "
|
|
|
|
|
"operations."
|
|
|
|
|
msgstr ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"Le module :mod:`copy` fait appel à ce protocole pour les opérations de copie "
|
|
|
|
|
"superficielle comme récursive."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/pickle.rst:1200
|
2016-10-30 09:46:26 +00:00
|
|
|
|
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 ""
|
2021-09-07 07:54:56 +00:00
|
|
|
|
"La restriction aux caractères alphanumériques est due au fait que, dans le "
|
|
|
|
|
"protocole 0, les ID persistants sont délimités par des retours à la ligne. "
|
|
|
|
|
"Si un quelconque retour à la ligne apparaissait dans ces ID, le flux binaire "
|
|
|
|
|
"deviendrait illisible."
|