From 6e3ce23f62bb0e632cfa9f46a1090dcfff1e7213 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sun, 26 Nov 2023 15:15:52 +0000 Subject: [PATCH] =?UTF-8?q?traduction=20du=20d=C3=A9but=20du=20dossier=20e?= =?UTF-8?q?xtending=20(#173)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Julien Palard Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/173 Reviewed-by: Julien Palard Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- extending/extending.po | 601 ++++++++++++++++++++++++++--------------- 1 file changed, 389 insertions(+), 212 deletions(-) diff --git a/extending/extending.po b/extending/extending.po index 080dfb49..dc48505b 100644 --- a/extending/extending.po +++ b/extending/extending.po @@ -6,14 +6,14 @@ 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-07-21 12:48+0200\n" -"Last-Translator: Julien Palard \n" +"PO-Revision-Date: 2023-11-26 10:23+0100\n" +"Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \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.3\n" +"X-Generator: Poedit 3.2.2\n" #: extending/extending.rst:8 msgid "Extending Python with C or C++" @@ -27,10 +27,10 @@ msgid "" "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:` extension modules` " -"permettent deux choses qui ne sont pas possibles directement en Python : " -"Elles peuvent définir de nouveaux types natifs, et peuvent appeler des " -"fonctions de bibliothèques C ou faire des appels systèmes." +"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 "" @@ -42,7 +42,7 @@ 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\"``." +"incorporée dans un fichier source C en incluant l'en-tête ``Python.h``." #: extending/extending.rst:20 msgid "" @@ -53,6 +53,7 @@ msgstr "" "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 " @@ -65,15 +66,15 @@ msgid "" "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 " +"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* `_ 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 " +"d'utiliser la bibliothèque `cffi `_ 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." @@ -90,10 +91,10 @@ msgid "" "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 " +"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 @@ -103,10 +104,10 @@ msgid "" "`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 " +"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`.)" +"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::" @@ -120,15 +121,16 @@ 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 "" -"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." +"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 "" @@ -150,9 +152,9 @@ msgid "" "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 " +"``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 d'en-têtes standard : ````, ````, ```` et ````. 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." @@ -207,7 +209,7 @@ msgstr "" "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." +"converties. Nous approfondirons ceci plus tard." #: extending/extending.rst:116 msgid "" @@ -220,17 +222,16 @@ msgid "" 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. 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)." +"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" +msgstr "Intermezzo : les erreurs et les exceptions" #: extending/extending.rst:128 -#, fuzzy msgid "" "An important convention throughout the Python interpreter is the following: " "when a function fails, it should set an exception condition and return an " @@ -241,18 +242,15 @@ msgid "" "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 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ées 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." +"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 "" @@ -274,7 +272,7 @@ msgstr "" "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." +"que « valeur associée » à l'exception." #: extending/extending.rst:145 msgid "" @@ -307,7 +305,6 @@ msgstr "" "de le déterminer à partir de la valeur renvoyée." #: extending/extending.rst:158 -#, fuzzy 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 " @@ -322,17 +319,16 @@ 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 :c:func:`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 :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é 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." +"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 -#, fuzzy 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 " @@ -341,11 +337,11 @@ msgid "" "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.)" +"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 "" @@ -356,8 +352,8 @@ msgid "" "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:" +"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é)." @@ -415,7 +411,7 @@ msgstr "" "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 " +"`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 " @@ -452,7 +448,6 @@ msgstr "" "``NULL``), voir :ref:`bltin-exceptions`." #: extending/extending.rst:238 -#, fuzzy msgid "" "Note also that the :c:data:`!SpamError` variable retains a reference to the " "newly created exception class; this is intentional! Since the exception " @@ -462,21 +457,21 @@ msgid "" "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` et devenir un pointeur défaillant. Si cela se produirait, le C " -"code qui lève cette exception peut engendrer un *core dump* ou des effets " -"secondaires inattendus." +"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 un type de " -"renvoi de fonction plus tard dans cette section." +"Nous traiterons de l'utilisation de ``PyMODINIT_FUNC`` comme type de renvoi " +"de fonction plus tard dans cette section." #: extending/extending.rst:248 msgid "" @@ -499,7 +494,6 @@ msgstr "" "capable de comprendre cette affirmation ::" #: extending/extending.rst:279 -#, fuzzy msgid "" "It returns ``NULL`` (the error indicator for functions returning object " "pointers) if an error is detected in the argument list, relying on the " @@ -513,9 +507,9 @@ msgstr "" "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 " +"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 " +"Standard, la variable :c:data:`!command` doit être clairement déclarée comme " "``const char *command``)." #: extending/extending.rst:287 @@ -528,26 +522,24 @@ msgstr "" "`PyArg_ParseTuple` ::" #: extending/extending.rst:292 -#, fuzzy 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`. ::" +"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 renverra un objet entier. (Oui, même les entiers sont des " -"objets dans le tas en Python !)" +"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 -#, fuzzy msgid "" "If you have a C function that returns no useful argument (a function " "returning :c:expr:`void`), the corresponding Python function must return " @@ -555,9 +547,9 @@ msgid "" "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`) ::" +"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 "" @@ -566,8 +558,8 @@ msgid "" "\"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 signifie qu'une erreur est survenue, dans la plupart des situations, " +"``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 @@ -609,7 +601,6 @@ msgstr "" "fournies plus bas." #: extending/extending.rst:338 -#, fuzzy 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 " @@ -617,11 +608,12 @@ msgid "" "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 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." +"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 "" @@ -649,9 +641,9 @@ msgid "" "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``." +"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 "" @@ -667,13 +659,13 @@ msgid "" "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é. (Voir ci-dessous pour les " -"commentaires sur l'intégration en Python.) Il 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 la table " -"(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. Il peut s'interrompre avec une erreur fatale pour certaines " +"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``." @@ -687,10 +679,11 @@ msgid "" 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 " +"`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 " @@ -699,12 +692,12 @@ msgid "" "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." +"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 "" @@ -716,6 +709,7 @@ msgstr "" "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* " @@ -723,11 +717,11 @@ msgid "" "``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 " +"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-phase, voir :PEP:`489`." +"l'initialisation multi-phases, voir :PEP:`489`." #: extending/extending.rst:446 msgid "Compilation and Linkage" @@ -742,6 +736,13 @@ msgid "" "`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 "" @@ -752,6 +753,13 @@ msgid "" "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 "" @@ -761,12 +769,21 @@ msgid "" "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" @@ -782,6 +799,14 @@ msgid "" "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 "" @@ -791,6 +816,12 @@ msgid "" "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 "" @@ -801,16 +832,22 @@ msgid "" "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 -#, fuzzy 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 :const:" +"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`." @@ -839,6 +876,16 @@ msgid "" "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 "" @@ -848,6 +895,12 @@ msgid "" "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 "" @@ -857,6 +910,12 @@ msgid "" "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 "" @@ -870,7 +929,7 @@ msgid "" 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 " -"la levée d'une exception. Si le code C qui a appelé :c:func:" +"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 " @@ -895,7 +954,7 @@ msgstr "" "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 " +"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 ::" @@ -907,6 +966,10 @@ msgid "" "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 "" @@ -935,6 +998,11 @@ msgid "" "Reference Manual. The remaining arguments must be addresses of variables " "whose type is determined by the format string." msgstr "" +"L'argument *arg* doit être un *n*-uplet contenant une liste d'arguments " +"passée de Python à une fonction C. L'argument *format* doit être une chaîne " +"de format, dont la syntaxe est expliquée dans :ref:`arg-parsing` dans le " +"manuel de référence de l'API Python/C. Les arguments restants doivent être " +"des adresses de variables dont le type est déterminé par la chaîne de format." #: extending/extending.rst:642 msgid "" @@ -943,15 +1011,19 @@ msgid "" "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 "" +"Notez que si :c:func:`PyArg_ParseTuple` vérifie que les arguments Python ont " +"les types requis, elle ne peut pas vérifier la validité des adresses des " +"variables C transmises à l'appel : si vous y faites des erreurs, votre code " +"plantera probablement ou au moins écrasera des bits aléatoires en mémoire. " +"Donc soyez prudent !" #: extending/extending.rst:647 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 !" +"Notez que toute référence sur un objet Python donnée à l'appelant est une " +"référence *empruntée* ; ne décrémentez pas son compteur de références !" #: extending/extending.rst:650 msgid "Some example calls::" @@ -984,26 +1056,27 @@ msgstr "" "*kwlist* est une liste de chaînes de caractères terminée par ``NULL`` qui " "identifie les paramètres ; les noms sont mis en correspondance, de gauche à " "droite, avec les informations de type de *format*. En cas de succès du " -"processus, :c:func:`PyArg_ParseTupleAndKeywords` renvoie vrai, sinon il " +"processus, :c:func:`PyArg_ParseTupleAndKeywords` renvoie vrai, sinon elle " "renvoie faux et lève une exception appropriée." +# suit un : #: extending/extending.rst:739 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." +"les *n*-uplets imbriqués ne peuvent pas être traités lorsqu'on utilise des " +"arguments nommés ! Ceux-ci doivent apparaître dans *kwlist*, dans le cas " +"contraire une exception :exc:`TypeError` est levée." #: extending/extending.rst:745 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) ::" +"Voici un exemple de module qui utilise des arguments nommés, basé sur un " +"exemple de *Geoff Philbrick* (philbrick@hks.com) ::" #: extending/extending.rst:800 msgid "Building Arbitrary Values" @@ -1024,14 +1097,13 @@ msgid "" "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 " +"Elle 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." +"entrée de la fonction, et non de la sortie) ne doivent pas être des " +"pointeurs, mais juste des valeurs. Elle renvoie un nouvel objet Python, " +"adapté pour être renvoyé par une fonction C appelée depuis Python." #: extending/extending.rst:812 -#, fuzzy 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 " @@ -1042,9 +1114,15 @@ msgid "" "that format unit. To force it to return a tuple of size 0 or one, " "parenthesize the format string." msgstr "" -"Une différence par rapport à :c:func:`PyArg_ParseTuple` : alors que ce " -"dernier nécessite que son premier argument soit un *n*-uplet (puisque les " -"listes d'arguments Python sont toujours représentées par des *n*-uplets en " +"Une différence avec :c:func:`PyArg_ParseTuple` : alors que cette dernière " +"nécessite que son premier argument soit un *n*-uplet (puisque les listes " +"d'arguments Python sont toujours représentées comme des *n*-uplets en " +"interne), :c:func:`Py_BuildValue` ne construit pas toujours un *n*-uplet. " +"Elle construit un *n*-uplet uniquement si sa chaîne de format contient deux " +"unités de format ou plus. Si la chaîne de format est vide, elle renvoie " +"``None`` ; si elle contient exactement une unité de format, elle renvoie " +"tout objet décrit par cette unité de format. Pour la forcer à renvoyer un " +"*n*-uplet de taille 0 ou un, mettez la chaîne de format entre parenthèses." #: extending/extending.rst:820 msgid "" @@ -1085,6 +1163,17 @@ msgid "" "as referencing uninitialized data --- core dumps, wrong results, mysterious " "crashes." msgstr "" +"Chaque bloc de mémoire alloué avec :c:func:`malloc` doit finalement être " +"libéré par exactement un appel à :c:func:`free`. Il est important d'appeler :" +"c:func:`free` au bon moment. Si l'adresse d'un bloc est oubliée mais que :c:" +"func:`free` n'est pas appelée, la mémoire qu'il occupe ne peut être " +"réutilisée tant que le programme n'est pas terminé. C'est ce qu'on appelle " +"une :dfn:`fuite de mémoire`. D'autre part, si un programme appelle :c:func:" +"`free` pour un bloc et continue ensuite à utiliser le bloc, il crée un " +"conflit avec la réutilisation du bloc via un autre appel :c:func:`malloc`. " +"Cela s'appelle :dfn:`utiliser de la mémoire libérée`. Cela a les mêmes " +"conséquences néfastes que le référencement de données non initialisées — " +"« *core dumps* », résultats erronés, plantages mystérieux." #: extending/extending.rst:865 msgid "" @@ -1102,6 +1191,20 @@ msgid "" "happening by having a coding convention or strategy that minimizes this kind " "of errors." msgstr "" +"Les causes courantes des fuites de mémoire sont des exécutions inhabituelles " +"du code. Par exemple, une fonction peut allouer un bloc de mémoire, " +"effectuer des calculs, puis libérer le bloc. Plus tard, une modification des " +"exigences de la fonction peut ajouter un test au calcul qui détecte une " +"condition d'erreur et peut sortir prématurément de la fonction. Il est " +"facile d'oublier de libérer le bloc de mémoire alloué lors de cette sortie " +"prématurée, surtout lorsqu'elle est ajoutée ultérieurement au code. De " +"telles fuites, une fois introduites, passent souvent inaperçues pendant " +"longtemps : la sortie d'erreur n'est prise que dans une petite fraction de " +"tous les appels, et la plupart des machines modernes ont beaucoup de mémoire " +"virtuelle, de sorte que la fuite ne devient apparente que dans un processus " +"de longue durée qui utilise fréquemment cette fonction. Par conséquent, il " +"est important d'éviter les fuites en ayant une convention ou une stratégie " +"de codage qui minimise ce type d'erreurs." #: extending/extending.rst:878 msgid "" @@ -1115,9 +1218,9 @@ msgid "" msgstr "" "Comme Python fait un usage intensif de :c:func:`malloc` et de :c:func:" "`free`, il a besoin d'une stratégie pour éviter les fuites de mémoire ainsi " -"que l'utilisation de la mémoire libérée. La méthode choisie est appelée :dfn:" -"`reference counting`. Le principe est simple : chaque objet contient un " -"compteur, qui est incrémenté lorsqu'une référence à l'objet est stockée " +"que l'utilisation de la mémoire libérée. La méthode choisie est appelée le :" +"dfn:`comptage de références`. Le principe est simple : chaque objet contient " +"un compteur, qui est incrémenté lorsqu'une référence à l'objet est stockée " "quelque part, et qui est décrémenté lorsqu'une référence à celui-ci est " "supprimée. Lorsque le compteur atteint zéro, la dernière référence à l'objet " "a été supprimée et l'objet est libéré." @@ -1137,19 +1240,19 @@ msgid "" "garbage collector will be available for C. Until then, we'll have to live " "with reference counts." msgstr "" -"Une stratégie alternative est appelée :dfn:`automatic garbage collection` " -"(ramasse-miettes). Parfois, le comptage des références est également appelé " -"stratégie de ramasse-miettes, d'où l'utilisation du terme \"automatique\" " -"pour distinguer les deux. Le grand avantage du ramasse-miettes est que " -"l'utilisateur n'a pas besoin d'appeler :c:func:`free` explicitement. (Un " -"autre avantage important est l'amélioration de la vitesse ou de " -"l'utilisation de la mémoire, ce n'est cependant pas un fait avéré). " -"L'inconvénient est que pour C, il n'y a pas de ramasse-miettes portable " -"proprement-dit, alors que le comptage des références peut être implémenté de " -"façon portable (tant que les fonctions :c:func:`malloc` et :c:func:`free` " -"soient disponibles, ce que la norme C garantit). Peut-être qu'un jour un " -"ramasse-miettes suffisamment portable sera disponible pour C. D'ici là, nous " -"devrons utiliser les compteurs des références." +"Une stratégie alternative est appelée :dfn:`ramasse-miettes automatique` " +"(*automatic garbage collection* en anglais). Parfois, le comptage des " +"références est également appelé stratégie de ramasse-miettes, d'où " +"l'utilisation du terme « automatique » pour distinguer les deux. Le grand " +"avantage du ramasse-miettes est que l'utilisateur n'a pas besoin d'appeler :" +"c:func:`free` explicitement (un autre avantage important est l'amélioration " +"de la vitesse ou de l'utilisation de la mémoire, ce n'est cependant pas un " +"fait avéré). L'inconvénient est que pour C, il n'y a pas de ramasse-miettes " +"portable proprement-dit, alors que le comptage des références peut être " +"implémenté de façon portable (tant que les fonctions :c:func:`malloc` et :c:" +"func:`free` sont disponibles, ce que la norme C garantit). Peut-être qu'un " +"jour un ramasse-miettes suffisamment portable sera disponible pour C. D'ici " +"là, nous devons utiliser les compteurs de références." #: extending/extending.rst:898 msgid "" @@ -1165,17 +1268,17 @@ msgid "" "though there are no further references to the cycle itself." msgstr "" "Bien que Python utilise l'implémentation traditionnelle de comptage de " -"référence, il contient également un détecteur de cycles qui fonctionne pour " -"détecter les cycles de référence. Cela permet aux applications d'empêcher la " -"création de références circulaires directes ou indirectes ; ceci sont les " -"faiblesses du ramasse-miettes mis en œuvre en utilisant uniquement le " -"comptage de référence. Les cycles de référence sont constitués d'objets qui " -"contiennent des références (éventuellement indirectes) à eux-mêmes, de sorte " -"que chaque objet du cycle a un comptage de référence qui n'est pas nul. Les " -"implémentations typiques de comptage de référence ne sont pas capables de " -"récupérer la mémoire appartenant à des objets dans un cycle de référence, ou " -"référencés à partir des objets dans le cycle, même s'il n'y a pas d'autres " -"références au cycle lui-même." +"références, il contient également un détecteur de cycles qui fonctionne pour " +"détecter les cycles de références. Cela permet aux applications de ne pas se " +"soucier de la création de références circulaires directes ou indirectes ; " +"celles-ci sont les faiblesses des ramasse-miettes utilisant uniquement le " +"comptage de références. Les cycles de références sont constitués d'objets " +"qui contiennent des références (éventuellement indirectes) à eux-mêmes, de " +"sorte que chaque objet du cycle a un compteur de références qui n'est pas " +"nul. Les implémentations typiques de comptage de références ne sont pas " +"capables de récupérer la mémoire des objets appartenant à un cycle de " +"références, ou référencés à partir des objets dans le cycle, même s'il n'y a " +"pas d'autre référence au cycle lui-même." #: extending/extending.rst:909 msgid "" @@ -1184,6 +1287,11 @@ msgid "" "collect` function), as well as configuration interfaces and the ability to " "disable the detector at runtime." msgstr "" +"Le détecteur de cycle est capable de détecter les cycles isolés et peut " +"récupérer la mémoire afférente. Le module :mod:`gc` expose un moyen " +"d'exécuter le détecteur (la fonction :func:`~gc.collect`), ainsi que des " +"interfaces de configuration et la possibilité de désactiver le détecteur au " +"moment de l'exécution." #: extending/extending.rst:918 msgid "Reference Counting in Python" @@ -1200,8 +1308,8 @@ msgid "" "object." msgstr "" "Il existe deux macros, ``Py_INCREF(x)`` et ``Py_DECREF(x)``, qui gèrent " -"l'incrémentation et la décrémentation du comptage de référence. :c:func:" -"`Py_DECREF` libère également l'objet lorsque le comptage atteint zéro. Pour " +"l'incrémentation et la décrémentation du comptage de références. :c:func:" +"`Py_DECREF` libère également l'objet lorsque le compteur atteint zéro. Pour " "plus de flexibilité, il n'appelle pas :c:func:`free` directement — plutôt, " "il fait un appel à travers un pointeur de fonction dans l'objet :dfn:`type " "objet` de l'objet. À cette fin (et pour d'autres), chaque objet contient " @@ -1222,13 +1330,13 @@ msgstr "" "La grande question demeure maintenant : quand utiliser ``Py_INCREF(x)`` et " "``Py_DECREF(x)`` ? Commençons par définir quelques termes. Personne ne " "possède un objet, mais vous pouvez en :dfn:`avoir une référence`. Le " -"comptage de références d'un objet est maintenant défini comme étant le " +"compteur de références d'un objet est maintenant défini comme étant le " "nombre de références à cet objet. Le propriétaire d'une référence est " "responsable d'appeler :c:func:`Py_DECREF` lorsque la référence n'est plus " -"nécessaire. La propriété d'une référence peut être transférée. Il y a trois " -"façons de disposer d'une référence : la transmettre, la stocker, ou appeler :" -"c:func:`Py_DECREF`. Oublier de se débarrasser d'une référence crée une fuite " -"de mémoire." +"nécessaire. La possession d'une référence peut être transférée. Il y a trois " +"façons de se débarrasser d'une référence que l'on possède : la transmettre, " +"la stocker ou appeler :c:func:`Py_DECREF`. Oublier de se débarrasser d'une " +"référence crée une fuite de mémoire." #: extending/extending.rst:936 msgid "" @@ -1238,6 +1346,12 @@ msgid "" "borrowed. Using a borrowed reference after the owner has disposed of it " "risks using freed memory and should be avoided completely [#]_." msgstr "" +"Il est également possible d':dfn:`emprunter` [#]_ une référence à un objet. " +"L'emprunteur d'une référence ne doit pas appeler :c:func:`Py_DECREF`. " +"L'emprunteur ne doit pas conserver l'objet plus longtemps que le " +"propriétaire à qui il a été emprunté. L'utilisation d'une référence " +"empruntée après que le propriétaire s'en est débarrassée risque d'utiliser " +"de la mémoire libérée et doit être absolument évitée [#]_." #: extending/extending.rst:942 msgid "" @@ -1249,14 +1363,14 @@ msgid "" "code a borrowed reference can be used after the owner from which it was " "borrowed has in fact disposed of it." msgstr "" -"L'avantage d'emprunter, plutôt qu'être propriétaire d'une référence est que " -"vous n'avez pas à vous soucier de disposer de la référence sur tous les " -"chemins possibles dans le code — en d'autres termes, avec une référence " -"empruntée, vous ne courez pas le risque de fuites lors d'une sortie " -"prématurée. L'inconvénient de l'emprunt par rapport à la possession est " -"qu'il existe certaines situations subtiles où, dans un code apparemment " -"correct, une référence empruntée peut être utilisée après que le " -"propriétaire auquel elle a été empruntée l'a en fait éliminée." +"L'avantage d'emprunter, plutôt qu'être propriétaire d'une référence, est que " +"vous n'avez pas à vous soucier de libérer la référence sur tous les chemins " +"possibles dans le code — en d'autres termes, avec une référence empruntée, " +"vous ne courez pas le risque de fuites lors d'une sortie prématurée. " +"L'inconvénient de l'emprunt par rapport à la possession est qu'il existe " +"certaines situations subtiles où, dans un code apparemment correct, une " +"référence empruntée peut être utilisée après que le propriétaire auquel elle " +"a été empruntée l'a en fait éliminée." #: extending/extending.rst:950 msgid "" @@ -1266,10 +1380,15 @@ msgid "" "full owner responsibilities (the new owner must dispose of the reference " "properly, as well as the previous owner)." msgstr "" +"Une référence empruntée peut être changée en une référence possédée en " +"appelant :c:func:`Py_INCREF`. Cela n'affecte pas le statut du propriétaire à " +"qui la référence a été empruntée — cela crée une nouvelle référence possédée " +"et donne l'entière responsabilité au propriétaire (le nouveau propriétaire " +"doit libérer la référence correctement, ainsi que le propriétaire précédent)." #: extending/extending.rst:960 msgid "Ownership Rules" -msgstr "Règles concernant la propriété de références" +msgstr "Règles concernant la possession de références" #: extending/extending.rst:962 msgid "" @@ -1279,7 +1398,7 @@ msgid "" msgstr "" "Chaque fois qu'une référence d'objet est passée à l'intérieur ou à " "l'extérieur d'une fonction, elle fait partie de la spécification de " -"l'interface de la fonction, peu importe que la propriété soit transférée " +"l'interface de la fonction, peu importe que la possession soit transférée " "avec la référence ou non." #: extending/extending.rst:966 @@ -1292,6 +1411,14 @@ msgid "" "func:`PyLong_FromLong` maintains a cache of popular values and can return a " "reference to a cached item." msgstr "" +"La plupart des fonctions qui renvoient une référence à un objet transmettent " +"la possession avec la référence. En particulier, toutes les fonctions dont " +"la fonction est de créer un nouvel objet, telles que :c:func:" +"`PyLong_FromLong` et :c:func:`Py_BuildValue`, transmettent la possession au " +"récepteur. Même si l'objet n'est pas réellement nouveau, vous recevez " +"toujours la possession d'une nouvelle référence à cet objet. Par exemple, :c:" +"func:`PyLong_FromLong` maintient un cache des valeurs souvent utilisées et " +"peut renvoyer une référence à un élément mis en cache." #: extending/extending.rst:974 msgid "" @@ -1303,6 +1430,13 @@ msgid "" "`PyDict_GetItemString` all return references that you borrow from the tuple, " "list or dictionary." msgstr "" +"De nombreuses fonctions qui extraient des objets d'autres objets transfèrent " +"également la possession avec la référence, par exemple :c:func:" +"`PyObject_GetAttrString`. L'image est moins claire ici, cependant, puisque " +"quelques routines courantes sont des exceptions : :c:func:" +"`PyTuple_GetItem`, :c:func:`PyList_GetItem`, :c:func:`PyDict_GetItem` et :c:" +"func:`PyDict_GetItemString` renvoient toutes des références qui sont " +"empruntées au *n*-uplet, à la liste ou au dictionnaire." #: extending/extending.rst:981 msgid "" @@ -1310,6 +1444,9 @@ msgid "" "even though it may actually create the object it returns: this is possible " "because an owned reference to the object is stored in ``sys.modules``." msgstr "" +"La fonction :c:func:`PyImport_AddModule` renvoie également une référence " +"empruntée, même si elle peut en fait créer l'objet qu'elle renvoie : c'est " +"possible car une référence à l'objet est stockée dans ``sys.modules``." #: extending/extending.rst:985 msgid "" @@ -1321,6 +1458,14 @@ msgid "" "them --- even if they fail! (Note that :c:func:`PyDict_SetItem` and friends " "don't take over ownership --- they are \"normal.\")" msgstr "" +"Lorsque vous passez une référence d'objet dans une autre fonction, en " +"général, la fonction vous emprunte la référence — si elle a besoin de la " +"stocker, elle utilise :c:func:`Py_INCREF` pour devenir un propriétaire " +"indépendant. Il existe exactement deux exceptions importantes à cette " +"règle : :c:func:`PyTuple_SetItem` et :c:func:`PyList_SetItem`. Ces fonctions " +"s'approprient l'élément qui leur est transmis, même en cas d'échec ! (Notez " +"que :c:func:`PyDict_SetItem` et compagnie ne prennent pas la possession de " +"l'objet, elles sont « normales ».)" #: extending/extending.rst:993 msgid "" @@ -1330,6 +1475,12 @@ msgid "" "Only when such a borrowed reference must be stored or passed on, it must be " "turned into an owned reference by calling :c:func:`Py_INCREF`." msgstr "" +"Lorsqu'une fonction C est appelée depuis Python, elle emprunte à l'appelant " +"des références aux arguments. L'appelant possède une référence à l'objet, de " +"sorte que la durée de vie de la référence empruntée est garantie jusqu'au " +"retour de la fonction. Ce n'est que lorsqu'une telle référence empruntée " +"doit être stockée ou transmise qu'elle doit être transformée en référence " +"possédée en appelant :c:func:`Py_INCREF`." #: extending/extending.rst:999 msgid "" @@ -1337,6 +1488,9 @@ msgid "" "must be an owned reference --- ownership is transferred from the function to " "its caller." msgstr "" +"La référence d'objet renvoyée par une fonction C appelée depuis Python doit " +"être une référence détenue en propre — la possession est transférée de la " +"fonction à son appelant." #: extending/extending.rst:1007 msgid "Thin Ice" @@ -1351,7 +1505,7 @@ msgid "" msgstr "" "Il existe quelques situations où l'utilisation apparemment inoffensive d'une " "référence empruntée peut entraîner des problèmes. Tous ces problèmes sont en " -"lien avec des invocations implicites de l’interpréteur, et peuvent amener le " +"lien avec des invocations implicites de l’interpréteur et peuvent amener le " "propriétaire d'une référence à s'en défaire." #: extending/extending.rst:1013 @@ -1360,8 +1514,8 @@ msgid "" "on an unrelated object while borrowing a reference to a list item. For " "instance::" msgstr "" -"Le premier cas, et le plus important à connaître, est celui de l'application " -"de :c:func:`Py_DECREF` à un objet non relié, tout en empruntant une " +"Le premier cas, et le plus important à connaître, est celui de l'utilisation " +"de :c:func:`Py_DECREF` à un objet non relié lors de l'emprunt d'une " "référence à un élément de liste. Par exemple ::" #: extending/extending.rst:1025 @@ -1414,6 +1568,9 @@ msgid "" "The solution, once you know the source of the problem, is easy: temporarily " "increment the reference count. The correct version of the function reads::" msgstr "" +"La solution, une fois que vous connaissez la source du problème, est " +"simple : incrémentez temporairement le compteur de références. La version " +"correcte de la fonction est ::" #: extending/extending.rst:1058 msgid "" @@ -1421,6 +1578,10 @@ msgid "" "bug and someone spent a considerable amount of time in a C debugger to " "figure out why his :meth:`__del__` methods would fail..." msgstr "" +"C'est une histoire vraie. Une ancienne version de Python contenait des " +"variantes de ce bogue et quelqu'un a passé beaucoup de temps dans un " +"débogueur C pour comprendre pourquoi il arrivait que ses méthodes :meth:" +"`__del__` échouent…" #: extending/extending.rst:1062 msgid "" @@ -1435,7 +1596,7 @@ msgid "" "previous one::" msgstr "" "Le deuxième cas de problèmes liés à une référence empruntée est une variante " -"impliquant des fils de discussion. Normalement, plusieurs threads dans " +"impliquant des fils d'exécution. Normalement, plusieurs threads dans " "l'interpréteur Python ne peuvent pas se gêner mutuellement, car il existe un " "verrou global protégeant tout l'espace objet de Python. Cependant, il est " "possible de libérer temporairement ce verrou en utilisant la macro :c:macro:" @@ -1477,7 +1638,7 @@ msgid "" "that may be ``NULL`` is received, for example, from :c:func:`malloc` or from " "a function that may raise an exception." msgstr "" -"Il est préférable de tester la présence de ``NULL`` uniquement au début : " +"Il est préférable de tester la présence de ``NULL`` uniquement au début : " "lorsqu'un pointeur qui peut être ``NULL`` est reçu, par exemple, de :c:func:" "`malloc` ou d'une fonction qui peut lever une exception." @@ -1499,6 +1660,12 @@ msgid "" "expected types, and this would generate redundant tests. There are no " "variants with ``NULL`` checking." msgstr "" +"Les macros de vérification d'un type d'objet particulier " +"(``Pytype_Check()``) ne vérifient pas les pointeurs ``NULL`` — encore une " +"fois, il y a beaucoup de code qui en appelle plusieurs à la suite pour " +"tester un objet par rapport à différents types attendus, ce qui générerait " +"des tests redondants. Il n'y a pas de variantes avec la vérification " +"``NULL``." #: extending/extending.rst:1109 msgid "" @@ -1508,14 +1675,14 @@ msgid "" msgstr "" "Le mécanisme d'appel de fonctions C garantit que la liste d'arguments passée " "aux fonctions C (``args`` dans les exemples) n'est jamais ``NULL``. En fait, " -"il garantit qu'il s'agit toujours d'un n-uplet [#]_." +"il garantit qu'il s'agit toujours d'un *n*-uplet [#]_." #: extending/extending.rst:1113 msgid "" "It is a severe error to ever let a ``NULL`` pointer \"escape\" to the Python " "user." msgstr "" -"C'est une grave erreur de laisser un pointeur ``NULL`` \"échapper\" à " +"C'est une grave erreur de laisser un pointeur ``NULL`` « s'échapper » vers " "l'utilisateur Python." #: extending/extending.rst:1124 @@ -1564,7 +1731,7 @@ msgstr "" "fonctions et de nouveaux types à utiliser à partir de Python, mais parfois " "le code d'un module d'extension peut être utile pour d'autres modules " "d'extension. Par exemple, un module d'extension peut mettre en œuvre un type " -"\"collection\" qui fonctionne comme des listes sans ordre. Tout comme le " +"« collection » qui fonctionne comme des listes sans ordre. Tout comme le " "type de liste Python standard possède une API C qui permet aux modules " "d'extension de créer et de manipuler des listes, ce nouveau type de " "collection devrait posséder un ensemble de fonctions C pour une manipulation " @@ -1586,7 +1753,7 @@ msgid "" "call might not have been loaded yet!" msgstr "" "À première vue, cela semble facile : il suffit d'écrire les fonctions (sans " -"les déclarer \"statiques\", bien sûr), de fournir un fichier d'en-tête " +"les déclarer « statiques », bien sûr), de fournir un fichier d'en-tête " "approprié et de documenter l'API C. Et en fait, cela fonctionnerait si tous " "les modules d'extension étaient toujours liés statiquement avec " "l'interpréteur Python. Cependant, lorsque les modules sont utilisés comme " @@ -1629,6 +1796,15 @@ msgid "" "module, retrieve the value of this name, and then retrieve the pointer from " "the Capsule." msgstr "" +"Python fournit un mécanisme spécial pour transmettre des informations de " +"niveau C (pointeurs) d'un module d'extension à un autre : les Capsules. Une " +"capsule est un type de données Python qui stocke un pointeur (:c:expr:`void " +"\\*`). Les capsules ne peuvent être créées et accessibles que via leur API " +"C, mais elles peuvent être transmises comme n'importe quel autre objet " +"Python. En particulier, elles peuvent être affectées à un nom dans l'espace " +"de noms d'un module d'extension. D'autres modules d'extension peuvent alors " +"importer ce module, récupérer la valeur de ce nom, puis récupérer le " +"pointeur de la Capsule." #: extending/extending.rst:1180 msgid "" @@ -1648,7 +1824,6 @@ msgstr "" "clients." #: extending/extending.rst:1186 -#, fuzzy msgid "" "Whichever method you choose, it's important to name your Capsules properly. " "The function :c:func:`PyCapsule_New` takes a name parameter (:c:expr:`const " @@ -1659,34 +1834,34 @@ msgid "" msgstr "" "Quelle que soit la méthode que vous choisissez, il est important de bien " "nommer vos Capsules. La fonction :c:func:`PyCapsule_New` prend un paramètre " -"nommé (:c:type:`const char \\*`). Vous êtes autorisé à passer un nom " +"nommé (:c:expr:`const char \\*`). Vous êtes autorisé à passer un nom " "``NULL``, mais nous vous encourageons vivement à spécifier un nom. Des " "Capsules correctement nommées offrent un certain degré de sécurité " "concernant un éventuel conflit de types, car il n'y a pas de moyen de " -"distinguer deux ou plusieurs Capsules non nommée entre elles." +"distinguer deux ou plusieurs Capsules non nommées entre elles." #: extending/extending.rst:1193 msgid "" "In particular, Capsules used to expose C APIs should be given a name " "following this convention::" msgstr "" +"En particulier, les capsules utilisées pour exposer les API C doivent " +"recevoir un nom suivant cette convention ::" #: extending/extending.rst:1198 -#, fuzzy msgid "" "The convenience function :c:func:`PyCapsule_Import` makes it easy to load a " "C API provided via a Capsule, but only if the Capsule's name matches this " "convention. This behavior gives C API users a high degree of certainty that " "the Capsule they load contains the correct C API." msgstr "" -"La fonction communément utilisée :c:func:`PyCapsule_Import` permet de " -"charger facilement une API C fournie via une Capsule, mais seulement si le " -"nom de la Capsule correspond à cette convention. Ce comportement donne aux " +"La fonction de commodité :c:func:`PyCapsule_Import` permet de charger " +"facilement une API C fournie via une Capsule, mais seulement si le nom de la " +"Capsule correspond à cette convention. Ce comportement donne aux " "utilisateurs d'API C un degré élevé de certitude que la Capsule qu'ils " "chargent contient l'API C correcte." #: extending/extending.rst:1203 -#, fuzzy msgid "" "The following example demonstrates an approach that puts most of the burden " "on the writer of the exporting module, which is appropriate for commonly " @@ -1700,7 +1875,7 @@ msgstr "" "de la charge sur le rédacteur du module d'exportation, ce qui est approprié " "pour les modules de bibliothèque couramment utilisés. Il stocke tous les " "pointeurs de l'API C (un seul dans l'exemple !) dans un tableau de " -"pointeurs :c:type:`void` qui devient la valeur d'une Capsule. Le fichier " +"pointeurs :c:expr:`void` qui devient la valeur d'une Capsule. Le fichier " "d'en-tête correspondant au module fournit une macro qui se charge d'importer " "le module et de récupérer ses pointeurs d'API C. Les modules clients n'ont " "qu'à appeler cette macro avant d'accéder à l'API C." @@ -1727,6 +1902,8 @@ msgid "" "The function :c:func:`PySpam_System` is a plain C function, declared " "``static`` like everything else::" msgstr "" +"La fonction :c:func:`PySpam_System` est une simple fonction C, déclarée " +"``static`` comme tout le reste ::" #: extending/extending.rst:1227 msgid "The function :c:func:`spam_system` is modified in a trivial way::" @@ -1734,7 +1911,7 @@ msgstr "La fonction :c:func:`spam_system` est modifiée de manière simple ::" #: extending/extending.rst:1241 msgid "In the beginning of the module, right after the line ::" -msgstr "Au début du module, immédiatement après la ligne ::" +msgstr "Au début du module, immédiatement après la ligne ::" #: extending/extending.rst:1245 msgid "two more lines must be added::" @@ -1798,13 +1975,13 @@ msgid "" "Capsules (files :file:`Include/pycapsule.h` and :file:`Objects/pycapsule.c` " "in the Python source code distribution)." msgstr "" -"Enfin, il convient de mentionner que Capsules offrent des fonctionnalités " -"supplémentaires, qui sont particulièrement utiles pour l'allocation de la " -"mémoire et la dés-allocation du pointeur stocké dans un objet Capsule. Les " -"détails sont décrits dans le manuel de référence de l'API Python/C dans la " -"section :ref:`capsules` et dans l'implémentation des Capsules (fichiers :" -"file:`Include/pycapsule.h` et :file:`Objects/pycapsule.c` dans la " -"distribution du code source Python)." +"Enfin, il convient de mentionner que les Capsules offrent des " +"fonctionnalités supplémentaires, qui sont particulièrement utiles pour " +"l'allocation de la mémoire et la dés-allocation du pointeur stocké dans un " +"objet Capsule. Les détails sont décrits dans le manuel de référence de l'API " +"Python/C dans la section :ref:`capsules` et dans l'implémentation des " +"Capsules (fichiers :file:`Include/pycapsule.h` et :file:`Objects/pycapsule." +"c` dans la distribution du code source Python)." #: extending/extending.rst:1364 msgid "Footnotes" @@ -1847,16 +2024,16 @@ msgstr "" #: extending/extending.rst:539 msgid "PyObject_CallObject()" -msgstr "" +msgstr "PyObject_CallObject()" #: extending/extending.rst:630 msgid "PyArg_ParseTuple()" -msgstr "" +msgstr "PyArg_ParseTuple()" #: extending/extending.rst:722 msgid "PyArg_ParseTupleAndKeywords()" -msgstr "" +msgstr "PyArg_ParseTupleAndKeywords()" #: extending/extending.rst:743 msgid "Philbrick, Geoff" -msgstr "" +msgstr "Philbrick, Geoff"