extending.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: 2023-07-23 14:38+0200\n"
"PO-Revision-Date: 2023-11-26 10:23+0100\n"
"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\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 3.2.2\n"

#: extending/extending.rst:8
msgid "Extending Python with C or C++"
msgstr "Étendre Python en C ou C++"

#: extending/extending.rst:10
msgid ""
"It is quite easy to add new built-in modules to Python, if you know how to "
"program in C.  Such :dfn:`extension modules` can do two things that can't be "
"done directly in Python: they can implement new built-in object types, and "
"they can call C library functions and system calls."
msgstr ""
"Il est relativement facile d'ajouter de nouveaux modules à Python, si vous "
"savez programmer en C. Ces :dfn:`modules d'extension` permettent deux choses "
"qui ne sont pas possibles directement en Python : ils peuvent définir de "
"nouveaux types natifs et peuvent appeler des fonctions de bibliothèques C ou "
"faire des appels systèmes."

#: extending/extending.rst:15
msgid ""
"To support extensions, the Python API (Application Programmers Interface) "
"defines a set of functions, macros and variables that provide access to most "
"aspects of the Python run-time system.  The Python API is incorporated in a "
"C source file by including the header ``\"Python.h\"``."
msgstr ""
"Pour gérer les extensions, l'API Python (*Application Programmer Interface*) "
"définit un ensemble de fonctions, macros et variables qui donnent accès à la "
"plupart des aspects du système d'exécution de Python. L'API Python est "
"incorporée dans un fichier source C en incluant l'en-tête ``Python.h``."

#: extending/extending.rst:20
msgid ""
"The compilation of an extension module depends on its intended use as well "
"as on your system setup; details are given in later chapters."
msgstr ""
"La compilation d'un module d'extension dépend de l'usage prévu et de la "
"configuration du système, plus de détails peuvent être trouvés dans les "
"chapitres suivants."

# suit un :
#: extending/extending.rst:25
msgid ""
"The C extension interface is specific to CPython, and extension modules do "
"not work on other Python implementations.  In many cases, it is possible to "
"avoid writing C extensions and preserve portability to other "
"implementations. For example, if your use case is calling C library "
"functions or system calls, you should consider using the :mod:`ctypes` "
"module or the `cffi <https://cffi.readthedocs.io/>`_ library rather than "
"writing custom C code. These modules let you write Python code to interface "
"with C code and are more portable between implementations of Python than "
"writing and compiling a C extension module."
msgstr ""
"l'interface d'extension C est spécifique à *CPython*, et les modules "
"d'extension ne fonctionnent pas sur les autres implémentations de Python. "
"Dans de nombreux cas, il est possible d'éviter la rédaction des extensions "
"en C et ainsi préserver la portabilité vers d'autres implémentations. Par "
"exemple, si vous devez appeler une fonction de la bibliothèque C ou faire un "
"appel système, vous devriez envisager d'utiliser le module :mod:`ctypes` ou "
"d'utiliser la bibliothèque `cffi <https://cffi.readthedocs.io/>`_ plutôt que "
"d'écrire du code C sur mesure. Ces modules vous permettent d'écrire du code "
"Python s'interfaçant avec le code C et sont plus portables entre les "
"implémentations de Python que l'écriture et la compilation d'une d'extension "
"C."

#: extending/extending.rst:40
msgid "A Simple Example"
msgstr "Un exemple simple"

#: extending/extending.rst:42
msgid ""
"Let's create an extension module called ``spam`` (the favorite food of Monty "
"Python fans...) and let's say we want to create a Python interface to the C "
"library function :c:func:`system` [#]_. This function takes a null-"
"terminated character string as argument and returns an integer.  We want "
"this function to be callable from Python as follows:"
msgstr ""
"Créons un module d'extension appelé ``spam`` (la nourriture préférée de fans "
"des *Monty Python*) et disons que nous voulons créer une interface Python à "
"la fonction de la bibliothèque C :c:func:`system` [#]_. Cette fonction prend "
"une chaîne de caractères à terminaison nulle comme argument et renvoie un "
"entier. Nous voulons que cette fonction soit appelable à partir de Python "
"comme suit :"

#: extending/extending.rst:53
msgid ""
"Begin by creating a file :file:`spammodule.c`.  (Historically, if a module "
"is called ``spam``, the C file containing its implementation is called :file:"
"`spammodule.c`; if the module name is very long, like ``spammify``, the "
"module name can be just :file:`spammify.c`.)"
msgstr ""
"Commençons par créer un fichier :file:`spammodule.c` (historiquement, si un "
"module se nomme ``spam``, le fichier C contenant son implémentation est "
"appelé :file:`spammodule.c` ; si le nom du module est très long, comme "
"``spammify``, le nom du module peut être juste :file:`spammify.c`)."

#: extending/extending.rst:58
msgid "The first two lines of our file can be::"
msgstr "Les deux premières lignes de notre fichier peuvent être ::"

#: extending/extending.rst:63
msgid ""
"which pulls in the Python API (you can add a comment describing the purpose "
"of the module and a copyright notice if you like)."
msgstr ""
"qui récupère l'API Python (vous pouvez ajouter un commentaire décrivant le "
"but du module et un avis de droit d'auteur si vous le souhaitez)."

# suit un :
#: extending/extending.rst:68
msgid ""
"Since Python may define some pre-processor definitions which affect the "
"standard headers on some systems, you *must* include :file:`Python.h` before "
"any standard headers are included."
msgstr ""
"il est possible que Python déclare certaines définitions pré-processeur qui "
"affectent les têtes standards sur certains systèmes, vous *devez* donc "
"inclure :file:`Python.h` avant les en-têtes standards."

#: extending/extending.rst:72
msgid ""
"It is recommended to always define ``PY_SSIZE_T_CLEAN`` before including "
"``Python.h``.  See :ref:`parsetuple` for a description of this macro."
msgstr ""
"Il est recommandé de toujours définir ``PY_SSIZE_T_CLEAN`` avant d'inclure "
"``Python.h``. Lisez :ref:`parsetuple` pour avoir une description de cette "
"macro."

