arg.po

# 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: 2025-10-17 09:58+0200\n"
"PO-Revision-Date: 2021-12-11 11:44+0100\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.1\n"

#: c-api/arg.rst:6
msgid "Parsing arguments and building values"
msgstr "Analyse des arguments et construction des valeurs"

#: c-api/arg.rst:8
#, fuzzy
msgid ""
"These functions are useful when creating your own extension functions and "
"methods.  Additional information and examples are available "
"in :ref:`extending-index`."
msgstr ""
"Ces fonctions sont utiles pour créer vos propres fonctions et méthodes "
"d'extensions. Des informations supplémentaires et des exemples sont "
"disponibles ici: :ref:`extending-index`."

#: c-api/arg.rst:12
msgid ""
"The first three of these functions "
"described, :c:func:`PyArg_ParseTuple`, :c:func:`PyArg_ParseTupleAndKeywords`, "
"and :c:func:`PyArg_Parse`, all use *format strings* which are used to tell "
"the function about the expected arguments.  The format strings use the same "
"syntax for each of these functions."
msgstr ""
"Dans Les trois premières de ces fonctions "
"décrites, :c:func:`PyArg_ParseTuple`, :c:func:`PyArg_ParseTupleAndKeywords`, "
"et :c:func:`PyArg_Parse`, toutes utilisent *des chaînes de format* qui sont "
"utilisées pour indiquer à la fonction les arguments attendus. Les chaînes de "
"format utilise la même syntaxe pour chacune de ces fonctions."

#: c-api/arg.rst:19
msgid "Parsing arguments"
msgstr "Analyse des arguments"

#: c-api/arg.rst:21
msgid ""
"A format string consists of zero or more \"format units.\"  A format unit "
"describes one Python object; it is usually a single character or a "
"parenthesized sequence of format units.  With a few exceptions, a format "
"unit that is not a parenthesized sequence normally corresponds to a single "
"address argument to these functions.  In the following description, the "
"quoted form is the format unit; the entry in (round) parentheses is the "
"Python object type that matches the format unit; and the entry in [square] "
"brackets is the type of the C variable(s) whose address should be passed."
msgstr ""
"Une chaîne de format se compose de zéro ou plusieurs \"unités de format\". "
"Une unité de format décrit un objet Python, elle est généralement composée "
"d'un seul caractère ou d'une séquence d'unités de format entre parenthèses. "
"À quelques exceptions près, une unité de format qui n'est pas une séquence "
"entre parenthèses correspond normalement à un argument d'une seule adresse "
"pour ces fonctions. Dans la description qui suit, la forme entre guillemets "
"est l'unité de format, l'entrée entre parenthèses est le type d'objet Python "
"qui correspond à l'unité de format, et l'entrée entre crochets est le type "
"de la variable C (ou des variables) dont l'adresse doit être donnée."

#: c-api/arg.rst:33
msgid "Strings and buffers"
msgstr "Chaînes et tampons"

#: c-api/arg.rst:37
msgid ""
"On Python 3.12 and older, the macro :c:macro:`!PY_SSIZE_T_CLEAN` must be "
"defined before including :file:`Python.h` to use all ``#`` variants of "
"formats (``s#``, ``y#``, etc.) explained below. This is not necessary on "
"Python 3.13 and later."
msgstr ""
"Dans Python 3.12 et précédents, la macro :c:macro:`!PY_SSIZE_T_CLEAN` doit "
"être définie avant d'inclure :file:`Python.h` pour utiliser toutes les "
"variantes ``#`` de format (``s#``, ``y#``, etc.) détaillées ci-dessous. Ce "
"n'est plus nécessaire pour Python 3.13 et les versions ultérieures."

#: c-api/arg.rst:42
msgid ""
"These formats allow accessing an object as a contiguous chunk of memory. You "
"don't have to provide raw storage for the returned unicode or bytes area."
msgstr ""
"Ces formats permettent d'accéder à un objet sous forme d'un fragment de "
"mémoire contiguë. Il n'est pas nécessaire d'allouer la mémoire pour "
"l'*unicode* ou le *bytes* renvoyé."

#: c-api/arg.rst:46
msgid "Unless otherwise stated, buffers are not NUL-terminated."
msgstr "Sauf indication contraire, les tampons ne se terminent pas par NUL."

#: c-api/arg.rst:48
msgid "There are three ways strings and buffers can be converted to C:"
msgstr ""
"Les chaînes de caractères et tampons peuvent être convertis de trois "
"manières vers C:"

#: c-api/arg.rst:50
#, fuzzy
msgid ""
"Formats such as ``y*`` and ``s*`` fill a :c:type:`Py_buffer` structure. This "
"locks the underlying buffer so that the caller can subsequently use the "
"buffer even inside a :c:type:`Py_BEGIN_ALLOW_THREADS` block without the risk "
"of mutable data being resized or destroyed. As a result, **you have to "
"call** :c:func:`PyBuffer_Release` after you have finished processing the "
"data (or in any early abort case)."
msgstr ""
"Néanmoins, quand une structure :c:type:`Py_buffer` est en cours de "
"remplissage, le tampon sous-jacent est verrouillé pour permettre à "
"l'appelant d'utiliser le tampon par la suite, même à l'intérieur d'un "
"bloc :c:type:`Py_BEGIN_ALLOW_THREADS`, sans risques de voir des données "
"mutables se faire redimensionner ou supprimer. En conséquence, **il vous "
"appartient d'appeler** :c:func:`PyBuffer_Release` après avoir terminé de "
"traiter les données (ou après une interruption prématurée du traitement de "
"ces données)."

#: c-api/arg.rst:57
msgid ""
"The ``es``, ``es#``, ``et`` and ``et#`` formats allocate the result buffer. "
"**You have to call** :c:func:`PyMem_Free` after you have finished processing "
"the data (or in any early abort case)."
msgstr ""
"Les formats ``es``, ``es#``, ``et`` et ``et#`` allouent le tampon de "
"résultats. **Vous devez appeler** :c:func:`PyMem_Free` après avoir fini de "
"traiter les données (ou en cas d'abandon prématuré)."

#: c-api/arg.rst:63
#, fuzzy
msgid ""
"Other formats take a :class:`str` or a read-only :term:`bytes-like object`, "
"such as :class:`bytes`, and provide a ``const char *`` pointer to its "
"buffer. In this case the buffer is \"borrowed\": it is managed by the "
"corresponding Python object, and shares the lifetime of this object. You "
"won't have to release any memory yourself."
msgstr ""
"En général, lorsqu'un format définit un pointeur vers un tampon, le tampon "
"est géré par l'objet Python correspondant et le tampon partage la durée de "
"vie de cet objet. vous n'avez pas à libérer de mémoire. Les seules "
"exceptions sont ``es``, ``es#``, ``et`` et ``et#``."

#: c-api/arg.rst:70
msgid ""
"To ensure that the underlying buffer may be safely borrowed, the "
"object's :c:member:`PyBufferProcs.bf_releasebuffer` field must be ``NULL``. "
"This disallows common mutable objects such as :class:`bytearray`, but also "
"some read-only objects such as :class:`memoryview` of :class:`bytes`."
msgstr ""

#: c-api/arg.rst:76
msgid ""
"Besides this ``bf_releasebuffer`` requirement, there is no check to verify "
"whether the input object is immutable (e.g. whether it would honor a request "
"for a writable buffer, or whether another thread can mutate the data)."
msgstr ""

