# 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: 2019-12-11 11:09+0100\n"
"Last-Translator: Zepmanbc <zepman@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.2.3\n"

#: faq/windows.rst:9
msgid "Python on Windows FAQ"
msgstr "FAQ : Python et Windows"

#: faq/windows.rst:12
msgid "Contents"
msgstr "Sommaire"

#: faq/windows.rst:22
msgid "How do I run a Python program under Windows?"
msgstr "Comment exécuter un programme Python sous Windows ?"

#: faq/windows.rst:24
msgid ""
"This is not necessarily a straightforward question. If you are already "
"familiar with running programs from the Windows command line then everything "
"will seem obvious; otherwise, you might need a little more guidance."
msgstr ""
"Ce n'est pas forcément une question simple. Si vous êtes déjà familier avec "
"le lancement de programmes depuis la ligne de commande de Windows alors tout "
"semblera évident ; sinon, vous pourriez avoir besoin d'être un peu guidé."

#: faq/windows.rst:28
msgid ""
"Unless you use some sort of integrated development environment, you will end "
"up *typing* Windows commands into what is variously referred to as a \"DOS "
"window\" or \"Command prompt window\".  Usually you can create such a window "
"from your search bar by searching for ``cmd``.  You should be able to "
"recognize when you have started such a window because you will see a Windows "
"\"command prompt\", which usually looks like this:"
msgstr ""
"À moins que vous n'utilisiez une sorte d'environnement de développement, "
"vous finirez par *taper* des commandes Windows dans ce qui est diversement "
"appelé une \"fenêtre DOS\" ou \"invite de commande Windows\". En général "
"vous pouvez ouvrir un telle fenêtre depuis votre barre de recherche en "
"cherchant ``cmd``. Vous devriez être capable de reconnaitre quand vous avez "
"lancé une telle fenêtre parce que vous verrez une invite de commande "
"Windows, qui en en général ressemble à ça :"

#: faq/windows.rst:39
msgid ""
"The letter may be different, and there might be other things after it, so "
"you might just as easily see something like:"
msgstr ""
"La lettre peut être différente, et il peut y avoir d'autres choses à la "
"suite, alors il se peut que ça ressemble également à ça :"

#: faq/windows.rst:46
msgid ""
"depending on how your computer has been set up and what else you have "
"recently done with it.  Once you have started such a window, you are well on "
"the way to running Python programs."
msgstr ""
"selon la configuration de votre ordinateur et ce que vous avez récemment "
"fait avec. Une fois que vous avez ouvert cette fenêtre, vous êtes bien "
"partis pour pouvoir lancer des programmes Python."

#: faq/windows.rst:50
msgid ""
"You need to realize that your Python scripts have to be processed by another "
"program called the Python *interpreter*.  The interpreter reads your script, "
"compiles it into bytecodes, and then executes the bytecodes to run your "
"program. So, how do you arrange for the interpreter to handle your Python?"
msgstr ""
"Retenez que vos scripts Python doivent être traités par un autre programme "
"appelé \"l’interpréteur\" Python. L’interpréteur lit votre script, le "
"compile en *bytecode*, et exécute le *bytecode* pour faire tourner votre "
"programme. Alors, comment faire pour donner votre code Python à "
"l'interpréteur ?"

#: faq/windows.rst:55
msgid ""
"First, you need to make sure that your command window recognises the word "
"\"py\" as an instruction to start the interpreter.  If you have opened a "
"command window, you should try entering the command ``py`` and hitting "
"return:"
msgstr ""
"Tout d'abord, vous devez vous assurer que votre fenêtre d'invite de commande "
"reconnaît le mot \"python\" comme une instruction pour démarrer "
"l'interpréteur. Si vous avez ouvert une invite de commande, entrez la "
"commande ``py``, puis appuyez sur entrée :"

#: faq/windows.rst:64
msgid "You should then see something like:"
msgstr "Vous devez voir quelque chose comme ça :"

#: faq/windows.rst:72
msgid ""
"You have started the interpreter in \"interactive mode\". That means you can "
"enter Python statements or expressions interactively and have them executed "
"or evaluated while you wait.  This is one of Python's strongest features.  "
"Check it by entering a few expressions of your choice and seeing the results:"
msgstr ""
"Vous avez lancé l'interpréteur dans son \"mode interactif\". Cela signifie "
"que vous pouvez entrer des instructions ou des expressions Python de manière "
"interactive pour qu'elles soient exécutées. Il s'agit là d'une des plus "
"puissantes fonctionnalités de Python. Vous pouvez le vérifier en entrant "
"quelques commandes de votre choix et en regardant le résultat :"