#: extending/extending.rst:75
msgid ""
"All user-visible symbols defined by :file:`Python.h` have a prefix of ``Py`` "
"or ``PY``, except those defined in standard header files. For convenience, "
"and since they are used extensively by the Python interpreter, ``\"Python."
"h\"`` includes a few standard header files: ``<stdio.h>``, ``<string.h>``, "
"``<errno.h>``, and ``<stdlib.h>``.  If the latter header file does not exist "
"on your system, it declares the functions :c:func:`malloc`, :c:func:`free` "
"and :c:func:`realloc` directly."
msgstr ""
"Tous les symboles exposés par :file:`Python.h` sont préfixés de ``Py`` ou "
"``PY``, sauf ceux qui sont définis dans les en-têtes standards. Pour le "
"confort, et comme ils sont largement utilisés par l'interpréteur Python, "
"``\"Python.h\"`` inclut lui-même quelques en-têtes standards : ``<stdio."
"h>``, ``<string.h>``, ``<errno.h>`` et ``<stdlib.h>``. Si ce dernier "
"n'existe pas sur votre système, il déclare les fonctions :c:func:`malloc`, :"
"c:func:`free` et :c:func:`realloc` directement."

#: extending/extending.rst:83
msgid ""
"The next thing we add to our module file is the C function that will be "
"called when the Python expression ``spam.system(string)`` is evaluated "
"(we'll see shortly how it ends up being called)::"
msgstr ""
"La prochaine chose que nous ajoutons à notre fichier de module est la "
"fonction C qui sera appelée lorsque l'expression Python ``spam."
"system(chaîne)`` sera évaluée (nous verrons bientôt comment elle finit par "
"être appelée) ::"

#: extending/extending.rst:99
msgid ""
"There is a straightforward translation from the argument list in Python (for "
"example, the single expression ``\"ls -l\"``) to the arguments passed to the "
"C function.  The C function always has two arguments, conventionally named "
"*self* and *args*."
msgstr ""
"Il y a une correspondance directe de la liste des arguments en Python (par "
"exemple, l'expression ``\"ls -l\"``) aux arguments passés à la fonction C. "
"La fonction C a toujours deux arguments, appelés par convention *self* et "
"*args*."

#: extending/extending.rst:104
msgid ""
"The *self* argument points to the module object for module-level functions; "
"for a method it would point to the object instance."
msgstr ""
"Pour les fonctions au niveau du module, l'argument *self* pointe sur l'objet "
"module, pour une méthode, il pointe sur l'instance de l'objet."

#: extending/extending.rst:107
msgid ""
"The *args* argument will be a pointer to a Python tuple object containing "
"the arguments.  Each item of the tuple corresponds to an argument in the "
"call's argument list.  The arguments are Python objects --- in order to do "
"anything with them in our C function we have to convert them to C values.  "
"The function :c:func:`PyArg_ParseTuple` in the Python API checks the "
"argument types and converts them to C values.  It uses a template string to "
"determine the required types of the arguments as well as the types of the C "
"variables into which to store the converted values.  More about this later."
msgstr ""
"L'argument *args* sera un pointeur vers un *n*-uplet Python contenant les "
"arguments. Chaque élément du *n*-uplet correspond à un argument dans la "
"liste des arguments de l'appel. Les arguments sont des objets Python, afin "
"d'en faire quelque chose dans notre fonction C, nous devons les convertir en "
"valeurs C. La fonction :c:func:`PyArg_ParseTuple` de l'API Python vérifie "
"les types des arguments et les convertit en valeurs C. Elle utilise un "
"modèle sous forme de chaîne pour déterminer les types requis des arguments "
"ainsi que les types de variables C dans lequel stocker les valeurs "
"converties. Nous approfondirons ceci plus tard."

#: extending/extending.rst:116
msgid ""
":c:func:`PyArg_ParseTuple` returns true (nonzero) if all arguments have the "
"right type and its components have been stored in the variables whose "
"addresses are passed.  It returns false (zero) if an invalid argument list "
"was passed.  In the latter case it also raises an appropriate exception so "
"the calling function can return ``NULL`` immediately (as we saw in the "
"example)."
msgstr ""
":c:func:`PyArg_ParseTuple` renvoie vrai (pas zéro) si tous les arguments ont "
"le bon type et que ses composants ont été stockés dans les variables dont "
"les adresses ont été données en entrée. Elle renvoie faux (zéro) si une "
"liste d'arguments invalide a été passée. Dans ce dernier cas, elle lève "
"également une exception appropriée de sorte que la fonction d'appel puisse "
"renvoyer ``NULL`` immédiatement (comme nous l'avons vu dans l'exemple)."

#: extending/extending.rst:126
msgid "Intermezzo: Errors and Exceptions"
msgstr "Intermezzo : les erreurs et les exceptions"

#: extending/extending.rst:128
msgid ""
"An important convention throughout the Python interpreter is the following: "
"when a function fails, it should set an exception condition and return an "
"error value (usually ``-1`` or a ``NULL`` pointer).  Exception information "
"is stored in three members of the interpreter's thread state.  These are "
"``NULL`` if there is no exception.  Otherwise they are the C equivalents of "
"the members of the Python tuple returned by :meth:`sys.exc_info`.  These are "
"the exception type, exception instance, and a traceback object.  It is "
"important to know about them to understand how errors are passed around."
msgstr ""
"Une convention importante dans l'interpréteur Python est la suivante : "
"lorsqu'une fonction échoue, elle doit définir une condition d'exception et "
"renvoyer une valeur d'erreur (généralement ``-1`` ou un pointeur ``NULL``). "
"Les informations d'exception sont stockées dans trois attributs de l'état du "
"thread de l'interpréteur. Ils valent ``NULL`` s'il n'y a pas d'exception. "
"Sinon, ce sont les équivalents C des membres du *n*-uplet Python renvoyé "
"par :meth:`sys.exc_info`. Il s'agit du type d'exception, de l'instance "
"d'exception et d'un objet de trace. Il est important de les connaître pour "
"comprendre comment les erreurs sont transmises."

#: extending/extending.rst:137
msgid ""
"The Python API defines a number of functions to set various types of "
"exceptions."
msgstr ""
"L'API Python définit un certain nombre de fonctions pour créer différents "
"types d'exceptions."

#: extending/extending.rst:139
msgid ""
"The most common one is :c:func:`PyErr_SetString`.  Its arguments are an "
"exception object and a C string.  The exception object is usually a "
"predefined object like :c:data:`PyExc_ZeroDivisionError`.  The C string "
"indicates the cause of the error and is converted to a Python string object "
"and stored as the \"associated value\" of the exception."
msgstr ""
"La plus courante est :c:func:`PyErr_SetString`. Ses arguments sont un objet "
"exception et une chaîne C. L'objet exception est généralement un objet "
"prédéfini comme :c:data:`PyExc_ZeroDivisionError`. La chaîne C indique la "
"cause de l'erreur et est convertie en une chaîne Python puis stockée en tant "
"que « valeur associée » à l'exception."