#: c-api/arg.rst:80
msgid "``s`` (:class:`str`) [const char \\*]"
msgstr "``s`` (:class:`str`) [``const char *``]"

#: c-api/arg.rst:81
msgid ""
"Convert a Unicode object to a C pointer to a character string. A pointer to "
"an existing string is stored in the character pointer variable whose address "
"you pass.  The C string is NUL-terminated. The Python string must not "
"contain embedded null code points; if it does, a :exc:`ValueError` exception "
"is raised. Unicode objects are converted to C strings using ``'utf-8'`` "
"encoding. If this conversion fails, a :exc:`UnicodeError` is raised."
msgstr ""
"Convertit un objet Unicode en un pointeur vers une chaîne de caractères. "
"S'il s'agit d'un pointeur vers une chaîne de caractères déjà existante, il "
"est stocké dans la variable de type pointeur vers un caractère dont vous "
"avez donné l'adresse. Une chaîne de caractères en C se termine par *NULL*. "
"La chaîne de caractères Python ne doit donc pas contenir de caractère dont "
"le code est *null*. Si elle en contient, une exception :exc:`ValueError` est "
"levée. Si la conversion échoue, une :exc:`UnicodeError` est levée."

#: c-api/arg.rst:90
msgid ""
"This format does not accept :term:`bytes-like objects <bytes-like object>`.  "
"If you want to accept filesystem paths and convert them to C character "
"strings, it is preferable to use the ``O&`` format "
"with :c:func:`PyUnicode_FSConverter` as *converter*."
msgstr ""
"Ce format n'accepte pas les :term:`objets compatibles avec une chaîne "
"d'octets  <bytes-like object>`. Si vous voulez accepter les chemins du "
"système de fichiers et les convertir vers des chaînes de caractères C, il "
"est préférable d'utiliser le format ``O&`` "
"avec :c:func:`PyUnicode_FSConverter` en tant que *converter*."

#: c-api/arg.rst:96
msgid ""
"Previously, :exc:`TypeError` was raised when embedded null code points were "
"encountered in the Python string."
msgstr ""
"Auparavant, une :exc:`TypeError` était levée quand la chaîne de caractères "
"Python contenait des codes NULL."

#: c-api/arg.rst:100
msgid "``s*`` (:class:`str` or :term:`bytes-like object`) [Py_buffer]"
msgstr "``s*`` (:class:`str` ou :term:`bytes-like object`) [``Py_buffer``]"

#: c-api/arg.rst:101
msgid ""
"This format accepts Unicode objects as well as bytes-like objects. It fills "
"a :c:type:`Py_buffer` structure provided by the caller. In this case the "
"resulting C string may contain embedded NUL bytes. Unicode objects are "
"converted to C strings using ``'utf-8'`` encoding."
msgstr ""
"Ce format accepte les objets Unicode et les *bytes-like object*. Cela "
"remplit une structure :c:type:`Py_buffer` qui est fournie par l'appelant. "
"Dans ce cas, la chaîne de caractères C qui en résulte peut contenir des "
"octets NULL. Les objets Unicode sont convertis en chaînes de caractères C en "
"utilisant l'encodage ``'utf-8'``."

#: c-api/arg.rst:106
#, fuzzy
msgid ""
"``s#`` (:class:`str`, read-only :term:`bytes-like object`) [const char "
"\\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str`, :term:`bytes-like object` en lecture seule) [``const "
"char \\*``, ``int`` ou :c:type:`Py_ssize_t`]"

#: c-api/arg.rst:107
#, fuzzy
msgid ""
"Like ``s*``, except that it provides a :ref:`borrowed buffer <c-arg-borrowed-"
"buffer>`. The result is stored into two C variables, the first one a pointer "
"to a C string, the second one its length. The string may contain embedded "
"null bytes. Unicode objects are converted to C strings using ``'utf-8'`` "
"encoding."
msgstr ""
"La même chose que ``s*``, mais n'accepte pas les objets mutables. Le "
"résultat est stocké dans deux variables C, la première est un pointeur vers "
"une chaîne de caractères C, la seconde contient sa taille. La chaîne de "
"caractères peut contenir des octets NULL. Les objets Unicode sont convertis "
"vers des chaînes de caractères C utilisant l'encodage ``'utf-8'``."

#: c-api/arg.rst:614
msgid "``z`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``z`` (:class:`str` ou ``None``) [``const char *``]"

#: c-api/arg.rst:114
#, fuzzy
msgid ""
"Like ``s``, but the Python object may also be ``None``, in which case the C "
"pointer is set to ``NULL``."
msgstr ""
"Comme ``s``, mais l'objet Python peut aussi être ``None``, auquel cas le "
"pointeur C devient *NULL*."

#: c-api/arg.rst:117
msgid ""
"``z*`` (:class:`str`, :term:`bytes-like object` or ``None``) [Py_buffer]"
msgstr ""
"``z*`` (:class:`str`, :term:`bytes-like object` ou ``None``) [``Py_buffer``]"

#: c-api/arg.rst:118
msgid ""
"Like ``s*``, but the Python object may also be ``None``, in which case the "
"``buf`` member of the :c:type:`Py_buffer` structure is set to ``NULL``."
msgstr ""
"Comme ``s*``, mais l'objet Python peut aussi être  ``None``, auquel cas le "
"membre ``buf``, dont la structure est :c:type:`Py_buffer` est fixée à *NULL*."

#: c-api/arg.rst:121
#, fuzzy
msgid ""
"``z#`` (:class:`str`, read-only :term:`bytes-like object` or ``None``) "
"[const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str`, :term:`bytes-like object` en lecture seule) [``const "
"char \\*``, ``int`` ou :c:type:`Py_ssize_t`]"

#: c-api/arg.rst:122
#, fuzzy
msgid ""
"Like ``s#``, but the Python object may also be ``None``, in which case the C "
"pointer is set to ``NULL``."
msgstr ""
"Comme ``s#``, mais l'objet Python peut également être ``None``, dans ce cas "
"le pointeur C est définie à *NULL*."

#: c-api/arg.rst:125
msgid "``y`` (read-only :term:`bytes-like object`) [const char \\*]"
msgstr ""
"``y`` (lecture seule :term:`objet compatible avec une chaîne d'octets <bytes-"
"like object>`) [constante char \\*]"

#: c-api/arg.rst:126
#, fuzzy
msgid ""
"This format converts a bytes-like object to a C pointer to a :ref:`borrowed "
"<c-arg-borrowed-buffer>` character string; it does not accept Unicode "
"objects.  The bytes buffer must not contain embedded null bytes; if it does, "
"a :exc:`ValueError` exception is raised."
msgstr ""
"Ce format convertit un *objet compatible avec une chaîne d'octets* en un "
"pointeur C vers une chaîne de caractères ; il n'accepte pas les objets "
"Unicode. Le tampon d'octets ne doit pas contenir d'octets *null* ; si c'est "
"le cas, une exception  :exc:`ValueError` est levée."

#: c-api/arg.rst:132
msgid ""
"Previously, :exc:`TypeError` was raised when embedded null bytes were "
"encountered in the bytes buffer."
msgstr ""
"Auparavant, :exc:`TypeError` était levée lorsque des octets *null* étaient "
"rencontrés dans le tampon d'octets."

#: c-api/arg.rst:136
msgid "``y*`` (:term:`bytes-like object`) [Py_buffer]"
msgstr "``y*`` (:term:`bytes-like object`) [``Py_buffer``]"