#: faq/windows.rst:84
msgid ""
"Many people use the interactive mode as a convenient yet highly programmable "
"calculator.  When you want to end your interactive Python session, call the :"
"func:`exit` function or hold the :kbd:`Ctrl` key down while you enter a :kbd:"
"`Z`, then hit the \":kbd:`Enter`\" key to get back to your Windows command "
"prompt."
msgstr ""
"Beaucoup de gens utilisent le mode interactif comme une calculatrice "
"pratique mais néanmoins hautement programmable. Lorsque vous souhaitez "
"mettre fin à votre session Python interactive, appelez la fonction :func:"
"`exit` ou maintenez la touche :kbd:`Ctrl` enfoncée pendant que vous entrez "
"un :kbd:`Z`, puis appuyez sur la touche \":kbd:`Enter`\" pour revenir à "
"votre invite de commande Windows."

#: faq/windows.rst:90
msgid ""
"You may also find that you have a Start-menu entry such as :menuselection:"
"`Start --> Programs --> Python 3.x --> Python (command line)` that results "
"in you seeing the ``>>>`` prompt in a new window.  If so, the window will "
"disappear after you call the :func:`exit` function or enter the :kbd:`Ctrl-"
"Z` character; Windows is running a single \"python\" command in the window, "
"and closes it when you terminate the interpreter."
msgstr ""
"Peut-être avez-vous remarqué une nouvelle entrée dans votre menu Démarrer "
"telle que :menuselection:`Démarrer --> Programmes --> Python 3.x --> Python "
"(ligne de commande)` qui a pour résultat que vous voyez l'invite ``>>>`` "
"dans une nouvelle fenêtre.  Si oui, la fenêtre va disparaître quand vous "
"appellerez la fonction :func:`exit` ou entrez le caractère :kbd:`Ctrl-Z` ; "
"Windows exécute une commande \"python\" dans la fenêtre et ferme celle-ci "
"lorsque vous fermez l'interpréteur."

#: faq/windows.rst:97
msgid ""
"Now that we know the ``py`` command is recognized, you can give your Python "
"script to it. You'll have to give either an absolute or a relative path to "
"the Python script. Let's say your Python script is located in your desktop "
"and is named ``hello.py``, and your command prompt is nicely opened in your "
"home directory so you're seeing something similar to::"
msgstr ""
"Maintenant que nous savons que la commande ``py`` est reconnue, vous pouvez "
"lui donner votre script Python. Vous devez donner le chemin absolu ou "
"relatif du script Python. Disons que votre script Python est situé sur votre "
"bureau et est nommé ``hello.py``, et votre invite de commande est bien "
"ouvert dans votre répertoire d’accueil, alors vous voyez quelque chose "
"comme ::"

#: faq/windows.rst:106
msgid ""
"So now you'll ask the ``py`` command to give your script to Python by typing "
"``py`` followed by your script path::"
msgstr ""
"Alors maintenant, vous demanderez à la commande ``py`` de donner votre "
"script à Python en tapant ``py`` suivi de votre chemin de script ::"

#: faq/windows.rst:114
msgid "How do I make Python scripts executable?"
msgstr "Comment rendre des scripts Python exécutables ?"

#: faq/windows.rst:116
msgid ""
"On Windows, the standard Python installer already associates the .py "
"extension with a file type (Python.File) and gives that file type an open "
"command that runs the interpreter (``D:\\Program Files\\Python\\python.exe "
"\"%1\" %*``).  This is enough to make scripts executable from the command "
"prompt as 'foo.py'.  If you'd rather be able to execute the script by simple "
"typing 'foo' with no extension you need to add .py to the PATHEXT "
"environment variable."
msgstr ""
"Sous Windows, l'installateur Python associe l'extension *.py* avec un type "
"de fichier (Python.File) et une commande qui lance l’interpréteur (``D:"
"\\Program Files\\Python\\python.exe \"%1\" %*``). Cela suffit pour pouvoir "
"exécuter les scripts Python depuis la ligne de commande en saisissant *foo."
"py*. Si vous souhaitez pouvoir exécuter les scripts en saisissant simplement "
"*foo* sans l’extension, vous devez ajouter *.py* au paramètre "
"d’environnement PATHEXT."