#: extending/extending.rst:145
msgid ""
"Another useful function is :c:func:`PyErr_SetFromErrno`, which only takes an "
"exception argument and constructs the associated value by inspection of the "
"global variable :c:data:`errno`.  The most general function is :c:func:"
"`PyErr_SetObject`, which takes two object arguments, the exception and its "
"associated value.  You don't need to :c:func:`Py_INCREF` the objects passed "
"to any of these functions."
msgstr ""
"Une autre fonction utile est :c:func:`PyErr_SetFromErrno`, qui construit une "
"exception à partir de la valeur de la variable globale :c:data:`errno`. La "
"fonction la plus générale est :c:func:`PyErr_SetObject`, qui prend deux "
"arguments : l'exception et sa valeur associée. Vous ne devez pas appliquer :"
"c:func:`Py_INCREF` aux objets transmis à ces fonctions."

#: extending/extending.rst:152
msgid ""
"You can test non-destructively whether an exception has been set with :c:"
"func:`PyErr_Occurred`.  This returns the current exception object, or "
"``NULL`` if no exception has occurred.  You normally don't need to call :c:"
"func:`PyErr_Occurred` to see whether an error occurred in a function call, "
"since you should be able to tell from the return value."
msgstr ""
"Vous pouvez tester de manière non destructive si une exception a été levée "
"avec :c:func:`PyErr_Occurred`. Cela renvoie l'objet exception actuel, ou "
"``NULL`` si aucune exception n'a eu lieu. Cependant, vous ne devriez pas "
"avoir besoin d'appeler :c:func:`PyErr_Occurred` pour voir si une erreur est "
"survenue durant l'appel d'une fonction, puisque vous devriez être en mesure "
"de le déterminer à partir de la valeur renvoyée."

#: extending/extending.rst:158
msgid ""
"When a function *f* that calls another function *g* detects that the latter "
"fails, *f* should itself return an error value (usually ``NULL`` or "
"``-1``).  It should *not* call one of the ``PyErr_*`` functions --- one has "
"already been called by *g*. *f*'s caller is then supposed to also return an "
"error indication to *its* caller, again *without* calling ``PyErr_*``, and "
"so on --- the most detailed cause of the error was already reported by the "
"function that first detected it.  Once the error reaches the Python "
"interpreter's main loop, this aborts the currently executing Python code and "
"tries to find an exception handler specified by the Python programmer."
msgstr ""
"Lorsqu'une fonction *f* ayant appelé une autre fonction *g* détecte que "
"cette dernière a échoué, *f* devrait donner une valeur d'erreur à son tour "
"(habituellement ``NULL`` ou ``-1``). La fonction *f* ne devrait *pas* "
"appeler l'une des fonctions ``PyErr_*``, l'une d'entre elles ayant déjà été "
"appelée par *g*. La fonction appelant *f* est alors censée renvoyer aussi un "
"code d'erreur à celle qui l'a appelée, toujours sans utiliser ``PyErr_*``, "
"et ainsi de suite. La cause la plus détaillée de l'erreur a déjà été "
"signalée par la fonction l'ayant détecté en premier. Une fois l'erreur "
"remontée à la boucle principale de l'interpréteur Python, il interrompt le "
"code en cours d'exécution et essaie de trouver un gestionnaire d'exception "
"spécifié par le développeur Python."

#: extending/extending.rst:168
msgid ""
"(There are situations where a module can actually give a more detailed error "
"message by calling another ``PyErr_*`` function, and in such cases it is "
"fine to do so.  As a general rule, however, this is not necessary, and can "
"cause information about the cause of the error to be lost: most operations "
"can fail for a variety of reasons.)"
msgstr ""
"(Il y a des situations où un module peut effectivement donner un message "
"d'erreur plus détaillé en appelant une autre fonction ``PyErr_*`` et, dans "
"de tels cas, il est tout à fait possible de le faire. Cependant, ce n'est "
"généralement pas nécessaire, et peut amener à perdre des informations sur la "
"cause de l'erreur : la plupart des opérations peuvent échouer pour tout un "
"tas de raisons.)"

#: extending/extending.rst:174
msgid ""
"To ignore an exception set by a function call that failed, the exception "
"condition must be cleared explicitly by calling :c:func:`PyErr_Clear`.  The "
"only time C code should call :c:func:`PyErr_Clear` is if it doesn't want to "
"pass the error on to the interpreter but wants to handle it completely by "
"itself (possibly by trying something else, or pretending nothing went wrong)."
msgstr ""
"Pour ignorer une exception qui aurait été émise lors d'un appel de fonction "
"qui a échoué, l'exception doit être retirée explicitement en appelant :c:"
"func:`PyErr_Clear`. Le seul cas pour lequel du code C devrait appeler :c:"
"func:`PyErr_Clear` est lorsqu'il ne veut pas passer l'erreur à "
"l'interpréteur, mais souhaite la gérer lui-même (peut-être en essayant "
"quelque chose d'autre, ou en prétendant que rien n'a mal tourné)."

#: extending/extending.rst:180
msgid ""
"Every failing :c:func:`malloc` call must be turned into an exception --- the "
"direct caller of :c:func:`malloc` (or :c:func:`realloc`) must call :c:func:"
"`PyErr_NoMemory` and return a failure indicator itself.  All the object-"
"creating functions (for example, :c:func:`PyLong_FromLong`) already do this, "
"so this note is only relevant to those who call :c:func:`malloc` directly."
msgstr ""
"Chaque échec de :c:func:`malloc` doit être transformé en une exception, "
"l'appelant direct de :c:func:`malloc` (ou :c:func:`realloc`) doit appeler :c:"
"func:`PyErr_NoMemory` et prendre l'initiative de renvoyer une valeur "
"d'erreur. Toutes les fonctions construisant des objets (tels que :c:func:"
"`PyLong_FromLong`) le font déjà, donc cette note ne concerne que ceux qui "
"appellent :c:func:`malloc` directement."

#: extending/extending.rst:186
msgid ""
"Also note that, with the important exception of :c:func:`PyArg_ParseTuple` "
"and friends, functions that return an integer status usually return a "
"positive value or zero for success and ``-1`` for failure, like Unix system "
"calls."
msgstr ""
"Notez également que, à l'exception notable de :c:func:`PyArg_ParseTuple` et "
"compagnie, les fonctions qui renvoient leur statut sous forme d'entier "
"donnent généralement une valeur positive ou zéro en cas de succès et ``-1`` "
"en cas d'échec, comme les appels du système Unix."