#: c-api/arg.rst:137
msgid ""
"This variant on ``s*`` doesn't accept Unicode objects, only bytes-like "
"objects.  **This is the recommended way to accept binary data.**"
msgstr ""

#: c-api/arg.rst:141
#, fuzzy
msgid ""
"``y#`` (read-only :term:`bytes-like object`) [const char "
"\\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str`, :term:`bytes-like object` en lecture seule) [``const "
"char \\*``, ``int`` ou :c:type:`Py_ssize_t`]"

#: c-api/arg.rst:142
msgid ""
"This variant on ``s#`` doesn't accept Unicode objects, only bytes-like "
"objects."
msgstr ""
"Cette variante de ``s#`` n'accepte pas les objets Unicode, uniquement des "
"objets assimilés à des octets."

#: c-api/arg.rst:145
msgid "``S`` (:class:`bytes`) [PyBytesObject \\*]"
msgstr "``S`` (:class:`bytes`) [``PyBytesObject *``]"

#: c-api/arg.rst:146
#, fuzzy
msgid ""
"Requires that the Python object is a :class:`bytes` object, without "
"attempting any conversion.  Raises :exc:`TypeError` if the object is not a "
"bytes object.  The C variable may also be declared as :c:expr:`PyObject*`."
msgstr ""
"Nécessite que l'objet Python soit de type :class:`bytes`, sans avoir tenté "
"de conversion. :exc:`TypeError` est levée si l'objet n'est pas un objet de "
"type *bytes*. La variable C doit aussi être déclarée en tant "
"que :c:type:`PyObject\\*`."

#: c-api/arg.rst:150
msgid "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"
msgstr "``Y`` (:class:`bytearray`) [``PyByteArrayObject *``]"

#: c-api/arg.rst:151
#, fuzzy
msgid ""
"Requires that the Python object is a :class:`bytearray` object, without "
"attempting any conversion.  Raises :exc:`TypeError` if the object is not "
"a :class:`bytearray` object. The C variable may also be declared "
"as :c:expr:`PyObject*`."
msgstr ""
"Nécessite que l'objet Python soit de type :class:`bytes`, sans avoir tenté "
"de conversion. :exc:`TypeError` est levée si l'objet n'est pas un objet de "
"type *bytes*. La variable C doit aussi être déclarée en tant "
"que :c:type:`PyObject\\*`."

#: c-api/arg.rst:155
msgid "``U`` (:class:`str`) [PyObject \\*]"
msgstr "``U`` (:class:`str`) [``PyObject *``]"

#: c-api/arg.rst:156
#, fuzzy
msgid ""
"Requires that the Python object is a Unicode object, without attempting any "
"conversion.  Raises :exc:`TypeError` if the object is not a Unicode object.  "
"The C variable may also be declared as :c:expr:`PyObject*`."
msgstr ""
"Nécessite que l'objet Python soit de type :class:`bytes`, sans avoir tenté "
"de conversion. :exc:`TypeError` est levée si l'objet n'est pas un objet de "
"type *bytes*. La variable C doit aussi être déclarée en tant "
"que :c:type:`PyObject\\*`."

#: c-api/arg.rst:160
msgid "``w*`` (read-write :term:`bytes-like object`) [Py_buffer]"
msgstr "``w*`` (lecture-écriture :term:`bytes-like object`) [``Py_buffer``]"

#: c-api/arg.rst:161
msgid ""
"This format accepts any object which implements the read-write buffer "
"interface. It fills a :c:type:`Py_buffer` structure provided by the caller. "
"The buffer may contain embedded null bytes. The caller have to "
"call :c:func:`PyBuffer_Release` when it is done with the buffer."
msgstr ""

#: c-api/arg.rst:166
msgid "``es`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer]"
msgstr ""

#: c-api/arg.rst:167
msgid ""
"This variant on ``s`` is used for encoding Unicode into a character buffer. "
"It only works for encoded data without embedded NUL bytes."
msgstr ""

#: c-api/arg.rst:170
msgid ""
"This format requires two arguments.  The first is only used as input, and "
"must be a :c:expr:`const char*` which points to the name of an encoding as a "
"NUL-terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is "
"used. An exception is raised if the named encoding is not known to Python.  "
"The second argument must be a :c:expr:`char**`; the value of the pointer it "
"references will be set to a buffer with the contents of the argument text. "
"The text will be encoded in the encoding specified by the first argument."
msgstr ""

#: c-api/arg.rst:178
msgid ""
":c:func:`PyArg_ParseTuple` will allocate a buffer of the needed size, copy "
"the encoded data into this buffer and adjust *\\*buffer* to reference the "
"newly allocated storage.  The caller is responsible for "
"calling :c:func:`PyMem_Free` to free the allocated buffer after use."
msgstr ""

#: c-api/arg.rst:183
msgid ""
"``et`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer]"
msgstr ""

#: c-api/arg.rst:184
msgid ""
"Same as ``es`` except that byte string objects are passed through without "
"recoding them.  Instead, the implementation assumes that the byte string "
"object uses the encoding passed in as parameter."
msgstr ""

#: c-api/arg.rst:188
#, fuzzy
msgid ""
"``es#`` (:class:`str`) [const char \\*encoding, char "
"\\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"
msgstr ""
"``s#`` (:class:`str`, :term:`bytes-like object` en lecture seule) [``const "
"char \\*``, ``int`` ou :c:type:`Py_ssize_t`]"

#: c-api/arg.rst:189
msgid ""
"This variant on ``s#`` is used for encoding Unicode into a character buffer. "
"Unlike the ``es`` format, this variant allows input data which contains NUL "
"characters."
msgstr ""

#: c-api/arg.rst:193
msgid ""
"It requires three arguments.  The first is only used as input, and must be "
"a :c:expr:`const char*` which points to the name of an encoding as a NUL-"
"terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is used. "
"An exception is raised if the named encoding is not known to Python.  The "
"second argument must be a :c:expr:`char**`; the value of the pointer it "
"references will be set to a buffer with the contents of the argument text. "
"The text will be encoded in the encoding specified by the first argument. "
"The third argument must be a pointer to an integer; the referenced integer "
"will be set to the number of bytes in the output buffer."
msgstr ""

#: c-api/arg.rst:203
msgid "There are two modes of operation:"
msgstr "Il existe deux modes de fonctionnement :"

#: c-api/arg.rst:205
msgid ""
"If *\\*buffer* points a ``NULL`` pointer, the function will allocate a "
"buffer of the needed size, copy the encoded data into this buffer and set "
"*\\*buffer* to reference the newly allocated storage.  The caller is "
"responsible for calling :c:func:`PyMem_Free` to free the allocated buffer "
"after usage."
msgstr ""

#: c-api/arg.rst:210
msgid ""
"If *\\*buffer* points to a non-``NULL`` pointer (an already allocated "
"buffer), :c:func:`PyArg_ParseTuple` will use this location as the buffer and "
"interpret the initial value of *\\*buffer_length* as the buffer size.  It "
"will then copy the encoded data into the buffer and NUL-terminate it.  If "
"the buffer is not large enough, a :exc:`ValueError` will be set."
msgstr ""

#: c-api/arg.rst:216
msgid ""
"In both cases, *\\*buffer_length* is set to the length of the encoded data "
"without the trailing NUL byte."
msgstr ""
"Dans les deux cas, *\\*buffer_length* est la longueur des données encodées, "
"sans l'octet NUL de fin."