#: faq/windows.rst:124
msgid "Why does Python sometimes take so long to start?"
msgstr "Pourquoi Python met-il du temps à démarrer ?"

#: faq/windows.rst:126
msgid ""
"Usually Python starts very quickly on Windows, but occasionally there are "
"bug reports that Python suddenly begins to take a long time to start up.  "
"This is made even more puzzling because Python will work fine on other "
"Windows systems which appear to be configured identically."
msgstr ""
"Normalement, sous Windows, Python se lance très rapidement, mais parfois des "
"rapports d'erreurs indiquent que Python commence soudain à prendre beaucoup "
"de temps pour démarrer. C'est d'autant plus intrigant que Python fonctionne "
"correctement avec d'autres Windows configurés de façon similaire."

#: faq/windows.rst:131
msgid ""
"The problem may be caused by a misconfiguration of virus checking software "
"on the problem machine.  Some virus scanners have been known to introduce "
"startup overhead of two orders of magnitude when the scanner is configured "
"to monitor all reads from the filesystem.  Try checking the configuration of "
"virus scanning software on your systems to ensure that they are indeed "
"configured identically. McAfee, when configured to scan all file system read "
"activity, is a particular offender."
msgstr ""
"Le problème peut venir d'un antivirus mal configuré. Certains antivirus sont "
"connus pour doubler le temps de démarrage lorsqu'ils sont configurés pour "
"surveiller toutes les lectures du système de fichiers. Essayez de regarder "
"si les antivirus des deux machines sont bien paramétrés à l'identique. "
"*McAfee* est particulièrement problématique lorsqu'il est paramétré pour "
"surveiller toutes les lectures du système de fichiers."

#: faq/windows.rst:141
msgid "How do I make an executable from a Python script?"
msgstr "Comment construire un exécutable depuis un script Python ?"

#: faq/windows.rst:143
msgid ""
"See `cx_Freeze <https://anthony-tuininga.github.io/cx_Freeze/>`_ for a "
"distutils extension that allows you to create console and GUI executables "
"from Python code. `py2exe <http://www.py2exe.org/>`_, the most popular "
"extension for building Python 2.x-based executables, does not yet support "
"Python 3 but a version that does is in development."
msgstr ""
"Regardez `cx_Freeze <https://anthony-tuininga.github.io/cx_Freeze/>`_ pour "
"une extension *distutils* qui permet de créer des exécutables console et IUG "
"à partir de code Python. `py2exe <http://www.py2exe.org/>`_ est l'extension "
"la plus populaire pour construire des exécutables basés sur Python 2.x mais "
"l'implémentation en Python 3 est en cours de développement."

#: faq/windows.rst:151
msgid "Is a ``*.pyd`` file the same as a DLL?"
msgstr "Est-ce qu'un fichier ``*.pyd`` est la même chose qu'une DLL ?"

#: faq/windows.rst:153
msgid ""
"Yes, .pyd files are dll's, but there are a few differences.  If you have a "
"DLL named ``foo.pyd``, then it must have a function ``PyInit_foo()``.  You "
"can then write Python \"import foo\", and Python will search for foo.pyd (as "
"well as foo.py, foo.pyc) and if it finds it, will attempt to call "
"``PyInit_foo()`` to initialize it.  You do not link your .exe with foo.lib, "
"as that would cause Windows to require the DLL to be present."
msgstr ""
"Oui, les fichiers *.pyd* sont des fichiers *dll*, mais il y a quelques "
"différences.  Si vous avez une *DLL* ``foo.pyd``, celle-ci doit posséder une "
"fonction ``PyInit_foo()``.  Vous pouvez alors écrire en Python « *import "
"foo* » et Python recherchera le fichier *foo.pyd* (ainsi que *foo.py* et "
"*foo.pyc*); s'il le trouve, il tentera d'appeler ``PyInit_foo()`` pour "
"l'initialiser.  Ne liez pas votre *.exe* avec *foo.lib* car dans ce cas "
"Windows aura besoin de la DLL."

