forked from AFPy/python-docs-fr
1204 lines
44 KiB
Plaintext
1204 lines
44 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
|
||
"PO-Revision-Date: 2022-10-18 15:59+0200\n"
|
||
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 2.2.3\n"
|
||
|
||
#: library/struct.rst:2
|
||
msgid ":mod:`struct` --- Interpret bytes as packed binary data"
|
||
msgstr ""
|
||
":mod:`struct` — manipulation de données agrégées sous forme binaire comme "
|
||
"une séquence d'octets"
|
||
|
||
#: library/struct.rst:7
|
||
msgid "**Source code:** :source:`Lib/struct.py`"
|
||
msgstr "**Code source :** :source:`Lib/struct.py`"
|
||
|
||
#: library/struct.rst:15
|
||
msgid ""
|
||
"This module converts between Python values and C structs represented as "
|
||
"Python :class:`bytes` objects. Compact :ref:`format strings <struct-format-"
|
||
"strings>` describe the intended conversions to/from Python values. The "
|
||
"module's functions and objects can be used for two largely distinct "
|
||
"applications, data exchange with external sources (files or network "
|
||
"connections), or data transfer between the Python application and the C "
|
||
"layer."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:25
|
||
msgid ""
|
||
"When no prefix character is given, native mode is the default. It packs or "
|
||
"unpacks data based on the platform and compiler on which the Python "
|
||
"interpreter was built. The result of packing a given C struct includes pad "
|
||
"bytes which maintain proper alignment for the C types involved; similarly, "
|
||
"alignment is taken into account when unpacking. In contrast, when "
|
||
"communicating data between external sources, the programmer is responsible "
|
||
"for defining byte ordering and padding between elements. See :ref:`struct-"
|
||
"alignment` for details."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:35
|
||
msgid ""
|
||
"Several :mod:`struct` functions (and methods of :class:`Struct`) take a "
|
||
"*buffer* argument. This refers to objects that implement the :ref:"
|
||
"`bufferobjects` and provide either a readable or read-writable buffer. The "
|
||
"most common types used for that purpose are :class:`bytes` and :class:"
|
||
"`bytearray`, but many other types that can be viewed as an array of bytes "
|
||
"implement the buffer protocol, so that they can be read/filled without "
|
||
"additional copying from a :class:`bytes` object."
|
||
msgstr ""
|
||
"Plusieurs fonctions de :mod:`struct` (et méthodes de :class:`Struct`) "
|
||
"prennent un argument *buffer*. Cet argument fait référence à des objets qui "
|
||
"implémentent :ref:`le protocole tampon <bufferobjects>` et qui proposent un "
|
||
"tampon soit en lecture seule, soit en lecture-écriture. Les types les plus "
|
||
"courants qui utilisent cette fonctionnalité sont :class:`bytes` et :class:"
|
||
"`bytearray`, mais beaucoup d'autres types qui peuvent être considérés comme "
|
||
"des tableaux d'octets implémentent le protocole tampon ; ils peuvent ainsi "
|
||
"être lus ou remplis depuis un objet :class:`bytes` sans faire de copie."
|
||
|
||
#: library/struct.rst:44
|
||
msgid "Functions and Exceptions"
|
||
msgstr "Fonctions et exceptions"
|
||
|
||
#: library/struct.rst:46
|
||
msgid "The module defines the following exception and functions:"
|
||
msgstr "Le module définit les exceptions et fonctions suivantes :"
|
||
|
||
#: library/struct.rst:51
|
||
msgid ""
|
||
"Exception raised on various occasions; argument is a string describing what "
|
||
"is wrong."
|
||
msgstr ""
|
||
"Exception levée à plusieurs occasions ; l'argument est une chaîne qui décrit "
|
||
"ce qui ne va pas."
|
||
|
||
#: library/struct.rst:57
|
||
msgid ""
|
||
"Return a bytes object containing the values *v1*, *v2*, ... packed according "
|
||
"to the format string *format*. The arguments must match the values required "
|
||
"by the format exactly."
|
||
msgstr ""
|
||
"Renvoie un objet *bytes* contenant les valeurs *v1*, *v2*… agrégées "
|
||
"conformément à la chaîne de format *format*. Les arguments doivent "
|
||
"correspondre exactement aux valeurs requises par le format."
|
||
|
||
#: library/struct.rst:64
|
||
msgid ""
|
||
"Pack the values *v1*, *v2*, ... according to the format string *format* and "
|
||
"write the packed bytes into the writable buffer *buffer* starting at "
|
||
"position *offset*. Note that *offset* is a required argument."
|
||
msgstr ""
|
||
"Agrège les valeurs *v1*, *v2*… conformément à la chaîne de format *format* "
|
||
"et écrit les octets agrégés dans le tampon *buffer*, en commençant à la "
|
||
"position *offset*. Notez que *offset* est un argument obligatoire."
|
||
|
||
#: library/struct.rst:71
|
||
msgid ""
|
||
"Unpack from the buffer *buffer* (presumably packed by ``pack(format, ...)``) "
|
||
"according to the format string *format*. The result is a tuple even if it "
|
||
"contains exactly one item. The buffer's size in bytes must match the size "
|
||
"required by the format, as reflected by :func:`calcsize`."
|
||
msgstr ""
|
||
"Dissocie depuis le tampon *buffer* (en supposant que celui-ci a été agrégé "
|
||
"avec ``pack(format, …)``) à l'aide de la chaîne de format *format*. Le "
|
||
"résultat est un *n*-uplet, qui peut éventuellement ne contenir qu'un seul "
|
||
"élément. La taille de *buffer* en octets doit correspondre à la taille "
|
||
"requise par le format, telle que calculée par :func:`calcsize`."
|
||
|
||
#: library/struct.rst:79
|
||
msgid ""
|
||
"Unpack from *buffer* starting at position *offset*, according to the format "
|
||
"string *format*. The result is a tuple even if it contains exactly one "
|
||
"item. The buffer's size in bytes, starting at position *offset*, must be at "
|
||
"least the size required by the format, as reflected by :func:`calcsize`."
|
||
msgstr ""
|
||
"Dissocie les éléments du tampon *buffer*, en commençant à la position "
|
||
"*offset*, conformément à la chaîne de format *format*. Le résultat est un n-"
|
||
"uplet, qui peut éventuellement ne contenir qu'un seul élément. La taille du "
|
||
"tampon en octets, en commençant à la position *offset*, doit être au moins "
|
||
"égale à la taille requise par le format, telle que calculée par :func:"
|
||
"`calcsize`."
|
||
|
||
#: library/struct.rst:87
|
||
#, fuzzy
|
||
msgid ""
|
||
"Iteratively unpack from the buffer *buffer* according to the format string "
|
||
"*format*. This function returns an iterator which will read equally sized "
|
||
"chunks from the buffer until all its contents have been consumed. The "
|
||
"buffer's size in bytes must be a multiple of the size required by the "
|
||
"format, as reflected by :func:`calcsize`."
|
||
msgstr ""
|
||
"Dissocie de manière itérative les éléments du tampon *buffer* conformément à "
|
||
"la chaîne de format *format*. Cette fonction renvoie un itérateur qui lit "
|
||
"des morceaux de taille fixe dans le tampon jusqu'à ce que tout le contenu "
|
||
"ait été consommé. La taille du tampon en octets doit être un multiple de la "
|
||
"taille requise par le format, telle que calculée par :func:`calcsize`."
|
||
|
||
#: library/struct.rst:93
|
||
msgid "Each iteration yields a tuple as specified by the format string."
|
||
msgstr ""
|
||
"Chaque itération produit un *n*-uplet tel que spécifié par la chaîne de "
|
||
"format."
|
||
|
||
#: library/struct.rst:100
|
||
msgid ""
|
||
"Return the size of the struct (and hence of the bytes object produced by "
|
||
"``pack(format, ...)``) corresponding to the format string *format*."
|
||
msgstr ""
|
||
"Renvoie la taille de la structure (et donc celle de l'objet *bytes* produit "
|
||
"par ``pack(format, ...)``) correspondant à la chaîne de format *format*."
|
||
|
||
#: library/struct.rst:107
|
||
msgid "Format Strings"
|
||
msgstr "Chaînes de spécification du format"
|
||
|
||
#: library/struct.rst:109
|
||
#, fuzzy
|
||
msgid ""
|
||
"Format strings describe the data layout when packing and unpacking data. "
|
||
"They are built up from :ref:`format characters<format-characters>`, which "
|
||
"specify the type of data being packed/unpacked. In addition, special "
|
||
"characters control the :ref:`byte order, size and alignment<struct-"
|
||
"alignment>`. Each format string consists of an optional prefix character "
|
||
"which describes the overall properties of the data and one or more format "
|
||
"characters which describe the actual data values and padding."
|
||
msgstr ""
|
||
"Les chaînes de spécification du format servent à définir l'agencement lors "
|
||
"de l'agrégation et la dissociation des données. Elles sont construites à "
|
||
"partir de :ref:`caractères de format <format-characters>`, qui spécifient le "
|
||
"type de donnée à agréger-dissocier. De plus, il existe des caractères "
|
||
"spéciaux pour contrôler :ref:`le boutisme, la taille et l'alignement <struct-"
|
||
"alignment>`."
|
||
|
||
#: library/struct.rst:121
|
||
msgid "Byte Order, Size, and Alignment"
|
||
msgstr "Boutisme, taille et alignement"
|
||
|
||
#: library/struct.rst:123
|
||
#, fuzzy
|
||
msgid ""
|
||
"By default, C types are represented in the machine's native format and byte "
|
||
"order, and properly aligned by skipping pad bytes if necessary (according to "
|
||
"the rules used by the C compiler). This behavior is chosen so that the bytes "
|
||
"of a packed struct correspond exactly to the memory layout of the "
|
||
"corresponding C struct. Whether to use native byte ordering and padding or "
|
||
"standard formats depends on the application."
|
||
msgstr ""
|
||
"Par défaut, les types C sont représentés dans le format et le boutisme "
|
||
"natifs de la machine ; ils sont alignés correctement en sautant des octets "
|
||
"si nécessaire (en fonction des règles utilisées par le compilateur C)."
|
||
|
||
#: library/struct.rst:139
|
||
msgid ""
|
||
"Alternatively, the first character of the format string can be used to "
|
||
"indicate the byte order, size and alignment of the packed data, according to "
|
||
"the following table:"
|
||
msgstr ""
|
||
"Cependant, le premier caractère de la chaîne de format peut être utilisé "
|
||
"pour indiquer le boutisme, la taille et l'alignement des données agrégées, "
|
||
"conformément à la table suivante :"
|
||
|
||
#: library/struct.rst:144
|
||
msgid "Character"
|
||
msgstr "Caractère"
|
||
|
||
#: library/struct.rst:144
|
||
msgid "Byte order"
|
||
msgstr "Boutisme"
|
||
|
||
#: library/struct.rst:144
|
||
msgid "Size"
|
||
msgstr "Taille"
|
||
|
||
#: library/struct.rst:144
|
||
msgid "Alignment"
|
||
msgstr "Alignement"
|
||
|
||
#: library/struct.rst:146
|
||
msgid "``@``"
|
||
msgstr "``@``"
|
||
|
||
#: library/struct.rst:148
|
||
msgid "native"
|
||
msgstr "natif"
|
||
|
||
#: library/struct.rst:148
|
||
msgid "``=``"
|
||
msgstr "``=``"
|
||
|
||
#: library/struct.rst:150 library/struct.rst:154
|
||
msgid "standard"
|
||
msgstr "standard"
|
||
|
||
#: library/struct.rst:150 library/struct.rst:154
|
||
msgid "none"
|
||
msgstr "aucun"
|
||
|
||
#: library/struct.rst:150
|
||
msgid "``<``"
|
||
msgstr "``<``"
|
||
|
||
#: library/struct.rst:150
|
||
msgid "little-endian"
|
||
msgstr "petit-boutiste"
|
||
|
||
#: library/struct.rst:152
|
||
msgid "``>``"
|
||
msgstr "``>``"
|
||
|
||
#: library/struct.rst:152
|
||
msgid "big-endian"
|
||
msgstr "gros-boutiste"
|
||
|
||
#: library/struct.rst:154
|
||
msgid "``!``"
|
||
msgstr "``!``"
|
||
|
||
#: library/struct.rst:154
|
||
msgid "network (= big-endian)"
|
||
msgstr "réseau (= gros-boutiste)"
|
||
|
||
#: library/struct.rst:157
|
||
msgid "If the first character is not one of these, ``'@'`` is assumed."
|
||
msgstr ""
|
||
"Si le premier caractère n'est pas dans cette liste, le module se comporte "
|
||
"comme si ``'@'`` avait été indiqué."
|
||
|
||
#: library/struct.rst:159
|
||
#, fuzzy
|
||
msgid ""
|
||
"Native byte order is big-endian or little-endian, depending on the host "
|
||
"system. For example, Intel x86, AMD64 (x86-64), and Apple M1 are little-"
|
||
"endian; IBM z and many legacy architectures are big-endian. Use :data:`sys."
|
||
"byteorder` to check the endianness of your system."
|
||
msgstr ""
|
||
"Le boutisme natif est gros-boutiste ou petit-boutiste, en fonction de la "
|
||
"machine sur laquelle s'exécute le programme. Par exemple, les Intel x86 et "
|
||
"les AMD64 (x86-64) sont petit-boutistes ; les Motorola 68000 et les *PowerPC "
|
||
"G5* sont gros-boutistes ; les ARM et les Intel Itanium peuvent changer de "
|
||
"boutisme. Utilisez ``sys.byteorder`` pour vérifier le boutisme de votre "
|
||
"système."
|
||
|
||
#: library/struct.rst:164
|
||
msgid ""
|
||
"Native size and alignment are determined using the C compiler's ``sizeof`` "
|
||
"expression. This is always combined with native byte order."
|
||
msgstr ""
|
||
"La taille et l'alignement natifs sont déterminés en utilisant l'expression "
|
||
"``sizeof`` du compilateur C. Leur valeur est toujours combinée au boutisme "
|
||
"natif."
|
||
|
||
#: library/struct.rst:167
|
||
msgid ""
|
||
"Standard size depends only on the format character; see the table in the :"
|
||
"ref:`format-characters` section."
|
||
msgstr ""
|
||
"La taille standard dépend seulement du caractère du format ; référez-vous au "
|
||
"tableau dans la section :ref:`format-characters`."
|
||
|
||
#: library/struct.rst:170
|
||
msgid ""
|
||
"Note the difference between ``'@'`` and ``'='``: both use native byte order, "
|
||
"but the size and alignment of the latter is standardized."
|
||
msgstr ""
|
||
"Notez la différence entre ``'@'`` et ``'='`` : les deux utilisent le "
|
||
"boutisme natif mais la taille et l'alignement du dernier sont standards."
|
||
|
||
#: library/struct.rst:173
|
||
msgid ""
|
||
"The form ``'!'`` represents the network byte order which is always big-"
|
||
"endian as defined in `IETF RFC 1700 <IETF RFC 1700_>`_."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:176
|
||
msgid ""
|
||
"There is no way to indicate non-native byte order (force byte-swapping); use "
|
||
"the appropriate choice of ``'<'`` or ``'>'``."
|
||
msgstr ""
|
||
"Il n'y a pas de moyen de spécifier le boutisme contraire au boutisme natif "
|
||
"(c'est-à-dire forcer la permutation des octets) ; utilisez le bon caractère "
|
||
"entre ``'<'`` et ``'>'``."
|
||
|
||
#: library/struct.rst:258
|
||
msgid "Notes:"
|
||
msgstr "Notes :"
|
||
|
||
#: library/struct.rst:181
|
||
msgid ""
|
||
"Padding is only automatically added between successive structure members. No "
|
||
"padding is added at the beginning or the end of the encoded struct."
|
||
msgstr ""
|
||
"Le bourrage (*padding* en anglais) n'est automatiquement ajouté qu'entre les "
|
||
"membres successifs de la structure. Il n'y a pas de bourrage au début ou à "
|
||
"la fin de la structure agrégée."
|
||
|
||
#: library/struct.rst:184
|
||
msgid ""
|
||
"No padding is added when using non-native size and alignment, e.g. with '<', "
|
||
"'>', '=', and '!'."
|
||
msgstr ""
|
||
"Il n'y a pas d'ajout de bourrage lorsque vous utilisez une taille et un "
|
||
"alignement non-natifs, par exemple avec ``'<'``, ``'>'``, ``'='`` ou ``'!'``."
|
||
|
||
#: library/struct.rst:187
|
||
msgid ""
|
||
"To align the end of a structure to the alignment requirement of a particular "
|
||
"type, end the format with the code for that type with a repeat count of "
|
||
"zero. See :ref:`struct-examples`."
|
||
msgstr ""
|
||
"Pour aligner la fin d'une structure à l'alignement requis par un type "
|
||
"particulier, terminez le format avec le code du type voulu et une valeur de "
|
||
"répétition à zéro. Référez-vous à :ref:`struct-examples`."
|
||
|
||
#: library/struct.rst:195
|
||
msgid "Format Characters"
|
||
msgstr "Caractères de format"
|
||
|
||
#: library/struct.rst:197
|
||
msgid ""
|
||
"Format characters have the following meaning; the conversion between C and "
|
||
"Python values should be obvious given their types. The 'Standard size' "
|
||
"column refers to the size of the packed value in bytes when using standard "
|
||
"size; that is, when the format string starts with one of ``'<'``, ``'>'``, "
|
||
"``'!'`` or ``'='``. When using native size, the size of the packed value is "
|
||
"platform-dependent."
|
||
msgstr ""
|
||
"Les caractères de format possèdent les significations suivantes ; la "
|
||
"conversion entre les valeurs C et Python doit être évidente compte tenu des "
|
||
"types concernés. La colonne « taille standard » fait référence à la taille "
|
||
"en octets de la valeur agrégée avec l'utilisation de la taille standard "
|
||
"(c'est-à-dire lorsque la chaîne de format commence par l'un des caractères "
|
||
"suivants : ``'<'``, ``'>'``, ``'!'`` ou ``'='``). Si vous utilisez la taille "
|
||
"native, la taille de la valeur agrégée dépend de la plateforme."
|
||
|
||
#: library/struct.rst:205
|
||
msgid "Format"
|
||
msgstr "Format"
|
||
|
||
#: library/struct.rst:205
|
||
msgid "C Type"
|
||
msgstr "Type C"
|
||
|
||
#: library/struct.rst:205
|
||
msgid "Python type"
|
||
msgstr "Type Python"
|
||
|
||
#: library/struct.rst:205
|
||
msgid "Standard size"
|
||
msgstr "Taille standard"
|
||
|
||
#: library/struct.rst:205
|
||
msgid "Notes"
|
||
msgstr "Notes"
|
||
|
||
#: library/struct.rst:207
|
||
msgid "``x``"
|
||
msgstr "``x``"
|
||
|
||
#: library/struct.rst:207
|
||
msgid "pad byte"
|
||
msgstr "octet de bourrage"
|
||
|
||
#: library/struct.rst:207
|
||
msgid "no value"
|
||
msgstr "pas de valeur"
|
||
|
||
#: library/struct.rst:207
|
||
msgid "\\(7)"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:209
|
||
msgid "``c``"
|
||
msgstr "``c``"
|
||
|
||
#: library/struct.rst:209
|
||
#, fuzzy
|
||
msgid ":c:expr:`char`"
|
||
msgstr ":c:type:`char`"
|
||
|
||
#: library/struct.rst:209
|
||
msgid "bytes of length 1"
|
||
msgstr "*bytes* (suite d'octets) de taille 1"
|
||
|
||
#: library/struct.rst:211 library/struct.rst:215
|
||
msgid "1"
|
||
msgstr "1"
|
||
|
||
#: library/struct.rst:211
|
||
msgid "``b``"
|
||
msgstr "``b``"
|
||
|
||
#: library/struct.rst:211
|
||
#, fuzzy
|
||
msgid ":c:expr:`signed char`"
|
||
msgstr ":c:type:`signed char`"
|
||
|
||
#: library/struct.rst:213 library/struct.rst:219 library/struct.rst:223
|
||
#: library/struct.rst:227 library/struct.rst:231 library/struct.rst:236
|
||
#: library/struct.rst:248
|
||
msgid "integer"
|
||
msgstr "*int* (entier)"
|
||
|
||
#: library/struct.rst:211
|
||
msgid "\\(1), \\(2)"
|
||
msgstr "\\(1), \\(2)"
|
||
|
||
#: library/struct.rst:213
|
||
msgid "``B``"
|
||
msgstr "``B``"
|
||
|
||
#: library/struct.rst:213
|
||
#, fuzzy
|
||
msgid ":c:expr:`unsigned char`"
|
||
msgstr ":c:type:`unsigned char`"
|
||
|
||
#: library/struct.rst:217 library/struct.rst:221 library/struct.rst:225
|
||
#: library/struct.rst:229 library/struct.rst:231
|
||
msgid "\\(2)"
|
||
msgstr "\\(2)"
|
||
|
||
#: library/struct.rst:215
|
||
msgid "``?``"
|
||
msgstr "``?``"
|
||
|
||
#: library/struct.rst:215
|
||
#, fuzzy
|
||
msgid ":c:expr:`_Bool`"
|
||
msgstr ":c:type:`_Bool`"
|
||
|
||
#: library/struct.rst:215
|
||
msgid "bool"
|
||
msgstr "*bool* (booléen)"
|
||
|
||
#: library/struct.rst:215
|
||
msgid "\\(1)"
|
||
msgstr "\\(1)"
|
||
|
||
#: library/struct.rst:217
|
||
msgid "``h``"
|
||
msgstr "``h``"
|
||
|
||
#: library/struct.rst:217
|
||
#, fuzzy
|
||
msgid ":c:expr:`short`"
|
||
msgstr ":c:type:`short`"
|
||
|
||
#: library/struct.rst:219 library/struct.rst:238
|
||
msgid "2"
|
||
msgstr "2"
|
||
|
||
#: library/struct.rst:219
|
||
msgid "``H``"
|
||
msgstr "``H``"
|
||
|
||
#: library/struct.rst:219
|
||
#, fuzzy
|
||
msgid ":c:expr:`unsigned short`"
|
||
msgstr ":c:type:`unsigned short`"
|
||
|
||
#: library/struct.rst:221
|
||
msgid "``i``"
|
||
msgstr "``i``"
|
||
|
||
#: library/struct.rst:221
|
||
#, fuzzy
|
||
msgid ":c:expr:`int`"
|
||
msgstr ":c:type:`int`"
|
||
|
||
#: library/struct.rst:223 library/struct.rst:227 library/struct.rst:240
|
||
msgid "4"
|
||
msgstr "4"
|
||
|
||
#: library/struct.rst:223
|
||
msgid "``I``"
|
||
msgstr "``I``"
|
||
|
||
#: library/struct.rst:223
|
||
#, fuzzy
|
||
msgid ":c:expr:`unsigned int`"
|
||
msgstr ":c:type:`unsigned int`"
|
||
|
||
#: library/struct.rst:225
|
||
msgid "``l``"
|
||
msgstr "``l``"
|
||
|
||
#: library/struct.rst:225
|
||
#, fuzzy
|
||
msgid ":c:expr:`long`"
|
||
msgstr ":c:type:`long`"
|
||
|
||
#: library/struct.rst:227
|
||
msgid "``L``"
|
||
msgstr "``L``"
|
||
|
||
#: library/struct.rst:227
|
||
#, fuzzy
|
||
msgid ":c:expr:`unsigned long`"
|
||
msgstr ":c:type:`unsigned long`"
|
||
|
||
#: library/struct.rst:229
|
||
msgid "``q``"
|
||
msgstr "``q``"
|
||
|
||
#: library/struct.rst:229
|
||
#, fuzzy
|
||
msgid ":c:expr:`long long`"
|
||
msgstr ":c:type:`long long`"
|
||
|
||
#: library/struct.rst:231 library/struct.rst:242
|
||
msgid "8"
|
||
msgstr "8"
|
||
|
||
#: library/struct.rst:231
|
||
msgid "``Q``"
|
||
msgstr "``Q``"
|
||
|
||
#: library/struct.rst:231
|
||
#, fuzzy
|
||
msgid ":c:expr:`unsigned long long`"
|
||
msgstr ":c:type:`unsigned long long`"
|
||
|
||
#: library/struct.rst:234
|
||
msgid "``n``"
|
||
msgstr "``n``"
|
||
|
||
#: library/struct.rst:234
|
||
#, fuzzy
|
||
msgid ":c:expr:`ssize_t`"
|
||
msgstr ":c:type:`ssize_t`"
|
||
|
||
#: library/struct.rst:236
|
||
msgid "\\(3)"
|
||
msgstr "\\(3)"
|
||
|
||
#: library/struct.rst:236
|
||
msgid "``N``"
|
||
msgstr "``N``"
|
||
|
||
#: library/struct.rst:236
|
||
#, fuzzy
|
||
msgid ":c:expr:`size_t`"
|
||
msgstr ":c:type:`size_t`"
|
||
|
||
#: library/struct.rst:238
|
||
msgid "``e``"
|
||
msgstr "``e``"
|
||
|
||
#: library/struct.rst:238
|
||
msgid "\\(6)"
|
||
msgstr "\\(6)"
|
||
|
||
#: library/struct.rst:240 library/struct.rst:242
|
||
msgid "float"
|
||
msgstr "*float* (nombre à virgule flottante)"
|
||
|
||
#: library/struct.rst:240 library/struct.rst:242
|
||
msgid "\\(4)"
|
||
msgstr "\\(4)"
|
||
|
||
#: library/struct.rst:240
|
||
msgid "``f``"
|
||
msgstr "``f``"
|
||
|
||
#: library/struct.rst:240
|
||
#, fuzzy
|
||
msgid ":c:expr:`float`"
|
||
msgstr ":c:type:`float`"
|
||
|
||
#: library/struct.rst:242
|
||
msgid "``d``"
|
||
msgstr "``d``"
|
||
|
||
#: library/struct.rst:242
|
||
#, fuzzy
|
||
msgid ":c:expr:`double`"
|
||
msgstr ":c:type:`double`"
|
||
|
||
#: library/struct.rst:244
|
||
msgid "``s``"
|
||
msgstr "``s``"
|
||
|
||
#: library/struct.rst:246
|
||
#, fuzzy
|
||
msgid ":c:expr:`char[]`"
|
||
msgstr ":c:type:`char[]`"
|
||
|
||
#: library/struct.rst:246
|
||
msgid "bytes"
|
||
msgstr "*bytes* (séquence d'octets)"
|
||
|
||
#: library/struct.rst:244
|
||
msgid "\\(9)"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:246
|
||
msgid "``p``"
|
||
msgstr "``p``"
|
||
|
||
#: library/struct.rst:246
|
||
msgid "\\(8)"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:248
|
||
msgid "``P``"
|
||
msgstr "``P``"
|
||
|
||
#: library/struct.rst:248
|
||
#, fuzzy
|
||
msgid ":c:expr:`void \\*`"
|
||
msgstr ":c:type:`void \\*`"
|
||
|
||
#: library/struct.rst:248
|
||
msgid "\\(5)"
|
||
msgstr "\\(5)"
|
||
|
||
# Suit un ':' dans la version affichée, donc pas de majuscule.
|
||
#: library/struct.rst:251
|
||
msgid "Added support for the ``'n'`` and ``'N'`` formats."
|
||
msgstr "ajouté la gestion des formats ``'n'`` et ``'N'``."
|
||
|
||
# Suit un ':' dans la version affichée, donc pas de majuscule.
|
||
#: library/struct.rst:254
|
||
msgid "Added support for the ``'e'`` format."
|
||
msgstr "ajouté la gestion du format ``'e'``."
|
||
|
||
#: library/struct.rst:263
|
||
#, fuzzy
|
||
msgid ""
|
||
"The ``'?'`` conversion code corresponds to the :c:expr:`_Bool` type defined "
|
||
"by C99. If this type is not available, it is simulated using a :c:expr:"
|
||
"`char`. In standard mode, it is always represented by one byte."
|
||
msgstr ""
|
||
"Le code de conversion ``'?'`` correspond au type :c:type:`_Bool` de C99. Si "
|
||
"ce type n'est pas disponible, il est simulé en utilisant un :c:type:`char`. "
|
||
"Dans le mode standard, il est toujours représenté par un octet."
|
||
|
||
#: library/struct.rst:268
|
||
msgid ""
|
||
"When attempting to pack a non-integer using any of the integer conversion "
|
||
"codes, if the non-integer has a :meth:`__index__` method then that method is "
|
||
"called to convert the argument to an integer before packing."
|
||
msgstr ""
|
||
"Lorsque vous essayez d'agréger un non-entier en utilisant un code de "
|
||
"conversion pour un entier, si ce non-entier possède une méthode :meth:"
|
||
"`__index__` alors cette méthode est appelée pour convertir l'argument en "
|
||
"entier avant l'agrégation."
|
||
|
||
# Suit un ':' dans la version affichée, donc pas de majuscule.
|
||
#: library/struct.rst:272
|
||
#, fuzzy
|
||
msgid "Added use of the :meth:`__index__` method for non-integers."
|
||
msgstr "utilisation de la méthode :meth:`__index__` pour les non-entiers. "
|
||
|
||
#: library/struct.rst:276
|
||
msgid ""
|
||
"The ``'n'`` and ``'N'`` conversion codes are only available for the native "
|
||
"size (selected as the default or with the ``'@'`` byte order character). For "
|
||
"the standard size, you can use whichever of the other integer formats fits "
|
||
"your application."
|
||
msgstr ""
|
||
"Les codes de conversion ``'n'`` et ``'N'`` ne sont disponibles que pour la "
|
||
"taille native (choisie par défaut ou à l'aide du caractère de boutisme "
|
||
"``'@'``). Pour la taille standard, vous pouvez utiliser n'importe quel "
|
||
"format d'entier qui convient à votre application."
|
||
|
||
#: library/struct.rst:282
|
||
msgid ""
|
||
"For the ``'f'``, ``'d'`` and ``'e'`` conversion codes, the packed "
|
||
"representation uses the IEEE 754 binary32, binary64 or binary16 format (for "
|
||
"``'f'``, ``'d'`` or ``'e'`` respectively), regardless of the floating-point "
|
||
"format used by the platform."
|
||
msgstr ""
|
||
"Pour les codes de conversion ``'f'``, ``'d'`` et ``'e'``, la représentation "
|
||
"agrégée utilise respectivement le format IEEE 754 *binaire32*, *binaire64* "
|
||
"ou *binaire16* (pour ``'f'``, ``'d'`` ou ``'e'`` respectivement), quel que "
|
||
"soit le format des nombres à virgule flottante de la plateforme."
|
||
|
||
#: library/struct.rst:288
|
||
msgid ""
|
||
"The ``'P'`` format character is only available for the native byte ordering "
|
||
"(selected as the default or with the ``'@'`` byte order character). The byte "
|
||
"order character ``'='`` chooses to use little- or big-endian ordering based "
|
||
"on the host system. The struct module does not interpret this as native "
|
||
"ordering, so the ``'P'`` format is not available."
|
||
msgstr ""
|
||
"Le caractère de format ``'P'`` n'est disponible que pour le boutisme natif "
|
||
"(choisi par défaut ou à l'aide du caractère ``'@'`` de boutisme). Le "
|
||
"caractère de boutisme ``'='`` choisit d'utiliser un petit ou un gros en "
|
||
"fonction du système hôte. Le module *struct* ne l'interprète pas comme un "
|
||
"boutisme natif, donc le format ``'P'`` n'est pas disponible."
|
||
|
||
#: library/struct.rst:295
|
||
msgid ""
|
||
"The IEEE 754 binary16 \"half precision\" type was introduced in the 2008 "
|
||
"revision of the `IEEE 754 standard <ieee 754 standard_>`_. It has a sign "
|
||
"bit, a 5-bit exponent and 11-bit precision (with 10 bits explicitly stored), "
|
||
"and can represent numbers between approximately ``6.1e-05`` and ``6.5e+04`` "
|
||
"at full precision. This type is not widely supported by C compilers: on a "
|
||
"typical machine, an unsigned short can be used for storage, but not for math "
|
||
"operations. See the Wikipedia page on the `half-precision floating-point "
|
||
"format <half precision format_>`_ for more information."
|
||
msgstr ""
|
||
"Le type IEEE 754 *binaire16* « demie-précision » a été introduit en 2008 par "
|
||
"la révision du `standard IEEE 754 <ieee 754 standard_>`_. Il comprend un bit "
|
||
"de signe, un exposant sur 5 bits et une précision de 11 bits (dont 10 bits "
|
||
"sont explicitement stockés) ; il peut représenter les nombres entre environ "
|
||
"``6.1e-05`` et ``6.5e+04`` avec une précision maximale. Ce type est rarement "
|
||
"pris en charge par les compilateurs C : sur une machine courante, un "
|
||
"*unsigned short* (entier court non signé) peut être utilisé pour le stockage "
|
||
"mais pas pour les opérations mathématiques. Lisez la page Wikipédia (NdT : "
|
||
"non traduite en français) `half-precision floating-point format <half "
|
||
"precision format_>`_ pour davantage d'informations."
|
||
|
||
#: library/struct.rst:305
|
||
msgid "When packing, ``'x'`` inserts one NUL byte."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:308
|
||
msgid ""
|
||
"The ``'p'`` format character encodes a \"Pascal string\", meaning a short "
|
||
"variable-length string stored in a *fixed number of bytes*, given by the "
|
||
"count. The first byte stored is the length of the string, or 255, whichever "
|
||
"is smaller. The bytes of the string follow. If the string passed in to :"
|
||
"func:`pack` is too long (longer than the count minus 1), only the leading "
|
||
"``count-1`` bytes of the string are stored. If the string is shorter than "
|
||
"``count-1``, it is padded with null bytes so that exactly count bytes in all "
|
||
"are used. Note that for :func:`unpack`, the ``'p'`` format character "
|
||
"consumes ``count`` bytes, but that the string returned can never contain "
|
||
"more than 255 bytes."
|
||
msgstr ""
|
||
"Le caractère de format ``'p'`` sert à encoder une « chaîne Pascal », c'est-à-"
|
||
"dire une courte chaîne de longueur variable, stockée dans un *nombre défini "
|
||
"d'octets* dont la valeur est définie par la répétition. Le premier octet "
|
||
"stocké est la longueur de la chaîne (dans la limite maximum de 255). Les "
|
||
"octets composant la chaîne suivent. Si la chaîne passée à :func:`pack` est "
|
||
"trop longue (supérieure à la valeur de la répétition moins 1), seuls les "
|
||
"``count-1`` premiers octets de la chaîne sont stockés. Si la chaîne est plus "
|
||
"courte que ``count-1``, des octets de bourrage nuls sont insérés de manière "
|
||
"à avoir exactement *count* octets au final. Notez que pour :func:`unpack`, "
|
||
"le caractère de format ``'p'`` consomme ``count`` octets mais que la chaîne "
|
||
"renvoyée ne peut pas excéder 255 octets."
|
||
|
||
#: library/struct.rst:320
|
||
#, fuzzy
|
||
msgid ""
|
||
"For the ``'s'`` format character, the count is interpreted as the length of "
|
||
"the bytes, not a repeat count like for the other format characters; for "
|
||
"example, ``'10s'`` means a single 10-byte string mapping to or from a single "
|
||
"Python byte string, while ``'10c'`` means 10 separate one byte character "
|
||
"elements (e.g., ``cccccccccc``) mapping to or from ten different Python byte "
|
||
"objects. (See :ref:`struct-examples` for a concrete demonstration of the "
|
||
"difference.) If a count is not given, it defaults to 1. For packing, the "
|
||
"string is truncated or padded with null bytes as appropriate to make it fit. "
|
||
"For unpacking, the resulting bytes object always has exactly the specified "
|
||
"number of bytes. As a special case, ``'0s'`` means a single, empty string "
|
||
"(while ``'0c'`` means 0 characters)."
|
||
msgstr ""
|
||
"Pour le caractère de format ``'s'``, un nombre en tête est interprété comme "
|
||
"la longueur du *bytes* et non comme le nombre de répétitions comme pour les "
|
||
"autres caractères de format ; par exemple, ``'10s'`` signifie une seule "
|
||
"chaîne de 10 octets alors que ``'10c'`` signifie 10 caractères. Si aucun "
|
||
"nombre n'est indiqué, la valeur par défaut est 1. Pour l'agrégation, la "
|
||
"chaîne est tronquée ou bourrée avec des octets nuls pour atteindre la taille "
|
||
"souhaitée. Pour la dissociation, l'objet *bytes* résultant possède le nombre "
|
||
"exact d'octets spécifiés. Un cas particulier est ``'0s'`` qui signifie une "
|
||
"chaîne (et une seule) vide (alors que ``'0c'`` signifie zéro caractère)."
|
||
|
||
#: library/struct.rst:333
|
||
msgid ""
|
||
"A format character may be preceded by an integral repeat count. For "
|
||
"example, the format string ``'4h'`` means exactly the same as ``'hhhh'``."
|
||
msgstr ""
|
||
"Un caractère de format peut être précédé par un entier indiquant le nombre "
|
||
"de répétitions. Par exemple, la chaîne de format ``'4h'`` a exactement la "
|
||
"même signification que ``'hhhh'``."
|
||
|
||
#: library/struct.rst:336
|
||
msgid ""
|
||
"Whitespace characters between formats are ignored; a count and its format "
|
||
"must not contain whitespace though."
|
||
msgstr ""
|
||
"Les caractères d'espacement entre les indications de format sont ignorés ; "
|
||
"cependant, le nombre de répétitions et le format associé ne doivent pas être "
|
||
"séparés par des caractères d'espacement."
|
||
|
||
#: library/struct.rst:339
|
||
msgid ""
|
||
"When packing a value ``x`` using one of the integer formats (``'b'``, "
|
||
"``'B'``, ``'h'``, ``'H'``, ``'i'``, ``'I'``, ``'l'``, ``'L'``, ``'q'``, "
|
||
"``'Q'``), if ``x`` is outside the valid range for that format then :exc:"
|
||
"`struct.error` is raised."
|
||
msgstr ""
|
||
"Lors de l'agrégation d'une valeur ``x`` en utilisant l'un des formats pour "
|
||
"les entiers (``'b'``, ``'B'``, ``'h'``, ``'H'``, ``'i'``, ``'I'``, ``'l'``, "
|
||
"``'L'``, ``'q'``, ``'Q'``), si ``x`` est en dehors de l'intervalle du format "
|
||
"spécifié, une :exc:`struct.error` est levée."
|
||
|
||
# Pas de majuscule en début car cela suit un ':' dans la version affichée.
|
||
#: library/struct.rst:344
|
||
#, fuzzy
|
||
msgid ""
|
||
"Previously, some of the integer formats wrapped out-of-range values and "
|
||
"raised :exc:`DeprecationWarning` instead of :exc:`struct.error`."
|
||
msgstr ""
|
||
"auparavant, certains formats d'entiers absorbaient les valeurs en dehors des "
|
||
"intervalles valides et levaient une :exc:`DeprecationWarning` au lieu d'une :"
|
||
"exc:`struct.error`."
|
||
|
||
#: library/struct.rst:350
|
||
msgid ""
|
||
"For the ``'?'`` format character, the return value is either :const:`True` "
|
||
"or :const:`False`. When packing, the truth value of the argument object is "
|
||
"used. Either 0 or 1 in the native or standard bool representation will be "
|
||
"packed, and any non-zero value will be ``True`` when unpacking."
|
||
msgstr ""
|
||
"Pour le caractère de format ``'?'``, la valeur renvoyée est :const:`True` "
|
||
"ou :const:`False`. Lors de l'agrégation, la valeur de vérité de l'objet "
|
||
"argument est utilisée. La valeur agrégée est 0 ou 1 dans la représentation "
|
||
"native ou standard et, lors de la dissociation, n'importe quelle valeur "
|
||
"différente de zéro est renvoyée ``True``."
|
||
|
||
#: library/struct.rst:360
|
||
msgid "Examples"
|
||
msgstr "Exemples"
|
||
|
||
#: library/struct.rst:363
|
||
msgid ""
|
||
"Native byte order examples (designated by the ``'@'`` format prefix or lack "
|
||
"of any prefix character) may not match what the reader's machine produces as "
|
||
"that depends on the platform and compiler."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:368
|
||
msgid ""
|
||
"Pack and unpack integers of three different sizes, using big endian "
|
||
"ordering::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:379
|
||
msgid "Attempt to pack an integer which is too large for the defined field::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:386
|
||
msgid ""
|
||
"Demonstrate the difference between ``'s'`` and ``'c'`` format characters::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:394
|
||
msgid ""
|
||
"Unpacked fields can be named by assigning them to variables or by wrapping "
|
||
"the result in a named tuple::"
|
||
msgstr ""
|
||
"Les champs dissociés peuvent être nommés en leur assignant des variables ou "
|
||
"en encapsulant le résultat dans un *n*-uplet nommé ::"
|
||
|
||
#: library/struct.rst:405
|
||
msgid ""
|
||
"The ordering of format characters may have an impact on size in native mode "
|
||
"since padding is implicit. In standard mode, the user is responsible for "
|
||
"inserting any desired padding. Note in the first ``pack`` call below that "
|
||
"three NUL bytes were added after the packed ``'#'`` to align the following "
|
||
"integer on a four-byte boundary. In this example, the output was produced on "
|
||
"a little endian machine::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:422
|
||
#, fuzzy
|
||
msgid ""
|
||
"The following format ``'llh0l'`` results in two pad bytes being added at the "
|
||
"end, assuming the platform's longs are aligned on 4-byte boundaries::"
|
||
msgstr ""
|
||
"Le format suivant ``'llh0l'`` spécifie deux octets de bourrage à la fin, "
|
||
"considérant que les entiers longs sont alignés sur des espacements de 4 "
|
||
"octets ::"
|
||
|
||
#: library/struct.rst:432
|
||
msgid "Module :mod:`array`"
|
||
msgstr "Module :mod:`array`"
|
||
|
||
#: library/struct.rst:432
|
||
msgid "Packed binary storage of homogeneous data."
|
||
msgstr "Stockage agrégé binaire de données homogènes."
|
||
|
||
#: library/struct.rst:435
|
||
#, fuzzy
|
||
msgid "Module :mod:`json`"
|
||
msgstr "Module :mod:`array`"
|
||
|
||
#: library/struct.rst:435
|
||
msgid "JSON encoder and decoder."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:437
|
||
#, fuzzy
|
||
msgid "Module :mod:`pickle`"
|
||
msgstr "Module :mod:`xdrlib`"
|
||
|
||
#: library/struct.rst:438
|
||
msgid "Python object serialization."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:444
|
||
msgid "Applications"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:446
|
||
msgid ""
|
||
"Two main applications for the :mod:`struct` module exist, data interchange "
|
||
"between Python and C code within an application or another application "
|
||
"compiled using the same compiler (:ref:`native formats<struct-native-"
|
||
"formats>`), and data interchange between applications using agreed upon data "
|
||
"layout (:ref:`standard formats<struct-standard-formats>`). Generally "
|
||
"speaking, the format strings constructed for these two domains are distinct."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:457
|
||
#, fuzzy
|
||
msgid "Native Formats"
|
||
msgstr "Format"
|
||
|
||
#: library/struct.rst:459
|
||
msgid ""
|
||
"When constructing format strings which mimic native layouts, the compiler "
|
||
"and machine architecture determine byte ordering and padding. In such cases, "
|
||
"the ``@`` format character should be used to specify native byte ordering "
|
||
"and data sizes. Internal pad bytes are normally inserted automatically. It "
|
||
"is possible that a zero-repeat format code will be needed at the end of a "
|
||
"format string to round up to the correct byte boundary for proper alignment "
|
||
"of consective chunks of data."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:467
|
||
msgid ""
|
||
"Consider these two simple examples (on a 64-bit, little-endian machine)::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:475
|
||
msgid ""
|
||
"Data is not padded to an 8-byte boundary at the end of the second format "
|
||
"string without the use of extra padding. A zero-repeat format code solves "
|
||
"that problem::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:482
|
||
msgid ""
|
||
"The ``'x'`` format code can be used to specify the repeat, but for native "
|
||
"formats it is better to use a zero-repeat format like ``'0l'``."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:485
|
||
msgid ""
|
||
"By default, native byte ordering and alignment is used, but it is better to "
|
||
"be explicit and use the ``'@'`` prefix character."
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:492
|
||
#, fuzzy
|
||
msgid "Standard Formats"
|
||
msgstr "Taille standard"
|
||
|
||
#: library/struct.rst:494
|
||
msgid ""
|
||
"When exchanging data beyond your process such as networking or storage, be "
|
||
"precise. Specify the exact byte order, size, and alignment. Do not assume "
|
||
"they match the native order of a particular machine. For example, network "
|
||
"byte order is big-endian, while many popular CPUs are little-endian. By "
|
||
"defining this explicitly, the user need not care about the specifics of the "
|
||
"platform their code is running on. The first character should typically be "
|
||
"``<`` or ``>`` (or ``!``). Padding is the responsibility of the "
|
||
"programmer. The zero-repeat format character won't work. Instead, the user "
|
||
"must explicitly add ``'x'`` pad bytes where needed. Revisiting the examples "
|
||
"from the previous section, we have::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:521
|
||
msgid ""
|
||
"The above results (executed on a 64-bit machine) aren't guaranteed to match "
|
||
"when executed on different machines. For example, the examples below were "
|
||
"executed on a 32-bit machine::"
|
||
msgstr ""
|
||
|
||
#: library/struct.rst:536
|
||
msgid "Classes"
|
||
msgstr "Classes"
|
||
|
||
#: library/struct.rst:538
|
||
msgid "The :mod:`struct` module also defines the following type:"
|
||
msgstr "Le module :mod:`struct` définit aussi le type suivant :"
|
||
|
||
#: library/struct.rst:543
|
||
#, fuzzy
|
||
msgid ""
|
||
"Return a new Struct object which writes and reads binary data according to "
|
||
"the format string *format*. Creating a ``Struct`` object once and calling "
|
||
"its methods is more efficient than calling module-level functions with the "
|
||
"same format since the format string is only compiled once."
|
||
msgstr ""
|
||
"Renvoie un nouvel objet Struct qui écrit et lit des données binaires "
|
||
"conformément à la chaîne de format *format*. Créer une fois pour toutes un "
|
||
"objet Struct puis appeler ses méthodes est plus efficace que d'appeler les "
|
||
"fonctions de :mod:`struct` avec le même format puisque la chaîne de format "
|
||
"n'est compilée qu'une seule fois."
|
||
|
||
# Pas de majuscule en début car suit un ':' dans la version affichée.
|
||
#: library/struct.rst:550
|
||
msgid ""
|
||
"The compiled versions of the most recent format strings passed to :class:"
|
||
"`Struct` and the module-level functions are cached, so programs that use "
|
||
"only a few format strings needn't worry about reusing a single :class:"
|
||
"`Struct` instance."
|
||
msgstr ""
|
||
"les versions compilées des dernières chaînes de format passées à :class:"
|
||
"`Struct` et aux fonctions de niveau module sont mises en cache, de manière à "
|
||
"ce que les programmes qui n'utilisent que quelques chaînes de format n'aient "
|
||
"pas à se préoccuper de n'utiliser qu'une seule instance de :class:`Struct`."
|
||
|
||
#: library/struct.rst:555
|
||
msgid "Compiled Struct objects support the following methods and attributes:"
|
||
msgstr ""
|
||
"Les objets ``Struct`` compilés gèrent les méthodes et attributs suivants :"
|
||
|
||
#: library/struct.rst:559
|
||
msgid ""
|
||
"Identical to the :func:`pack` function, using the compiled format. "
|
||
"(``len(result)`` will equal :attr:`size`.)"
|
||
msgstr ""
|
||
"Identique à la fonction :func:`pack`, en utilisant le format compilé "
|
||
"(``len(result)`` vaut :attr:`size`)."
|
||
|
||
#: library/struct.rst:565
|
||
msgid "Identical to the :func:`pack_into` function, using the compiled format."
|
||
msgstr ""
|
||
"Identique à la fonction :func:`pack_into`, en utilisant le format compilé."
|
||
|
||
#: library/struct.rst:570
|
||
msgid ""
|
||
"Identical to the :func:`unpack` function, using the compiled format. The "
|
||
"buffer's size in bytes must equal :attr:`size`."
|
||
msgstr ""
|
||
"Identique à la fonction :func:`unpack`, en utilisant le format compilé. La "
|
||
"taille du tampon *buffer* en octets doit valoir :attr:`size`."
|
||
|
||
#: library/struct.rst:576
|
||
msgid ""
|
||
"Identical to the :func:`unpack_from` function, using the compiled format. "
|
||
"The buffer's size in bytes, starting at position *offset*, must be at least :"
|
||
"attr:`size`."
|
||
msgstr ""
|
||
"Identique à la fonction :func:`unpack_from`, en utilisant le format compilé. "
|
||
"La taille du tampon *buffer* en octets, en commençant à la position "
|
||
"*offset*, doit valoir au moins :attr:`size`."
|
||
|
||
#: library/struct.rst:583
|
||
msgid ""
|
||
"Identical to the :func:`iter_unpack` function, using the compiled format. "
|
||
"The buffer's size in bytes must be a multiple of :attr:`size`."
|
||
msgstr ""
|
||
"Identique à la fonction :func:`iter_unpack`, en utilisant le format compilé. "
|
||
"La taille du tampon *buffer* en octets doit être un multiple de :attr:`size`."
|
||
|
||
#: library/struct.rst:590
|
||
msgid "The format string used to construct this Struct object."
|
||
msgstr "La chaîne de format utilisée pour construire l'objet ``Struct``."
|
||
|
||
# Pas de majuscule car suit un ':' dans la version affichée.
|
||
#: library/struct.rst:592
|
||
msgid "The format string type is now :class:`str` instead of :class:`bytes`."
|
||
msgstr ""
|
||
"la chaîne de format est maintenant de type :class:`str` au lieu de :class:"
|
||
"`bytes`."
|
||
|
||
#: library/struct.rst:597
|
||
msgid ""
|
||
"The calculated size of the struct (and hence of the bytes object produced by "
|
||
"the :meth:`pack` method) corresponding to :attr:`format`."
|
||
msgstr ""
|
||
"La taille calculée de la structure agrégée (et donc de l'objet ``bytes`` "
|
||
"produit par la méthode :meth:`pack`) correspondante à :attr:`format`."
|
||
|
||
#~ msgid ""
|
||
#~ "This module performs conversions between Python values and C structs "
|
||
#~ "represented as Python :class:`bytes` objects. This can be used in "
|
||
#~ "handling binary data stored in files or from network connections, among "
|
||
#~ "other sources. It uses :ref:`struct-format-strings` as compact "
|
||
#~ "descriptions of the layout of the C structs and the intended conversion "
|
||
#~ "to/from Python values."
|
||
#~ msgstr ""
|
||
#~ "Ce module effectue des conversions entre des valeurs Python et des "
|
||
#~ "structures C représentées sous la forme de :class:`bytes` (séquences "
|
||
#~ "d'octets) Python. Cela permet, entre autres, de manipuler des données "
|
||
#~ "agrégées sous forme binaire dans des fichiers ou à travers des "
|
||
#~ "connecteurs réseau. Il utilise :ref:`les chaînes de spécification de "
|
||
#~ "format <struct-format-strings>` comme description de l'agencement des "
|
||
#~ "structures afin de réaliser les conversions depuis et vers les valeurs "
|
||
#~ "Python."
|
||
|
||
# Pas de majuscule car suit un ':' dans la version affichée (« Note »).
|
||
#~ msgid ""
|
||
#~ "By default, the result of packing a given C struct includes pad bytes in "
|
||
#~ "order to maintain proper alignment for the C types involved; similarly, "
|
||
#~ "alignment is taken into account when unpacking. This behavior is chosen "
|
||
#~ "so that the bytes of a packed struct correspond exactly to the layout in "
|
||
#~ "memory of the corresponding C struct. To handle platform-independent "
|
||
#~ "data formats or omit implicit pad bytes, use ``standard`` size and "
|
||
#~ "alignment instead of ``native`` size and alignment: see :ref:`struct-"
|
||
#~ "alignment` for details."
|
||
#~ msgstr ""
|
||
#~ "par défaut, le résultat de l'agrégation d'une structure C donnée comprend "
|
||
#~ "des octets de bourrage afin de maintenir un alignement correct des types "
|
||
#~ "C sous-jacents ; de la même manière, l'alignement est pris en compte lors "
|
||
#~ "de la dissociation. Ce comportement a été choisi de manière à ce que les "
|
||
#~ "octets d'une structure agrégée reproduisent exactement l'agencement en "
|
||
#~ "mémoire de la structure C équivalente. Pour gérer des formats de données "
|
||
#~ "indépendants de la plateforme ou omettre les octets implicites de "
|
||
#~ "bourrage, utilisez la taille et l'alignement ``standard`` en lieu et "
|
||
#~ "place de la taille et l'alignement ``native`` (voir :ref:`struct-"
|
||
#~ "alignment` pour les détails)."
|
||
|
||
# Pas de majuscule en début car cela suit un ':' dans la version affichée.
|
||
#~ msgid ""
|
||
#~ "All examples assume a native byte order, size, and alignment with a big-"
|
||
#~ "endian machine."
|
||
#~ msgstr ""
|
||
#~ "tous les exemples présentés supposent que l'on utilise le boutisme, la "
|
||
#~ "taille et l'alignement natifs sur une machine gros-boutiste."
|
||
|
||
#~ msgid "A basic example of packing/unpacking three integers::"
|
||
#~ msgstr "Un exemple de base d'agrégation et dissociation de trois entiers ::"
|
||
|
||
#~ msgid ""
|
||
#~ "The ordering of format characters may have an impact on size since the "
|
||
#~ "padding needed to satisfy alignment requirements is different::"
|
||
#~ msgstr ""
|
||
#~ "L'ordre des caractères de format peut avoir un impact sur la taille "
|
||
#~ "puisque le bourrage nécessaire pour réaliser l'alignement est différent ::"
|
||
|
||
#~ msgid ""
|
||
#~ "This only works when native size and alignment are in effect; standard "
|
||
#~ "size and alignment does not enforce any alignment."
|
||
#~ msgstr ""
|
||
#~ "Ceci ne fonctionne que quand la taille et l'alignement natifs sont "
|
||
#~ "utilisés ; la taille et l'alignement standards ne forcent aucun "
|
||
#~ "alignement."
|
||
|
||
#~ msgid "Packing and unpacking of XDR data."
|
||
#~ msgstr "Agrégation et dissociation de données XDR."
|
||
|
||
#~ msgid ""
|
||
#~ "The form ``'!'`` is available for those poor souls who claim they can't "
|
||
#~ "remember whether network byte order is big-endian or little-endian."
|
||
#~ msgstr ""
|
||
#~ "La forme ``'!'`` existe pour les têtes en l'air qui prétendent ne pas se "
|
||
#~ "rappeler si le boutisme réseau est gros-boutiste ou petit-boutiste."
|