#: c-api/arg.rst:219
#, fuzzy
msgid ""
"``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"
msgstr ""
"``s#`` (:class:`str`, :term:`bytes-like object` en lecture seule) [``const "
"char \\*``, ``int`` ou :c:type:`Py_ssize_t`]"

#: c-api/arg.rst:220
msgid ""
"Same as ``es#`` except that byte string objects are passed through without "
"recoding them. Instead, the implementation assumes that the byte string "
"object uses the encoding passed in as parameter."
msgstr ""

#: c-api/arg.rst:224
msgid ""
"``u``, ``u#``, ``Z``, and ``Z#`` are removed because they used a legacy "
"``Py_UNICODE*`` representation."
msgstr ""

#: c-api/arg.rst:230
msgid "Numbers"
msgstr "Les nombres"

#: c-api/arg.rst:232
msgid ""
"These formats allow representing Python numbers or single characters as C "
"numbers. Formats that require :class:`int`, :class:`float` "
"or :class:`complex` can also use the corresponding special "
"methods :meth:`~object.__index__`, :meth:`~object.__float__` "
"or :meth:`~object.__complex__` to convert the Python object to the required "
"type."
msgstr ""

#: c-api/arg.rst:238
msgid ""
"For signed integer formats, :exc:`OverflowError` is raised if the value is "
"out of range for the C type. For unsigned integer formats, no range checking "
"is done --- the most significant bits are silently truncated when the "
"receiving field is too small to receive the value."
msgstr ""

#: c-api/arg.rst:244
msgid "``b`` (:class:`int`) [unsigned char]"
msgstr "``b`` (:class:`int`) [``unsigned char``]"

#: c-api/arg.rst:245
#, fuzzy
msgid ""
"Convert a nonnegative Python integer to an unsigned tiny integer, stored in "
"a C :c:expr:`unsigned char`."
msgstr ""
"Convertit un entier Python positif ou nul en un ``unsigned tiny int``, "
"stocké dans un :c:type:`unsigned char` C."

#: c-api/arg.rst:648
msgid "``B`` (:class:`int`) [unsigned char]"
msgstr "``B`` (:class:`int`) [``unsigned char``]"

#: c-api/arg.rst:249
#, fuzzy
msgid ""
"Convert a Python integer to a tiny integer without overflow checking, stored "
"in a C :c:expr:`unsigned char`."
msgstr ""
"Convertit un entier Python en un ``tiny int`` sans vérifier le débordement, "
"stocké dans un :c:type:`unsigned char` C."

#: c-api/arg.rst:642
msgid "``h`` (:class:`int`) [short int]"
msgstr "``h`` (:class:`int`) [``short int``]"

#: c-api/arg.rst:253
#, fuzzy
msgid "Convert a Python integer to a C :c:expr:`short int`."
msgstr "Convertit un entier Python en un :c:type:`short int` C."

#: c-api/arg.rst:651
msgid "``H`` (:class:`int`) [unsigned short int]"
msgstr "``H`` (:class:`int`) [``unsigned short int``]"

#: c-api/arg.rst:256
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned short int`, without "
"overflow checking."
msgstr ""
"Convertit un entier Python en un :c:type:`unsigned short int` C, sans "
"contrôle de débordement."

#: c-api/arg.rst:636
msgid "``i`` (:class:`int`) [int]"
msgstr "``i`` (:class:`int`) [``int``]"

#: c-api/arg.rst:260
#, fuzzy
msgid "Convert a Python integer to a plain C :c:expr:`int`."
msgstr "Convertit un entier Python en un :c:type:`int` C."

#: c-api/arg.rst:654
msgid "``I`` (:class:`int`) [unsigned int]"
msgstr "``I`` (:class:`int`) [``unsigned int``]"

#: c-api/arg.rst:263
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned int`, without overflow "
"checking."
msgstr ""
"Convertit un entier Python en un :c:type:`unsigned int` C, sans contrôle de "
"le débordement."

#: c-api/arg.rst:645
msgid "``l`` (:class:`int`) [long int]"
msgstr "``l`` (:class:`int`) [``long int``]"

#: c-api/arg.rst:267
#, fuzzy
msgid "Convert a Python integer to a C :c:expr:`long int`."
msgstr "Convertit un entier Python en un :c:type:`long int`."

#: c-api/arg.rst:657
msgid "``k`` (:class:`int`) [unsigned long]"
msgstr "``k`` (:class:`int`) [``unsigned long``]"

#: c-api/arg.rst:270
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned long` without overflow "
"checking."
msgstr ""
"Convertit un entier Python en un :c:type:`unsigned long` C sans en vérifier "
"le débordement."

#: c-api/arg.rst:283
msgid "Use :meth:`~object.__index__` if available."
msgstr ""

#: c-api/arg.rst:660
msgid "``L`` (:class:`int`) [long long]"
msgstr "``L`` (:class:`int`) [``long long``]"

#: c-api/arg.rst:277
#, fuzzy
msgid "Convert a Python integer to a C :c:expr:`long long`."
msgstr "Convertit un entier Python en un :c:type:`long int`."

#: c-api/arg.rst:665
msgid "``K`` (:class:`int`) [unsigned long long]"
msgstr "``K`` (:class:`int`) [``unsigned long long``]"

#: c-api/arg.rst:280
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned long long` without "
"overflow checking."
msgstr ""
"Convertit un entier Python en un :c:type:`unsigned long` C sans en vérifier "
"le débordement."

#: c-api/arg.rst:668
#, fuzzy
msgid "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"
msgstr "``n`` (:class:`int`) [``Py_ssize_t``]"

#: c-api/arg.rst:287
msgid "Convert a Python integer to a C :c:type:`Py_ssize_t`."
msgstr "Convertit un entier Python en un :c:type:`Py_ssize_t`."

#: c-api/arg.rst:289
msgid "``c`` (:class:`bytes` or :class:`bytearray` of length 1) [char]"
msgstr "``c`` (:class:`bytes` ou :class:`bytearray` de longueur 1) [``char``]"

#: c-api/arg.rst:290
#, fuzzy
msgid ""
"Convert a Python byte, represented as a :class:`bytes` or :class:`bytearray` "
"object of length 1, to a C :c:expr:`char`."
msgstr ""
"Convertit un *byte* Python, représenté comme un objet :class:`bytes` "
"ou :class:`bytearray` de longueur 1, en un :c:type:`char` C."

#: c-api/arg.rst:293
msgid "Allow :class:`bytearray` objects."
msgstr ""

#: c-api/arg.rst:686
msgid "``C`` (:class:`str` of length 1) [int]"
msgstr "``C`` (:class:`str` de longueur 1) [``int``]"

#: c-api/arg.rst:297
#, fuzzy
msgid ""
"Convert a Python character, represented as a :class:`str` object of length "
"1, to a C :c:expr:`int`."
msgstr ""
"Convertit un caractère Python, représenté comme un objet :class:`str` de "
"longueur 1, en un :c:type:`int` C."

#: c-api/arg.rst:693
msgid "``f`` (:class:`float`) [float]"
msgstr "``f`` (:class:`float`) [``float``]"

#: c-api/arg.rst:301
#, fuzzy
msgid "Convert a Python floating-point number to a C :c:expr:`float`."
msgstr "Convertit un nombre flottant Python vers un :c:type:`float`."

#: c-api/arg.rst:690
msgid "``d`` (:class:`float`) [double]"
msgstr "``d`` (:class:`float`) [``double``]"