#: faq/windows.rst:160
msgid ""
"Note that the search path for foo.pyd is PYTHONPATH, not the same as the "
"path that Windows uses to search for foo.dll.  Also, foo.pyd need not be "
"present to run your program, whereas if you linked your program with a dll, "
"the dll is required.  Of course, foo.pyd is required if you want to say "
"``import foo``.  In a DLL, linkage is declared in the source code with "
"``__declspec(dllexport)``. In a .pyd, linkage is defined in a list of "
"available functions."
msgstr ""
"Notez que le chemin de recherche pour *foo.pyd* est *PYTHONPATH*, il est "
"différent de celui qu'utilise Windows pour rechercher *foo.dll*.  De plus, "
"*foo.pyd* n'a pas besoin d'être présent pour que votre programme s'exécute "
"alors que si vous avez lié votre programme avec une *dll* celle-ci est "
"requise.  Bien sûr *foo.pyd* est nécessaire si vous écrivez ``import foo``.  "
"Dans une *DLL* le lien est déclaré dans le code source avec "
"``__declspec(dllexport)``. Dans un *.pyd* la liaison est définie dans une "
"liste de fonctions disponibles."

#: faq/windows.rst:169
msgid "How can I embed Python into a Windows application?"
msgstr "Comment puis-je intégrer Python dans une application Windows ?"

#: faq/windows.rst:171
msgid ""
"Embedding the Python interpreter in a Windows app can be summarized as "
"follows:"
msgstr ""
"L'intégration de l'interpréteur Python dans une application Windows peut se "
"résumer comme suit :"

#: faq/windows.rst:173
msgid ""
"Do _not_ build Python into your .exe file directly.  On Windows, Python must "
"be a DLL to handle importing modules that are themselves DLL's.  (This is "
"the first key undocumented fact.)  Instead, link to :file:`python{NN}.dll`; "
"it is typically installed in ``C:\\Windows\\System``.  *NN* is the Python "
"version, a number such as \"33\" for Python 3.3."
msgstr ""
"Ne compilez **pas** Python directement dans votre fichier *.exe*.  Sous "
"Windows, Python doit être une DLL pour pouvoir importer des modules qui sont "
"eux-mêmes des DLL (ceci constitue une information de première importance non "
"documentée). Au lieu de cela faites un lien vers :file:`python{NN}.dll` qui "
"est généralement placé dans ``C:\\Windows\\System``.  *NN* étant la version "
"Python, par exemple « 33 » pour Python 3.3."

#: faq/windows.rst:179
msgid ""
"You can link to Python in two different ways.  Load-time linking means "
"linking against :file:`python{NN}.lib`, while run-time linking means linking "
"against :file:`python{NN}.dll`.  (General note: :file:`python{NN}.lib` is "
"the so-called \"import lib\" corresponding to :file:`python{NN}.dll`.  It "
"merely defines symbols for the linker.)"
msgstr ""
"Vous pouvez créer un lien vers Python de deux manières différentes.  Un lien "
"au moment du chargement signifie pointer vers :file:`python{NN}.lib`, tandis "
"qu'un lien au moment de l'exécution signifie pointer vers :file:`python{NN}."
"dll`.  (Note générale : :file:`python{NN}.lib` est le soi-disant « *import "
"lib* » correspondant à :file:`python{NN}.dll`.  Il définit simplement des  "
"liens symboliques pour l'éditeur de liens.)"

#: faq/windows.rst:185
msgid ""
"Run-time linking greatly simplifies link options; everything happens at run "
"time.  Your code must load :file:`python{NN}.dll` using the Windows "
"``LoadLibraryEx()`` routine.  The code must also use access routines and "
"data in :file:`python{NN}.dll` (that is, Python's C API's) using pointers "
"obtained by the Windows ``GetProcAddress()`` routine.  Macros can make using "
"these pointers transparent to any C code that calls routines in Python's C "
"API."
msgstr ""
"La liaison en temps réel simplifie grandement les options de liaison ; tout "
"se passe au moment de l'exécution.  Votre code doit charger :file:"
"`python{NN}.dll` en utilisant la routine Windows ``LoadLibraryEx()``.  Le "
"code doit aussi utiliser des routines d'accès et des données dans :file:"
"`python{NN}.dll` (c'est-à-dire les API C de Python) en utilisant des "
"pointeurs obtenus par la routine Windows ``GetProcAddress()``.  Les macros "
"peuvent rendre l'utilisation de ces pointeurs transparente à tout code C qui "
"appelle des routines dans l'API C de Python."

#: faq/windows.rst:192
msgid ""
"Borland note: convert :file:`python{NN}.lib` to OMF format using Coff2Omf."
"exe first."
msgstr ""
"Note Borland : convertir :file:`python{NN}.lib` au format OMF en utilisant "
"*Coff2Omf.exe* en premier."