#: extending/extending.rst:190
msgid ""
"Finally, be careful to clean up garbage (by making :c:func:`Py_XDECREF` or :"
"c:func:`Py_DECREF` calls for objects you have already created) when you "
"return an error indicator!"
msgstr ""
"Enfin, lorsque vous renvoyez un code d'erreur, n'oubliez pas faire un brin "
"de nettoyage (en appelant :c:func:`Py_XDECREF` ou :c:func:`Py_DECREF` avec "
"les objets que vous auriez déjà créés) !"

#: extending/extending.rst:194
msgid ""
"The choice of which exception to raise is entirely yours.  There are "
"predeclared C objects corresponding to all built-in Python exceptions, such "
"as :c:data:`PyExc_ZeroDivisionError`, which you can use directly. Of course, "
"you should choose exceptions wisely --- don't use :c:data:`PyExc_TypeError` "
"to mean that a file couldn't be opened (that should probably be :c:data:"
"`PyExc_IOError`). If something's wrong with the argument list, the :c:func:"
"`PyArg_ParseTuple` function usually raises :c:data:`PyExc_TypeError`.  If "
"you have an argument whose value must be in a particular range or must "
"satisfy other conditions, :c:data:`PyExc_ValueError` is appropriate."
msgstr ""
"Le choix de l'exception à lever vous incombe. Il existe des objets C "
"correspondant à chaque exception Python, tel que :c:data:"
"`PyExc_ZeroDivisionError`, que vous pouvez utiliser directement. Choisissez "
"judicieusement vos exceptions, typiquement n'utilisez pas :c:data:"
"`PyExc_TypeError` pour indiquer qu'un fichier n'a pas pu être ouvert (cela "
"devrait probablement être :c:data:`PyExc_IOError`). Si quelque chose ne va "
"pas avec la liste des arguments, la fonction :c:func:`PyArg_ParseTuple` lève "
"habituellement une exception :c:data:`PyExc_TypeError`. Mais si vous avez un "
"argument dont la valeur doit être dans un intervalle particulier ou qui doit "
"satisfaire d'autres conditions, :c:data:`PyExc_ValueError` sera plus "
"appropriée."

#: extending/extending.rst:204
msgid ""
"You can also define a new exception that is unique to your module. For this, "
"you usually declare a static object variable at the beginning of your file::"
msgstr ""
"Vous pouvez également créer une exception spécifique à votre module. Pour "
"cela, déclarez simplement une variable statique au début de votre fichier ::"

#: extending/extending.rst:209
msgid ""
"and initialize it in your module's initialization function (:c:func:"
"`PyInit_spam`) with an exception object::"
msgstr ""
"et initialisez-la dans la fonction d'initialisation de votre module (:c:func:"
"`PyInit_spam`) avec un objet exception ::"

#: extending/extending.rst:233
msgid ""
"Note that the Python name for the exception object is :exc:`spam.error`.  "
"The :c:func:`PyErr_NewException` function may create a class with the base "
"class being :exc:`Exception` (unless another class is passed in instead of "
"``NULL``), described in :ref:`bltin-exceptions`."
msgstr ""
"Notez que le nom de l'exception en Python est :exc:`spam.error`. La "
"fonction :c:func:`PyErr_NewException` peut créer une classe héritant de :exc:"
"`Exception` (à moins qu'une autre classe ne lui soit fournie à la place de "
"``NULL``), voir :ref:`bltin-exceptions`."

#: extending/extending.rst:238
msgid ""
"Note also that the :c:data:`!SpamError` variable retains a reference to the "
"newly created exception class; this is intentional!  Since the exception "
"could be removed from the module by external code, an owned reference to the "
"class is needed to ensure that it will not be discarded, causing :c:data:`!"
"SpamError` to become a dangling pointer. Should it become a dangling "
"pointer, C code which raises the exception could cause a core dump or other "
"unintended side effects."
msgstr ""
"Notez également que la variable :c:data:`!SpamError` contient une référence "
"à la nouvelle classe créée ; ceci est intentionnel ! Comme l'exception peut "
"être enlevée du module par du code externe, une référence à la classe est "
"nécessaire pour assurer qu'elle ne sera pas supprimée par le ramasse-"
"miettes, entraînant que :c:data:`!SpamError` devienne un pointeur dans le "
"vide. Si cela se produisait, le code C qui lève cette exception peut "
"engendrer un *core dump* ou des effets secondaires inattendus."

#: extending/extending.rst:245
msgid ""
"We discuss the use of ``PyMODINIT_FUNC`` as a function return type later in "
"this sample."
msgstr ""
"Nous traiterons de l'utilisation de ``PyMODINIT_FUNC`` comme type de renvoi "
"de fonction plus tard dans cette section."

#: extending/extending.rst:248
msgid ""
"The :exc:`spam.error` exception can be raised in your extension module using "
"a call to :c:func:`PyErr_SetString` as shown below::"
msgstr ""
"L'exception :exc:`spam.error` peut être levée dans votre module d'extension "
"en appelant :c:func:`PyErr_SetString` comme montré ci-dessous ::"

#: extending/extending.rst:271
msgid "Back to the Example"
msgstr "Retour vers l'exemple"

#: extending/extending.rst:273
msgid ""
"Going back to our example function, you should now be able to understand "
"this statement::"
msgstr ""
"En revenant vers notre fonction exemple, vous devriez maintenant être "
"capable de comprendre cette affirmation ::"

#: extending/extending.rst:279
msgid ""
"It returns ``NULL`` (the error indicator for functions returning object "
"pointers) if an error is detected in the argument list, relying on the "
"exception set by :c:func:`PyArg_ParseTuple`.  Otherwise the string value of "
"the argument has been copied to the local variable :c:data:`!command`.  This "
"is a pointer assignment and you are not supposed to modify the string to "
"which it points (so in Standard C, the variable :c:data:`!command` should "
"properly be declared as ``const char *command``)."
msgstr ""
"Elle renvoie ``NULL`` (l'indicateur d'erreur pour les fonctions renvoyant "
"des pointeurs d'objet) si une erreur est détectée dans la liste des "
"arguments, se fiant à l'exception définie par :c:func:`PyArg_ParseTuple`. "
"Autrement, la valeur chaîne de l'argument a été copiée dans la variable "
"locale :c:data:`!command`. Il s'agit d'une attribution de pointeur et vous "
"n'êtes pas supposés modifier la chaîne vers laquelle il pointe (donc en C "
"Standard, la variable :c:data:`!command` doit être clairement déclarée comme "
"``const char *command``)."