#: c-api/arg.rst:304
#, fuzzy
msgid "Convert a Python floating-point number to a C :c:expr:`double`."
msgstr "Convertit un nombre flottant Python vers un :c:type:`double` C."

#: c-api/arg.rst:306
msgid "``D`` (:class:`complex`) [Py_complex]"
msgstr "``D`` (:class:`complex`) [``Py_complex``]"

#: c-api/arg.rst:307
msgid "Convert a Python complex number to a C :c:type:`Py_complex` structure."
msgstr ""
"Convertit un nombre complexe Python vers une structure :c:type:`Py_complex` "
"C."

#: c-api/arg.rst:310
msgid "Other objects"
msgstr "Autres objets"

#: c-api/arg.rst:699
msgid "``O`` (object) [PyObject \\*]"
msgstr "``O`` (objet) [``PyObject *``]"

#: c-api/arg.rst:313
#, fuzzy
msgid ""
"Store a Python object (without any conversion) in a C object pointer.  The C "
"program thus receives the actual object that was passed.  A "
"new :term:`strong reference` to the object is not created (i.e. its "
"reference count is not increased). The pointer stored is not ``NULL``."
msgstr ""
"Stocke un objet Python (sans aucune conversion) en un pointeur sur un objet "
"C. Ainsi, Le programme C reçoit l'objet réel qui a été passé. Le compteur de "
"référence sur l'objet n'est pas incrémenté. Le pointeur stocké n'est pas "
"*NULL*."

#: c-api/arg.rst:319
msgid "``O!`` (object) [*typeobject*, PyObject \\*]"
msgstr "``O!`` (objet) [*typeobject*, ``PyObject *``]"

#: c-api/arg.rst:320
msgid ""
"Store a Python object in a C object pointer.  This is similar to ``O``, but "
"takes two C arguments: the first is the address of a Python type object, the "
"second is the address of the C variable (of type :c:expr:`PyObject*`) into "
"which the object pointer is stored.  If the Python object does not have the "
"required type, :exc:`TypeError` is raised."
msgstr ""

#: c-api/arg.rst:328
#, fuzzy
msgid "``O&`` (object) [*converter*, *address*]"
msgstr "``O&`` (objet) [*converter*, *anything*]"

#: c-api/arg.rst:329
msgid ""
"Convert a Python object to a C variable through a *converter* function.  "
"This takes two arguments: the first is a function, the second is the address "
"of a C variable (of arbitrary type), converted to :c:expr:`void *`.  The "
"*converter* function in turn is called as follows::"
msgstr ""

#: c-api/arg.rst:336
msgid ""
"where *object* is the Python object to be converted and *address* is "
"the :c:expr:`void*` argument that was passed to the ``PyArg_Parse*`` "
"function. The returned *status* should be ``1`` for a successful conversion "
"and ``0`` if the conversion has failed.  When the conversion fails, the "
"*converter* function should raise an exception and leave the content of "
"*address* unmodified."
msgstr ""

#: c-api/arg.rst:345
msgid ""
"If the *converter* returns :c:macro:`!Py_CLEANUP_SUPPORTED`, it may get "
"called a second time if the argument parsing eventually fails, giving the "
"converter a chance to release any memory that it had already allocated. In "
"this second call, the *object* parameter will be ``NULL``; *address* will "
"have the same value as in the original call."
msgstr ""

#: c-api/arg.rst:351
msgid ""
"Examples of converters: :c:func:`PyUnicode_FSConverter` "
"and :c:func:`PyUnicode_FSDecoder`."
msgstr ""

#: c-api/arg.rst:354
#, fuzzy
msgid ":c:macro:`!Py_CLEANUP_SUPPORTED` was added."
msgstr "``Py_CLEANUP_SUPPORTED`` à été ajouté."

#: c-api/arg.rst:671
msgid "``p`` (:class:`bool`) [int]"
msgstr "``p`` (:class:`bool`) [``int``]"

#: c-api/arg.rst:358
msgid ""
"Tests the value passed in for truth (a boolean **p**\\ redicate) and "
"converts the result to its equivalent C true/false integer value. Sets the "
"int to ``1`` if the expression was true and ``0`` if it was false. This "
"accepts any valid Python value.  See :ref:`truth` for more information about "
"how Python tests values for truth."
msgstr ""

#: c-api/arg.rst:366
#, fuzzy
msgid "``(items)`` (sequence) [*matching-items*]"
msgstr "``(items)`` (:class:`tuple`) [*matching-items*]"

#: c-api/arg.rst:367
#, fuzzy
msgid ""
"The object must be a Python sequence (except :class:`str`, :class:`bytes` "
"or :class:`bytearray`) whose length is the number of format units in "
"*items*.  The C arguments must correspond to the individual format units in "
"*items*.  Format units for sequences may be nested."
msgstr ""
"L'objet doit être une séquence Python dont la longueur est le nombre "
"d'unités de formats dans *articles*. Les arguments C doivent correspondre à "
"chaque unité de format particulière dans *articles*. Les unités de formats "
"pour les séquences peuvent être imbriquées."

#: c-api/arg.rst:372
msgid ""
"If *items* contains format units which store a :ref:`borrowed buffer <c-arg-"
"borrowed-buffer>` (``s``, ``s#``, ``z``, ``z#``, ``y``, or ``y#``) or "
"a :term:`borrowed reference` (``S``, ``Y``, ``U``, ``O``, or ``O!``), the "
"object must be a Python tuple. The *converter* for the ``O&`` format unit in "
"*items* must not store a borrowed buffer or a borrowed reference."
msgstr ""

#: c-api/arg.rst:379
msgid ""
":class:`str` and :class:`bytearray` objects no longer accepted as a sequence."
msgstr ""

#: c-api/arg.rst:382
msgid ""
"Non-tuple sequences are deprecated if *items* contains format units which "
"store a borrowed buffer or a borrowed reference."
msgstr ""

#: c-api/arg.rst:386
msgid ""
"A few other characters have a meaning in a format string.  These may not "
"occur inside nested parentheses.  They are:"
msgstr ""
"Quelques autres caractères ont un sens dans une chaîne de format. On ne doit "
"pas les trouvées dans des parenthèses imbriquées. Ce sont :"

#: c-api/arg.rst:389
msgid "``|``"
msgstr "``|``"

#: c-api/arg.rst:390
msgid ""
"Indicates that the remaining arguments in the Python argument list are "
"optional. The C variables corresponding to optional arguments should be "
"initialized to their default value --- when an optional argument is not "
"specified, :c:func:`PyArg_ParseTuple` does not touch the contents of the "
"corresponding C variable(s)."
msgstr ""

#: c-api/arg.rst:396
msgid "``$``"
msgstr "``$``"

#: c-api/arg.rst:397
msgid ""
":c:func:`PyArg_ParseTupleAndKeywords` only: Indicates that the remaining "
"arguments in the Python argument list are keyword-only.  Currently, all "
"keyword-only arguments must also be optional arguments, so ``|`` must always "
"be specified before ``$`` in the format string."
msgstr ""

#: c-api/arg.rst:405
msgid "``:``"
msgstr ""

#: c-api/arg.rst:406
msgid ""
"The list of format units ends here; the string after the colon is used as "
"the function name in error messages (the \"associated value\" of the "
"exception that :c:func:`PyArg_ParseTuple` raises)."
msgstr ""

#: c-api/arg.rst:410
msgid "``;``"
msgstr ""