#: faq/windows.rst:197
msgid ""
"If you use SWIG, it is easy to create a Python \"extension module\" that "
"will make the app's data and methods available to Python.  SWIG will handle "
"just about all the grungy details for you.  The result is C code that you "
"link *into* your .exe file (!)  You do _not_ have to create a DLL file, and "
"this also simplifies linking."
msgstr ""
"Si vous utilisez SWIG, il est facile de créer un « module d'extension » "
"Python qui rendra les données et les méthodes de l'application disponibles "
"pour Python.  SWIG s'occupera de tous les détails ennuyeux pour vous.  Le "
"résultat est du code C que vous liez *dans* votre *fichier.exe* (!) Vous "
"n'avez **pas** besoin de créer un fichier DLL, et cela simplifie également "
"la liaison."

#: faq/windows.rst:203
msgid ""
"SWIG will create an init function (a C function) whose name depends on the "
"name of the extension module.  For example, if the name of the module is "
"leo, the init function will be called initleo().  If you use SWIG shadow "
"classes, as you should, the init function will be called initleoc().  This "
"initializes a mostly hidden helper class used by the shadow class."
msgstr ""
"SWIG va créer une fonction d'initialisation (fonction en C) dont le nom "
"dépend du nom du module d'extension.  Par exemple, si le nom du module est "
"*leo*, la fonction *init* sera appelée *initleo()*.  Si vous utilisez des "
"classes *shadow* SWIG, comme vous le devriez, la fonction *init* sera "
"appelée *initleoc()*.  Ceci initialise une classe auxiliaire invisible "
"utilisée par la classe *shadow*."

#: faq/windows.rst:209
msgid ""
"The reason you can link the C code in step 2 into your .exe file is that "
"calling the initialization function is equivalent to importing the module "
"into Python! (This is the second key undocumented fact.)"
msgstr ""
"La raison pour laquelle vous pouvez lier le code C à l'étape 2 dans votre "
"*fichier.exe* est que l'appel de la fonction d'initialisation équivaut à "
"importer le module dans Python ! (C'est le deuxième fait clé non documenté.)"

#: faq/windows.rst:213
msgid ""
"In short, you can use the following code to initialize the Python "
"interpreter with your extension module."
msgstr ""
"En bref, vous pouvez utiliser le code suivant pour initialiser "
"l'interpréteur Python avec votre module d'extension."

#: faq/windows.rst:224
msgid ""
"There are two problems with Python's C API which will become apparent if you "
"use a compiler other than MSVC, the compiler used to build pythonNN.dll."
msgstr ""
"Il y a deux problèmes avec l'API C de Python qui apparaîtront si vous "
"utilisez un compilateur autre que MSVC, le compilateur utilisé pour "
"construire *pythonNN.dll*."

#: faq/windows.rst:227
msgid ""
"Problem 1: The so-called \"Very High Level\" functions that take FILE * "
"arguments will not work in a multi-compiler environment because each "
"compiler's notion of a struct FILE will be different.  From an "
"implementation standpoint these are very _low_ level functions."
msgstr ""
"Problème 1 : Les fonctions dites de \"Très Haut Niveau\" qui prennent les "
"arguments FILE * ne fonctionneront pas dans un environnement multi-"
"compilateur car chaque compilateur aura une notion différente de la "
"structure de FILE.  Du point de vue de l'implémentation, il s'agit de "
"fonctions de très bas niveau."

#: faq/windows.rst:232
msgid ""
"Problem 2: SWIG generates the following code when generating wrappers to "
"void functions:"
msgstr ""
"Problème 2 : SWIG génère le code suivant lors de la génération "
"*d'encapsuleurs* pour annuler les fonctions :"

#: faq/windows.rst:241
msgid ""
"Alas, Py_None is a macro that expands to a reference to a complex data "
"structure called _Py_NoneStruct inside pythonNN.dll.  Again, this code will "
"fail in a mult-compiler environment.  Replace such code by:"
msgstr ""
"Hélas, *Py_None* est une macro qui se développe en référence à une structure "
"de données complexe appelée *_Py_NoneStruct* dans *pythonNN.dll*.  Encore "
"une fois, ce code échouera dans un environnement multi-compilateur.  "
"Remplacez ce code par :"

