# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2016, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.6\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2018-04-29 00:24+0200\n"

"PO-Revision-Date: 2018-05-08 17:12+0200\n"

"Last-Translator: Julien Palard <julien@palard.fr>\n"

"Language-Team: \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.0.4\n"

#: ../Doc/extending/extending.rst:8

msgid "Extending Python with C or C++"

msgstr "Étendre Python en C ou C++"

#: ../Doc/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> extension modules` "

"permettent deux choses qui ne sont pas possible directement en Python: Elles "

"peuvent définir de nouveaux types natifs, et peuvent appeler des fonctions "

"de bibliothèques C ou appels systèmes."

#: ../Doc/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\"``."

#: ../Doc/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."

#: ../Doc/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.org>`_ 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 fonctionne 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.org>`_ 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."

#: ../Doc/extending/extending.rst:39

msgid "A Simple Example"

msgstr "Un exemple simple"

#: ../Doc/extending/extending.rst:41

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 terminée par NULL comme argument et renvoie "

"un entier. Nous voulons que cette fonction soit appelable à partir de Python "

"comme suit :"

#: ../Doc/extending/extending.rst:52

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

"Commencez 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`.)"

#: ../Doc/extending/extending.rst:57

msgid "The first line of our file can be::"

msgstr "La première ligne de notre fichier peut être : ::"

#: ../Doc/extending/extending.rst:61

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

#: ../Doc/extending/extending.rst:66

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

"Python pouvant définir certaines définitions pré-processeur qui affectent "

"les têtes standard sur certains systèmes, vous *devez* inclure :file:`Python."

"h` avant les en-têtes standards."

#: ../Doc/extending/extending.rst:70

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 standard. Pour le "

"confort, et comme ils sont largement utilisés par l'interpréteur Python, ``"

"\"Python.h\"`` inclut lui même quelques d'en-têtes standard : ``<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."

#: ../Doc/extending/extending.rst:78

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

#: ../Doc/extending/extending.rst:94

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

#: ../Doc/extending/extending.rst:99

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

#: ../Doc/extending/extending.rst:102

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 *tuple* Python contenant les "

"arguments. Chaque élément du *tuple* 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 en verront plus, plus tard."

#: ../Doc/extending/extending.rst:111

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 données. Il 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)."

#: ../Doc/extending/extending.rst:121

msgid "Intermezzo: Errors and Exceptions"

msgstr "Intermezzo: Les erreurs et exceptions"

#: ../Doc/extending/extending.rst:123

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 a *NULL* pointer). Exceptions are stored in a static "

"global variable inside the interpreter; if this variable is *NULL* no "

"exception has occurred. A second global variable stores the \"associated "

"value\" of the exception (the second argument to :keyword:`raise`). A third "

"variable contains the stack traceback in case the error originated in Python "

"code. These three variables are the C equivalents of the result in Python "

"of :meth:`sys.exc_info` (see the section on module :mod:`sys` in the Python "

"Library Reference). It is important to know about them to understand how "

"errors are passed around."

msgstr ""

"Une convention primordiale imprégnant tout l'interpréteur Python est: quand "

"une fonction échoue, elle devrait laisser une exception et renvoyer une "

"valeur d'erreur (typiquement un pointeur *NULL*). Dans l'interpréteur, les "

"exceptions sont stockés dans une variable globale statique, si cette "

"variable est *NULL*, aucune exception n'a eu lieu. Une seconde variable "

"globale stocke la \"valeur associée\" à l'exception (le deuxième argument "

"de :keyword:`raise`). Une troisième variable contient la trace de la pile "

"dans le cas où l'erreur soit survenue dans du code Python. Ces trois "

"variables sont les équivalents C du résultat de :meth:`sys.exc_info` en "

"Python (voir la section sur le module :mod:`sys` dans *The Python Library "

"Reference*). Il est important de les connaître pour comprendre comment les "

"erreurs sont propagées."

#: ../Doc/extending/extending.rst:134

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

#: ../Doc/extending/extending.rst:136

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

#: ../Doc/extending/extending.rst:142

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

#: ../Doc/extending/extending.rst:149

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 de retour."

#: ../Doc/extending/extending.rst:155

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 :c:func:`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 :c:func:`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``). *f* ne devrait *pas* appeler l'une des "

"fonctions :c:func:`PyErr_\\*`, l'une d'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 :c:func:`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ée 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."

#: ../Doc/extending/extending.rst:165

msgid ""

"(There are situations where a module can actually give a more detailed error "

"message by calling another :c:func:`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 :c:func:`PyErr_\\*`, "

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

#: ../Doc/extending/extending.rst:171

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 aurait é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é)."

#: ../Doc/extending/extending.rst:177

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

#: ../Doc/extending/extending.rst:183

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