#: c-api/arg.rst:411
msgid ""
"The list of format units ends here; the string after the semicolon is used "
"as the error message *instead* of the default error message.  ``:`` and "
"``;`` mutually exclude each other."
msgstr ""
"La liste des unités de format s'arrête ici ; la chaîne après le point-"
"virgule est utilise comme message d'erreur *au lieu* du message d'erreur par "
"défaut. ``:`` et ``;`` sont mutuellement exclusifs."

#: c-api/arg.rst:415
#, fuzzy
msgid ""
"Note that any Python object references which are provided to the caller are "
"*borrowed* references; do not release them (i.e. do not decrement their "
"reference count)!"
msgstr ""
"Notez que n'importe quelles références sur un objet Python qui sont données "
"à l'appelant sont des références *empruntées* ; ne décrémentez pas leur "
"compteur de références !"

#: c-api/arg.rst:419
msgid ""
"Additional arguments passed to these functions must be addresses of "
"variables whose type is determined by the format string; these are used to "
"store values from the input tuple.  There are a few cases, as described in "
"the list of format units above, where these parameters are used as input "
"values; they should match what is specified for the corresponding format "
"unit in that case."
msgstr ""
"Les arguments additionnels qui sont donnés à ces fonctions doivent être des "
"adresses de variables dont le type est déterminé par la chaîne de format. "
"Elles sont utilisées pour stocker les valeurs du *n*-uplet d'entrée. Il y a "
"quelques cas, comme décrit précédemment dans le liste des unités de formats, "
"où ces paramètres sont utilisés comme valeurs d'entrée. Dans ce cas, ils "
"devraient correspondre à ce qui est spécifié pour l'unité de format "
"correspondante."

#: c-api/arg.rst:425
msgid ""
"For the conversion to succeed, the *arg* object must match the format and "
"the format must be exhausted.  On success, the ``PyArg_Parse*`` functions "
"return true, otherwise they return false and raise an appropriate exception. "
"When the ``PyArg_Parse*`` functions fail due to conversion failure in one of "
"the format units, the variables at the addresses corresponding to that and "
"the following format units are left untouched."
msgstr ""

#: c-api/arg.rst:434
msgid "API Functions"
msgstr "Fonction de l'API"

#: c-api/arg.rst:438
msgid ""
"Parse the parameters of a function that takes only positional parameters "
"into local variables.  Returns true on success; on failure, it returns false "
"and raises the appropriate exception."
msgstr ""

#: c-api/arg.rst:445
msgid ""
"Identical to :c:func:`PyArg_ParseTuple`, except that it accepts a va_list "
"rather than a variable number of arguments."
msgstr ""

#: c-api/arg.rst:451
msgid ""
"Parse the parameters of a function that takes both positional and keyword "
"parameters into local variables. The *keywords* argument is a ``NULL``-"
"terminated array of keyword parameter names specified as null-terminated "
"ASCII or UTF-8 encoded C strings. Empty names denote :ref:`positional-only "
"parameters <positional-only_parameter>`. Returns true on success; on "
"failure, it returns false and raises the appropriate exception."
msgstr ""

#: c-api/arg.rst:462
msgid ""
"The *keywords* parameter declaration is :c:expr:`char * const *` in C "
"and :c:expr:`const char * const *` in C++. This can be overridden with "
"the :c:macro:`PY_CXX_CONST` macro."
msgstr ""

#: c-api/arg.rst:466
msgid ""
"Added support for :ref:`positional-only parameters <positional-"
"only_parameter>`."
msgstr ""

#: c-api/arg.rst:470
msgid ""
"The *keywords* parameter has now type :c:expr:`char * const *` in C "
"and :c:expr:`const char * const *` in C++, instead of :c:expr:`char **`. "
"Added support for non-ASCII keyword parameter names."
msgstr ""

#: c-api/arg.rst:479
msgid ""
"Identical to :c:func:`PyArg_ParseTupleAndKeywords`, except that it accepts a "
"va_list rather than a variable number of arguments."
msgstr ""

#: c-api/arg.rst:485
msgid ""
"Ensure that the keys in the keywords argument dictionary are strings.  This "
"is only needed if :c:func:`PyArg_ParseTupleAndKeywords` is not used, since "
"the latter already does this check."
msgstr ""

#: c-api/arg.rst:494
msgid ""
"Parse the parameter of a function that takes a single positional parameter "
"into a local variable.  Returns true on success; on failure, it returns "
"false and raises the appropriate exception."
msgstr ""

#: c-api/arg.rst:498
msgid "Example::"
msgstr "Exemple ::"

#: c-api/arg.rst:514
msgid ""
"A simpler form of parameter retrieval which does not use a format string to "
"specify the types of the arguments.  Functions which use this method to "
"retrieve their parameters should be declared as :c:macro:`METH_VARARGS` in "
"function or method tables.  The tuple containing the actual parameters "
"should be passed as *args*; it must actually be a tuple.  The length of the "
"tuple must be at least *min* and no more than *max*; *min* and *max* may be "
"equal.  Additional arguments must be passed to the function, each of which "
"should be a pointer to a :c:expr:`PyObject*` variable; these will be filled "
"in with the values from *args*; they will contain :term:`borrowed references "
"<borrowed reference>`. The variables which correspond to optional parameters "
"not given by *args* will not be filled in; these should be initialized by "
"the caller. This function returns true on success and false if *args* is not "
"a tuple or contains the wrong number of elements; an exception will be set "
"if there was a failure."
msgstr ""

#: c-api/arg.rst:529
msgid ""
"This is an example of the use of this function, taken from the sources for "
"the :mod:`!_weakref` helper module for weak references::"
msgstr ""

#: c-api/arg.rst:545
msgid ""
"The call to :c:func:`PyArg_UnpackTuple` in this example is entirely "
"equivalent to this call to :c:func:`PyArg_ParseTuple`::"
msgstr ""

#: c-api/arg.rst:552
msgid ""
"The value to be inserted, if any, before :c:expr:`char * const *` in the "
"*keywords* parameter declaration of :c:func:`PyArg_ParseTupleAndKeywords` "
"and :c:func:`PyArg_VaParseTupleAndKeywords`. Default empty for C and "
"``const`` for C++ (:c:expr:`const char * const *`). To override, define it "
"to the desired value before including :file:`Python.h`."
msgstr ""

#: c-api/arg.rst:566
msgid "Building values"
msgstr "Construction des valeurs"

#: c-api/arg.rst:570
msgid ""
"Create a new value based on a format string similar to those accepted by the "
"``PyArg_Parse*`` family of functions and a sequence of values.  Returns the "
"value or ``NULL`` in the case of an error; an exception will be raised if "
"``NULL`` is returned."
msgstr ""

#: c-api/arg.rst:575
msgid ""
":c:func:`Py_BuildValue` does not always build a tuple.  It builds a tuple "
"only if its format string contains two or more format units.  If the format "
"string is empty, it returns ``None``; if it contains exactly one format "
"unit, it returns whatever object is described by that format unit.  To force "
"it to return a tuple of size 0 or one, parenthesize the format string."
msgstr ""

#: c-api/arg.rst:581
msgid ""
"When memory buffers are passed as parameters to supply data to build "
"objects, as for the ``s`` and ``s#`` formats, the required data is copied.  "
"Buffers provided by the caller are never referenced by the objects created "
"by :c:func:`Py_BuildValue`.  In other words, if your code "
"invokes :c:func:`malloc` and passes the allocated memory "
"to :c:func:`Py_BuildValue`, your code is responsible for "
"calling :c:func:`free` for that memory once :c:func:`Py_BuildValue` returns."
msgstr ""

