# 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: 2024-10-29 21:40+0100\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

msgid ""

"These functions are useful when creating your own extensions 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:31

msgid "Strings and buffers"

msgstr "Chaînes et tampons"

#: c-api/arg.rst:33

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:37

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:39

msgid "There are three ways strings and buffers can be converted to C:"

msgstr ""

#: c-api/arg.rst:41

#, 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:48

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 ""

#: c-api/arg.rst:54

#, 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:61

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:67

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:73

msgid ""

"For all ``#`` variants of formats (``s#``, ``y#``, etc.), the macro :c:macro:"

"`PY_SSIZE_T_CLEAN` must be defined before including :file:`Python.h`. On "

"Python 3.9 and older, the type of the length argument is :c:type:"

"`Py_ssize_t` if the :c:macro:`PY_SSIZE_T_CLEAN` macro is defined, or int "

"otherwise."

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:546

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 "``b`` (:class:`int`) [unsigned char]"

msgstr "``b`` (:class:`int`) [``unsigned char``]"

#: c-api/arg.rst:233

#, fuzzy

msgid ""

"Convert a nonnegative Python integer to an unsigned tiny int, 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:580

msgid "``B`` (:class:`int`) [unsigned char]"

msgstr "``B`` (:class:`int`) [``unsigned char``]"

#: c-api/arg.rst:237

#, fuzzy

msgid ""

"Convert a Python integer to a tiny int 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:574

msgid "``h`` (:class:`int`) [short int]"

msgstr "``h`` (:class:`int`) [``short int``]"

#: c-api/arg.rst:241

#, 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:583

msgid "``H`` (:class:`int`) [unsigned short int]"

msgstr "``H`` (:class:`int`) [``unsigned short int``]"

#: c-api/arg.rst:244

#, 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:568

msgid "``i`` (:class:`int`) [int]"

msgstr "``i`` (:class:`int`) [``int``]"

#: c-api/arg.rst:248

#, 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:586

msgid "``I`` (:class:`int`) [unsigned int]"

msgstr "``I`` (:class:`int`) [``unsigned int``]"

#: c-api/arg.rst:251

#, 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:577

msgid "``l`` (:class:`int`) [long int]"

msgstr "``l`` (:class:`int`) [``long int``]"

#: c-api/arg.rst:255

#, 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:589

msgid "``k`` (:class:`int`) [unsigned long]"

msgstr "``k`` (:class:`int`) [``unsigned long``]"

#: c-api/arg.rst:258

#, 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:592

msgid "``L`` (:class:`int`) [long long]"

msgstr "``L`` (:class:`int`) [``long long``]"

#: c-api/arg.rst:262

#, 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:595

msgid "``K`` (:class:`int`) [unsigned long long]"

msgstr "``K`` (:class:`int`) [``unsigned long long``]"

#: c-api/arg.rst:265

#, 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:598

#, fuzzy

msgid "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"

msgstr "``n`` (:class:`int`) [``Py_ssize_t``]"

#: c-api/arg.rst:269

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:271

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:272

#, 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:275

msgid "Allow :class:`bytearray` objects."

msgstr ""

#: c-api/arg.rst:605

msgid "``C`` (:class:`str` of length 1) [int]"

msgstr "``C`` (:class:`str` de longueur 1) [``int``]"

#: c-api/arg.rst:279

#, 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:612

msgid "``f`` (:class:`float`) [float]"

msgstr "``f`` (:class:`float`) [``float``]"

#: c-api/arg.rst:283

#, 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:609

msgid "``d`` (:class:`float`) [double]"

msgstr "``d`` (:class:`float`) [``double``]"

#: c-api/arg.rst:286

#, 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:288

msgid "``D`` (:class:`complex`) [Py_complex]"

msgstr "``D`` (:class:`complex`) [``Py_complex``]"

#: c-api/arg.rst:289

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:292

msgid "Other objects"

msgstr "Autres objets"

#: c-api/arg.rst:618

msgid "``O`` (object) [PyObject \\*]"

msgstr "``O`` (objet) [``PyObject *``]"

#: c-api/arg.rst:295

#, 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:301

msgid "``O!`` (object) [*typeobject*, PyObject \\*]"

msgstr "``O!`` (objet) [*typeobject*, ``PyObject *``]"

#: c-api/arg.rst:302

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:636

msgid "``O&`` (object) [*converter*, *anything*]"

msgstr "``O&`` (objet) [*converter*, *anything*]"

#: c-api/arg.rst:311

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:316

msgid "status = converter(object, address);"

msgstr ""

#: c-api/arg.rst:318

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:324

msgid ""

"If the *converter* returns ``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:330

msgid "``Py_CLEANUP_SUPPORTED`` was added."

msgstr "``Py_CLEANUP_SUPPORTED`` à été ajouté."

#: c-api/arg.rst:333

msgid "``p`` (:class:`bool`) [int]"

msgstr "``p`` (:class:`bool`) [``int``]"

#: c-api/arg.rst:334

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:642

msgid "``(items)`` (:class:`tuple`) [*matching-items*]"

msgstr "``(items)`` (:class:`tuple`) [*matching-items*]"

#: c-api/arg.rst:343

msgid ""

"The object must be a Python sequence 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:347

msgid ""

"It is possible to pass \"long\" integers (integers whose value exceeds the "

"platform's :c:macro:`LONG_MAX`) however no proper range checking is done --- "

"the most significant bits are silently truncated when the receiving field is "

"too small to receive the value (actually, the semantics are inherited from "

"downcasts in C --- your mileage may vary)."

msgstr ""

#: c-api/arg.rst:353

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:356

msgid "``|``"

msgstr "``|``"

#: c-api/arg.rst:357

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:363

msgid "``$``"

msgstr "``$``"

#: c-api/arg.rst:364

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:372

msgid "``:``"

msgstr ""

#: c-api/arg.rst:373

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:377

msgid "``;``"

msgstr ""

#: c-api/arg.rst:378

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:382

#, 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:386

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:392

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:401

msgid "API Functions"

msgstr "Fonction de l'API"

#: c-api/arg.rst:405

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:412

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:418

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. 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:425

msgid ""

"Added support for :ref:`positional-only parameters <positional-"

"only_parameter>`."

msgstr ""

#: c-api/arg.rst:432

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:438

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:448

msgid ""

"Function used to deconstruct the argument lists of \"old-style\" functions "

"--- these are functions which use the :const:`METH_OLDARGS` parameter "

"parsing method, which has been removed in Python 3. This is not recommended "

"for use in parameter parsing in new code, and most code in the standard "

"interpreter has been modified to no longer use this for that purpose. It "

"does remain a convenient way to decompose other tuples, however, and may "

"continue to be used for that purpose."

msgstr ""

#: c-api/arg.rst:459

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:474

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:477

msgid ""

"static PyObject *\n"

"weakref_ref(PyObject *self, PyObject *args)\n"

"{\n"

" PyObject *object;\n"

" PyObject *callback = NULL;\n"

" PyObject *result = NULL;\n"

"\n"