#: extending/extending.rst:287
msgid ""
"The next statement is a call to the Unix function :c:func:`system`, passing "
"it the string we just got from :c:func:`PyArg_ParseTuple`::"
msgstr ""
"La prochaine instruction est un appel à la fonction Unix :c:func:`system`, "
"en lui passant la chaîne que nous venons d'obtenir à partir de :c:func:"
"`PyArg_ParseTuple` ::"

#: extending/extending.rst:292
msgid ""
"Our :func:`!spam.system` function must return the value of :c:data:`!sts` as "
"a Python object.  This is done using the function :c:func:"
"`PyLong_FromLong`. ::"
msgstr ""
"Notre fonction :func:`!spam.system` doit renvoyer la valeur de :c:data:`!"
"sts` comme un objet Python. Cela est effectué par l'utilisation de la "
"fonction :c:func:`PyLong_FromLong`. ::"

#: extending/extending.rst:297
msgid ""
"In this case, it will return an integer object.  (Yes, even integers are "
"objects on the heap in Python!)"
msgstr ""
"Dans ce cas, elle renvoie un objet de type entier (oui, même les entiers "
"sont des objets, stockés dans le tas, en Python !)."

#: extending/extending.rst:300
msgid ""
"If you have a C function that returns no useful argument (a function "
"returning :c:expr:`void`), the corresponding Python function must return "
"``None``.   You need this idiom to do so (which is implemented by the :c:"
"macro:`Py_RETURN_NONE` macro)::"
msgstr ""
"Si vous avez une fonction C qui ne renvoie aucun argument utile (une "
"fonction renvoyant :c:expr:`void`), la fonction Python correspondante doit "
"renvoyer ``None``. Vous aurez besoin de cet idiome pour cela (qui est "
"implémenté par la macro :c:macro:`Py_RETURN_NONE`) ::"

#: extending/extending.rst:308
msgid ""
":c:data:`Py_None` is the C name for the special Python object ``None``.  It "
"is a genuine Python object rather than a ``NULL`` pointer, which means "
"\"error\" in most contexts, as we have seen."
msgstr ""
":c:data:`Py_None` est la dénomination en C pour l'objet spécial Python "
"``None``. C'est un authentique objet Python plutôt qu'un pointeur ``NULL`` "
"qui, dans la plupart des situations, signifie qu'une erreur est survenue "
"comme nous l'avons vu."

#: extending/extending.rst:316
msgid "The Module's Method Table and Initialization Function"
msgstr "La fonction d'initialisation et le tableau des méthodes du module"

#: extending/extending.rst:318
msgid ""
"I promised to show how :c:func:`spam_system` is called from Python programs. "
"First, we need to list its name and address in a \"method table\"::"
msgstr ""
"Nous avons promis de montrer comment :c:func:`spam_system` est appelée "
"depuis les programmes Python. D'abord, nous avons besoin d'avoir son nom et "
"son adresse dans un « tableau des méthodes » ::"

#: extending/extending.rst:329
msgid ""
"Note the third entry (``METH_VARARGS``).  This is a flag telling the "
"interpreter the calling convention to be used for the C function.  It should "
"normally always be ``METH_VARARGS`` or ``METH_VARARGS | METH_KEYWORDS``; a "
"value of ``0`` means that an obsolete variant of :c:func:`PyArg_ParseTuple` "
"is used."
msgstr ""
"Notez la troisième entrée (``METH_VARARGS``). C'est un indicateur du type de "
"convention à utiliser pour la fonction C, à destination de l'interpréteur. "
"Il doit valoir normalement ``METH_VARARGS`` ou ``METH_VARARGS | "
"METH_KEYWORDS`` ; la valeur ``0`` indique qu'une variante obsolète de :c:"
"func:`PyArg_ParseTuple` est utilisée."

#: extending/extending.rst:334
msgid ""
"When using only ``METH_VARARGS``, the function should expect the Python-"
"level parameters to be passed in as a tuple acceptable for parsing via :c:"
"func:`PyArg_ParseTuple`; more information on this function is provided below."
msgstr ""
"Si seulement ``METH_VARARGS`` est utilisé, la fonction s'attend à ce que les "
"paramètres Python soient passés comme un *n*-uplet que l'on peut analyser "
"*via* :c:func:`PyArg_ParseTuple` ; des informations supplémentaires sont "
"fournies plus bas."

#: extending/extending.rst:338
msgid ""
"The :c:macro:`METH_KEYWORDS` bit may be set in the third field if keyword "
"arguments should be passed to the function.  In this case, the C function "
"should accept a third ``PyObject *`` parameter which will be a dictionary of "
"keywords. Use :c:func:`PyArg_ParseTupleAndKeywords` to parse the arguments "
"to such a function."
msgstr ""
"Le bit :c:macro:`METH_KEYWORDS` peut être mis à un dans le troisième champ "
"si des arguments par mots-clés doivent être passés à la fonction. Dans ce "
"cas, la fonction C doit accepter un troisième paramètre ``PyObject *`` qui "
"est un dictionnaire des mots-clés. Utilisez :c:func:"
"`PyArg_ParseTupleAndKeywords` pour analyser les arguments d'une telle "
"fonction."

#: extending/extending.rst:344
msgid ""
"The method table must be referenced in the module definition structure::"
msgstr ""
"Le tableau des méthodes doit être référencé dans la structure de définition "
"du module ::"

#: extending/extending.rst:355
msgid ""
"This structure, in turn, must be passed to the interpreter in the module's "
"initialization function.  The initialization function must be named :c:func:"
"`PyInit_name`, where *name* is the name of the module, and should be the "
"only non-\\ ``static`` item defined in the module file::"
msgstr ""
"Cette structure, à son tour, doit être transmise à l'interpréteur dans la "
"fonction d'initialisation du module.  La fonction d'initialisation doit être "
"nommée :c:func:`PyInit_name`, où *nom* est le nom du module, et doit être le "
"seul élément non ``static`` défini dans le fichier du module ::"

#: extending/extending.rst:366
msgid ""
"Note that PyMODINIT_FUNC declares the function as ``PyObject *`` return "
"type, declares any special linkage declarations required by the platform, "
"and for C++ declares the function as ``extern \"C\"``."
msgstr ""
"Notez que *PyMODINIT_FUNC* déclare la fonction comme renvoyant un objet de "
"type ``PyObject *``, déclare également toute déclaration de liaison spéciale "
"requise par la plate-forme et, pour le C++, déclare la fonction comme "
"``extern C``."