#: c-api/arg.rst:589
msgid ""
"In the following description, the quoted form is the format unit; the entry "
"in (round) parentheses is the Python object type that the format unit will "
"return; and the entry in [square] brackets is the type of the C value(s) to "
"be passed."
msgstr ""

#: c-api/arg.rst:593
msgid ""
"The characters space, tab, colon and comma are ignored in format strings "
"(but not within format units such as ``s#``).  This can be used to make long "
"format strings a tad more readable."
msgstr ""

#: c-api/arg.rst:597
msgid "``s`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``s`` (:class:`str` ou ``None``) [``const char *``]"

#: c-api/arg.rst:598
msgid ""
"Convert a null-terminated C string to a Python :class:`str` object using "
"``'utf-8'`` encoding. If the C string pointer is ``NULL``, ``None`` is used."
msgstr ""

#: c-api/arg.rst:601
#, fuzzy
msgid ""
"``s#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr "``s#`` (:class:`str` ou ``None``) [``const char *``, ``int``]"

#: c-api/arg.rst:602
msgid ""
"Convert a C string and its length to a Python :class:`str` object using "
"``'utf-8'`` encoding. If the C string pointer is ``NULL``, the length is "
"ignored and ``None`` is returned."
msgstr ""

#: c-api/arg.rst:606
msgid "``y`` (:class:`bytes`) [const char \\*]"
msgstr "``y`` (:class:`bytes`) [``const char *``]"

#: c-api/arg.rst:607
msgid ""
"This converts a C string to a Python :class:`bytes` object.  If the C string "
"pointer is ``NULL``, ``None`` is returned."
msgstr ""

#: c-api/arg.rst:610
#, fuzzy
msgid "``y#`` (:class:`bytes`) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr "``y#`` (:class:`bytes`) [``const char *, int``]"

#: c-api/arg.rst:611
msgid ""
"This converts a C string and its lengths to a Python object.  If the C "
"string pointer is ``NULL``, ``None`` is returned."
msgstr ""

#: c-api/arg.rst:631
msgid "Same as ``s``."
msgstr ""

#: c-api/arg.rst:617
#, fuzzy
msgid ""
"``z#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr "``z#`` (:class:`str` ou ``None``) [``const char *``, ``int``]"

#: c-api/arg.rst:634
msgid "Same as ``s#``."
msgstr ""

#: c-api/arg.rst:620
msgid "``u`` (:class:`str`) [const wchar_t \\*]"
msgstr "``u`` (:class:`str`) [``const wchar_t *``]"

#: c-api/arg.rst:621
msgid ""
"Convert a null-terminated :c:type:`wchar_t` buffer of Unicode (UTF-16 or "
"UCS-4) data to a Python Unicode object.  If the Unicode buffer pointer is "
"``NULL``, ``None`` is returned."
msgstr ""

#: c-api/arg.rst:625
#, fuzzy
msgid "``u#`` (:class:`str`) [const wchar_t \\*, :c:type:`Py_ssize_t`]"
msgstr "``u#`` (:class:`str`) [``const wchar_t *``, ``int``]"

#: c-api/arg.rst:626
msgid ""
"Convert a Unicode (UTF-16 or UCS-4) data buffer and its length to a Python "
"Unicode object.   If the Unicode buffer pointer is ``NULL``, the length is "
"ignored and ``None`` is returned."
msgstr ""

#: c-api/arg.rst:630
msgid "``U`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``U`` (:class:`str` ou ``None``) [``const char *``]"

#: c-api/arg.rst:633
#, fuzzy
msgid ""
"``U#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr "``U#`` (:class:`str` ou ``None``) [``const char *``, ``int``]"

#: c-api/arg.rst:637
#, fuzzy
msgid "Convert a plain C :c:expr:`int` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:639
msgid "``b`` (:class:`int`) [char]"
msgstr "``b`` (:class:`int`) [``char``]"

#: c-api/arg.rst:640
#, fuzzy
msgid "Convert a plain C :c:expr:`char` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:643
#, fuzzy
msgid "Convert a plain C :c:expr:`short int` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:646
#, fuzzy
msgid "Convert a C :c:expr:`long int` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:649
#, fuzzy
msgid "Convert a C :c:expr:`unsigned char` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:652
#, fuzzy
msgid "Convert a C :c:expr:`unsigned short int` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:655
#, fuzzy
msgid "Convert a C :c:expr:`unsigned int` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:658
#, fuzzy
msgid "Convert a C :c:expr:`unsigned long` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:661
#, fuzzy
msgid "Convert a C :c:expr:`long long` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:666
#, fuzzy
msgid "Convert a C :c:expr:`unsigned long long` to a Python integer object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:669
msgid "Convert a C :c:type:`Py_ssize_t` to a Python integer."
msgstr ""

#: c-api/arg.rst:672
#, fuzzy
msgid "Convert a C :c:expr:`int` to a Python :class:`bool` object."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:674
msgid ""
"Be aware that this format requires an ``int`` argument. Unlike most other "
"contexts in C, variadic arguments are not coerced to a suitable type "
"automatically. You can convert another type (for example, a pointer or a "
"float) to a suitable ``int`` value using ``(x) ? 1 : 0`` or ``!!x``."
msgstr ""

#: c-api/arg.rst:682
msgid "``c`` (:class:`bytes` of length 1) [char]"
msgstr "``c`` (:class:`bytes` de taille 1) [``char``]"

#: c-api/arg.rst:683
#, fuzzy
msgid ""
"Convert a C :c:expr:`int` representing a byte to a Python :class:`bytes` "
"object of length 1."
msgstr ""
"Convertit un caractère Python, représenté comme un objet :class:`str` de "
"longueur 1, en un :c:type:`int` C."

#: c-api/arg.rst:687
#, fuzzy
msgid ""
"Convert a C :c:expr:`int` representing a character to Python :class:`str` "
"object of length 1."
msgstr ""
"Convertit un caractère Python, représenté comme un objet :class:`str` de "
"longueur 1, en un :c:type:`int` C."

#: c-api/arg.rst:691
#, fuzzy
msgid "Convert a C :c:expr:`double` to a Python floating-point number."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:694
#, fuzzy
msgid "Convert a C :c:expr:`float` to a Python floating-point number."
msgstr "Convertit un :c:type:`long int` en un *int* Python."

#: c-api/arg.rst:696
msgid "``D`` (:class:`complex`) [Py_complex \\*]"
msgstr "``D`` (:class:`complex`) [``Py_complex *``]"

#: c-api/arg.rst:697
msgid "Convert a C :c:type:`Py_complex` structure to a Python complex number."
msgstr ""

#: c-api/arg.rst:700
msgid ""
"Pass a Python object untouched but create a new :term:`strong reference` to "
"it (i.e. its reference count is incremented by one). If the object passed in "
"is a ``NULL`` pointer, it is assumed that this was caused because the call "
"producing the argument found an error and set an exception. "
"Therefore, :c:func:`Py_BuildValue` will return ``NULL`` but won't raise an "
"exception.  If no exception has been raised yet, :exc:`SystemError` is set."
msgstr ""

#: c-api/arg.rst:709
msgid "``S`` (object) [PyObject \\*]"
msgstr "``S`` (objet) [``PyObject *``]"

#: c-api/arg.rst:710
msgid "Same as ``O``."
msgstr ""

