forked from AFPy/python-docs-fr
1191 lines
51 KiB
Plaintext
1191 lines
51 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2020-08-24 09:01+0200\n"
|
||
"PO-Revision-Date: 2020-04-27 22:27+0200\n"
|
||
"Last-Translator: Antoine Wecxsteen\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 2.2.3\n"
|
||
|
||
#: faq/library.rst:5
|
||
msgid "Library and Extension FAQ"
|
||
msgstr "FAQ sur la bibliothèque et les extensions"
|
||
|
||
#: faq/library.rst:8
|
||
msgid "Contents"
|
||
msgstr "Sommaire"
|
||
|
||
#: faq/library.rst:12
|
||
msgid "General Library Questions"
|
||
msgstr "Questions générales sur la bibliothèque"
|
||
|
||
#: faq/library.rst:15
|
||
msgid "How do I find a module or application to perform task X?"
|
||
msgstr ""
|
||
"Comment trouver un module ou une application pour effectuer la tâche X ?"
|
||
|
||
#: faq/library.rst:17
|
||
msgid ""
|
||
"Check :ref:`the Library Reference <library-index>` to see if there's a "
|
||
"relevant standard library module. (Eventually you'll learn what's in the "
|
||
"standard library and will be able to skip this step.)"
|
||
msgstr ""
|
||
"Regardez si la :ref:`bibliothèque standard <library-index>` contient un "
|
||
"module approprié (avec l'expérience, vous connaitrez le contenu de la "
|
||
"bibliothèque standard et pourrez sauter cette étape)."
|
||
|
||
#: faq/library.rst:21
|
||
msgid ""
|
||
"For third-party packages, search the `Python Package Index <https://pypi."
|
||
"org>`_ or try `Google <https://www.google.com>`_ or another Web search "
|
||
"engine. Searching for \"Python\" plus a keyword or two for your topic of "
|
||
"interest will usually find something helpful."
|
||
msgstr ""
|
||
"Pour des paquets tiers, regardez dans `l'index des paquets Python <https://"
|
||
"pypi.org>`_ ou essayez `Google <https://www.google.com>`_ ou un autre moteur "
|
||
"de recherche (NDT : comme le moteur français `Qwant <https://www.qwant."
|
||
"com>`_). Rechercher « Python » accompagné d'un ou deux mots-clés se "
|
||
"rapportant à ce qui vous intéresse donne souvent de bons résultats."
|
||
|
||
#: faq/library.rst:28
|
||
msgid "Where is the math.py (socket.py, regex.py, etc.) source file?"
|
||
msgstr ""
|
||
"Où sont stockés les fichiers sources *math.py*, *socket.py*, *regex.py*, "
|
||
"etc ?"
|
||
|
||
#: faq/library.rst:30
|
||
msgid ""
|
||
"If you can't find a source file for a module it may be a built-in or "
|
||
"dynamically loaded module implemented in C, C++ or other compiled language. "
|
||
"In this case you may not have the source file or it may be something like :"
|
||
"file:`mathmodule.c`, somewhere in a C source directory (not on the Python "
|
||
"Path)."
|
||
msgstr ""
|
||
"Si vous ne parvenez pas à trouver le fichier source d'un module, c'est peut-"
|
||
"être parce que celui-ci est un module natif ou bien un module implémenté en "
|
||
"C, C++, ou autre langage compilé, qui est chargé dynamiquement. Dans ce cas, "
|
||
"vous ne possédez peut-être pas le fichier source ou celui-ci est en réalité "
|
||
"stocké quelque part dans un dossier de fichiers source C (qui ne sera pas "
|
||
"dans le chemin Python), comme par exemple :file:`mathmodule.c`."
|
||
|
||
#: faq/library.rst:35
|
||
msgid "There are (at least) three kinds of modules in Python:"
|
||
msgstr "Il y a (au moins) trois types de modules dans Python :"
|
||
|
||
#: faq/library.rst:37
|
||
msgid "modules written in Python (.py);"
|
||
msgstr "les modules écrits en Python (*.py*) ;"
|
||
|
||
#: faq/library.rst:38
|
||
msgid ""
|
||
"modules written in C and dynamically loaded (.dll, .pyd, .so, .sl, etc);"
|
||
msgstr ""
|
||
"les modules écrits en C et chargés dynamiquement (*.dll*, *.pyd*, *.so*, *."
|
||
"sl*, *etc.*) ;"
|
||
|
||
#: faq/library.rst:39
|
||
msgid ""
|
||
"modules written in C and linked with the interpreter; to get a list of "
|
||
"these, type::"
|
||
msgstr ""
|
||
"les modules écrits en C et liés à l'interpréteur ; pour obtenir leur liste, "
|
||
"entrez ::"
|
||
|
||
#: faq/library.rst:47
|
||
msgid "How do I make a Python script executable on Unix?"
|
||
msgstr "Comment rendre un script Python exécutable sous Unix ?"
|
||
|
||
#: faq/library.rst:49
|
||
msgid ""
|
||
"You need to do two things: the script file's mode must be executable and the "
|
||
"first line must begin with ``#!`` followed by the path of the Python "
|
||
"interpreter."
|
||
msgstr ""
|
||
"Deux conditions doivent être remplies : les droits d'accès au fichier "
|
||
"doivent permettre son exécution et la première ligne du script doit "
|
||
"commencer par ``#!`` suivi du chemin vers l'interpréteur Python."
|
||
|
||
#: faq/library.rst:53
|
||
msgid ""
|
||
"The first is done by executing ``chmod +x scriptfile`` or perhaps ``chmod "
|
||
"755 scriptfile``."
|
||
msgstr ""
|
||
"La première condition est remplie en exécutant ``chmod +x scriptfile`` ou "
|
||
"``chmod 755 scriptfile``."
|
||
|
||
#: faq/library.rst:56
|
||
msgid ""
|
||
"The second can be done in a number of ways. The most straightforward way is "
|
||
"to write ::"
|
||
msgstr ""
|
||
"Il y a plusieurs façons de remplir la seconde. La plus simple consiste à "
|
||
"écrire au tout début du fichier ::"
|
||
|
||
#: faq/library.rst:61
|
||
msgid ""
|
||
"as the very first line of your file, using the pathname for where the Python "
|
||
"interpreter is installed on your platform."
|
||
msgstr "en utilisant le chemin de l'interpréteur Python sur votre machine."
|
||
|
||
#: faq/library.rst:64
|
||
msgid ""
|
||
"If you would like the script to be independent of where the Python "
|
||
"interpreter lives, you can use the :program:`env` program. Almost all Unix "
|
||
"variants support the following, assuming the Python interpreter is in a "
|
||
"directory on the user's :envvar:`PATH`::"
|
||
msgstr ""
|
||
"Pour rendre ce script indépendant de la localisation de l'interpréteur "
|
||
"Python, il faut utiliser le programme :program:`env`. La ligne ci-dessous "
|
||
"fonctionne sur la quasi-totalité des dérivés de Unix, à condition que "
|
||
"l'interpréteur Python soit dans un dossier référencé dans la variable :"
|
||
"envvar:`PATH` de l'utilisateur ::"
|
||
|
||
#: faq/library.rst:71
|
||
msgid ""
|
||
"*Don't* do this for CGI scripts. The :envvar:`PATH` variable for CGI "
|
||
"scripts is often very minimal, so you need to use the actual absolute "
|
||
"pathname of the interpreter."
|
||
msgstr ""
|
||
"Ne faites *pas* ceci pour des scripts CGI. La variable :envvar:`PATH` des "
|
||
"scripts CGI est souvent très succincte, il faut par conséquent préciser le "
|
||
"chemin absolu réel de l'interpréteur."
|
||
|
||
#: faq/library.rst:75
|
||
msgid ""
|
||
"Occasionally, a user's environment is so full that the :program:`/usr/bin/"
|
||
"env` program fails; or there's no env program at all. In that case, you can "
|
||
"try the following hack (due to Alex Rezinsky):"
|
||
msgstr ""
|
||
"Il peut arriver que l'environnement d'un utilisateur soit si chargé que le "
|
||
"programme :program:`/usr/bin/env` échoue ; ou que le programme *env* "
|
||
"n'existe pas du tout. Dans ce cas, vous pouvez utiliser l'astuce suivante, "
|
||
"élaborée par Alex Rezinsky :"
|
||
|
||
#: faq/library.rst:86
|
||
msgid ""
|
||
"The minor disadvantage is that this defines the script's __doc__ string. "
|
||
"However, you can fix that by adding ::"
|
||
msgstr ""
|
||
"Le léger inconvénient est que cela définit la variable *__doc__* du script. "
|
||
"Cependant, il est possible de corriger cela en ajoutant ::"
|
||
|
||
#: faq/library.rst:94
|
||
msgid "Is there a curses/termcap package for Python?"
|
||
msgstr "Existe-t'il un module *curse* ou *termcap* en Python ?"
|
||
|
||
#: faq/library.rst:98
|
||
msgid ""
|
||
"For Unix variants: The standard Python source distribution comes with a "
|
||
"curses module in the :source:`Modules` subdirectory, though it's not "
|
||
"compiled by default. (Note that this is not available in the Windows "
|
||
"distribution -- there is no curses module for Windows.)"
|
||
msgstr ""
|
||
"Pour les dérivés d'Unix : la distribution standard de Python contient un "
|
||
"module *curses* dans le sous-dossier :source:`Modules`, bien qu'il ne soit "
|
||
"pas compilé par défaut. Il n'est pas disponible en Windows — le module "
|
||
"*curses* n'existant pas en Windows."
|
||
|
||
#: faq/library.rst:103
|
||
msgid ""
|
||
"The :mod:`curses` module supports basic curses features as well as many "
|
||
"additional functions from ncurses and SYSV curses such as colour, "
|
||
"alternative character set support, pads, and mouse support. This means the "
|
||
"module isn't compatible with operating systems that only have BSD curses, "
|
||
"but there don't seem to be any currently maintained OSes that fall into this "
|
||
"category."
|
||
msgstr ""
|
||
"Le module :mod:`curses` comprend les fonctionnalités de base de *curses* et "
|
||
"beaucoup de fonctionnalités supplémentaires provenant de *ncurses* et de "
|
||
"*SYSV curses* comme la couleur, la gestion des ensembles de caractères "
|
||
"alternatifs, la prise en charge du pavé tactile et de la souris. Cela "
|
||
"implique que le module n'est pas compatible avec des systèmes d'exploitation "
|
||
"qui n'ont que le *curses* de BSD mais, de nos jours, de tels systèmes "
|
||
"d'exploitation ne semblent plus exister ou être maintenus."
|
||
|
||
#: faq/library.rst:109
|
||
msgid ""
|
||
"For Windows: use `the consolelib module <http://effbot.org/zone/console-"
|
||
"index.htm>`_."
|
||
msgstr ""
|
||
"Pour Windows : utilisez le module `consolelib <http://effbot.org/zone/"
|
||
"console-index.htm>`_."
|
||
|
||
#: faq/library.rst:114
|
||
msgid "Is there an equivalent to C's onexit() in Python?"
|
||
msgstr "Existe-t'il un équivalent à la fonction C ``onexit()`` en Python ?"
|
||
|
||
#: faq/library.rst:116
|
||
msgid ""
|
||
"The :mod:`atexit` module provides a register function that is similar to "
|
||
"C's :c:func:`onexit`."
|
||
msgstr ""
|
||
"Le module :mod:`atexit` fournit une fonction d'enregistrement similaire à la "
|
||
"fonction C :c:func:`onexit`."
|
||
|
||
#: faq/library.rst:121
|
||
msgid "Why don't my signal handlers work?"
|
||
msgstr "Pourquoi mes gestionnaires de signaux ne fonctionnent-t'ils pas ?"
|
||
|
||
#: faq/library.rst:123
|
||
msgid ""
|
||
"The most common problem is that the signal handler is declared with the "
|
||
"wrong argument list. It is called as ::"
|
||
msgstr ""
|
||
"Le problème le plus courant est d'appeler le gestionnaire de signaux avec "
|
||
"les mauvais arguments. Un gestionnaire est appelé de la façon suivante ::"
|
||
|
||
#: faq/library.rst:128
|
||
#, fuzzy
|
||
msgid "so it should be declared with two parameters::"
|
||
msgstr "donc il doit être déclaré avec deux paramètres ::"
|
||
|
||
#: faq/library.rst:135
|
||
msgid "Common tasks"
|
||
msgstr "Tâches fréquentes"
|
||
|
||
#: faq/library.rst:138
|
||
msgid "How do I test a Python program or component?"
|
||
msgstr "Comment tester un programme ou un composant Python ?"
|
||
|
||
#: faq/library.rst:140
|
||
msgid ""
|
||
"Python comes with two testing frameworks. The :mod:`doctest` module finds "
|
||
"examples in the docstrings for a module and runs them, comparing the output "
|
||
"with the expected output given in the docstring."
|
||
msgstr ""
|
||
"Python fournit deux cadriciels de test. Le module :mod:`doctest` cherche des "
|
||
"exemples dans les *docstrings* d'un module et les exécute. Il compare alors "
|
||
"la sortie avec la sortie attendue, telle que définie dans la *docstring*."
|
||
|
||
#: faq/library.rst:144
|
||
msgid ""
|
||
"The :mod:`unittest` module is a fancier testing framework modelled on Java "
|
||
"and Smalltalk testing frameworks."
|
||
msgstr ""
|
||
"Le module :mod:`unittest` est un cadriciel un peu plus élaboré basé sur les "
|
||
"cadriciels de test de Java et de Smalltalk."
|
||
|
||
#: faq/library.rst:147
|
||
msgid ""
|
||
"To make testing easier, you should use good modular design in your program. "
|
||
"Your program should have almost all functionality encapsulated in either "
|
||
"functions or class methods -- and this sometimes has the surprising and "
|
||
"delightful effect of making the program run faster (because local variable "
|
||
"accesses are faster than global accesses). Furthermore the program should "
|
||
"avoid depending on mutating global variables, since this makes testing much "
|
||
"more difficult to do."
|
||
msgstr ""
|
||
"Pour rendre le test plus aisé, il est nécessaire de bien découper le code "
|
||
"d'un programme. Votre programme doit avoir la quasi-totalité des "
|
||
"fonctionnalités dans des fonctions ou des classes — et ceci a parfois "
|
||
"l'avantage aussi plaisant qu'inattendu de rendre le programme plus rapide, "
|
||
"les accès aux variables locales étant en effet plus rapides que les accès "
|
||
"aux variables globales. De plus le programme doit éviter au maximum de "
|
||
"manipuler des variables globales, car ceci rend le test beaucoup plus "
|
||
"difficile."
|
||
|
||
#: faq/library.rst:155
|
||
msgid "The \"global main logic\" of your program may be as simple as ::"
|
||
msgstr ""
|
||
"La « logique générale » d'un programme devrait être aussi simple que ::"
|
||
|
||
#: faq/library.rst:160
|
||
msgid "at the bottom of the main module of your program."
|
||
msgstr "à la fin du module principal du programme."
|
||
|
||
#: faq/library.rst:162
|
||
#, fuzzy
|
||
msgid ""
|
||
"Once your program is organized as a tractable collection of function and "
|
||
"class behaviours, you should write test functions that exercise the "
|
||
"behaviours. A test suite that automates a sequence of tests can be "
|
||
"associated with each module. This sounds like a lot of work, but since "
|
||
"Python is so terse and flexible it's surprisingly easy. You can make coding "
|
||
"much more pleasant and fun by writing your test functions in parallel with "
|
||
"the \"production code\", since this makes it easy to find bugs and even "
|
||
"design flaws earlier."
|
||
msgstr ""
|
||
"Une fois que la logique du programme est implémentée par un ensemble de "
|
||
"fonctions et de comportements de classes, il faut écrire des fonctions de "
|
||
"test qui vont éprouver cette logique. À chaque module, il est possible "
|
||
"d'associer une suite de tests qui joue de manière automatique un ensemble de "
|
||
"tests. Au premier abord, il semble qu'il faille fournir un effort "
|
||
"conséquent, mais comme Python est un langage concis et flexible, c'est "
|
||
"surprenamment aisé. Écrire simultanément le code « de production » et les "
|
||
"fonctions de test associées rend le développement plus agréable et plus "
|
||
"amusant, car ceci permet de trouver des bogues, voire des défauts de "
|
||
"conception, plus facilement."
|
||
|
||
#: faq/library.rst:170
|
||
msgid ""
|
||
"\"Support modules\" that are not intended to be the main module of a program "
|
||
"may include a self-test of the module. ::"
|
||
msgstr ""
|
||
"Les « modules auxiliaires » qui n'ont pas vocation à être le module "
|
||
"principal du programme peuvent inclure un test pour se vérifier eux-mêmes. ::"
|
||
|
||
#: faq/library.rst:176
|
||
msgid ""
|
||
"Even programs that interact with complex external interfaces may be tested "
|
||
"when the external interfaces are unavailable by using \"fake\" interfaces "
|
||
"implemented in Python."
|
||
msgstr ""
|
||
"Les programmes qui interagissent avec des interfaces externes complexes "
|
||
"peuvent être testés même quand ces interfaces ne sont pas disponibles, en "
|
||
"utilisant des interfaces « simulacres » implémentées en Python."
|
||
|
||
#: faq/library.rst:182
|
||
msgid "How do I create documentation from doc strings?"
|
||
msgstr "Comment générer la documentation à partir des *docstrings* ?"
|
||
|
||
#: faq/library.rst:184
|
||
msgid ""
|
||
"The :mod:`pydoc` module can create HTML from the doc strings in your Python "
|
||
"source code. An alternative for creating API documentation purely from "
|
||
"docstrings is `epydoc <http://epydoc.sourceforge.net/>`_. `Sphinx <http://"
|
||
"sphinx-doc.org>`_ can also include docstring content."
|
||
msgstr ""
|
||
"Le module :mod:`pydoc` peut générer du HTML à partir des *docstrings* du "
|
||
"code source Python. Il est aussi possible de documenter une API uniquement à "
|
||
"partir des *docstrings* à l'aide de `epydoc <http://epydoc.sourceforge.net/"
|
||
">`_. `Sphinx <http://sphinx-doc.org>`_ peut également inclure du contenu "
|
||
"provenant de *docstrings*."
|
||
|
||
#: faq/library.rst:191
|
||
msgid "How do I get a single keypress at a time?"
|
||
msgstr "Comment détecter qu'une touche est pressée ?"
|
||
|
||
#: faq/library.rst:193
|
||
msgid ""
|
||
"For Unix variants there are several solutions. It's straightforward to do "
|
||
"this using curses, but curses is a fairly large module to learn."
|
||
msgstr ""
|
||
"Pour les dérivés d'Unix, plusieurs solutions s'offrent à vous. C'est facile "
|
||
"en utilisant le module *curses*, mais *curses* est un module assez "
|
||
"conséquent à apprendre."
|
||
|
||
#: faq/library.rst:237
|
||
msgid "Threads"
|
||
msgstr "Fils d'exécution"
|
||
|
||
#: faq/library.rst:240
|
||
msgid "How do I program using threads?"
|
||
msgstr "Comment programmer avec des fils d'exécution ?"
|
||
|
||
#: faq/library.rst:242
|
||
msgid ""
|
||
"Be sure to use the :mod:`threading` module and not the :mod:`_thread` "
|
||
"module. The :mod:`threading` module builds convenient abstractions on top of "
|
||
"the low-level primitives provided by the :mod:`_thread` module."
|
||
msgstr ""
|
||
"Veillez à bien utiliser le module :mod:`threading` et non le module :mod:"
|
||
"`_thread`. Le module :mod:`threading` fournit une abstraction plus facile à "
|
||
"manipuler que les primitives de bas-niveau du module :mod:`_thread`."
|
||
|
||
#: faq/library.rst:246
|
||
msgid ""
|
||
"Aahz has a set of slides from his threading tutorial that are helpful; see "
|
||
"http://www.pythoncraft.com/OSCON2001/."
|
||
msgstr ""
|
||
"Un ensemble de diapositives issues du didacticiel de Aahz sur les fils "
|
||
"d'exécution est disponible à http://www.pythoncraft.com/OSCON2001/."
|
||
|
||
#: faq/library.rst:251
|
||
msgid "None of my threads seem to run: why?"
|
||
msgstr "Aucun de mes fils ne semble s'exécuter : pourquoi ?"
|
||
|
||
#: faq/library.rst:253
|
||
msgid ""
|
||
"As soon as the main thread exits, all threads are killed. Your main thread "
|
||
"is running too quickly, giving the threads no time to do any work."
|
||
msgstr ""
|
||
"Dès que le fil d'exécution principal se termine, tous les fils sont tués. Le "
|
||
"fil principal s'exécute trop rapidement, sans laisser le temps aux autres "
|
||
"fils de faire quoi que ce soit."
|
||
|
||
#: faq/library.rst:256
|
||
msgid ""
|
||
"A simple fix is to add a sleep to the end of the program that's long enough "
|
||
"for all the threads to finish::"
|
||
msgstr ""
|
||
"Une correction simple consiste à ajouter un temps d'attente suffisamment "
|
||
"long à la fin du programme pour que tous les fils puissent se terminer ::"
|
||
|
||
#: faq/library.rst:271
|
||
msgid ""
|
||
"But now (on many platforms) the threads don't run in parallel, but appear to "
|
||
"run sequentially, one at a time! The reason is that the OS thread scheduler "
|
||
"doesn't start a new thread until the previous thread is blocked."
|
||
msgstr ""
|
||
"Mais à présent, sur beaucoup de plates-formes, les fils ne s'exécutent pas "
|
||
"en parallèle, mais semblent s'exécuter de manière séquentielle, l'un après "
|
||
"l'autre ! En réalité, l'ordonnanceur de fils du système d'exploitation ne "
|
||
"démarre pas de nouveau fil avant que le précédent ne soit bloqué."
|
||
|
||
#: faq/library.rst:275
|
||
msgid "A simple fix is to add a tiny sleep to the start of the run function::"
|
||
msgstr ""
|
||
"Une correction simple consiste à ajouter un petit temps d'attente au début "
|
||
"de la fonction ::"
|
||
|
||
#: faq/library.rst:288
|
||
msgid ""
|
||
"Instead of trying to guess a good delay value for :func:`time.sleep`, it's "
|
||
"better to use some kind of semaphore mechanism. One idea is to use the :mod:"
|
||
"`queue` module to create a queue object, let each thread append a token to "
|
||
"the queue when it finishes, and let the main thread read as many tokens from "
|
||
"the queue as there are threads."
|
||
msgstr ""
|
||
"Au lieu d'essayer de trouver une bonne valeur d'attente pour la fonction :"
|
||
"func:`time.sleep`, il vaut mieux utiliser un mécanisme basé sur les "
|
||
"sémaphores. Une solution consiste à utiliser le module :mod:`queue` pour "
|
||
"créer un objet file, faire en sorte que chaque fil ajoute un jeton à la file "
|
||
"quand il se termine, et que le fil principal retire autant de jetons de la "
|
||
"file qu'il y a de fils."
|
||
|
||
#: faq/library.rst:296
|
||
msgid "How do I parcel out work among a bunch of worker threads?"
|
||
msgstr ""
|
||
"Comment découper et répartir une tâche au sein d'un ensemble de fils "
|
||
"d'exécutions ?"
|
||
|
||
#: faq/library.rst:298
|
||
#, fuzzy
|
||
msgid ""
|
||
"The easiest way is to use the :mod:`concurrent.futures` module, especially "
|
||
"the :mod:`~concurrent.futures.ThreadPoolExecutor` class."
|
||
msgstr ""
|
||
"La manière la plus simple est d'utiliser le nouveau module :mod:`concurrent."
|
||
"futures`, en particulier la classe :mod:`~concurrent.futures."
|
||
"ThreadPoolExecutor`."
|
||
|
||
#: faq/library.rst:301
|
||
msgid ""
|
||
"Or, if you want fine control over the dispatching algorithm, you can write "
|
||
"your own logic manually. Use the :mod:`queue` module to create a queue "
|
||
"containing a list of jobs. The :class:`~queue.Queue` class maintains a list "
|
||
"of objects and has a ``.put(obj)`` method that adds items to the queue and a "
|
||
"``.get()`` method to return them. The class will take care of the locking "
|
||
"necessary to ensure that each job is handed out exactly once."
|
||
msgstr ""
|
||
"Ou bien, si vous désirez contrôler plus finement l'algorithme de "
|
||
"distribution, vous pouvez écrire votre propre logique « à la main ». "
|
||
"Utilisez le module :mod:`queue` pour créer une file de tâches ; la classe :"
|
||
"class:`~queue.Queue` gère une liste d'objets et a une méthode ``."
|
||
"put(objet)`` pour ajouter un élément à la file, et une méthode ``.get()`` "
|
||
"pour les récupérer. La classe s'occupe de gérer les verrous pour que chaque "
|
||
"tâche soit exécutée une et une seule fois."
|
||
|
||
#: faq/library.rst:308
|
||
msgid "Here's a trivial example::"
|
||
msgstr "Voici un exemple trivial ::"
|
||
|
||
#: faq/library.rst:346
|
||
msgid "When run, this will produce the following output:"
|
||
msgstr "Quand celui-ci est exécuté, il produit la sortie suivante :"
|
||
|
||
#: faq/library.rst:364
|
||
msgid ""
|
||
"Consult the module's documentation for more details; the :class:`~queue."
|
||
"Queue` class provides a featureful interface."
|
||
msgstr ""
|
||
"Consultez la documentation du module pour plus de détails ; la classe :class:"
|
||
"`~queue.Queue` fournit une interface pleine de fonctionnalités."
|
||
|
||
#: faq/library.rst:369
|
||
msgid "What kinds of global value mutation are thread-safe?"
|
||
msgstr ""
|
||
"Quels types de mutations sur des variables globales sont compatibles avec "
|
||
"les programmes à fils d'exécution multiples ? sécurisé ?"
|
||
|
||
#: faq/library.rst:371
|
||
msgid ""
|
||
"A :term:`global interpreter lock` (GIL) is used internally to ensure that "
|
||
"only one thread runs in the Python VM at a time. In general, Python offers "
|
||
"to switch among threads only between bytecode instructions; how frequently "
|
||
"it switches can be set via :func:`sys.setswitchinterval`. Each bytecode "
|
||
"instruction and therefore all the C implementation code reached from each "
|
||
"instruction is therefore atomic from the point of view of a Python program."
|
||
msgstr ""
|
||
"Le :term:`verrou global de l'interpréteur <global interpreter lock>` (GIL "
|
||
"pour *global interpreter lock*) est utilisé en interne pour s'assurer que la "
|
||
"machine virtuelle Python (MVP) n'exécute qu'un seul fil à la fois. De "
|
||
"manière générale, Python ne change de fil qu'entre les instructions du code "
|
||
"intermédiaire ; :func:`sys.setswitchinterval` permet de contrôler la "
|
||
"fréquence de bascule entre les fils. Chaque instruction du code "
|
||
"intermédiaire, et, par conséquent, tout le code C appelé par cette "
|
||
"instruction est donc atomique du point de vue d'un programme Python."
|
||
|
||
#: faq/library.rst:378
|
||
msgid ""
|
||
"In theory, this means an exact accounting requires an exact understanding of "
|
||
"the PVM bytecode implementation. In practice, it means that operations on "
|
||
"shared variables of built-in data types (ints, lists, dicts, etc) that "
|
||
"\"look atomic\" really are."
|
||
msgstr ""
|
||
"En théorie, cela veut dire qu'un décompte exact nécessite une connaissance "
|
||
"parfaite de l'implémentation de la MVP. En pratique, cela veut dire que les "
|
||
"opérations sur des variables partagées de type natif (les entier, les "
|
||
"listes, les dictionnaires etc.) qui « semblent atomiques » le sont "
|
||
"réellement."
|
||
|
||
#: faq/library.rst:383
|
||
msgid ""
|
||
"For example, the following operations are all atomic (L, L1, L2 are lists, "
|
||
"D, D1, D2 are dicts, x, y are objects, i, j are ints)::"
|
||
msgstr ""
|
||
"Par exemple, les opérations suivantes sont toutes atomiques (*L*, *L1* et "
|
||
"*L2* sont des listes, *D*, *D1* et *D2* sont des dictionnaires, *x* et *y* "
|
||
"sont des objets, *i* et *j* des entiers) ::"
|
||
|
||
#: faq/library.rst:398
|
||
msgid "These aren't::"
|
||
msgstr "Les suivantes ne le sont pas ::"
|
||
|
||
#: faq/library.rst:405
|
||
msgid ""
|
||
"Operations that replace other objects may invoke those other objects' :meth:"
|
||
"`__del__` method when their reference count reaches zero, and that can "
|
||
"affect things. This is especially true for the mass updates to dictionaries "
|
||
"and lists. When in doubt, use a mutex!"
|
||
msgstr ""
|
||
"Les opérations qui remplacent d'autres objets peuvent invoquer la méthode :"
|
||
"meth:`__del__` de ces objets quand leur compteur de référence passe à zéro, "
|
||
"et cela peut avoir de l'impact. C'est tout particulièrement vrai pour les "
|
||
"des changements massifs sur des dictionnaires ou des listes. En cas de "
|
||
"doute, il vaut mieux utiliser un mutex."
|
||
|
||
#: faq/library.rst:412
|
||
msgid "Can't we get rid of the Global Interpreter Lock?"
|
||
msgstr "Pourquoi ne pas se débarrasser du verrou global de l'interpréteur ?"
|
||
|
||
#: faq/library.rst:416
|
||
msgid ""
|
||
"The :term:`global interpreter lock` (GIL) is often seen as a hindrance to "
|
||
"Python's deployment on high-end multiprocessor server machines, because a "
|
||
"multi-threaded Python program effectively only uses one CPU, due to the "
|
||
"insistence that (almost) all Python code can only run while the GIL is held."
|
||
msgstr ""
|
||
"Le :term:`verrou global de l'interpréteur <global interpreter lock>` (GIL) "
|
||
"est souvent vu comme un obstacle au déploiement de code Python sur des "
|
||
"serveurs puissants avec de nombreux processeurs, car un programme Python à "
|
||
"fils d'exécutions multiples n'utilise en réalité qu'un seul processeur. "
|
||
"Presque tout le code Python ne peut en effet être exécuté qu'avec le GIL "
|
||
"acquis."
|
||
|
||
#: faq/library.rst:421
|
||
msgid ""
|
||
"Back in the days of Python 1.5, Greg Stein actually implemented a "
|
||
"comprehensive patch set (the \"free threading\" patches) that removed the "
|
||
"GIL and replaced it with fine-grained locking. Adam Olsen recently did a "
|
||
"similar experiment in his `python-safethread <https://code.google.com/"
|
||
"archive/p/python-safethread>`_ project. Unfortunately, both experiments "
|
||
"exhibited a sharp drop in single-thread performance (at least 30% slower), "
|
||
"due to the amount of fine-grained locking necessary to compensate for the "
|
||
"removal of the GIL."
|
||
msgstr ""
|
||
"À l'époque de Python 1.5, Greg Stein a bien implémenté un ensemble complet "
|
||
"de correctifs (les correctifs « fils d'exécution libres ») qui remplaçaient "
|
||
"le GIL par des verrous plus granulaires. Adam Olsen a conduit une expérience "
|
||
"similaire dans son projet `python-safethread <https://code.google.com/"
|
||
"archive/p/python-safethread>`_. Malheureusement, ces deux tentatives ont "
|
||
"induit une baisse significative (d'au moins 30%) des performances du code à "
|
||
"un seul fil d'exécution, à cause de la quantité de verrouillage plus "
|
||
"granulaire nécessaire pour contrebalancer la suppression du GIL."
|
||
|
||
#: faq/library.rst:429
|
||
msgid ""
|
||
"This doesn't mean that you can't make good use of Python on multi-CPU "
|
||
"machines! You just have to be creative with dividing the work up between "
|
||
"multiple *processes* rather than multiple *threads*. The :class:"
|
||
"`~concurrent.futures.ProcessPoolExecutor` class in the new :mod:`concurrent."
|
||
"futures` module provides an easy way of doing so; the :mod:`multiprocessing` "
|
||
"module provides a lower-level API in case you want more control over "
|
||
"dispatching of tasks."
|
||
msgstr ""
|
||
"Cela ne signifie pas qu'il est impossible de tirer profit de Python sur des "
|
||
"machines à plusieurs cœurs ! Il faut seulement être malin et diviser le "
|
||
"travail à faire entre plusieurs *processus* plutôt qu'entre plusieurs *fils "
|
||
"d'exécution*. La classe :class:`~concurrent.futures.ProcessPoolExecutor` du "
|
||
"nouveau module :mod:`concurrent.futures` permet de faire cela facilement ; "
|
||
"le module :mod:`multiprocessing` fournit une API de plus bas-niveau pour un "
|
||
"meilleur contrôle sur la distribution des tâches."
|
||
|
||
#: faq/library.rst:437
|
||
msgid ""
|
||
"Judicious use of C extensions will also help; if you use a C extension to "
|
||
"perform a time-consuming task, the extension can release the GIL while the "
|
||
"thread of execution is in the C code and allow other threads to get some "
|
||
"work done. Some standard library modules such as :mod:`zlib` and :mod:"
|
||
"`hashlib` already do this."
|
||
msgstr ""
|
||
"Des extensions C appropriées peuvent aussi aider ; en utilisant une "
|
||
"extension C pour effectuer une tâche longue, l'extension peut relâcher le "
|
||
"GIL pendant que le fil est en train d'exécuter ce code et laisser les autres "
|
||
"fils travailler. Des modules de la bibliothèque standard comme :mod:`zlib` "
|
||
"ou :mod:`hashlib` utilisent cette technique."
|
||
|
||
#: faq/library.rst:443
|
||
msgid ""
|
||
"It has been suggested that the GIL should be a per-interpreter-state lock "
|
||
"rather than truly global; interpreters then wouldn't be able to share "
|
||
"objects. Unfortunately, this isn't likely to happen either. It would be a "
|
||
"tremendous amount of work, because many object implementations currently "
|
||
"have global state. For example, small integers and short strings are cached; "
|
||
"these caches would have to be moved to the interpreter state. Other object "
|
||
"types have their own free list; these free lists would have to be moved to "
|
||
"the interpreter state. And so on."
|
||
msgstr ""
|
||
"On a déjà proposé de restreindre le GIL par interpréteur, et non plus d'être "
|
||
"complétement global ; les interpréteurs ne seraient plus en mesure de "
|
||
"partager des objets. Malheureusement, cela n'a pas beaucoup de chance non "
|
||
"plus d'arriver. Cela nécessiterait un travail considérable, car la façon "
|
||
"dont beaucoup d'objets sont implémentés rend leur état global. Par exemple, "
|
||
"les entiers et les chaînes de caractères courts sont mis en cache ; ces "
|
||
"caches devraient être déplacés au niveau de l'interpréteur. D'autres objets "
|
||
"ont leur propre liste de suppression, ces listes devraient être déplacées au "
|
||
"niveau de l'interpréteur et ainsi de suite."
|
||
|
||
#: faq/library.rst:452
|
||
msgid ""
|
||
"And I doubt that it can even be done in finite time, because the same "
|
||
"problem exists for 3rd party extensions. It is likely that 3rd party "
|
||
"extensions are being written at a faster rate than you can convert them to "
|
||
"store all their global state in the interpreter state."
|
||
msgstr ""
|
||
"C'est une tâche sans fin, car les extensions tierces ont le même problème, "
|
||
"et il est probable que les extensions tierces soient développées plus vite "
|
||
"qu'il ne soit possible de les corriger pour les faire stocker leur état au "
|
||
"niveau de l'interpréteur et non plus au niveau global."
|
||
|
||
#: faq/library.rst:457
|
||
msgid ""
|
||
"And finally, once you have multiple interpreters not sharing any state, what "
|
||
"have you gained over running each interpreter in a separate process?"
|
||
msgstr ""
|
||
"Et enfin, quel intérêt y-a t'il à avoir plusieurs interpréteurs qui ne "
|
||
"partagent pas d'état, par rapport à faire tourner chaque interpréteur dans "
|
||
"un processus différent ?"
|
||
|
||
#: faq/library.rst:462
|
||
msgid "Input and Output"
|
||
msgstr "Les entrées/sorties"
|
||
|
||
#: faq/library.rst:465
|
||
msgid "How do I delete a file? (And other file questions...)"
|
||
msgstr "Comment supprimer un fichier ? (et autres questions sur les fichiers…)"
|
||
|
||
#: faq/library.rst:467
|
||
msgid ""
|
||
"Use ``os.remove(filename)`` or ``os.unlink(filename)``; for documentation, "
|
||
"see the :mod:`os` module. The two functions are identical; :func:`~os."
|
||
"unlink` is simply the name of the Unix system call for this function."
|
||
msgstr ""
|
||
"Utilisez ``os.remove(filename)`` ou ``os.unlink(filename)`` ; pour la "
|
||
"documentation, référez-vous au module :mod:`os`. Ces deux fonctions sont "
|
||
"identiques, :func:`~os.unlink` n'est tout simplement que le nom de l'appel "
|
||
"système à cette fonction sous Unix."
|
||
|
||
#: faq/library.rst:471
|
||
msgid ""
|
||
"To remove a directory, use :func:`os.rmdir`; use :func:`os.mkdir` to create "
|
||
"one. ``os.makedirs(path)`` will create any intermediate directories in "
|
||
"``path`` that don't exist. ``os.removedirs(path)`` will remove intermediate "
|
||
"directories as long as they're empty; if you want to delete an entire "
|
||
"directory tree and its contents, use :func:`shutil.rmtree`."
|
||
msgstr ""
|
||
"Utilisez :func:`os.rmdir` pour supprimer un dossier et :func:`os.mkdir` pour "
|
||
"en créer un nouveau. ``os.makedirs(chemin)`` crée les dossiers "
|
||
"intermédiaires de ``chemin`` qui n'existent pas et ``os.removedirs(chemin)`` "
|
||
"supprime les dossiers intermédiaires si ceux-ci sont vides. Pour supprimer "
|
||
"une arborescence et tout son contenu, utilisez :func:`shutil.rmtree`."
|
||
|
||
#: faq/library.rst:477
|
||
msgid "To rename a file, use ``os.rename(old_path, new_path)``."
|
||
msgstr ""
|
||
"``os.rename(ancien_chemin, nouveau_chemin)`` permet de renommer un fichier."
|
||
|
||
#: faq/library.rst:479
|
||
msgid ""
|
||
"To truncate a file, open it using ``f = open(filename, \"rb+\")``, and use "
|
||
"``f.truncate(offset)``; offset defaults to the current seek position. "
|
||
"There's also ``os.ftruncate(fd, offset)`` for files opened with :func:`os."
|
||
"open`, where *fd* is the file descriptor (a small integer)."
|
||
msgstr ""
|
||
"Pour supprimer le contenu d'un fichier, ouvrez celui-ci avec ``f = "
|
||
"open(nom_du_fichier, \"rb+\")``, puis exécutez ``f.truncate(décalage)`` où "
|
||
"*décalage* est par défaut la position actuelle de la tête de lecture. Il "
|
||
"existe aussi ``os.ftruncate(df, décalage)`` pour les fichiers ouverts avec :"
|
||
"func:`os.open`, où *df* est le descripteur de fichier (un entier court)."
|
||
|
||
#: faq/library.rst:484
|
||
msgid ""
|
||
"The :mod:`shutil` module also contains a number of functions to work on "
|
||
"files including :func:`~shutil.copyfile`, :func:`~shutil.copytree`, and :"
|
||
"func:`~shutil.rmtree`."
|
||
msgstr ""
|
||
"Le module :mod:`shutil` propose aussi un grand nombre de fonctions pour "
|
||
"effectuer des opérations sur des fichiers comme :func:`~shutil.copyfile`, :"
|
||
"func:`~shutil.copytree` et :func:`~shutil.rmtree`."
|
||
|
||
#: faq/library.rst:490
|
||
msgid "How do I copy a file?"
|
||
msgstr "Comment copier un fichier ?"
|
||
|
||
#: faq/library.rst:492
|
||
msgid ""
|
||
"The :mod:`shutil` module contains a :func:`~shutil.copyfile` function. Note "
|
||
"that on MacOS 9 it doesn't copy the resource fork and Finder info."
|
||
msgstr ""
|
||
"Le module :mod:`shutil` fournit la fonction :func:`~shutil.copyfile`. Sous "
|
||
"MacOS 9, celle-ci ne copie pas le clonage de ressources ni les informations "
|
||
"du chercheur."
|
||
|
||
#: faq/library.rst:497
|
||
msgid "How do I read (or write) binary data?"
|
||
msgstr "Comment lire (ou écrire) des données binaires ?"
|
||
|
||
#: faq/library.rst:499
|
||
msgid ""
|
||
"To read or write complex binary data formats, it's best to use the :mod:"
|
||
"`struct` module. It allows you to take a string containing binary data "
|
||
"(usually numbers) and convert it to Python objects; and vice versa."
|
||
msgstr ""
|
||
"Pour lire ou écrire des formats de données complexes en binaire, il est "
|
||
"recommandé d'utiliser le module :mod:`struct`. Celui-ci permet de convertir "
|
||
"une chaîne de caractères qui contient des données binaires, souvent des "
|
||
"nombres, en objets Python, et vice-versa."
|
||
|
||
#: faq/library.rst:503
|
||
msgid ""
|
||
"For example, the following code reads two 2-byte integers and one 4-byte "
|
||
"integer in big-endian format from a file::"
|
||
msgstr ""
|
||
"Par exemple, le code suivant lit, depuis un fichier, deux entiers codés sur "
|
||
"2 octets et un entier codé sur 4 octets, en format gros-boutiste ::"
|
||
|
||
#: faq/library.rst:512
|
||
msgid ""
|
||
"The '>' in the format string forces big-endian data; the letter 'h' reads "
|
||
"one \"short integer\" (2 bytes), and 'l' reads one \"long integer\" (4 "
|
||
"bytes) from the string."
|
||
msgstr ""
|
||
"« > » dans la chaîne de formatage indique que la donnée doit être lue en "
|
||
"mode gros-boutiste, la lettre « h » indique un entier court (2 octets) et la "
|
||
"lettre « l » indique un entier long (4 octets)."
|
||
|
||
#: faq/library.rst:516
|
||
msgid ""
|
||
"For data that is more regular (e.g. a homogeneous list of ints or floats), "
|
||
"you can also use the :mod:`array` module."
|
||
msgstr ""
|
||
"Pour une donnée plus régulière (p. ex. une liste homogène d'entiers ou de "
|
||
"nombres à virgule flottante), il est possible d'utiliser le module :mod:"
|
||
"`array`."
|
||
|
||
#: faq/library.rst:521
|
||
msgid ""
|
||
"To read and write binary data, it is mandatory to open the file in binary "
|
||
"mode (here, passing ``\"rb\"`` to :func:`open`). If you use ``\"r\"`` "
|
||
"instead (the default), the file will be open in text mode and ``f.read()`` "
|
||
"will return :class:`str` objects rather than :class:`bytes` objects."
|
||
msgstr ""
|
||
"Pour lire et écrire de la donnée binaire, il est obligatoire d'ouvrir le "
|
||
"fichier en mode binaire également (ici, en passant ``\"rb\"`` à :func:"
|
||
"`open`). En utilisant ``\"r\"`` (valeur par défaut), le fichier est ouvert "
|
||
"en mode textuel et ``f.read()`` renvoie des objets :class:`str` au lieu "
|
||
"d'objets :class:`bytes`."
|
||
|
||
#: faq/library.rst:529
|
||
msgid "I can't seem to use os.read() on a pipe created with os.popen(); why?"
|
||
msgstr ""
|
||
"Il me semble impossible d'utiliser ``os.read()`` sur un tube créé avec ``os."
|
||
"popen()`` ; pourquoi ?"
|
||
|
||
#: faq/library.rst:531
|
||
msgid ""
|
||
":func:`os.read` is a low-level function which takes a file descriptor, a "
|
||
"small integer representing the opened file. :func:`os.popen` creates a high-"
|
||
"level file object, the same type returned by the built-in :func:`open` "
|
||
"function. Thus, to read *n* bytes from a pipe *p* created with :func:`os."
|
||
"popen`, you need to use ``p.read(n)``."
|
||
msgstr ""
|
||
":func:`os.read` est une fonction de bas niveau qui prend en paramètre un "
|
||
"descripteur de fichier — un entier court qui représente le fichier ouvert. :"
|
||
"func:`os.popen` crée un objet fichier de haut niveau, du même type que celui "
|
||
"renvoyé par la fonction native :func:`open`. Par conséquent, pour lire *n* "
|
||
"octets d'un tube *p* créé avec :func:`os.popen`, il faut utiliser ``p."
|
||
"read(n)``."
|
||
|
||
#: faq/library.rst:618
|
||
msgid "How do I access the serial (RS232) port?"
|
||
msgstr "Comment accéder au port de transmission en série (RS-232) ?"
|
||
|
||
#: faq/library.rst:620
|
||
msgid "For Win32, POSIX (Linux, BSD, etc.), Jython:"
|
||
msgstr "Pour Win32, POSIX (Linux, BSD, etc.) et Jython :"
|
||
|
||
#: faq/library.rst:622
|
||
msgid "http://pyserial.sourceforge.net"
|
||
msgstr "http://pyserial.sourceforge.net"
|
||
|
||
#: faq/library.rst:624
|
||
msgid "For Unix, see a Usenet post by Mitch Chapman:"
|
||
msgstr ""
|
||
"Pour Unix, référez-vous à une publication sur Usenet de Mitch Chapman :"
|
||
|
||
#: faq/library.rst:626
|
||
msgid "https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com"
|
||
msgstr "https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com"
|
||
|
||
#: faq/library.rst:630
|
||
msgid "Why doesn't closing sys.stdout (stdin, stderr) really close it?"
|
||
msgstr ""
|
||
"Pourquoi fermer *sys.stdout*, *sys.stdin*, *sys.stderr* ne les ferme pas "
|
||
"réellement ?"
|
||
|
||
#: faq/library.rst:632
|
||
msgid ""
|
||
"Python :term:`file objects <file object>` are a high-level layer of "
|
||
"abstraction on low-level C file descriptors."
|
||
msgstr ""
|
||
"Les :term:`objets fichiers <file object>` en Python sont des abstractions de "
|
||
"haut niveau sur les descripteurs de fichier C de bas niveau."
|
||
|
||
#: faq/library.rst:635
|
||
msgid ""
|
||
"For most file objects you create in Python via the built-in :func:`open` "
|
||
"function, ``f.close()`` marks the Python file object as being closed from "
|
||
"Python's point of view, and also arranges to close the underlying C file "
|
||
"descriptor. This also happens automatically in ``f``'s destructor, when "
|
||
"``f`` becomes garbage."
|
||
msgstr ""
|
||
"Pour la plupart des objets fichiers créés en Python avec la fonction native :"
|
||
"func:`open`, ``f.close()`` marque le fichier comme fermé du point de vue de "
|
||
"Python et ferme aussi le descripteur C sous-jacent. Le même mécanisme est "
|
||
"enclenché automatiquement dans le destructeur de ``f``, lorsque ``f`` est "
|
||
"recyclé."
|
||
|
||
#: faq/library.rst:641
|
||
msgid ""
|
||
"But stdin, stdout and stderr are treated specially by Python, because of the "
|
||
"special status also given to them by C. Running ``sys.stdout.close()`` "
|
||
"marks the Python-level file object as being closed, but does *not* close the "
|
||
"associated C file descriptor."
|
||
msgstr ""
|
||
"Mais *stdin*, *stdout* et *stderr* ont droit à un traitement spécial en "
|
||
"Python, car leur statut en C est lui-aussi spécial. Exécuter ``sys.stdout."
|
||
"close()`` marque l'objet fichier comme fermé du point de vue de Python, mais "
|
||
"le descripteur de fichier C associé n'est *pas* fermé."
|
||
|
||
#: faq/library.rst:646
|
||
msgid ""
|
||
"To close the underlying C file descriptor for one of these three, you should "
|
||
"first be sure that's what you really want to do (e.g., you may confuse "
|
||
"extension modules trying to do I/O). If it is, use :func:`os.close`::"
|
||
msgstr ""
|
||
"Pour fermer le descripteur de fichier sous-jacent C de l'une de ces trois "
|
||
"sorties, demandez-vous avant tout si vous êtes sûr de vous (cela peut, par "
|
||
"exemple, perturber le bon fonctionnement de modules qui font des opérations "
|
||
"d'entrée-sortie). Si c'est le cas, utilisez :func:`os.close` ::"
|
||
|
||
#: faq/library.rst:654
|
||
msgid "Or you can use the numeric constants 0, 1 and 2, respectively."
|
||
msgstr ""
|
||
"Il est aussi possible de fermer respectivement les constantes numériques 0, "
|
||
"1 ou 2."
|
||
|
||
#: faq/library.rst:658
|
||
msgid "Network/Internet Programming"
|
||
msgstr "Programmation réseau et Internet"
|
||
|
||
#: faq/library.rst:661
|
||
msgid "What WWW tools are there for Python?"
|
||
msgstr "Quels sont les outils Python dédiés à la Toile ?"
|
||
|
||
#: faq/library.rst:663
|
||
msgid ""
|
||
"See the chapters titled :ref:`internet` and :ref:`netdata` in the Library "
|
||
"Reference Manual. Python has many modules that will help you build server-"
|
||
"side and client-side web systems."
|
||
msgstr ""
|
||
"Référez-vous aux chapitres intitulés :ref:`internet` et :ref:`netdata` dans "
|
||
"le manuel de référence de la bibliothèque. Python a de nombreux modules pour "
|
||
"construire des applications de Toile côté client comme côté serveur."
|
||
|
||
#: faq/library.rst:669
|
||
msgid ""
|
||
"A summary of available frameworks is maintained by Paul Boddie at https://"
|
||
"wiki.python.org/moin/WebProgramming\\ ."
|
||
msgstr ""
|
||
"Un résumé des cadriciels disponibles est maintenu par Paul Boddie à "
|
||
"l'adresse https://wiki.python.org/moin/WebProgramming\\ ."
|
||
|
||
#: faq/library.rst:672
|
||
msgid ""
|
||
"Cameron Laird maintains a useful set of pages about Python web technologies "
|
||
"at http://phaseit.net/claird/comp.lang.python/web_python."
|
||
msgstr ""
|
||
"Cameron Laird maintient un ensemble intéressant d'articles sur les "
|
||
"technologies Python dédiées à la Toile à l'adresse http://phaseit.net/claird/"
|
||
"comp.lang.python/web_python."
|
||
|
||
#: faq/library.rst:677
|
||
msgid "How can I mimic CGI form submission (METHOD=POST)?"
|
||
msgstr "Comment reproduire un envoi de formulaire CGI (``METHOD=POST``) ?"
|
||
|
||
#: faq/library.rst:679
|
||
msgid ""
|
||
"I would like to retrieve web pages that are the result of POSTing a form. Is "
|
||
"there existing code that would let me do this easily?"
|
||
msgstr ""
|
||
"J'aimerais récupérer la page de retour d'un envoi de formulaire sur la "
|
||
"Toile. Existe-t'il déjà du code qui pourrait m'aider à le faire facilement ?"
|
||
|
||
#: faq/library.rst:682
|
||
#, fuzzy
|
||
msgid "Yes. Here's a simple example that uses :mod:`urllib.request`::"
|
||
msgstr "Oui. Voici un exemple simple d'utilisation de *urllib.request* ::"
|
||
|
||
#: faq/library.rst:697
|
||
msgid ""
|
||
"Note that in general for percent-encoded POST operations, query strings must "
|
||
"be quoted using :func:`urllib.parse.urlencode`. For example, to send "
|
||
"``name=Guy Steele, Jr.``::"
|
||
msgstr ""
|
||
"Remarquez qu'en général, la chaîne de caractères d'une requête POST encodée "
|
||
"avec des des signes « % » doit être mise entre guillemets à l'aide de :func:"
|
||
"`urllib.parse.urlencode`. Par exemple pour envoyer ``name=Guy Steele, Jr."
|
||
"`` ::"
|
||
|
||
#: faq/library.rst:705
|
||
msgid ":ref:`urllib-howto` for extensive examples."
|
||
msgstr ":ref:`urllib-howto` pour des exemples complets."
|
||
|
||
#: faq/library.rst:709
|
||
msgid "What module should I use to help with generating HTML?"
|
||
msgstr "Quel module utiliser pour générer du HTML ?"
|
||
|
||
#: faq/library.rst:713
|
||
msgid ""
|
||
"You can find a collection of useful links on the `Web Programming wiki page "
|
||
"<https://wiki.python.org/moin/WebProgramming>`_."
|
||
msgstr ""
|
||
"La `page wiki de la programmation Toile <https://wiki.python.org/moin/"
|
||
"WebProgramming>`_ (en anglais) répertorie un ensemble de liens pertinents."
|
||
|
||
#: faq/library.rst:718
|
||
msgid "How do I send mail from a Python script?"
|
||
msgstr "Comment envoyer un courriel avec un script Python ?"
|
||
|
||
#: faq/library.rst:720
|
||
msgid "Use the standard library module :mod:`smtplib`."
|
||
msgstr "Utilisez le module :mod:`smtplib` de la bibliothèque standard."
|
||
|
||
#: faq/library.rst:722
|
||
msgid ""
|
||
"Here's a very simple interactive mail sender that uses it. This method will "
|
||
"work on any host that supports an SMTP listener. ::"
|
||
msgstr ""
|
||
"Voici un exemple très simple d'un envoyeur de courriel qui l'utilise. Cette "
|
||
"méthode fonctionne sur tous les serveurs qui implémentent SMTP. ::"
|
||
|
||
#: faq/library.rst:742
|
||
msgid ""
|
||
"A Unix-only alternative uses sendmail. The location of the sendmail program "
|
||
"varies between systems; sometimes it is ``/usr/lib/sendmail``, sometimes ``/"
|
||
"usr/sbin/sendmail``. The sendmail manual page will help you out. Here's "
|
||
"some sample code::"
|
||
msgstr ""
|
||
"Sous Unix, il est possible d'utiliser *sendmail*. La localisation de "
|
||
"l'exécutable *sendmail* dépend du système ; cela peut-être ``/usr/lib/"
|
||
"sendmail`` ou ``/usr/sbin/sendmail``, la page de manuel de *sendmail* peut "
|
||
"vous aider. Par exemple ::"
|
||
|
||
#: faq/library.rst:762
|
||
msgid "How do I avoid blocking in the connect() method of a socket?"
|
||
msgstr ""
|
||
"Comment éviter de bloquer dans la méthode ``connect()`` d'un connecteur "
|
||
"réseau ?"
|
||
|
||
#: faq/library.rst:764
|
||
msgid ""
|
||
"The :mod:`select` module is commonly used to help with asynchronous I/O on "
|
||
"sockets."
|
||
msgstr ""
|
||
"Le module :mod:`select` est fréquemment utilisé pour effectuer des entrées-"
|
||
"sorties asynchrones sur des connecteurs réseaux."
|
||
|
||
#: faq/library.rst:767
|
||
#, fuzzy
|
||
msgid ""
|
||
"To prevent the TCP connect from blocking, you can set the socket to non-"
|
||
"blocking mode. Then when you do the :meth:`socket.connect`, you will either "
|
||
"connect immediately (unlikely) or get an exception that contains the error "
|
||
"number as ``.errno``. ``errno.EINPROGRESS`` indicates that the connection is "
|
||
"in progress, but hasn't finished yet. Different OSes will return different "
|
||
"values, so you're going to have to check what's returned on your system."
|
||
msgstr ""
|
||
"Pour empêcher une connexion TCP de se bloquer, il est possible de mettre le "
|
||
"connecteur en mode lecture seule. Avec cela, au moment du ``connect()``, la "
|
||
"connexion pourra être immédiate (peu probable) ou bien vous obtiendrez une "
|
||
"exception qui contient le numéro d'erreur dans ``.errno``. ``errno."
|
||
"EINPROGRESS`` indique que la connexion est en cours, mais qu'elle n'a pas "
|
||
"encore aboutie. La valeur dépend du système d'exploitation, donc renseignez-"
|
||
"vous sur la valeur utilisée par votre système."
|
||
|
||
#: faq/library.rst:774
|
||
#, fuzzy
|
||
msgid ""
|
||
"You can use the :meth:`socket.connect_ex` method to avoid creating an "
|
||
"exception. It will just return the errno value. To poll, you can call :"
|
||
"meth:`socket.connect_ex` again later -- ``0`` or ``errno.EISCONN`` indicate "
|
||
"that you're connected -- or you can pass this socket to :meth:`select."
|
||
"select` to check if it's writable."
|
||
msgstr ""
|
||
"``connect_ex()`` permet d'éviter la création de l'exception, et de ne "
|
||
"renvoyer que la valeur de *errno*. Pour vérifier l'état de la connexion, "
|
||
"utilisez encore une fois ``connect_ex()`` — ``0`` ou ``errno.EISCONN`` "
|
||
"indiquent que la connexion est active — ou passez le connecteur en argument "
|
||
"de ``select()`` pour vérifier si le connecteur est prêt à recevoir des "
|
||
"entrées."
|
||
|
||
#: faq/library.rst:780
|
||
#, fuzzy
|
||
msgid ""
|
||
"The :mod:`asyncio` module provides a general purpose single-threaded and "
|
||
"concurrent asynchronous library, which can be used for writing non-blocking "
|
||
"network code. The third-party `Twisted <https://twistedmatrix.com/trac/>`_ "
|
||
"library is a popular and feature-rich alternative."
|
||
msgstr ""
|
||
"Le module :mod:`asyncore` propose une approche en cadriciel pour écrire du "
|
||
"code réseau non-bloquant. La bibliothèque tierce `Twisted <https://"
|
||
"twistedmatrix.com/trac/>`_ en est une alternative plébiscitée, avec un grand "
|
||
"nombre de fonctionnalités."
|
||
|
||
#: faq/library.rst:788
|
||
msgid "Databases"
|
||
msgstr "Bases de données"
|
||
|
||
#: faq/library.rst:791
|
||
msgid "Are there any interfaces to database packages in Python?"
|
||
msgstr ""
|
||
"Existe-t'il des modules Python pour s'interfacer avec des bases de données ?"
|
||
|
||
#: faq/library.rst:793
|
||
msgid "Yes."
|
||
msgstr "Oui."
|
||
|
||
#: faq/library.rst:795
|
||
msgid ""
|
||
"Interfaces to disk-based hashes such as :mod:`DBM <dbm.ndbm>` and :mod:`GDBM "
|
||
"<dbm.gnu>` are also included with standard Python. There is also the :mod:"
|
||
"`sqlite3` module, which provides a lightweight disk-based relational "
|
||
"database."
|
||
msgstr ""
|
||
"La distribution standard de Python fournit aussi des interfaces à des bases "
|
||
"de données comme :mod:`DBM <dbm.ndbm>` ou :mod:`GDBM <dbm.gnu>`. Il existe "
|
||
"aussi le module :mod:`sqlite3` qui implémente une base de données "
|
||
"relationelle légère sur disque."
|
||
|
||
#: faq/library.rst:800
|
||
msgid ""
|
||
"Support for most relational databases is available. See the "
|
||
"`DatabaseProgramming wiki page <https://wiki.python.org/moin/"
|
||
"DatabaseProgramming>`_ for details."
|
||
msgstr ""
|
||
"La gestion de la plupart des bases de données relationnelles est assurée. "
|
||
"Voir la page wiki `DatabaseProgramming <https://wiki.python.org/moin/"
|
||
"DatabaseProgramming>`_ pour plus de détails."
|
||
|
||
#: faq/library.rst:806
|
||
msgid "How do you implement persistent objects in Python?"
|
||
msgstr "Comment implémenter la persistance d'objets en Python ?"
|
||
|
||
#: faq/library.rst:808
|
||
msgid ""
|
||
"The :mod:`pickle` library module solves this in a very general way (though "
|
||
"you still can't store things like open files, sockets or windows), and the :"
|
||
"mod:`shelve` library module uses pickle and (g)dbm to create persistent "
|
||
"mappings containing arbitrary Python objects."
|
||
msgstr ""
|
||
"Le module :mod:`pickle` répond à cela de manière large (bien qu'il ne soit "
|
||
"pas possible de stocker des fichiers ouverts, des connecteurs ou des "
|
||
"fenêtres par exemple), et le module :mod:`shelve` de la bibliothèque utilise "
|
||
"*pickle* et *(g)dbm* pour créer des liens persistants vers des objets Python."
|
||
|
||
#: faq/library.rst:815
|
||
msgid "Mathematics and Numerics"
|
||
msgstr "Mathématiques et calcul numérique"
|
||
|
||
#: faq/library.rst:818
|
||
msgid "How do I generate random numbers in Python?"
|
||
msgstr "Comment générer des nombres aléatoires en Python ?"
|
||
|
||
#: faq/library.rst:820
|
||
msgid ""
|
||
"The standard module :mod:`random` implements a random number generator. "
|
||
"Usage is simple::"
|
||
msgstr ""
|
||
"Le module :mod:`random` de la bibliothèque standard comprend un générateur "
|
||
"de nombres aléatoires. Son utilisation est simple ::"
|
||
|
||
#: faq/library.rst:826
|
||
msgid "This returns a random floating point number in the range [0, 1)."
|
||
msgstr ""
|
||
"Le code précédent renvoie un nombre à virgule flottante aléatoire dans "
|
||
"l'intervalle [0, 1[."
|
||
|
||
#: faq/library.rst:828
|
||
msgid ""
|
||
"There are also many other specialized generators in this module, such as:"
|
||
msgstr "Ce module fournit beaucoup d'autres générateurs spécialisés comme :"
|
||
|
||
#: faq/library.rst:830
|
||
msgid "``randrange(a, b)`` chooses an integer in the range [a, b)."
|
||
msgstr "``randrange(a, b)`` génère un entier dans l'intervalle [a, b[."
|
||
|
||
#: faq/library.rst:831
|
||
msgid "``uniform(a, b)`` chooses a floating point number in the range [a, b)."
|
||
msgstr ""
|
||
"``uniform(a, b)`` génère un nombre à virgule flottante aléatoire dans "
|
||
"l'intervalle [a, b[."
|
||
|
||
#: faq/library.rst:832
|
||
msgid ""
|
||
"``normalvariate(mean, sdev)`` samples the normal (Gaussian) distribution."
|
||
msgstr "``normalvariate(mean, sdev)`` simule la loi normale (Gaussienne)."
|
||
|
||
#: faq/library.rst:834
|
||
msgid "Some higher-level functions operate on sequences directly, such as:"
|
||
msgstr ""
|
||
"Des fonctions de haut niveau opèrent directement sur des séquences comme :"
|
||
|
||
#: faq/library.rst:836
|
||
#, fuzzy
|
||
msgid "``choice(S)`` chooses a random element from a given sequence."
|
||
msgstr "``choice(S)`` sélectionne au hasard un élément d'une séquence donnée"
|
||
|
||
#: faq/library.rst:837
|
||
#, fuzzy
|
||
msgid "``shuffle(L)`` shuffles a list in-place, i.e. permutes it randomly."
|
||
msgstr ""
|
||
"``shuffle(L)`` mélange une liste en-place, c.-à-d. lui applique une "
|
||
"permutation aléatoire"
|
||
|
||
#: faq/library.rst:839
|
||
msgid ""
|
||
"There's also a ``Random`` class you can instantiate to create independent "
|
||
"multiple random number generators."
|
||
msgstr ""
|
||
"Il existe aussi une classe ``Random`` qu'il est possible d'instancier pour "
|
||
"créer des générateurs aléatoires indépendants."
|