#: extending/extending.rst:370
msgid ""
"When the Python program imports module :mod:`spam` for the first time, :c:"
"func:`PyInit_spam` is called. (See below for comments about embedding "
"Python.) It calls :c:func:`PyModule_Create`, which returns a module object, "
"and inserts built-in function objects into the newly created module based "
"upon the table (an array of :c:type:`PyMethodDef` structures) found in the "
"module definition. :c:func:`PyModule_Create` returns a pointer to the module "
"object that it creates.  It may abort with a fatal error for certain errors, "
"or return ``NULL`` if the module could not be initialized satisfactorily. "
"The init function must return the module object to its caller, so that it "
"then gets inserted into ``sys.modules``."
msgstr ""
"Lorsque le programme Python importe le module :mod:`spam` pour la première "
"fois, :c:func:`PyInit_spam` est appelée (voir ci-dessous pour les "
"commentaires sur l'intégration en Python). Elle appelle :c:func:"
"`PyModule_Create`, qui renvoie un objet module et insère des objets fonction "
"intégrés dans le module nouvellement créé en se basant sur le tableau (un "
"tableau de structures :c:type:`PyMethodDef`) trouvée dans la définition du "
"module. :c:func:`PyModule_Create` renvoie un pointeur vers l'objet module "
"qu'il crée. Elle peut s'interrompre avec une erreur fatale pour certaines "
"erreurs, ou renvoyer ``NULL`` si le module n'a pas pu être initialisé de "
"manière satisfaisante. La fonction *init* doit renvoyer l'objet module à son "
"appelant, afin qu'il soit ensuite inséré dans ``sys.modules``."

#: extending/extending.rst:381
msgid ""
"When embedding Python, the :c:func:`PyInit_spam` function is not called "
"automatically unless there's an entry in the :c:data:`PyImport_Inittab` "
"table. To add the module to the initialization table, use :c:func:"
"`PyImport_AppendInittab`, optionally followed by an import of the module::"
msgstr ""
"Lors de l'intégration de Python, la fonction :c:func:`PyInit_spam` n'est pas "
"appelée automatiquement, sauf s'il y a une entrée dans la table :c:data:"
"`PyImport_Inittab`. Pour ajouter le module au tableau d'initialisation, "
"utilisez :c:func:`PyImport_AppendInittab`, suivie éventuellement d'une "
"importation du module ::"

# suit un :
#: extending/extending.rst:425
msgid ""
"Removing entries from ``sys.modules`` or importing compiled modules into "
"multiple interpreters within a process (or following a :c:func:`fork` "
"without an intervening :c:func:`exec`) can create problems for some "
"extension modules. Extension module authors should exercise caution when "
"initializing internal data structures."
msgstr ""
"supprimer des entrées de ``sys.modules`` ou importer des modules compilés "
"dans plusieurs interpréteurs au sein d'un même processus (ou le faire à la "
"suite d'un :c:func:`fork` sans un :c:func:`exec` préalable) peut créer des "
"problèmes pour certains modules d'extension. Les auteurs de modules "
"d'extension doivent faire preuve de prudence lorsqu'ils initialisent des "
"structures de données internes."

#: extending/extending.rst:431
msgid ""
"A more substantial example module is included in the Python source "
"distribution as :file:`Modules/xxmodule.c`.  This file may be used as a  "
"template or simply read as an example."
msgstr ""
"Un exemple de module plus substantiel est inclus dans la distribution des "
"sources Python sous le nom :file:`Modules/xxmodule.c`. Ce fichier peut être "
"utilisé comme modèle ou simplement lu comme exemple."

# suit un :
#: extending/extending.rst:437
msgid ""
"Unlike our ``spam`` example, ``xxmodule`` uses *multi-phase initialization* "
"(new in Python 3.5), where a PyModuleDef structure is returned from "
"``PyInit_spam``, and creation of the module is left to the import machinery. "
"For details on multi-phase initialization, see :PEP:`489`."
msgstr ""
"contrairement à notre exemple de ``spam``, ``xxmodule`` utilise une "
"*initialisation multi-phases* (nouveau en Python 3.5), où une structure "
"*PyModuleDef* est renvoyée à partir de ``PyInit_spam``, et la création du "
"module est laissée au mécanisme d'importation. Pour plus de détails sur "
"l'initialisation multi-phases, voir :PEP:`489`."

#: extending/extending.rst:446
msgid "Compilation and Linkage"
msgstr "Compilation et liaison"

#: extending/extending.rst:448
msgid ""
"There are two more things to do before you can use your new extension: "
"compiling and linking it with the Python system.  If you use dynamic "
"loading, the details may depend on the style of dynamic loading your system "
"uses; see the chapters about building extension modules (chapter :ref:"
"`building`) and additional information that pertains only to building on "
"Windows (chapter :ref:`building-on-windows`) for more information about this."
msgstr ""
"Il y a encore deux choses à faire avant de pouvoir utiliser votre nouvelle "
"extension : la compiler et la lier au système Python. Si vous utilisez le "
"chargement dynamique, les détails peuvent dépendre du style de chargement "
"dynamique utilisé par votre système ; voir les chapitres sur la compilation "
"de modules d'extension (chapitre :ref:`building`) et les informations "
"supplémentaires concernant uniquement la construction sous Windows "
"(chapitre :ref:`building-on-windows`) pour plus d'informations à ce sujet."

#: extending/extending.rst:455
msgid ""
"If you can't use dynamic loading, or if you want to make your module a "
"permanent part of the Python interpreter, you will have to change the "
"configuration setup and rebuild the interpreter.  Luckily, this is very "
"simple on Unix: just place your file (:file:`spammodule.c` for example) in "
"the :file:`Modules/` directory of an unpacked source distribution, add a "
"line to the file :file:`Modules/Setup.local` describing your file:"
msgstr ""
"Si vous ne pouvez pas utiliser le chargement dynamique, ou si vous voulez "
"faire de votre module une partie permanente de l'interpréteur Python, vous "
"devez modifier la configuration et reconstruire l'interpréteur. "
"Heureusement, c'est très simple sous Unix : placez simplement votre fichier "
"(:file:`spammodule.c` par exemple) dans le répertoire :file:`Modules/` d'une "
"distribution source décompressée, ajoutez une ligne au fichier :file:"
"`Modules/Setup.local` décrivant votre fichier :"