#: faq/windows.rst:249
msgid ""
"It may be possible to use SWIG's ``%typemap`` command to make the change "
"automatically, though I have not been able to get this to work (I'm a "
"complete SWIG newbie)."
msgstr ""
"Il est possible d'utiliser la commande ``%typemap`` de SWIG pour effectuer "
"le changement automatiquement, bien que je n'ai pas réussi à le faire "
"fonctionner (je suis un débutant complet avec SWIG)."

#: faq/windows.rst:253
msgid ""
"Using a Python shell script to put up a Python interpreter window from "
"inside your Windows app is not a good idea; the resulting window will be "
"independent of your app's windowing system.  Rather, you (or the "
"wxPythonWindow class) should create a \"native\" interpreter window.  It is "
"easy to connect that window to the Python interpreter.  You can redirect "
"Python's i/o to _any_ object that supports read and write, so all you need "
"is a Python object (defined in your extension module) that contains read() "
"and write() methods."
msgstr ""
"Utiliser un script shell Python pour créer une fenêtre d'interpréteur Python "
"depuis votre application Windows n'est pas une bonne idée ; la fenêtre "
"résultante sera indépendante du système de fenêtrage de votre application.  "
"Vous (ou la classe *wxPythonWindow*) devriez plutôt créer une fenêtre "
"d'interpréteur « native ».  Il est facile de connecter cette fenêtre à "
"l'interpréteur Python.  Vous pouvez rediriger l'entrée/sortie de Python vers "
"*n'importe quel* objet qui supporte la lecture et l'écriture, donc tout ce "
"dont vous avez besoin est un objet Python (défini dans votre module "
"d'extension) qui contient les méthodes *read()* et *write()*."

#: faq/windows.rst:262
msgid "How do I keep editors from inserting tabs into my Python source?"
msgstr ""
"Comment empêcher mon éditeur d'utiliser des tabulations dans mes fichiers "
"Python ?"

#: faq/windows.rst:264
msgid ""
"The FAQ does not recommend using tabs, and the Python style guide, :pep:`8`, "
"recommends 4 spaces for distributed Python code; this is also the Emacs "
"python-mode default."
msgstr ""
"La FAQ ne recommande pas l'utilisation des indentations et le guide "
"stylistique de Python, la :pep:`8`, recommande l'utilisation de 4 espaces "
"dans les codes Python. C'est aussi le comportement par défaut d'Emacs avec "
"Python."

#: faq/windows.rst:268
msgid ""
"Under any editor, mixing tabs and spaces is a bad idea.  MSVC is no "
"different in this respect, and is easily configured to use spaces: Take :"
"menuselection:`Tools --> Options --> Tabs`, and for file type \"Default\" "
"set \"Tab size\" and \"Indent size\" to 4, and select the \"Insert spaces\" "
"radio button."
msgstr ""
"Quel que soit votre éditeur, mélanger des tabulations et des espaces est une "
"mauvaise idée. *Visual C++*, par exemple, peut être facilement configuré "
"pour utiliser des espaces : allez dans :menuselection:`Tools --> Options --> "
"Tabs` et pour le type de fichier par défaut, vous devez mettre *Tab size* et "
"*Indent size* à 4, puis sélectionner *Insert spaces*."

#: faq/windows.rst:273
msgid ""
"Python raises :exc:`IndentationError` or :exc:`TabError` if mixed tabs and "
"spaces are causing problems in leading whitespace. You may also run the :mod:"
"`tabnanny` module to check a directory tree in batch mode."
msgstr ""
"Python va lever :exc:`IndentationError` ou :exc:`TabError` si un mélange de "
"tabulation et d’indentation pose problème en début de ligne. Vous pouvez "
"aussi utiliser le module  :mod:`tabnanny` pour détecter ces erreurs."

#: faq/windows.rst:280
msgid "How do I check for a keypress without blocking?"
msgstr ""
"Comment puis-je vérifier de manière non bloquante qu'une touche a été "
"pressée ?"

#: faq/windows.rst:282
msgid ""
"Use the msvcrt module.  This is a standard Windows-specific extension "
"module. It defines a function ``kbhit()`` which checks whether a keyboard "
"hit is present, and ``getch()`` which gets one character without echoing it."
msgstr ""
"Utilisez le module ``msvcrt``. C'est une extension standard spécifique à "
"Windows, qui définit une fonction ``kbhit()`` qui vérifie si une pression de "
"touche s'est produite,  et ``getch()`` qui récupère le caractère sans "
"l'afficher."