#: ../Doc/extending/extending.rst:187

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

#: ../Doc/extending/extending.rst:191

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

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

#: ../Doc/extending/extending.rst:201

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

#: ../Doc/extending/extending.rst:206

msgid ""

"and initialize it in your module's initialization function (:c:func:"

"`PyInit_spam`) with an exception object (leaving out the error checking for "

"now)::"

msgstr ""

"et initialisez-la dans la fonction d'initialisation de votre module (:c:func:"

"`PyInit_spam`) avec un objet exception (Passons, pour le moment, la "

"vérification des codes d'erreur) ::"

#: ../Doc/extending/extending.rst:224

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 exception, côté 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`."

#: ../Doc/extending/extending.rst:229

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 "

"retirée du module par un code externe, une référence à la classe est "

"nécessaire pour assurer qu'il ne sera pas rejeté, causant :c:data:"

"`SpamError` à devenir un pointeur défaillant. S'il devenait un pointeur "

"défaillant, le C code qui lève l'exception peut engendrer un rejet central "

"ou des effets secondaires inattendus."

#: ../Doc/extending/extending.rst:236

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 un type de "

"retour de fonction plus tard dans cette section."

#: ../Doc/extending/extending.rst:239

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

#: ../Doc/extending/extending.rst:262

msgid "Back to the Example"

msgstr "Retour vers l'exemple"

#: ../Doc/extending/extending.rst:264

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

#: ../Doc/extending/extending.rst:270

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 qui vers laquelle il pointe (donc en C Standard, "

"la variable :c:data:`command` doit être clairement déclarée comme ``const "

"char *command``)."

#: ../Doc/extending/extending.rst:278

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

#: ../Doc/extending/extending.rst:283

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`. ::"