#: extending/extending.rst:466
msgid ""
"and rebuild the interpreter by running :program:`make` in the toplevel "
"directory.  You can also run :program:`make` in the :file:`Modules/` "
"subdirectory, but then you must first rebuild :file:`Makefile` there by "
"running ':program:`make` Makefile'.  (This is necessary each time you change "
"the :file:`Setup` file.)"
msgstr ""
"et reconstruisez l'interpréteur en exécutant :program:`make` dans le "
"répertoire de niveau supérieur. Vous pouvez également exécuter :program:"
"`make` dans le sous-répertoire :file:`Modules/`, mais vous devez d'abord "
"reconstruire le :file:`Makefile` en exécutant « :program:`make` "
"Makefile » (c'est nécessaire chaque fois que vous modifiez le fichier :file:"
"`Setup`)."

#: extending/extending.rst:472
msgid ""
"If your module requires additional libraries to link with, these can be "
"listed on the line in the configuration file as well, for instance:"
msgstr ""
"Si votre module nécessite d'être lié à des bibliothèques supplémentaires, "
"celles-ci peuvent être ajoutées à la fin de la ligne de votre module dans le "
"fichier de configuration, par exemple :"

#: extending/extending.rst:483
msgid "Calling Python Functions from C"
msgstr "Appeler des fonctions Python en C"

#: extending/extending.rst:485
msgid ""
"So far we have concentrated on making C functions callable from Python.  The "
"reverse is also useful: calling Python functions from C. This is especially "
"the case for libraries that support so-called \"callback\" functions.  If a "
"C interface makes use of callbacks, the equivalent Python often needs to "
"provide a callback mechanism to the Python programmer; the implementation "
"will require calling the Python callback functions from a C callback.  Other "
"uses are also imaginable."
msgstr ""
"Jusqu'à présent, nous nous sommes concentrés sur le fait de rendre les "
"fonctions C appelables depuis Python. L'inverse est également utile : "
"appeler des fonctions Python depuis C. C'est notamment le cas pour les "
"bibliothèques qui gèrent les fonctions dites de « rappel » (*callback* en "
"anglais). Si une interface C utilise des rappels, l'équivalent Python doit "
"souvent fournir un mécanisme de rappel au développeur Python ; "
"l'implémentation nécessite d'appeler les fonctions de rappel Python à partir "
"d'un rappel C. D'autres utilisations sont également envisageables."

#: extending/extending.rst:493
msgid ""
"Fortunately, the Python interpreter is easily called recursively, and there "
"is a standard interface to call a Python function.  (I won't dwell on how to "
"call the Python parser with a particular string as input --- if you're "
"interested, have a look at the implementation of the :option:`-c` command "
"line option in :file:`Modules/main.c` from the Python source code.)"
msgstr ""
"Heureusement, l'interpréteur Python est facilement appelé de manière "
"récursive et il existe une interface standard pour appeler une fonction "
"Python (nous ne nous attarderons pas sur la façon d'appeler l'analyseur "
"Python avec une chaîne particulière en entrée — si vous êtes intéressé, "
"jetez un œil à l'implémentation de l'option de ligne de commande :option:`-"
"c` dans :file:`Modules/main.c` à partir du code source Python)."

#: extending/extending.rst:499
msgid ""
"Calling a Python function is easy.  First, the Python program must somehow "
"pass you the Python function object.  You should provide a function (or some "
"other interface) to do this.  When this function is called, save a pointer "
"to the Python function object (be careful to :c:func:`Py_INCREF` it!) in a "
"global variable --- or wherever you see fit. For example, the following "
"function might be part of a module definition::"
msgstr ""
"L'appel d'une fonction Python est facile. Tout d'abord, le programme Python "
"doit vous transmettre d'une manière ou d'une autre l'objet de fonction "
"Python. Vous devez fournir une fonction (ou une autre interface) pour ce "
"faire. Lorsque cette fonction est appelée, enregistrez un pointeur vers "
"l'objet de la fonction Python (faites attention à :c:func:`Py_INCREF` !) "
"dans une variable globale — ou là où vous le souhaitez. Par exemple, la "
"fonction suivante peut faire partie d'une définition de module ::"

#: extending/extending.rst:529
msgid ""
"This function must be registered with the interpreter using the :c:macro:"
"`METH_VARARGS` flag; this is described in section :ref:`methodtable`.  The :"
"c:func:`PyArg_ParseTuple` function and its arguments are documented in "
"section :ref:`parsetuple`."
msgstr ""
"Cette fonction doit être déclarée en utilisant le drapeau :c:macro:"
"`METH_VARARGS` ; ceci est décrit dans la section :ref:`methodtable`.  La "
"fonction :c:func:`PyArg_ParseTuple` et ses arguments sont documentés dans la "
"section :ref:`parsetuple`."

#: extending/extending.rst:534
msgid ""
"The macros :c:func:`Py_XINCREF` and :c:func:`Py_XDECREF` increment/decrement "
"the reference count of an object and are safe in the presence of ``NULL`` "
"pointers (but note that *temp* will not be  ``NULL`` in this context).  More "
"info on them in section :ref:`refcounts`."
msgstr ""
"Les macros :c:func:`Py_XINCREF` et :c:func:`Py_XDECREF` incrémentent/"
"décrémentent le compteur des références d'un objet et sont sûres quant à la "
"présence de pointeurs ``NULL`` (mais notez que *temp* ne sera pas ``NULL`` "
"dans ce contexte).  Plus d'informations à ce sujet dans la section :ref:"
"`refcounts`."

#: extending/extending.rst:541
msgid ""
"Later, when it is time to call the function, you call the C function :c:func:"
"`PyObject_CallObject`.  This function has two arguments, both pointers to "
"arbitrary Python objects: the Python function, and the argument list.  The "
"argument list must always be a tuple object, whose length is the number of "
"arguments.  To call the Python function with no arguments, pass in ``NULL``, "
"or an empty tuple; to call it with one argument, pass a singleton tuple. :c:"
"func:`Py_BuildValue` returns a tuple when its format string consists of zero "
"or more format codes between parentheses.  For example::"
msgstr ""
"Plus tard, quand il est temps d'appeler la fonction, vous appelez la "
"fonction C :c:func:`PyObject_CallObject`. Cette fonction requiert deux "
"arguments, tous deux des pointeurs vers des objets Python arbitraires : la "
"fonction Python et la liste d'arguments. La liste d'arguments doit toujours "
"être un objet *n*-uplet, dont la longueur est le nombre d'arguments. Pour "
"appeler la fonction Python sans argument, passez ``NULL`` ou le *n*-uplet "
"vide ; pour l'appeler avec un argument, passez un *n*-uplet singleton. :c:"
"func:`Py_BuildValue` renvoie un *n*-uplet lorsque sa chaîne de format se "
"compose de zéro ou plusieurs codes de format entre parenthèses. Par "
"exemple ::"