#: c-api/arg.rst:712
msgid "``N`` (object) [PyObject \\*]"
msgstr "``N`` (objet) [``PyObject *``]"

#: c-api/arg.rst:713
msgid ""
"Same as ``O``, except it doesn't create a new :term:`strong reference`. "
"Useful when the object is created by a call to an object constructor in the "
"argument list."
msgstr ""

#: c-api/arg.rst:717
msgid "``O&`` (object) [*converter*, *anything*]"
msgstr "``O&`` (objet) [*converter*, *anything*]"

#: c-api/arg.rst:718
msgid ""
"Convert *anything* to a Python object through a *converter* function.  The "
"function is called with *anything* (which should be compatible "
"with :c:expr:`void*`) as its argument and should return a \"new\" Python "
"object, or ``NULL`` if an error occurred."
msgstr ""

#: c-api/arg.rst:723
msgid "``(items)`` (:class:`tuple`) [*matching-items*]"
msgstr "``(items)`` (:class:`tuple`) [*matching-items*]"

#: c-api/arg.rst:724
msgid ""
"Convert a sequence of C values to a Python tuple with the same number of "
"items."
msgstr ""

#: c-api/arg.rst:726
msgid "``[items]`` (:class:`list`) [*matching-items*]"
msgstr "``[items]`` (:class:`list`) [*matching-items*]"

#: c-api/arg.rst:727
msgid ""
"Convert a sequence of C values to a Python list with the same number of "
"items."
msgstr ""

#: c-api/arg.rst:729
msgid "``{items}`` (:class:`dict`) [*matching-items*]"
msgstr "``{items}`` (:class:`dict`) [*matching-items*]"

#: c-api/arg.rst:730
msgid ""
"Convert a sequence of C values to a Python dictionary.  Each pair of "
"consecutive C values adds one item to the dictionary, serving as key and "
"value, respectively."
msgstr ""

#: c-api/arg.rst:734
msgid ""
"If there is an error in the format string, the :exc:`SystemError` exception "
"is set and ``NULL`` returned."
msgstr ""

#: c-api/arg.rst:739
msgid ""
"Identical to :c:func:`Py_BuildValue`, except that it accepts a va_list "
"rather than a variable number of arguments."
msgstr ""

#~ msgid "``u`` (:class:`str`) [const Py_UNICODE \\*]"
#~ msgstr "``u`` (:class:`str`) [``const Py_UNICODE *``]"

#~ msgid ""
#~ "Convert a Python Unicode object to a C pointer to a NUL-terminated buffer "
#~ "of Unicode characters.  You must pass the address of "
#~ "a :c:type:`Py_UNICODE` pointer variable, which will be filled with the "
#~ "pointer to an existing Unicode buffer.  Please note that the width of "
#~ "a :c:type:`Py_UNICODE` character depends on compilation options (it is "
#~ "either 16 or 32 bits). The Python string must not contain embedded null "
#~ "code points; if it does, a :exc:`ValueError` exception is raised."
#~ msgstr ""
#~ "Convertit un objet Python Unicode en un pointeur C vers un tampon de "
#~ "caractères Unicode terminé par *NULL*. Vous devez passer l'adresse d'un "
#~ "pointeur :c:type:`Py_UNICODE`, qui sera rempli avec le pointeur vers un "
#~ "tampon Unicode existant. Veuillez noter que la taille "
#~ "d'un  :c:type:`Py_UNICODE` dépend des options de compilation (soit 16, "
#~ "soit 32 bits). La chaîne de caractères Python ne doit pas contenir de "
#~ "code *NULL*. Si elle en contient, une exception :exc:`ValueError` est "
#~ "levée."

#, fuzzy
#~ msgid "``u#`` (:class:`str`) [const Py_UNICODE \\*, :c:type:`Py_ssize_t`]"
#~ msgstr "``u#`` (:class:`str`) [``const Py_UNICODE *``, ``int``]"

#~ msgid "``Z`` (:class:`str` or ``None``) [const Py_UNICODE \\*]"
#~ msgstr "``Z`` (:class:`str` ou ``None``) [``const Py_UNICODE *``]"

#, fuzzy
#~ msgid ""
#~ "Like ``u``, but the Python object may also be ``None``, in which case "
#~ "the :c:type:`Py_UNICODE` pointer is set to ``NULL``."
#~ msgstr ""
#~ "Comme ``u``, mais l'objet Python peut aussi être ``None``, auquel cas le "
#~ "pointeur :c:type:`Py_UNICODE` vaut *NULL*."

#, fuzzy
#~ msgid ""
#~ "``Z#`` (:class:`str` or ``None``) [const Py_UNICODE "
#~ "\\*, :c:type:`Py_ssize_t`]"
#~ msgstr "``Z#`` (:class:`str` ou ``None``) [``const Py_UNICODE *``, ``int``]"

#, fuzzy
#~ msgid ""
#~ "Like ``u#``, but the Python object may also be ``None``, in which case "
#~ "the :c:type:`Py_UNICODE` pointer is set to ``NULL``."
#~ msgstr ""
#~ "Comme ``u#``, mais l'objet Python peut également être ``None``, auquel "
#~ "cas le pointeur :c:type:`Py_UNICODE` vaut *NULL*."

#~ msgid ""
#~ "Some formats require a read-only :term:`bytes-like object`, and set a "
#~ "pointer instead of a buffer structure.  They work by checking that the "
#~ "object's :c:member:`PyBufferProcs.bf_releasebuffer` field is ``NULL``, "
#~ "which disallows mutable objects such as :class:`bytearray`."
#~ msgstr ""
#~ "Certains formats requièrent un :term:`objet compatible avec une chaîne "
#~ "d'octets <bytes-like object>` en lecture seule, et définissent un "
#~ "pointeur à la place d'une structure tampon. Ils fonctionnent en vérifiant "
#~ "que le champ :c:member:`PyBufferProcs.bf_releasebuffer` de l'objet est "
#~ "*NULL*, ce qui n'autorise pas les objets mutables tels "
#~ "que :class:`bytearray`."

#~ msgid ""
#~ "For all ``#`` variants of formats (``s#``, ``y#``, etc.), the type of the "
#~ "length argument (int or :c:type:`Py_ssize_t`) is controlled by defining "
#~ "the macro :c:macro:`PY_SSIZE_T_CLEAN` before including :file:`Python.h`.  "
#~ "If the macro was defined, length is a :c:type:`Py_ssize_t` rather than "
#~ "an :c:type:`int`. This behavior will change in a future Python version to "
#~ "only support :c:type:`Py_ssize_t` and drop :c:type:`int` support. It is "
#~ "best to always define :c:macro:`PY_SSIZE_T_CLEAN`."
#~ msgstr ""
#~ "Pour toutes les variantes du marqueur ``#`` (``s#``, ``y#``, etc), le "
#~ "type de l'argument *length* (*int* ou :c:type:`Py_ssize_t`) est contrôlé "
#~ "en définissant la macro :c:macro:`PY_SSIZE_T_CLEAN` avant d'inclure le "
#~ "fichier :file:`Python.h`. Si la macro est définie, la longueur est de "
#~ "type :c:type:`Py_ssize_t` au lieu d'être de type :c:type:`int`. Ce "
#~ "comportement changera dans une future version de Python, qui supportera "
#~ "seulement :c:type:`Py_ssize_t` a la place de :c:type:`int`. Il est "
#~ "préférable de toujours définir :c:macro:`PY_SSIZE_T_CLEAN`."