#: ../Doc/extending/extending.rst:288

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 renverra un objet entier. (Oui, même les entiers sont des "

"objets dans le tas en Python!)"

#: ../Doc/extending/extending.rst:291

msgid ""

"If you have a C function that returns no useful argument (a function "

"returning :c:type:`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:type:`void`), la fonction Python correspondante doit "

"renvoyer ``None``. Vous aurez besoin de cette locution pour cela (qui est "

"implémentée par la macro :c:macro:`Py_RETURN_NONE`) ::"

#: ../Doc/extending/extending.rst:299

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 le nom C pour l'objet spécial Python ``None``. C'est "

"un authentique objet Python plutôt qu'un pointeur *NULL*, qui signifie "

"qu'une erreur est survenue, dans la plupart des situations, comme nous "

"l'avons vu."

#: ../Doc/extending/extending.rst:307

msgid "The Module's Method Table and Initialization Function"

msgstr "La fonction d'initialisation et le tableau des méthodes du module"

#: ../Doc/extending/extending.rst:309

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

#: ../Doc/extending/extending.rst:320

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

#: ../Doc/extending/extending.rst:325

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

#: ../Doc/extending/extending.rst:329

msgid ""

"The :const:`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 :const:`METH_KEYWORDS` peut être mis à un dans le troisième champ si "

"des arguments par mot-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."

#: ../Doc/extending/extending.rst:335

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

#: ../Doc/extending/extending.rst:346

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

#: ../Doc/extending/extending.rst:357

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 *``, et déclare également toute déclaration de liaison "

"spéciale requise par la plate-forme, et pour le C++ déclare la fonction "

"comme un C ``extern``."

#: ../Doc/extending/extending.rst:361

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

#: ../Doc/extending/extending.rst:372

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 à la table d'initialisation, "

"utilisez :c:func:`PyImport_AppendInittab`, suivi éventuellement d'une "

"importation du module ::"

#: ../Doc/extending/extending.rst:408

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 processus (ou suivre un :c:func:"

"`fork` sans l'intervention d'un :c:func:`exec`) 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."

#: ../Doc/extending/extending.rst:414

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

#: ../Doc/extending/extending.rst:420

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-phase* (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-phase, voir :PEP:`489`."

#: ../Doc/extending/extending.rst:429

msgid "Compilation and Linkage"

msgstr "Compilation et liaison"

#: ../Doc/extending/extending.rst:431

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

#: ../Doc/extending/extending.rst:438

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

#: ../Doc/extending/extending.rst:449

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

#: ../Doc/extending/extending.rst:455

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

#: ../Doc/extending/extending.rst:466

msgid "Calling Python Functions from C"

msgstr "Appeler des fonctions Python en C"

#: ../Doc/extending/extending.rst:468

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

#: ../Doc/extending/extending.rst:476

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

#: ../Doc/extending/extending.rst:482

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

#: ../Doc/extending/extending.rst:512

msgid ""

"This function must be registered with the interpreter using the :const:"

"`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 :const:"

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

#: ../Doc/extending/extending.rst:517

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

#: ../Doc/extending/extending.rst:524

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

#: ../Doc/extending/extending.rst:544

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

#: ../Doc/extending/extending.rst:550

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

#: ../Doc/extending/extending.rst:556

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

#: ../Doc/extending/extending.rst:569

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

#: ../Doc/extending/extending.rst:588

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

#: ../Doc/extending/extending.rst:592

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

#: ../Doc/extending/extending.rst:610

msgid "Extracting Parameters in Extension Functions"

msgstr "Extraire des paramètres dans des fonctions d'extension"

#: ../Doc/extending/extending.rst:614

msgid "The :c:func:`PyArg_ParseTuple` function is declared as follows::"

msgstr "La fonction :c:func:`PyArg_ParseTuple` est déclarée ainsi ::"

#: ../Doc/extending/extending.rst:618

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

#: ../Doc/extending/extending.rst:624

msgid ""

"Note that while :c:func:`PyArg_ParseTuple` checks that the Python arguments "

"have the required types, it cannot check the validity of the addresses of C "

"variables passed to the call: if you make mistakes there, your code will "

"probably crash or at least overwrite random bits in memory. So be careful!"

msgstr ""

#: ../Doc/extending/extending.rst:629

msgid ""

"Note that any Python object references which are provided to the caller are "

"*borrowed* references; 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 !"

#: ../Doc/extending/extending.rst:632

msgid "Some example calls::"

msgstr "Quelques exemples d'appels ::"

#: ../Doc/extending/extending.rst:702

msgid "Keyword Parameters for Extension Functions"

msgstr "Paramètres nommés pour des fonctions d'extension"

#: ../Doc/extending/extending.rst:706

msgid ""

"The :c:func:`PyArg_ParseTupleAndKeywords` function is declared as follows::"

msgstr ""

"La fonction :c:func:`PyArg_ParseTupleAndKeywords` est déclarée ainsi ::"

#: ../Doc/extending/extending.rst:711

msgid ""

"The *arg* and *format* parameters are identical to those of the :c:func:"

"`PyArg_ParseTuple` function. The *kwdict* parameter is the dictionary of "

"keywords received as the third parameter from the Python runtime. The "

"*kwlist* parameter is a *NULL*-terminated list of strings which identify the "

"parameters; the names are matched with the type information from *format* "

"from left to right. On success, :c:func:`PyArg_ParseTupleAndKeywords` "

"returns true, otherwise it returns false and raises an appropriate exception."

msgstr ""

#: ../Doc/extending/extending.rst:721

msgid ""

"Nested tuples cannot be parsed when using keyword arguments! Keyword "

"parameters passed in which are not present in the *kwlist* will cause :exc:"

"`TypeError` to be raised."

msgstr ""

"Les n-uplets imbriqués ne peuvent pas être traités lorsqu'on utilise des "

"arguments de type mot-clé ! Ceux-ci doivent apparaître dans dans *kwlist*, "

"dans le cas contraire une exception :exc:`TypeError` est levée."

#: ../Doc/extending/extending.rst:727

msgid ""

"Here is an example module which uses keywords, based on an example by Geoff "

"Philbrick (philbrick@hks.com)::"

msgstr ""

"Voici un exemple de module qui utilise des mots-clés, basé sur un exemple de "

"*Geoff Philbrick* (philbrick@hks.com) ::"

#: ../Doc/extending/extending.rst:781

msgid "Building Arbitrary Values"

msgstr "Créer des valeurs arbitraires"

#: ../Doc/extending/extending.rst:783

msgid ""

"This function is the counterpart to :c:func:`PyArg_ParseTuple`. It is "

"declared as follows::"

msgstr ""

"Cette fonction est le complément de :c:func:`PyArg_ParseTuple`. Elle est "

"déclarée comme suit ::"

#: ../Doc/extending/extending.rst:788

msgid ""

"It recognizes a set of format units similar to the ones recognized by :c:"

"func:`PyArg_ParseTuple`, but the arguments (which are input to the function, "

"not output) must not be pointers, just values. It returns a new Python "

"object, suitable for returning from a C function called from Python."

msgstr ""

"Il reconnaît un ensemble d'unités de format similaires à celles reconnues "

"par :c:func:`PyArg_ParseTuple`, mais les arguments (qui sont les données en "

"entrée de fonction, et non de la sortie) ne doivent pas être des pointeurs, "

"mais juste des valeurs. Il renvoie un nouvel objet Python, adapté pour être "

"renvoyé par une fonction C appelée depuis Python."

#: ../Doc/extending/extending.rst:793

msgid ""

"One difference with :c:func:`PyArg_ParseTuple`: while the latter requires "

"its first argument to be a tuple (since Python argument lists are always "

"represented as tuples internally), :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 ""

#: ../Doc/extending/extending.rst:801