#: extending/extending.rst:561
msgid ""
":c:func:`PyObject_CallObject` returns a Python object pointer: this is the "
"return value of the Python function.  :c:func:`PyObject_CallObject` is "
"\"reference-count-neutral\" with respect to its arguments.  In the example a "
"new tuple was created to serve as the argument list, which is :c:func:"
"`Py_DECREF`\\ -ed immediately after the :c:func:`PyObject_CallObject` call."
msgstr ""
":c:func:`PyObject_CallObject` renvoie un pointeur d'objet Python : c'est la "
"valeur de retour de la fonction Python. :c:func:`PyObject_CallObject` est "
"« neutre en nombre de références » par rapport à ses arguments. Dans "
"l'exemple, un nouveau *n*-uplet a été créé pour servir de liste d'arguments, "
"qui est décrémenté (avec :c:func:`Py_DECREF`) immédiatement après l'appel :c:"
"func:`PyObject_CallObject`."

#: extending/extending.rst:568
msgid ""
"The return value of :c:func:`PyObject_CallObject` is \"new\": either it is a "
"brand new object, or it is an existing object whose reference count has been "
"incremented.  So, unless you want to save it in a global variable, you "
"should somehow :c:func:`Py_DECREF` the result, even (especially!) if you are "
"not interested in its value."
msgstr ""
"La valeur de retour de :c:func:`PyObject_CallObject` est « nouvelle » : soit "
"c'est un tout nouvel objet, soit c'est un objet existant dont le nombre de "
"références a été incrémenté. Donc, à moins que vous ne vouliez l'enregistrer "
"dans une variable globale, vous devriez en quelque sorte décrémenter avec :c:"
"func:`Py_DECREF` le résultat, même (surtout !) si vous n'êtes pas intéressé "
"par sa valeur."

#: extending/extending.rst:574
msgid ""
"Before you do this, however, it is important to check that the return value "
"isn't ``NULL``.  If it is, the Python function terminated by raising an "
"exception. If the C code that called :c:func:`PyObject_CallObject` is called "
"from Python, it should now return an error indication to its Python caller, "
"so the interpreter can print a stack trace, or the calling Python code can "
"handle the exception. If this is not possible or desirable, the exception "
"should be cleared by calling :c:func:`PyErr_Clear`.  For example::"
msgstr ""
"Mais avant de le faire, il est important de vérifier que la valeur renvoyée "
"n'est pas ``NULL``.  Si c'est le cas, la fonction Python s'est terminée par "
"une levée d'exception. Si le code C qui a appelé :c:func:"
"`PyObject_CallObject` est appelé depuis Python, il devrait maintenant "
"renvoyer une indication d'erreur à son appelant Python, afin que "
"l'interpréteur puisse afficher la pile d'appels, ou que le code Python "
"appelant puisse gérer l'exception. Si cela n'est pas possible ou "
"souhaitable, l'exception doit être effacée en appelant :c:func:"
"`PyErr_Clear`. Par exemple ::"

#: extending/extending.rst:587
msgid ""
"Depending on the desired interface to the Python callback function, you may "
"also have to provide an argument list to :c:func:`PyObject_CallObject`.  In "
"some cases the argument list is also provided by the Python program, through "
"the same interface that specified the callback function.  It can then be "
"saved and used in the same manner as the function object.  In other cases, "
"you may have to construct a new tuple to pass as the argument list.  The "
"simplest way to do this is to call :c:func:`Py_BuildValue`.  For example, if "
"you want to pass an integral event code, you might use the following code::"
msgstr ""
"Selon l'interface souhaitée pour la fonction de rappel Python, vous devrez "
"peut-être aussi fournir une liste d'arguments à :c:func:"
"`PyObject_CallObject`. Dans certains cas, la liste d'arguments est également "
"fournie par le programme Python, par l'intermédiaire de la même interface "
"qui a spécifié la fonction de rappel. Elle peut alors être sauvegardée et "
"utilisée de la même manière que l'objet fonction. Dans d'autres cas, vous "
"pouvez avoir à construire un nouveau *n*-uplet à passer comme liste "
"d'arguments. La façon la plus simple de faire cela est d'appeler :c:func:"
"`Py_BuildValue`. Par exemple, si vous voulez passer un code d'événement "
"intégral, vous pouvez utiliser le code suivant ::"

#: extending/extending.rst:606
msgid ""
"Note the placement of ``Py_DECREF(arglist)`` immediately after the call, "
"before the error check!  Also note that strictly speaking this code is not "
"complete: :c:func:`Py_BuildValue` may run out of memory, and this should be "
"checked."
msgstr ""
"Notez la présence de ``Py_DECREF(arglist)`` immédiatement après l'appel, "
"avant la vérification des erreurs ! Notez également qu'à proprement parler, "
"ce code n'est pas complet : :c:func:`Py_BuildValue` peut manquer de mémoire, "
"et cela doit être vérifié."

#: extending/extending.rst:610
msgid ""
"You may also call a function with keyword arguments by using :c:func:"
"`PyObject_Call`, which supports arguments and keyword arguments.  As in the "
"above example, we use :c:func:`Py_BuildValue` to construct the dictionary. ::"
msgstr ""
"Vous pouvez également appeler une fonction avec des arguments nommés en "
"utilisant :c:func:`PyObject_Call`, qui accepte les arguments et les "
"arguments nommés. Comme dans l'exemple ci-dessus, nous utilisons :c:func:"
"`Py_BuildValue` pour construire le dictionnaire. ::"

#: extending/extending.rst:628
msgid "Extracting Parameters in Extension Functions"
msgstr "Extraire des paramètres dans des fonctions d'extension"

#: extending/extending.rst:632
msgid "The :c:func:`PyArg_ParseTuple` function is declared as follows::"
msgstr "La fonction :c:func:`PyArg_ParseTuple` est déclarée ainsi ::"

#: extending/extending.rst:636
msgid ""
"The *arg* argument must be a tuple object containing an argument list passed "
"from Python to a C function.  The *format* argument must be a format string, "
"whose syntax is explained in :ref:`arg-parsing` in the Python/C API "
"Reference Manual.  The remaining arguments must be addresses of variables "
"whose type is determined by the format string."
msgstr ""