forked from AFPy/python-docs-fr
6398 lines
249 KiB
Plaintext
6398 lines
249 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 2001-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3.6\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-17 21:44+0200\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/faq/design.rst:3
|
||
msgid "Design and History FAQ"
|
||
msgstr "FAQ Histoire et Design"
|
||
|
||
#: ../Doc/faq/design.rst:6
|
||
msgid "Why does Python use indentation for grouping of statements?"
|
||
msgstr "Pourquoi Python utilise l'indentation pour grouper les instructions ?"
|
||
|
||
#: ../Doc/faq/design.rst:8
|
||
msgid ""
|
||
"Guido van Rossum believes that using indentation for grouping is extremely "
|
||
"elegant and contributes a lot to the clarity of the average Python program. "
|
||
"Most people learn to love this feature after a while."
|
||
msgstr ""
|
||
"Guido van Rossum pense que l'usage de l'indentation pour regrouper les blocs "
|
||
"d'instruction est élégant et contribue énormément à la clareté globale du "
|
||
"programme Python. La plupart des gens finissent par aimer cette "
|
||
"particularité au bout d'un moment."
|
||
|
||
#: ../Doc/faq/design.rst:12
|
||
msgid ""
|
||
"Since there are no begin/end brackets there cannot be a disagreement between "
|
||
"grouping perceived by the parser and the human reader. Occasionally C "
|
||
"programmers will encounter a fragment of code like this::"
|
||
msgstr ""
|
||
"Comme il n'y a pas d'accolades de début/fin, il ne peut y avoir de "
|
||
"différence entre le bloc perçu par l'analyseur syntaxique et le lecteur "
|
||
"humain. Parfois les programmeurs C pourront trouver un morceau de code comme "
|
||
"celui-ci::"
|
||
|
||
#: ../Doc/faq/design.rst:21
|
||
msgid ""
|
||
"Only the ``x++`` statement is executed if the condition is true, but the "
|
||
"indentation leads you to believe otherwise. Even experienced C programmers "
|
||
"will sometimes stare at it a long time wondering why ``y`` is being "
|
||
"decremented even for ``x > y``."
|
||
msgstr ""
|
||
"Seule l'instruction ``x++`` sera exécutée si la condition est vraie, mais "
|
||
"l'indentation pourrait vous faire penser le contraire. Mêmes des "
|
||
"développeurs C expérimentés resteront pendant un moment à se demander "
|
||
"pourquoi ``y`` est décrémenté même si ``x > y``."
|
||
|
||
#: ../Doc/faq/design.rst:26
|
||
msgid ""
|
||
"Because there are no begin/end brackets, Python is much less prone to coding-"
|
||
"style conflicts. In C there are many different ways to place the braces. If "
|
||
"you're used to reading and writing code that uses one style, you will feel "
|
||
"at least slightly uneasy when reading (or being required to write) another "
|
||
"style."
|
||
msgstr ""
|
||
"Comme il n'y a pas d'accolades de début/fin, Python est moins sujet aux "
|
||
"conflits de style de code. En C, on peut placer les accolades de nombreuses "
|
||
"façons. Si vous êtes habitués à lire et écrire selon un style particulier, "
|
||
"vous pourriez vous sentir perturbé en lisant (ou en devant écrire) avec un "
|
||
"autre style."
|
||
|
||
#: ../Doc/faq/design.rst:31
|
||
msgid ""
|
||
"Many coding styles place begin/end brackets on a line by themselves. This "
|
||
"makes programs considerably longer and wastes valuable screen space, making "
|
||
"it harder to get a good overview of a program. Ideally, a function should "
|
||
"fit on one screen (say, 20-30 lines). 20 lines of Python can do a lot more "
|
||
"work than 20 lines of C. This is not solely due to the lack of begin/end "
|
||
"brackets -- the lack of declarations and the high-level data types are also "
|
||
"responsible -- but the indentation-based syntax certainly helps."
|
||
msgstr ""
|
||
"Nombre de styles de programmation placent les accolades de début/fin sur une "
|
||
"ligne à part. Cela rend les sources beaucoup plus longues et fait perdre une "
|
||
"bonne partie de l'espace visible sur l'écran, empêchant un peu d'avoir une "
|
||
"vue globale du programme. Idéalement, une fonction doit être visible sur un "
|
||
"écran (environ 20 ou 30 lignes). 20 lignes de Python peuvent faire beaucoup "
|
||
"plus que 20 lignes de C. Ce n'est pas seulement dû à l'absence d'accolades "
|
||
"de début/fin -- l'absence de déclarations et les types de haut-niveau en "
|
||
"sont également responsables -- mais la syntaxe basée sur l'indentation y est "
|
||
"pour beaucoup."
|
||
|
||
#: ../Doc/faq/design.rst:41
|
||
msgid "Why am I getting strange results with simple arithmetic operations?"
|
||
msgstr ""
|
||
"Pourquoi ai-je d'étranges résultats suite à de simples opérations "
|
||
"arithmétiques ?"
|
||
|
||
#: ../Doc/faq/design.rst:43
|
||
msgid "See the next question."
|
||
msgstr "Voir la question suivante."
|
||
|
||
#: ../Doc/faq/design.rst:47
|
||
msgid "Why are floating-point calculations so inaccurate?"
|
||
msgstr "Pourquoi les calculs à virgules flottantes sont si imprécis ?"
|
||
|
||
#: ../Doc/faq/design.rst:49
|
||
msgid "Users are often surprised by results like this::"
|
||
msgstr ""
|
||
"Les gens sont très souvent surpris par des résultats comme celui-ci : ::"
|
||
|
||
#: ../Doc/faq/design.rst:54
|
||
msgid ""
|
||
"and think it is a bug in Python. It's not. This has little to do with "
|
||
"Python, and much more to do with how the underlying platform handles "
|
||
"floating-point numbers."
|
||
msgstr ""
|
||
"et pensent que c'est un *bug* dans Python. Ça ne l'est pas. Ceci n'a "
|
||
"d'ailleurs que peu à voir avec Python, mais avec la manière dont la "
|
||
"plateforme sous-jacente gère les nombres à virgule flottante."
|
||
|
||
#: ../Doc/faq/design.rst:58
|
||
msgid ""
|
||
"The :class:`float` type in CPython uses a C ``double`` for storage. A :"
|
||
"class:`float` object's value is stored in binary floating-point with a fixed "
|
||
"precision (typically 53 bits) and Python uses C operations, which in turn "
|
||
"rely on the hardware implementation in the processor, to perform floating-"
|
||
"point operations. This means that as far as floating-point operations are "
|
||
"concerned, Python behaves like many popular languages including C and Java."
|
||
msgstr ""
|
||
"La classe :class:`float` dans CPython utilise le type double du langage C "
|
||
"comme stockage. La valeur d'un objet :class:`float` est stockée dans un "
|
||
"format binaire à virgule flottante avec une précision fixe (généralement 53 "
|
||
"bits). Python utilise des opérations qui proviennent du langage C qui à leur "
|
||
"tour reposent sur l'implémentation au niveau du processeur afin d'effectuer "
|
||
"des opérations en virgule flottante. Cela signifie que dans le cadre des "
|
||
"opérations sur les nombres à virgule flottante, Python se comporte comme "
|
||
"beaucoup de langages populaires dont C et Java."
|
||
|
||
#: ../Doc/faq/design.rst:65
|
||
msgid ""
|
||
"Many numbers that can be written easily in decimal notation cannot be "
|
||
"expressed exactly in binary floating-point. For example, after::"
|
||
msgstr ""
|
||
"Beaucoup de nombres pouvant être écrits facilement en notation décimale ne "
|
||
"peuvent pas s'exprimer de manière exacte en binaire à virgule flottante. Par "
|
||
"exemple, après : ::"
|
||
|
||
#: ../Doc/faq/design.rst:70
|
||
msgid ""
|
||
"the value stored for ``x`` is a (very good) approximation to the decimal "
|
||
"value ``1.2``, but is not exactly equal to it. On a typical machine, the "
|
||
"actual stored value is::"
|
||
msgstr ""
|
||
"la valeur stockée pour ``x`` est une (très bonne) approximation de la valeur "
|
||
"décimale ``1.2``, mais cette valeur n'est pas exacte. Sur une machine "
|
||
"typique, la valeur stockée est en fait : ::"
|
||
|
||
#: ../Doc/faq/design.rst:76
|
||
msgid "which is exactly::"
|
||
msgstr "qui est, exactement : ::"
|
||
|
||
#: ../Doc/faq/design.rst:80
|
||
msgid ""
|
||
"The typical precision of 53 bits provides Python floats with 15-16 decimal "
|
||
"digits of accuracy."
|
||
msgstr ""
|
||
"La précision typique, de 53 bits, permet une précision de 15-16 décimales "
|
||
"sur les nombres à virgule flottante."
|
||
|
||
#: ../Doc/faq/design.rst:83
|
||
msgid ""
|
||
"For a fuller explanation, please see the :ref:`floating point arithmetic "
|
||
"<tut-fp-issues>` chapter in the Python tutorial."
|
||
msgstr ""
|
||
"Veuillez vous référer au chapitre sur :ref:`floating point arithmetic <tut-"
|
||
"fp-issues>` du tutoriel python pour de plus amples informations."
|
||
|
||
#: ../Doc/faq/design.rst:88
|
||
msgid "Why are Python strings immutable?"
|
||
msgstr "Pourquoi les chaînes de caractères Python sont-elles immuables ?"
|
||
|
||
#: ../Doc/faq/design.rst:90
|
||
msgid "There are several advantages."
|
||
msgstr "Il y a plusieurs avantages."
|
||
|
||
#: ../Doc/faq/design.rst:92
|
||
msgid ""
|
||
"One is performance: knowing that a string is immutable means we can allocate "
|
||
"space for it at creation time, and the storage requirements are fixed and "
|
||
"unchanging. This is also one of the reasons for the distinction between "
|
||
"tuples and lists."
|
||
msgstr ""
|
||
"La première concerne la performance : savoir qu'une chaîne de caractères est "
|
||
"immuable signifie que l'allocation mémoire allouée lors de la création de "
|
||
"cette chaîne est fixe et figée. C'est aussi l'une des raisons pour "
|
||
"lesquelles on fait la distinction entre les *tuples* et les listes."
|
||
|
||
#: ../Doc/faq/design.rst:97
|
||
msgid ""
|
||
"Another advantage is that strings in Python are considered as \"elemental\" "
|
||
"as numbers. No amount of activity will change the value 8 to anything else, "
|
||
"and in Python, no amount of activity will change the string \"eight\" to "
|
||
"anything else."
|
||
msgstr ""
|
||
"Un autre avantage est que les chaînes en Python sont considérées aussi "
|
||
"\"élémentaires\" que les nombres. Aucun processus ne changera la valeur du "
|
||
"nombre 8 en autre chose, et en Python, aucun processus changera la chaîne de "
|
||
"caractère \"huit\" en autre chose."
|
||
|
||
#: ../Doc/faq/design.rst:105
|
||
msgid "Why must 'self' be used explicitly in method definitions and calls?"
|
||
msgstr ""
|
||
"Pourquoi \"self\" doit-il être explicitement utilisé dans les définitions et "
|
||
"les appels de méthode ?"
|
||
|
||
#: ../Doc/faq/design.rst:107
|
||
msgid ""
|
||
"The idea was borrowed from Modula-3. It turns out to be very useful, for a "
|
||
"variety of reasons."
|
||
msgstr ""
|
||
"L'idée a été empruntée à Modula-3. Il s'avère être très utile, pour diverses "
|
||
"raisons."
|
||
|
||
#: ../Doc/faq/design.rst:110
|
||
msgid ""
|
||
"First, it's more obvious that you are using a method or instance attribute "
|
||
"instead of a local variable. Reading ``self.x`` or ``self.meth()`` makes it "
|
||
"absolutely clear that an instance variable or method is used even if you "
|
||
"don't know the class definition by heart. In C++, you can sort of tell by "
|
||
"the lack of a local variable declaration (assuming globals are rare or "
|
||
"easily recognizable) -- but in Python, there are no local variable "
|
||
"declarations, so you'd have to look up the class definition to be sure. "
|
||
"Some C++ and Java coding standards call for instance attributes to have an "
|
||
"``m_`` prefix, so this explicitness is still useful in those languages, too."
|
||
msgstr ""
|
||
"Tout d'abord, il est plus évident d'utiliser une méthode ou un attribut "
|
||
"d'instance par exemple au lieu d'une variable locale. Lire ``self.x`` ou "
|
||
"``self.meth()`` est sans ambiguité sur le fait que c'est une variable "
|
||
"d'instance ou une méthode qui est utilisée, même si vous ne connaissez pas "
|
||
"la définition de classe par cœur. En C++, vous pouvez les reconnaitre par "
|
||
"l'absence d'une déclaration de variable locale (en supposant que les "
|
||
"variables globales sont rares ou facilement reconnaissables) - mais en "
|
||
"Python, il n'y a pas de déclarations de variables locales, de sorte que vous "
|
||
"devez chercher la définition de classe pour être sûr. Certaines normes de "
|
||
"programmation C++ et Java préfixent les attributs d'instance par ``m_``. "
|
||
"Cette syntaxe explicite est ainsi utile également pour ces langages."
|
||
|
||
#: ../Doc/faq/design.rst:120
|
||
msgid ""
|
||
"Second, it means that no special syntax is necessary if you want to "
|
||
"explicitly reference or call the method from a particular class. In C++, if "
|
||
"you want to use a method from a base class which is overridden in a derived "
|
||
"class, you have to use the ``::`` operator -- in Python you can write "
|
||
"``baseclass.methodname(self, <argument list>)``. This is particularly "
|
||
"useful for :meth:`__init__` methods, and in general in cases where a derived "
|
||
"class method wants to extend the base class method of the same name and thus "
|
||
"has to call the base class method somehow."
|
||
msgstr ""
|
||
"Ensuite, ça veut dire qu'aucune syntaxe spéciale n'est nécessaire si vous "
|
||
"souhaitez explicitement référencer ou appeler la méthode depuis une classe "
|
||
"en particulier. En C++, si vous utilisez la méthode d'une classe de base "
|
||
"elle-même surchargée par une classe dérivée, vous devez utiliser l'opérateur "
|
||
"``::`` -- en Python vous pouvez écrire ``baseclass.methodname(self, "
|
||
"<argument list>)``. C'est particulièrement utile pour les méthodes :meth:"
|
||
"`__init__`, et de manière générale dans les cas où une classe dérivée veut "
|
||
"étendre la méthode du même nom de la classe de base, devant ainsi appeler la "
|
||
"méthode de la classe de base d'une certaine manière."
|
||
|
||
#: ../Doc/faq/design.rst:129
|
||
msgid ""
|
||
"Finally, for instance variables it solves a syntactic problem with "
|
||
"assignment: since local variables in Python are (by definition!) those "
|
||
"variables to which a value is assigned in a function body (and that aren't "
|
||
"explicitly declared global), there has to be some way to tell the "
|
||
"interpreter that an assignment was meant to assign to an instance variable "
|
||
"instead of to a local variable, and it should preferably be syntactic (for "
|
||
"efficiency reasons). C++ does this through declarations, but Python doesn't "
|
||
"have declarations and it would be a pity having to introduce them just for "
|
||
"this purpose. Using the explicit ``self.var`` solves this nicely. "
|
||
"Similarly, for using instance variables, having to write ``self.var`` means "
|
||
"that references to unqualified names inside a method don't have to search "
|
||
"the instance's directories. To put it another way, local variables and "
|
||
"instance variables live in two different namespaces, and you need to tell "
|
||
"Python which namespace to use."
|
||
msgstr ""
|
||
"Enfin, pour des variables d'instance, ça résout un problème syntactique pour "
|
||
"l'assignation : puisque les variables locales en Python sont (par "
|
||
"définition !) ces variables auxquelles les valeurs sont assignées dans le "
|
||
"corps d'une fonction (et n'étant pas déclarées explicitement globales), il "
|
||
"doit y avoir un moyen de dire à l'interpréteur qu'une assignation est censée "
|
||
"assigner une variable d'instance plutôt qu'une variable locale, et doit de "
|
||
"préférence être syntactique (pour des raisons d'efficacité). C++ fait ça au "
|
||
"travers de déclarations, mais Python n'a pas de déclarations et ça serait "
|
||
"dommage d'avoir à les introduire juste pour cette raison. Utiliser "
|
||
"explicitement ``self.var`` résout ça avec élégance. Pareillement, pour "
|
||
"utiliser des variables d'instance, avoir à écrire ``self.var`` signifie que "
|
||
"les références vers des noms non-qualifiés au sein d'une méthode n'ont pas à "
|
||
"être cherchés dans l'annuaire d'instances. En d'autres termes, les variables "
|
||
"locales et les variables d'instance vivent dans deux différents espaces de "
|
||
"noms, et vous devez dire à Python quel espace de noms utiliser."
|
||
|
||
#: ../Doc/faq/design.rst:145
|
||
msgid "Why can't I use an assignment in an expression?"
|
||
msgstr "Pourquoi ne puis-je pas utiliser d'assignation dans une expression ?"
|
||
|
||
#: ../Doc/faq/design.rst:147
|
||
msgid ""
|
||
"Many people used to C or Perl complain that they want to use this C idiom:"
|
||
msgstr ""
|
||
"De nombreuses personnes habituées à C ou Perl se plaignent de vouloir "
|
||
"utiliser cet idiome C :"
|
||
|
||
#: ../Doc/faq/design.rst:155
|
||
msgid "where in Python you're forced to write this::"
|
||
msgstr "où en Python vous êtes forcé à écrire ceci : ::"
|
||
|
||
#: ../Doc/faq/design.rst:163
|
||
msgid ""
|
||
"The reason for not allowing assignment in Python expressions is a common, "
|
||
"hard-to-find bug in those other languages, caused by this construct:"
|
||
msgstr ""
|
||
"La raison pour ne pas autoriser l'assignation dans les expressions en Python "
|
||
"est un bug fréquent, et difficile à trouver dans ces autres langages, causé "
|
||
"par cette construction :"
|
||
|
||
#: ../Doc/faq/design.rst:175
|
||
msgid ""
|
||
"The error is a simple typo: ``x = 0``, which assigns 0 to the variable "
|
||
"``x``, was written while the comparison ``x == 0`` is certainly what was "
|
||
"intended."
|
||
msgstr ""
|
||
"Cette erreur est une simple coquille : ``x = 0``, qui assigne 0 à la "
|
||
"variable ``x``, a été écrit alors que la comparaison ``x == 0`` est "
|
||
"certainement ce qui était souhaité."
|
||
|
||
#: ../Doc/faq/design.rst:178
|
||
msgid ""
|
||
"Many alternatives have been proposed. Most are hacks that save some typing "
|
||
"but use arbitrary or cryptic syntax or keywords, and fail the simple "
|
||
"criterion for language change proposals: it should intuitively suggest the "
|
||
"proper meaning to a human reader who has not yet been introduced to the "
|
||
"construct."
|
||
msgstr ""
|
||
"De nombreuses alternatives ont été proposées. La plupart des hacks "
|
||
"économisaient de la frappe mais utilisaient d'arbitraires ou cryptiques "
|
||
"syntaxes ou mot-clés et faillait le simple critère pour proposition de "
|
||
"changement du langage : ça doit intuitivement suggérer la bonne "
|
||
"signification au lecteur qui n'a pas encore été introduit à la construction."
|
||
|
||
#: ../Doc/faq/design.rst:183
|
||
msgid ""
|
||
"An interesting phenomenon is that most experienced Python programmers "
|
||
"recognize the ``while True`` idiom and don't seem to be missing the "
|
||
"assignment in expression construct much; it's only newcomers who express a "
|
||
"strong desire to add this to the language."
|
||
msgstr ""
|
||
"Un phénomène intéressant est que la plupart des programmeurs Python "
|
||
"expérimentés reconnaissent l'idiome ``while True`` et ne semblent pas "
|
||
"manquer l'assignation dans la construction de l'expression; seuls les "
|
||
"nouveaux-venus expriment un fort désir d'ajouter ceci au langage."
|
||
|
||
#: ../Doc/faq/design.rst:188
|
||
msgid ""
|
||
"There's an alternative way of spelling this that seems attractive but is "
|
||
"generally less robust than the \"while True\" solution::"
|
||
msgstr ""
|
||
"Il y a une manière alternative de faire ça qui semble attrayante mais elle "
|
||
"est généralement moins robuste que la solution ``while True`` ::"
|
||
|
||
#: ../Doc/faq/design.rst:196
|
||
msgid ""
|
||
"The problem with this is that if you change your mind about exactly how you "
|
||
"get the next line (e.g. you want to change it into ``sys.stdin.readline()``) "
|
||
"you have to remember to change two places in your program -- the second "
|
||
"occurrence is hidden at the bottom of the loop."
|
||
msgstr ""
|
||
"Le problème avec ceci est que si vous changez d'avis sur la manière dont "
|
||
"vous allez récupérer la prochaine ligne (ex : vous voulez changer en ``sys."
|
||
"stdin.readline()``) vous devez vous souvenir de le changer à deux endroits "
|
||
"dans votre programme -- la deuxième occurrence est cachée en bas de la "
|
||
"boucle."
|
||
|
||
#: ../Doc/faq/design.rst:201
|
||
msgid ""
|
||
"The best approach is to use iterators, making it possible to loop through "
|
||
"objects using the ``for`` statement. For example, :term:`file objects <file "
|
||
"object>` support the iterator protocol, so you can write simply::"
|
||
msgstr ""
|
||
"La meilleur approche est d'utiliser les itérateurs, rendant possible de "
|
||
"parcourir des objets en utilisant l'instruction ``for``. Par exemple, les :"
|
||
"term:`objets fichiers <file object>` gèrent le protocole d'itération, donc "
|
||
"vous pouvez simplement écrire : ::"
|
||
|
||
#: ../Doc/faq/design.rst:211
|
||
msgid ""
|
||
"Why does Python use methods for some functionality (e.g. list.index()) but "
|
||
"functions for other (e.g. len(list))?"
|
||
msgstr ""
|
||
"Pourquoi Python utilise des méthodes pour certaines fonctionnalités (ex : "
|
||
"list.index()) mais des fonctions pour d'autres (ex : len(list)) ?"
|
||
|
||
#: ../Doc/faq/design.rst:213
|
||
msgid ""
|
||
"The major reason is history. Functions were used for those operations that "
|
||
"were generic for a group of types and which were intended to work even for "
|
||
"objects that didn't have methods at all (e.g. tuples). It is also "
|
||
"convenient to have a function that can readily be applied to an amorphous "
|
||
"collection of objects when you use the functional features of Python "
|
||
"(``map()``, ``zip()`` et al)."
|
||
msgstr ""
|
||
"La raison principale est historique. Les fonctions étaient utilisées pour "
|
||
"ces opérations qui étaient génériques pour un groupe de types et qui étaient "
|
||
"censés fonctionner même pour les objets qui n'avaient pas de méthodes du "
|
||
"tout (ex : tuples). C'est aussi pratique d'avoir une fonction qui s'apprête "
|
||
"bien à une collection amorphe d'objets lorsque vous utiliser les outils "
|
||
"fonctionnels de Python (``map()``, ``zip()`` et autres)."
|
||
|
||
#: ../Doc/faq/design.rst:219
|
||
msgid ""
|
||
"In fact, implementing ``len()``, ``max()``, ``min()`` as a built-in function "
|
||
"is actually less code than implementing them as methods for each type. One "
|
||
"can quibble about individual cases but it's a part of Python, and it's too "
|
||
"late to make such fundamental changes now. The functions have to remain to "
|
||
"avoid massive code breakage."
|
||
msgstr ""
|
||
"En fait, implémenter ``len()``, ``max()``, ``min()`` en tant que fonction "
|
||
"intégrée produit moins de code que de les implémenter en tant que méthode "
|
||
"pour chaque type. Certains peuvent rouspéter pour des cas individuels mais "
|
||
"ça fait partie de Python et il est trop tard pour faire des changements si "
|
||
"fondamentaux maintenant. Ces fonctions doivent rester pour éviter la casse "
|
||
"massive de code."
|
||
|
||
#: ../Doc/faq/design.rst:229
|
||
msgid ""
|
||
"For string operations, Python has moved from external functions (the "
|
||
"``string`` module) to methods. However, ``len()`` is still a function."
|
||
msgstr ""
|
||
"Pour les opérations de chaînes, Python a déplacé les fonctions externes (le "
|
||
"module ``string``) vers des méthodes. Cependant, ``len()`` est toujours une "
|
||
"fonction."
|
||
|
||
#: ../Doc/faq/design.rst:234
|
||
msgid "Why is join() a string method instead of a list or tuple method?"
|
||
msgstr ""
|
||
"Pourquoi join() est une méthode de chaîne plutôt qu'une de liste ou de "
|
||
"tuple ?"
|
||
|
||
#: ../Doc/faq/design.rst:236
|
||
msgid ""
|
||
"Strings became much more like other standard types starting in Python 1.6, "
|
||
"when methods were added which give the same functionality that has always "
|
||
"been available using the functions of the string module. Most of these new "
|
||
"methods have been widely accepted, but the one which appears to make some "
|
||
"programmers feel uncomfortable is::"
|
||
msgstr ""
|
||
"Les chaînes sont devenues bien plus comme d'autres types standards à partir "
|
||
"de Python 1.6, lorsque les méthodes ont été ajoutées fournissant ainsi les "
|
||
"mêmes fonctionnalités que celles qui étaient déjà disponibles en utilisant "
|
||
"les fonctions du module string. La plupart de ces nouvelles méthodes ont été "
|
||
"largement acceptées, mais celle qui semble rendre certains programmeurs "
|
||
"inconfortables est : ::"
|
||
|
||
#: ../Doc/faq/design.rst:244
|
||
msgid "which gives the result::"
|
||
msgstr "qui donne le résultat : ::"
|
||
|
||
#: ../Doc/faq/design.rst:248
|
||
msgid "There are two common arguments against this usage."
|
||
msgstr "Il y a deux arguments fréquents contre cet usage."
|
||
|
||
#: ../Doc/faq/design.rst:250
|
||
msgid ""
|
||
"The first runs along the lines of: \"It looks really ugly using a method of "
|
||
"a string literal (string constant)\", to which the answer is that it might, "
|
||
"but a string literal is just a fixed value. If the methods are to be allowed "
|
||
"on names bound to strings there is no logical reason to make them "
|
||
"unavailable on literals."
|
||
msgstr ""
|
||
"Le premier se caractérise par les lignes suivantes : \"C'est vraiment moche "
|
||
"d'utiliser une méthode de chaîne littérale (chaîne constante)\", à laquelle "
|
||
"la réponse est qu'il se peut, mais une chaîne littérale est juste une valeur "
|
||
"fixe. Si la méthode est autorisée sur des noms liés à des chaînes, il n'y a "
|
||
"pas de raison logique à les rendre indisponibles sur des chaînes littérales."
|
||
|
||
#: ../Doc/faq/design.rst:256
|
||
msgid ""
|
||
"The second objection is typically cast as: \"I am really telling a sequence "
|
||
"to join its members together with a string constant\". Sadly, you aren't. "
|
||
"For some reason there seems to be much less difficulty with having :meth:"
|
||
"`~str.split` as a string method, since in that case it is easy to see that ::"
|
||
msgstr ""
|
||
"La deuxième objection se réfère typiquement à : \"Je suis réellement en "
|
||
"train de dire à une séquence de joindre ses membres avec une constante de "
|
||
"chaîne\". Malheureusement, vous ne l'êtes pas. Pour quelque raison, il "
|
||
"semble être bien moins difficile d'avoir :meth:`~str.split` en tant que "
|
||
"méthode de chaîne, puisque dans ce cas il est facile de voir que::"
|
||
|
||
#: ../Doc/faq/design.rst:263
|
||
msgid ""
|
||
"is an instruction to a string literal to return the substrings delimited by "
|
||
"the given separator (or, by default, arbitrary runs of white space)."
|
||
msgstr ""
|
||
"est une instruction à une chaîne littérale de retourner les sous-chaînes "
|
||
"délimitées par le séparateur fournit (ou, par défaut, les espaces, ou "
|
||
"groupes d'espaces)."
|
||
|
||
#: ../Doc/faq/design.rst:266
|
||
msgid ""
|
||
":meth:`~str.join` is a string method because in using it you are telling the "
|
||
"separator string to iterate over a sequence of strings and insert itself "
|
||
"between adjacent elements. This method can be used with any argument which "
|
||
"obeys the rules for sequence objects, including any new classes you might "
|
||
"define yourself. Similar methods exist for bytes and bytearray objects."
|
||
msgstr ""
|
||
":meth:`~str.join` est une méthode de chaîne parce qu'en l'utilisant vous "
|
||
"dites au séparateur de chaîne d'itérer une séquence de chaînes et de "
|
||
"s'insérer entre les éléments adjacents. Cette méthode peut être utilisée "
|
||
"avec n'importe quel argument qui obéit aux règles d'objets séquence, "
|
||
"incluant n'importe quelles nouvelles classes que vous pourriez définir vous-"
|
||
"même. Des méthodes similaires existent pour des objets bytes et bytearray."
|
||
|
||
#: ../Doc/faq/design.rst:274
|
||
msgid "How fast are exceptions?"
|
||
msgstr "À quel point les exceptions sont-elles rapides ?"
|
||
|
||
#: ../Doc/faq/design.rst:276
|
||
msgid ""
|
||
"A try/except block is extremely efficient if no exceptions are raised. "
|
||
"Actually catching an exception is expensive. In versions of Python prior to "
|
||
"2.0 it was common to use this idiom::"
|
||
msgstr ""
|
||
"Un bloc try/except est extrêmement efficient tant qu'aucune exception ne "
|
||
"sont levée. En effet, intercepter une exception s'avère coûteux. Dans les "
|
||
"versions de précédant Python 2.0, il était courant d'utiliser cette "
|
||
"pratique::"
|
||
|
||
#: ../Doc/faq/design.rst:286
|
||
msgid ""
|
||
"This only made sense when you expected the dict to have the key almost all "
|
||
"the time. If that wasn't the case, you coded it like this::"
|
||
msgstr ""
|
||
"Cela n'a de sens que si vous vous attendez à ce que le dictionnaire ait la "
|
||
"clé presque tout le temps. Si ce n'était pas le cas, vous l'auriez codé "
|
||
"comme suit : ::"
|
||
|
||
#: ../Doc/faq/design.rst:294
|
||
msgid ""
|
||
"For this specific case, you could also use ``value = dict.setdefault(key, "
|
||
"getvalue(key))``, but only if the ``getvalue()`` call is cheap enough "
|
||
"because it is evaluated in all cases."
|
||
msgstr ""
|
||
"Pour ce cas, vous pouvez également utiliser ``value = dict.setdefault(key, "
|
||
"getvalue(key))``, mais seulement si l'appel à ``getvalue()`` est "
|
||
"suffisamment peu coûteux car il est évalué dans tous les cas."
|
||
|
||
#: ../Doc/faq/design.rst:300
|
||
msgid "Why isn't there a switch or case statement in Python?"
|
||
msgstr ""
|
||
"Pourquoi n'y a-t-il pas une instruction *switch* ou une structure similaire "
|
||
"à *switch / case* en Python ?"
|
||
|
||
#: ../Doc/faq/design.rst:302
|
||
msgid ""
|
||
"You can do this easily enough with a sequence of ``if... elif... elif... "
|
||
"else``. There have been some proposals for switch statement syntax, but "
|
||
"there is no consensus (yet) on whether and how to do range tests. See :pep:"
|
||
"`275` for complete details and the current status."
|
||
msgstr ""
|
||
"Vous pouvez le faire assez facilement avec une séquence de ``if... elif... "
|
||
"elif... else``. Il y a eu quelques propositions pour la syntaxe de "
|
||
"l'instruction switch, mais il n'y a pas (encore) de consensus sur le cas des "
|
||
"intervalles. Voir la :pep:`275` pour tous les détails et l'état actuel."
|
||
|
||
#: ../Doc/faq/design.rst:307
|
||
msgid ""
|
||
"For cases where you need to choose from a very large number of "
|
||
"possibilities, you can create a dictionary mapping case values to functions "
|
||
"to call. For example::"
|
||
msgstr ""
|
||
"Dans les cas où vous devez choisir parmi un très grand nombre de "
|
||
"possibilités, vous pouvez créer un dictionnaire faisant correspondre des "
|
||
"valeurs à des fonctions à appeler. Par exemple : ::"
|
||
|
||
#: ../Doc/faq/design.rst:321
|
||
msgid ""
|
||
"For calling methods on objects, you can simplify yet further by using the :"
|
||
"func:`getattr` built-in to retrieve methods with a particular name::"
|
||
msgstr ""
|
||
"Pour appeler les méthodes sur des objets, vous pouvez simplifier davantage "
|
||
"en utilisant la fonction native :func:`getattr` pour récupérer les méthodes "
|
||
"avec un nom donné : ::"
|
||
|
||
#: ../Doc/faq/design.rst:333
|
||
msgid ""
|
||
"It's suggested that you use a prefix for the method names, such as "
|
||
"``visit_`` in this example. Without such a prefix, if values are coming "
|
||
"from an untrusted source, an attacker would be able to call any method on "
|
||
"your object."
|
||
msgstr ""
|
||
"Il est suggéré que vous utilisiez un préfixe pour les noms de méthodes, "
|
||
"telles que ``visit_`` dans cet exemple. Sans ce préfixe, si les valeurs "
|
||
"proviennent d'une source non fiable, un attaquant serait en mesure d'appeler "
|
||
"n'importe quelle méthode sur votre objet."
|
||
|
||
#: ../Doc/faq/design.rst:339
|
||
msgid ""
|
||
"Can't you emulate threads in the interpreter instead of relying on an OS-"
|
||
"specific thread implementation?"
|
||
msgstr ""
|
||
"Est-il possible d'émuler des *threads* dans l'interpréteur plutôt que se "
|
||
"baser sur les implémentations spécifique aux OS ?"
|
||
|
||
#: ../Doc/faq/design.rst:341
|
||
msgid ""
|
||
"Answer 1: Unfortunately, the interpreter pushes at least one C stack frame "
|
||
"for each Python stack frame. Also, extensions can call back into Python at "
|
||
"almost random moments. Therefore, a complete threads implementation "
|
||
"requires thread support for C."
|
||
msgstr ""
|
||
"Réponse 1: Malheureusement, l'interpréteur pousse au moins un block de pile "
|
||
"C (*stack frame*) pour chaque bloc de pile de Python. Aussi, les extensions "
|
||
"peuvent rappeler dans Python à presque n'importe quel moment. Par "
|
||
"conséquent, une implémentation complète des *thread* nécessiterai un support "
|
||
"complet en C."
|
||
|
||
#: ../Doc/faq/design.rst:346
|
||
msgid ""
|
||
"Answer 2: Fortunately, there is `Stackless Python <http://www.stackless."
|
||
"com>`_, which has a completely redesigned interpreter loop that avoids the C "
|
||
"stack."
|
||
msgstr ""
|
||
"Réponse 2: Heureusement, il existe `Stackless Python <d'http://www.stackless."
|
||
"com>`_, qui à complètement ré-architecturé la boucle principale de "
|
||
"l'interpréteur afin de ne pas utiliser la pile C."
|
||
|
||
#: ../Doc/faq/design.rst:351
|
||
msgid "Why can't lambda expressions contain statements?"
|
||
msgstr ""
|
||
"Pourquoi les expressions lambda ne peuvent pas contenir d'instructions ?"
|
||
|
||
#: ../Doc/faq/design.rst:353
|
||
msgid ""
|
||
"Python lambda expressions cannot contain statements because Python's "
|
||
"syntactic framework can't handle statements nested inside expressions. "
|
||
"However, in Python, this is not a serious problem. Unlike lambda forms in "
|
||
"other languages, where they add functionality, Python lambdas are only a "
|
||
"shorthand notation if you're too lazy to define a function."
|
||
msgstr ""
|
||
"Les expressions lambda de Python ne peuvent pas contenir d'instructions "
|
||
"parce que le cadre syntaxique de Python ne peut pas gérer les instructions "
|
||
"imbriquées à l'intérieur d'expressions. Cependant, en Python, ce n'est pas "
|
||
"vraiment un problème. Contrairement aux formes lambda dans d'autres "
|
||
"langages, où elles ajoutent des fonctionnalités, les expressions lambda de "
|
||
"Python sont seulement une notation concise si vous êtes trop paresseux pour "
|
||
"définir une fonction."
|
||
|
||
#: ../Doc/faq/design.rst:359
|
||
msgid ""
|
||
"Functions are already first class objects in Python, and can be declared in "
|
||
"a local scope. Therefore the only advantage of using a lambda instead of a "
|
||
"locally-defined function is that you don't need to invent a name for the "
|
||
"function -- but that's just a local variable to which the function object "
|
||
"(which is exactly the same type of object that a lambda expression yields) "
|
||
"is assigned!"
|
||
msgstr ""
|
||
"Les fonctions sont déjà des objets de première classe en Python et peuvent "
|
||
"être déclarées dans une portée locale. L'unique avantage d'utiliser une "
|
||
"fonction lambda au lieu d'une fonction définie localement est que vous "
|
||
"n'avez nullement besoin d'un nom pour la fonction -- Mais c'est juste une "
|
||
"variable locale à laquelle est affecté l'objet fonction (qui est exactement "
|
||
"le même type d'objet qui donne une expression lambda) !"
|
||
|
||
#: ../Doc/faq/design.rst:367
|
||
msgid "Can Python be compiled to machine code, C or some other language?"
|
||
msgstr ""
|
||
"Python peut-il être compilé en code machine, en C ou dans un autre langage ?"
|
||
|
||
#: ../Doc/faq/design.rst:369
|
||
msgid "Practical answer:"
|
||
msgstr "Réponse concrète :"
|
||
|
||
#: ../Doc/faq/design.rst:371
|
||
msgid ""
|
||
"`Cython <http://cython.org/>`_ and `Pyrex <https://www.cosc.canterbury.ac.nz/"
|
||
"greg.ewing/python/Pyrex/>`_ compile a modified version of Python with "
|
||
"optional annotations into C extensions. `Weave <https://scipy.github.io/"
|
||
"devdocs/tutorial/weave.html>`_ makes it easy to intermingle Python and C "
|
||
"code in various ways to increase performance. `Nuitka <http://www.nuitka.net/"
|
||
">`_ is an up-and-coming compiler of Python into C++ code, aiming to support "
|
||
"the full Python language."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:378
|
||
msgid "Theoretical answer:"
|
||
msgstr "Réponse théorique :"
|
||
|
||
#: ../Doc/faq/design.rst:382
|
||
msgid ""
|
||
"Not trivially. Python's high level data types, dynamic typing of objects "
|
||
"and run-time invocation of the interpreter (using :func:`eval` or :func:"
|
||
"`exec`) together mean that a naïvely \"compiled\" Python program would "
|
||
"probably consist mostly of calls into the Python run-time system, even for "
|
||
"seemingly simple operations like ``x+1``."
|
||
msgstr ""
|
||
"Pas de façon triviale. Les types de données haut niveau de Python, le typage "
|
||
"dynamique des objets et l'invocation de l’interpréteur à l'exécution (via :"
|
||
"func:`eval` ou :func:`exec`) font qu'un programme Python compilé naïvement "
|
||
"consisterait probablement principalement à faire des appels au système "
|
||
"d'exécution de Python, même pour des opérations simples comme ``x + 1``."
|
||
|
||
#: ../Doc/faq/design.rst:388
|
||
msgid ""
|
||
"Several projects described in the Python newsgroup or at past `Python "
|
||
"conferences <https://www.python.org/community/workshops/>`_ have shown that "
|
||
"this approach is feasible, although the speedups reached so far are only "
|
||
"modest (e.g. 2x). Jython uses the same strategy for compiling to Java "
|
||
"bytecode. (Jim Hugunin has demonstrated that in combination with whole-"
|
||
"program analysis, speedups of 1000x are feasible for small demo programs. "
|
||
"See the proceedings from the `1997 Python conference <http://legacy.python."
|
||
"org/workshops/1997-10/proceedings/>`_ for more information.)"
|
||
msgstr ""
|
||
"Plusieurs projets décrits dans le forum de Python ou dans les anciennes "
|
||
"`Conférences Python <https://www.python.org/community/workshops/>`_ ont "
|
||
"montré que cette approche est réalisable, même si les améliorations "
|
||
"atteintes restaient modestes (autour de ×2). Jython utilise la même "
|
||
"stratégie pour compiler en *bytecode* Java. (Jim Hugunin a démontré qu'en "
|
||
"combinaison avec une analyse de la totalité du programme, des améliorations "
|
||
"de ×1000 sont possibles sur de petits programmes de démonstration. Voir le "
|
||
"compte rendu de la `Conférence de Python 1997 <http://legacy.python.org/"
|
||
"workshops/1997-10/proceedings/>`_ pour plus d'informations.)"
|
||
|
||
#: ../Doc/faq/design.rst:399
|
||
msgid "How does Python manage memory?"
|
||
msgstr "Comment Python gère la mémoire ?"
|
||
|
||
#: ../Doc/faq/design.rst:401
|
||
msgid ""
|
||
"The details of Python memory management depend on the implementation. The "
|
||
"standard implementation of Python, :term:`CPython`, uses reference counting "
|
||
"to detect inaccessible objects, and another mechanism to collect reference "
|
||
"cycles, periodically executing a cycle detection algorithm which looks for "
|
||
"inaccessible cycles and deletes the objects involved. The :mod:`gc` module "
|
||
"provides functions to perform a garbage collection, obtain debugging "
|
||
"statistics, and tune the collector's parameters."
|
||
msgstr ""
|
||
"Les détails de la gestion de la mémoire en Python dépendent de "
|
||
"l'implémentation. En effet, l'implémentation standard de Python, :term:"
|
||
"`CPython`, utilise des compteurs de références afin de détecter des objets "
|
||
"inaccessibles et un autre mécanisme pour collecter les références "
|
||
"circulaires, exécutant périodiquement un algorithme de détection de cycles "
|
||
"qui recherche les cycles inaccessibles et supprime les objets implqués. Le "
|
||
"module :mod:`gc` fournit des fonctions pour lancer le ramasse-miettes, "
|
||
"d'obtenir des statistiques de débogage et ajuster ses paramètres."
|
||
|
||
#: ../Doc/faq/design.rst:409
|
||
msgid ""
|
||
"Other implementations (such as `Jython <http://www.jython.org>`_ or `PyPy "
|
||
"<http://www.pypy.org>`_), however, can rely on a different mechanism such as "
|
||
"a full-blown garbage collector. This difference can cause some subtle "
|
||
"porting problems if your Python code depends on the behavior of the "
|
||
"reference counting implementation."
|
||
msgstr ""
|
||
"Cependant, d'autres implémentations (par exemple `Jython <http://www.jython."
|
||
"org>`_ ou `PyPy <http://www.pypy.org>`_) peuvent compter sur un mécanisme "
|
||
"différent comme un véritable ramasse-miette. Cette différence peut causer de "
|
||
"subtils problèmes de portabilité si votre code Python dépend du comportement "
|
||
"de l'implémentation du compteur de références."
|
||
|
||
#: ../Doc/faq/design.rst:415
|
||
msgid ""
|
||
"In some Python implementations, the following code (which is fine in "
|
||
"CPython) will probably run out of file descriptors::"
|
||
msgstr ""
|
||
"Dans certaines implémentations de Python, le code suivant (qui marche "
|
||
"parfaitement avec *CPython*) aurait probablement manqué de descripteurs de "
|
||
"fichiers::"
|
||
|
||
#: ../Doc/faq/design.rst:422
|
||
msgid ""
|
||
"Indeed, using CPython's reference counting and destructor scheme, each new "
|
||
"assignment to *f* closes the previous file. With a traditional GC, however, "
|
||
"those file objects will only get collected (and closed) at varying and "
|
||
"possibly long intervals."
|
||
msgstr ""
|
||
"En effet, à l'aide du comptage de références et du destructeur d'objets de "
|
||
"*CPython*, chaque nouvelle affectation à *f* ferme le fichier précédent. "
|
||
"Cependant, avec un *GC* classique, ces objets seront seulement recueillies "
|
||
"(et fermés) à intervalles variables et possiblement avec de longs "
|
||
"intervalles."
|
||
|
||
#: ../Doc/faq/design.rst:427
|
||
msgid ""
|
||
"If you want to write code that will work with any Python implementation, you "
|
||
"should explicitly close the file or use the :keyword:`with` statement; this "
|
||
"will work regardless of memory management scheme::"
|
||
msgstr ""
|
||
"Si vous souhaitez écrire du code qui fonctionne avec n'importe quelle "
|
||
"implémentation de Python, vous devez explicitement fermer le fichier ou "
|
||
"utiliser l'instruction :keyword:`with` ; ceci fonctionnera indépendamment du "
|
||
"système de gestion de la mémoire::"
|
||
|
||
#: ../Doc/faq/design.rst:437
|
||
msgid "Why doesn't CPython use a more traditional garbage collection scheme?"
|
||
msgstr ""
|
||
"Pourquoi CPython n'utilise-il pas un ramasse-miette plus traditionnel ?"
|
||
|
||
#: ../Doc/faq/design.rst:439
|
||
msgid ""
|
||
"For one thing, this is not a C standard feature and hence it's not portable. "
|
||
"(Yes, we know about the Boehm GC library. It has bits of assembler code for "
|
||
"*most* common platforms, not for all of them, and although it is mostly "
|
||
"transparent, it isn't completely transparent; patches are required to get "
|
||
"Python to work with it.)"
|
||
msgstr ""
|
||
"D'une part, ce n'est pas une caractéristique normalisé en C et par "
|
||
"conséquent ce n'est pas portable. (Oui, nous connaissons la bibliothèque *GC "
|
||
"Boehm*. Elle contient du code assembleur pour la plupart des plates-formes "
|
||
"classiques, mais pas toutes, et bien qu'elle soit le plus souvent "
|
||
"transparent, c'est loin d'être le cas, des correctifs sont nécessaires afin "
|
||
"que Python fonctionne correctement avec.)"
|
||
|
||
#: ../Doc/faq/design.rst:445
|
||
msgid ""
|
||
"Traditional GC also becomes a problem when Python is embedded into other "
|
||
"applications. While in a standalone Python it's fine to replace the "
|
||
"standard malloc() and free() with versions provided by the GC library, an "
|
||
"application embedding Python may want to have its *own* substitute for "
|
||
"malloc() and free(), and may not want Python's. Right now, CPython works "
|
||
"with anything that implements malloc() and free() properly."
|
||
msgstr ""
|
||
"Le *GC* classique devient également un problème lorsque Python est incorporé "
|
||
"dans d'autres applications. Bien que dans une application Python, il ne soit "
|
||
"pas gênant de remplacer les fonctions malloc() et free() avec les versions "
|
||
"fournies par la bibliothèque *GC*, une application incluant Python peut "
|
||
"vouloir avoir ses propres implémentations de malloc() et free() et peut ne "
|
||
"pas vouloir celles de Python. À l'heure actuelle, CPython fonctionne avec "
|
||
"n'importe quelle implémentation correcte de malloc() et free()."
|
||
|
||
#: ../Doc/faq/design.rst:454
|
||
msgid "Why isn't all memory freed when CPython exits?"
|
||
msgstr ""
|
||
"Pourquoi toute la mémoire n'est pas libérée lorsque *CPython* s'arrête ?"
|
||
|
||
#: ../Doc/faq/design.rst:456
|
||
msgid ""
|
||
"Objects referenced from the global namespaces of Python modules are not "
|
||
"always deallocated when Python exits. This may happen if there are circular "
|
||
"references. There are also certain bits of memory that are allocated by the "
|
||
"C library that are impossible to free (e.g. a tool like Purify will complain "
|
||
"about these). Python is, however, aggressive about cleaning up memory on "
|
||
"exit and does try to destroy every single object."
|
||
msgstr ""
|
||
"Les objets référencés depuis les espaces de noms globaux des modules Python "
|
||
"ne sont pas toujours désalloués lorsque Python s'arrête. Cela peut se "
|
||
"produire s'il y a des références circulaires. Il y a aussi certaines parties "
|
||
"de mémoire qui sont alloués par la bibliothèque C qui sont impossibles à "
|
||
"libérer (par exemple un outil comme *Purify* s'en plaindra). Python est, "
|
||
"cependant, agressif sur le nettoyage de la mémoire en quittant et cherche à "
|
||
"détruire chaque objet."
|
||
|
||
#: ../Doc/faq/design.rst:463
|
||
msgid ""
|
||
"If you want to force Python to delete certain things on deallocation use "
|
||
"the :mod:`atexit` module to run a function that will force those deletions."
|
||
msgstr ""
|
||
"Si vous voulez forcer Python à désallouer certains objets en quittant, "
|
||
"utilisez le module :mod:`texit` pour exécuter une fonction qui va forcer ces "
|
||
"destructions."
|
||
|
||
#: ../Doc/faq/design.rst:468
|
||
msgid "Why are there separate tuple and list data types?"
|
||
msgstr ""
|
||
"Pourquoi les *tuples* et les *list* sont deux types de données séparés ?"
|
||
|
||
#: ../Doc/faq/design.rst:470
|
||
msgid ""
|
||
"Lists and tuples, while similar in many respects, are generally used in "
|
||
"fundamentally different ways. Tuples can be thought of as being similar to "
|
||
"Pascal records or C structs; they're small collections of related data which "
|
||
"may be of different types which are operated on as a group. For example, a "
|
||
"Cartesian coordinate is appropriately represented as a tuple of two or three "
|
||
"numbers."
|
||
msgstr ""
|
||
"Les listes et les *tuples*, bien que semblable à bien des égards, sont "
|
||
"généralement utilisés de façons fondamentalement différentes. Les *tuples* "
|
||
"peuvent être considérés comme étant similaires aux dossiers en Pascal ou aux "
|
||
"structures en C; Ce sont de petites collections de données associées qui "
|
||
"peuvent être de différents types qui sont utilisées sensemble. Par exemple, "
|
||
"un repère cartésien est correctement représenté comme un *tuple* de deux ou "
|
||
"trois nombres."
|
||
|
||
#: ../Doc/faq/design.rst:477
|
||
msgid ""
|
||
"Lists, on the other hand, are more like arrays in other languages. They "
|
||
"tend to hold a varying number of objects all of which have the same type and "
|
||
"which are operated on one-by-one. For example, ``os.listdir('.')`` returns "
|
||
"a list of strings representing the files in the current directory. "
|
||
"Functions which operate on this output would generally not break if you "
|
||
"added another file or two to the directory."
|
||
msgstr ""
|
||
"Les listes, ressemblent davantage à des tableaux dans d'autres langues. "
|
||
"Elles ont tendance à contenir un nombre variable d'objets de même type "
|
||
"manipulés individuellement. Par exemple, ``os.listdir('.')`` retourne une "
|
||
"liste de chaînes représentant les fichiers dans le dossier courant. Les "
|
||
"fonctions travaillant sur cette sortie accepteraient généralement sans aucun "
|
||
"problème que vous ajoutiez un ou deux fichiers supplémentaire dans le "
|
||
"dossier."
|
||
|
||
#: ../Doc/faq/design.rst:484
|
||
msgid ""
|
||
"Tuples are immutable, meaning that once a tuple has been created, you can't "
|
||
"replace any of its elements with a new value. Lists are mutable, meaning "
|
||
"that you can always change a list's elements. Only immutable elements can "
|
||
"be used as dictionary keys, and hence only tuples and not lists can be used "
|
||
"as keys."
|
||
msgstr ""
|
||
"Les *tuples* sont immuables, ce qui signifie que lorsqu'un *tuple* a été "
|
||
"créé, vous ne pouvez remplacer aucun de ses éléments par une nouvelle "
|
||
"valeur. Les listes sont mutables, ce qui signifie que vous pouvez toujours "
|
||
"modifier les éléments d'une liste. Seuls des éléments immuables peuvent être "
|
||
"utilisés comme clés de dictionnaires, et donc de ``tuple`` et ``list`` seul "
|
||
"des *tuples* peuvent être utilisés comme clés."
|
||
|
||
#: ../Doc/faq/design.rst:491
|
||
msgid "How are lists implemented?"
|
||
msgstr "Comment est-ce que les listes sont implémentées ?"
|
||
|
||
#: ../Doc/faq/design.rst:493
|
||
msgid ""
|
||
"Python's lists are really variable-length arrays, not Lisp-style linked "
|
||
"lists. The implementation uses a contiguous array of references to other "
|
||
"objects, and keeps a pointer to this array and the array's length in a list "
|
||
"head structure."
|
||
msgstr ""
|
||
"Les listes en Python sont de vrais tableaux de longueur variable "
|
||
"contrairement à des listes orientées *Lisp* (i.e des listes chaînées). "
|
||
"L'implémentation utilise un tableau contigu de références à d'autres objets. "
|
||
"Elle conserve également un pointeur vers ce tableau et la longueur du "
|
||
"tableau dans une structure de tête de liste."
|
||
|
||
#: ../Doc/faq/design.rst:497
|
||
msgid ""
|
||
"This makes indexing a list ``a[i]`` an operation whose cost is independent "
|
||
"of the size of the list or the value of the index."
|
||
msgstr ""
|
||
"Cela rend l'indexation d'une liste ``a[i]`` une opération dont le coût est "
|
||
"indépendant de la taille de la liste ou de la valeur de l'indice."
|
||
|
||
#: ../Doc/faq/design.rst:500
|
||
msgid ""
|
||
"When items are appended or inserted, the array of references is resized. "
|
||
"Some cleverness is applied to improve the performance of appending items "
|
||
"repeatedly; when the array must be grown, some extra space is allocated so "
|
||
"the next few times don't require an actual resize."
|
||
msgstr ""
|
||
"Lorsque des éléments sont ajoutés ou insérés, le tableau de références est "
|
||
"redimensionné. Un savoir-faire ingénieux permet l'amélioration des "
|
||
"performances lors de l'ajout fréquent d'éléments ; Lorsque le tableau doit "
|
||
"être étendu, un certain espace supplémentaire est alloué de sorte que pour "
|
||
"la prochaine fois, ceci ne nécessite plus un redimensionnement effectif."
|
||
|
||
#: ../Doc/faq/design.rst:507
|
||
msgid "How are dictionaries implemented?"
|
||
msgstr "Comment les dictionnaires sont-ils implémentés ?"
|
||
|
||
#: ../Doc/faq/design.rst:509
|
||
msgid ""
|
||
"Python's dictionaries are implemented as resizable hash tables. Compared to "
|
||
"B-trees, this gives better performance for lookup (the most common operation "
|
||
"by far) under most circumstances, and the implementation is simpler."
|
||
msgstr ""
|
||
"Les dictionnaires Python sont implémentés sous forme de tables de hachage "
|
||
"redimensionnables. Par rapport aux *B-trees*, cela donne de meilleures "
|
||
"performances pour la recherche (l'opération la plus courante de loin) dans "
|
||
"la plupart des circonstances, et leur implémentation est plus simple."
|
||
|
||
#: ../Doc/faq/design.rst:513
|
||
msgid ""
|
||
"Dictionaries work by computing a hash code for each key stored in the "
|
||
"dictionary using the :func:`hash` built-in function. The hash code varies "
|
||
"widely depending on the key and a per-process seed; for example, \"Python\" "
|
||
"could hash to -539294296 while \"python\", a string that differs by a single "
|
||
"bit, could hash to 1142331976. The hash code is then used to calculate a "
|
||
"location in an internal array where the value will be stored. Assuming that "
|
||
"you're storing keys that all have different hash values, this means that "
|
||
"dictionaries take constant time -- O(1), in computer science notation -- to "
|
||
"retrieve a key. It also means that no sorted order of the keys is "
|
||
"maintained, and traversing the array as the ``.keys()`` and ``.items()`` do "
|
||
"will output the dictionary's content in some arbitrary jumbled order that "
|
||
"can change with every invocation of a program."
|
||
msgstr ""
|
||
"Les dictionnaires fonctionnent en calculant un code de hachage pour chaque "
|
||
"clé stockée dans le dictionnaire en utilisant la fonction :func:`hash`. Le "
|
||
"code de hachage varie grandement selon la clé et du nombre de processus "
|
||
"utilisés ; Par exemple, la chaine de caractère \"Python\" pourrait avoir "
|
||
"comme code de hachage une valeur allant jusqu'à-539294296 tandis que la "
|
||
"chaine \"python\",qui se distingue de la première par un seul bit, pourrait "
|
||
"avoir comme code de hachage une valeur allant jusqu'à 1142331976. Le code "
|
||
"de hachage est ensuite utilisé pour calculer un emplacement dans un tableau "
|
||
"interne où la valeur est stockée. Dans l'hypothèse où vous stockez les clés "
|
||
"qui ont toutes des valeurs de hachage différentes, cela signifie que les "
|
||
"dictionnaires parcourt le dictionnaire en un temps constant -- O(1), en "
|
||
"notation scientifique informatique - - pour récupérer une clé. Cela "
|
||
"signifie également qu'aucun ordre de tri des clés n'est maintenu, et lors du "
|
||
"parcours du tableau, les ``.keys()`` et ``.items()`` afficheront le contenu "
|
||
"du dictionnaire dans un certain ordre arbitraire qui peut changer à chaque "
|
||
"appel d'un programme."
|
||
|
||
#: ../Doc/faq/design.rst:528
|
||
msgid "Why must dictionary keys be immutable?"
|
||
msgstr "Pourquoi les clés du dictionnaire sont immuables ?"
|
||
|
||
#: ../Doc/faq/design.rst:530
|
||
msgid ""
|
||
"The hash table implementation of dictionaries uses a hash value calculated "
|
||
"from the key value to find the key. If the key were a mutable object, its "
|
||
"value could change, and thus its hash could also change. But since whoever "
|
||
"changes the key object can't tell that it was being used as a dictionary "
|
||
"key, it can't move the entry around in the dictionary. Then, when you try "
|
||
"to look up the same object in the dictionary it won't be found because its "
|
||
"hash value is different. If you tried to look up the old value it wouldn't "
|
||
"be found either, because the value of the object found in that hash bin "
|
||
"would be different."
|
||
msgstr ""
|
||
"L'implémentation de la table de hachage des dictionnaires utilise une valeur "
|
||
"de hachage calculée à partir de la valeur de la clé pour trouver la clé elle-"
|
||
"même. Si la clé était un objet mutable, sa valeur peut changer, et donc son "
|
||
"hachage pourrait également changer. Mais toute personne modifiant l'objet "
|
||
"clé ne peut pas dire qu'elle a été utilisée comme une clé de dictionnaire. "
|
||
"Il ne peut déplacer l'entrée dans le dictionnaire. Ainsi, lorsque vous "
|
||
"essayez de rechercher le même objet dans le dictionnaire, il ne sera pas "
|
||
"disponible parce que sa valeur de hachage est différente. Si vous essayez de "
|
||
"chercher l'ancienne valeur, elle serait également introuvable car la valeur "
|
||
"de l'objet trouvé dans cet emplacement de hachage serait différente."
|
||
|
||
#: ../Doc/faq/design.rst:539
|
||
msgid ""
|
||
"If you want a dictionary indexed with a list, simply convert the list to a "
|
||
"tuple first; the function ``tuple(L)`` creates a tuple with the same entries "
|
||
"as the list ``L``. Tuples are immutable and can therefore be used as "
|
||
"dictionary keys."
|
||
msgstr ""
|
||
"Si vous voulez un dictionnaire indexé avec une liste, il faut simplement "
|
||
"convertir la liste en un *tuple* ; la fonction ``tuple(L)`` crée un "
|
||
"*tuple* avec les mêmes entrées que la liste ``L``. Les *tuples* sont "
|
||
"immuables et peuvent donc être utilisés comme clés du dictionnaire."
|
||
|
||
#: ../Doc/faq/design.rst:543
|
||
msgid "Some unacceptable solutions that have been proposed:"
|
||
msgstr "Certaines solutions insatisfaisantes qui ont été proposées :"
|
||
|
||
#: ../Doc/faq/design.rst:545
|
||
msgid ""
|
||
"Hash lists by their address (object ID). This doesn't work because if you "
|
||
"construct a new list with the same value it won't be found; e.g.::"
|
||
msgstr ""
|
||
"Les listes de hachage par leur adresse (*ID* de l'objet). Cela ne "
|
||
"fonctionne pas parce que si vous créez une nouvelle liste avec la même "
|
||
"valeur, elle ne sera pas retrouvée; par exemple.::"
|
||
|
||
#: ../Doc/faq/design.rst:551
|
||
msgid ""
|
||
"would raise a KeyError exception because the id of the ``[1, 2]`` used in "
|
||
"the second line differs from that in the first line. In other words, "
|
||
"dictionary keys should be compared using ``==``, not using :keyword:`is`."
|
||
msgstr ""
|
||
"cela soulèverait une exception de type *KeyError* car l'id de ``[1, 2]`` "
|
||
"utilisée dans la deuxième ligne diffère de celle de la première ligne. En "
|
||
"d'autres termes, les clés de dictionnaire doivent être comparées à l'aide du "
|
||
"comparateur ``==`` et non à l'aide du :keyword:`is`."
|
||
|
||
#: ../Doc/faq/design.rst:555
|
||
msgid ""
|
||
"Make a copy when using a list as a key. This doesn't work because the list, "
|
||
"being a mutable object, could contain a reference to itself, and then the "
|
||
"copying code would run into an infinite loop."
|
||
msgstr ""
|
||
"Faire une copie lors de l'utilisation d'une liste en tant que clé. Cela ne "
|
||
"fonctionne pas puisque la liste, étant un objet mutable, pourrait contenir "
|
||
"une référence à elle-même ou avoir une boucle infinie au niveau du code "
|
||
"copié."
|
||
|
||
#: ../Doc/faq/design.rst:559
|
||
msgid ""
|
||
"Allow lists as keys but tell the user not to modify them. This would allow "
|
||
"a class of hard-to-track bugs in programs when you forgot or modified a list "
|
||
"by accident. It also invalidates an important invariant of dictionaries: "
|
||
"every value in ``d.keys()`` is usable as a key of the dictionary."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:564
|
||
msgid ""
|
||
"Mark lists as read-only once they are used as a dictionary key. The problem "
|
||
"is that it's not just the top-level object that could change its value; you "
|
||
"could use a tuple containing a list as a key. Entering anything as a key "
|
||
"into a dictionary would require marking all objects reachable from there as "
|
||
"read-only -- and again, self-referential objects could cause an infinite "
|
||
"loop."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:570
|
||
msgid ""
|
||
"There is a trick to get around this if you need to, but use it at your own "
|
||
"risk: You can wrap a mutable structure inside a class instance which has "
|
||
"both a :meth:`__eq__` and a :meth:`__hash__` method. You must then make "
|
||
"sure that the hash value for all such wrapper objects that reside in a "
|
||
"dictionary (or other hash based structure), remain fixed while the object is "
|
||
"in the dictionary (or other structure). ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:594
|
||
msgid ""
|
||
"Note that the hash computation is complicated by the possibility that some "
|
||
"members of the list may be unhashable and also by the possibility of "
|
||
"arithmetic overflow."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:598
|
||
msgid ""
|
||
"Furthermore it must always be the case that if ``o1 == o2`` (ie ``o1."
|
||
"__eq__(o2) is True``) then ``hash(o1) == hash(o2)`` (ie, ``o1.__hash__() == "
|
||
"o2.__hash__()``), regardless of whether the object is in a dictionary or "
|
||
"not. If you fail to meet these restrictions dictionaries and other hash "
|
||
"based structures will misbehave."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:603
|
||
msgid ""
|
||
"In the case of ListWrapper, whenever the wrapper object is in a dictionary "
|
||
"the wrapped list must not change to avoid anomalies. Don't do this unless "
|
||
"you are prepared to think hard about the requirements and the consequences "
|
||
"of not meeting them correctly. Consider yourself warned."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:610
|
||
msgid "Why doesn't list.sort() return the sorted list?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:612
|
||
msgid ""
|
||
"In situations where performance matters, making a copy of the list just to "
|
||
"sort it would be wasteful. Therefore, :meth:`list.sort` sorts the list in "
|
||
"place. In order to remind you of that fact, it does not return the sorted "
|
||
"list. This way, you won't be fooled into accidentally overwriting a list "
|
||
"when you need a sorted copy but also need to keep the unsorted version "
|
||
"around."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:618
|
||
msgid ""
|
||
"If you want to return a new list, use the built-in :func:`sorted` function "
|
||
"instead. This function creates a new list from a provided iterable, sorts "
|
||
"it and returns it. For example, here's how to iterate over the keys of a "
|
||
"dictionary in sorted order::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:628
|
||
msgid "How do you specify and enforce an interface spec in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:630
|
||
msgid ""
|
||
"An interface specification for a module as provided by languages such as C++ "
|
||
"and Java describes the prototypes for the methods and functions of the "
|
||
"module. Many feel that compile-time enforcement of interface specifications "
|
||
"helps in the construction of large programs."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:635
|
||
msgid ""
|
||
"Python 2.6 adds an :mod:`abc` module that lets you define Abstract Base "
|
||
"Classes (ABCs). You can then use :func:`isinstance` and :func:`issubclass` "
|
||
"to check whether an instance or a class implements a particular ABC. The :"
|
||
"mod:`collections.abc` module defines a set of useful ABCs such as :class:"
|
||
"`~collections.abc.Iterable`, :class:`~collections.abc.Container`, and :class:"
|
||
"`~collections.abc.MutableMapping`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:642
|
||
msgid ""
|
||
"For Python, many of the advantages of interface specifications can be "
|
||
"obtained by an appropriate test discipline for components. There is also a "
|
||
"tool, PyChecker, which can be used to find problems due to subclassing."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:646
|
||
msgid ""
|
||
"A good test suite for a module can both provide a regression test and serve "
|
||
"as a module interface specification and a set of examples. Many Python "
|
||
"modules can be run as a script to provide a simple \"self test.\" Even "
|
||
"modules which use complex external interfaces can often be tested in "
|
||
"isolation using trivial \"stub\" emulations of the external interface. The :"
|
||
"mod:`doctest` and :mod:`unittest` modules or third-party test frameworks can "
|
||
"be used to construct exhaustive test suites that exercise every line of code "
|
||
"in a module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:654
|
||
msgid ""
|
||
"An appropriate testing discipline can help build large complex applications "
|
||
"in Python as well as having interface specifications would. In fact, it can "
|
||
"be better because an interface specification cannot test certain properties "
|
||
"of a program. For example, the :meth:`append` method is expected to add new "
|
||
"elements to the end of some internal list; an interface specification cannot "
|
||
"test that your :meth:`append` implementation will actually do this "
|
||
"correctly, but it's trivial to check this property in a test suite."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:662
|
||
msgid ""
|
||
"Writing test suites is very helpful, and you might want to design your code "
|
||
"with an eye to making it easily tested. One increasingly popular technique, "
|
||
"test-directed development, calls for writing parts of the test suite first, "
|
||
"before you write any of the actual code. Of course Python allows you to be "
|
||
"sloppy and not write test cases at all."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:670
|
||
msgid "Why is there no goto?"
|
||
msgstr "Pourquoi n'y a-t-il pas de goto en Python ?"
|
||
|
||
#: ../Doc/faq/design.rst:672
|
||
msgid ""
|
||
"You can use exceptions to provide a \"structured goto\" that even works "
|
||
"across function calls. Many feel that exceptions can conveniently emulate "
|
||
"all reasonable uses of the \"go\" or \"goto\" constructs of C, Fortran, and "
|
||
"other languages. For example::"
|
||
msgstr ""
|
||
"Vous pouvez utiliser les exceptions afin de mettre en place un \"goto "
|
||
"structuré\" qui fonctionne même avec les appels de fonctions. Beaucoup de "
|
||
"personnes estiment que les exceptions peuvent émuler idéalement tout "
|
||
"utilisation raisonnable des constructions \"go\" ou \"goto\" en C, en "
|
||
"Fortran ou autres langages de programmation. Par exemple::"
|
||
|
||
#: ../Doc/faq/design.rst:687
|
||
msgid ""
|
||
"This doesn't allow you to jump into the middle of a loop, but that's usually "
|
||
"considered an abuse of goto anyway. Use sparingly."
|
||
msgstr ""
|
||
"Cela ne vous permet pas de sauter au milieu d'une boucle. Néanmoins, dans "
|
||
"tous les cas cela est généralement considéré comme un abus de goto. À "
|
||
"Utiliser avec parcimonie."
|
||
|
||
#: ../Doc/faq/design.rst:692
|
||
msgid "Why can't raw strings (r-strings) end with a backslash?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:694
|
||
msgid ""
|
||
"More precisely, they can't end with an odd number of backslashes: the "
|
||
"unpaired backslash at the end escapes the closing quote character, leaving "
|
||
"an unterminated string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:698
|
||
msgid ""
|
||
"Raw strings were designed to ease creating input for processors (chiefly "
|
||
"regular expression engines) that want to do their own backslash escape "
|
||
"processing. Such processors consider an unmatched trailing backslash to be "
|
||
"an error anyway, so raw strings disallow that. In return, they allow you to "
|
||
"pass on the string quote character by escaping it with a backslash. These "
|
||
"rules work well when r-strings are used for their intended purpose."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:705
|
||
msgid ""
|
||
"If you're trying to build Windows pathnames, note that all Windows system "
|
||
"calls accept forward slashes too::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:710
|
||
msgid ""
|
||
"If you're trying to build a pathname for a DOS command, try e.g. one of ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:718
|
||
msgid "Why doesn't Python have a \"with\" statement for attribute assignments?"
|
||
msgstr ""
|
||
"Pourquoi la déclaration \"with\" pour les assignations d'attributs n'existe "
|
||
"pas en Python ?"
|
||
|
||
#: ../Doc/faq/design.rst:720
|
||
msgid ""
|
||
"Python has a 'with' statement that wraps the execution of a block, calling "
|
||
"code on the entrance and exit from the block. Some language have a "
|
||
"construct that looks like this::"
|
||
msgstr ""
|
||
"Python a une instruction \"with\" qui encapsule l'exécution d'un bloc, en "
|
||
"appelant le code sur l'entrée et la sortie du bloc. Certains langages "
|
||
"possèdent une construction qui ressemble à ceci::"
|
||
|
||
#: ../Doc/faq/design.rst:728
|
||
msgid "In Python, such a construct would be ambiguous."
|
||
msgstr "En Python, une telle construction serait ambiguë."
|
||
|
||
#: ../Doc/faq/design.rst:730
|
||
msgid ""
|
||
"Other languages, such as Object Pascal, Delphi, and C++, use static types, "
|
||
"so it's possible to know, in an unambiguous way, what member is being "
|
||
"assigned to. This is the main point of static typing -- the compiler "
|
||
"*always* knows the scope of every variable at compile time."
|
||
msgstr ""
|
||
"Les autres langages, tels que le Pascal, le Delphi et le C++ utilisent des "
|
||
"types statiques, il est donc possible de savoir d'une manière claire et "
|
||
"directe ce à quoi est attribué un membre. C'est le point principal du typage "
|
||
"statique --le compilateur connaît *toujours* la portée de toutes les "
|
||
"variables au moment de la compilation."
|
||
|
||
#: ../Doc/faq/design.rst:735
|
||
msgid ""
|
||
"Python uses dynamic types. It is impossible to know in advance which "
|
||
"attribute will be referenced at runtime. Member attributes may be added or "
|
||
"removed from objects on the fly. This makes it impossible to know, from a "
|
||
"simple reading, what attribute is being referenced: a local one, a global "
|
||
"one, or a member attribute?"
|
||
msgstr ""
|
||
"Python utilise le typage dynamique. Il est impossible de savoir à l'avance "
|
||
"quel attribut est utilisé comme référence lors de l'exécution. Les attributs "
|
||
"membres peuvent être ajoutés ou retirés des objets à la volée. Il est donc "
|
||
"impossible de savoir, d'une simple lecture, quel attribut est référencé : "
|
||
"s'il est local, global ou un attribut membre?"
|
||
|
||
#: ../Doc/faq/design.rst:741
|
||
msgid "For instance, take the following incomplete snippet::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:747
|
||
msgid ""
|
||
"The snippet assumes that \"a\" must have a member attribute called \"x\". "
|
||
"However, there is nothing in Python that tells the interpreter this. What "
|
||
"should happen if \"a\" is, let us say, an integer? If there is a global "
|
||
"variable named \"x\", will it be used inside the with block? As you see, "
|
||
"the dynamic nature of Python makes such choices much harder."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:753
|
||
msgid ""
|
||
"The primary benefit of \"with\" and similar language features (reduction of "
|
||
"code volume) can, however, easily be achieved in Python by assignment. "
|
||
"Instead of::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:760
|
||
msgid "write this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:767
|
||
msgid ""
|
||
"This also has the side-effect of increasing execution speed because name "
|
||
"bindings are resolved at run-time in Python, and the second version only "
|
||
"needs to perform the resolution once."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:773
|
||
msgid "Why are colons required for the if/while/def/class statements?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:775
|
||
msgid ""
|
||
"The colon is required primarily to enhance readability (one of the results "
|
||
"of the experimental ABC language). Consider this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:781
|
||
msgid "versus ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:786
|
||
msgid ""
|
||
"Notice how the second one is slightly easier to read. Notice further how a "
|
||
"colon sets off the example in this FAQ answer; it's a standard usage in "
|
||
"English."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:789
|
||
msgid ""
|
||
"Another minor reason is that the colon makes it easier for editors with "
|
||
"syntax highlighting; they can look for colons to decide when indentation "
|
||
"needs to be increased instead of having to do a more elaborate parsing of "
|
||
"the program text."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:795
|
||
msgid "Why does Python allow commas at the end of lists and tuples?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:797
|
||
msgid ""
|
||
"Python lets you add a trailing comma at the end of lists, tuples, and "
|
||
"dictionaries::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:808
|
||
msgid "There are several reasons to allow this."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:810
|
||
msgid ""
|
||
"When you have a literal value for a list, tuple, or dictionary spread across "
|
||
"multiple lines, it's easier to add more elements because you don't have to "
|
||
"remember to add a comma to the previous line. The lines can also be "
|
||
"reordered without creating a syntax error."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:815
|
||
msgid ""
|
||
"Accidentally omitting the comma can lead to errors that are hard to "
|
||
"diagnose. For example::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:825
|
||
msgid ""
|
||
"This list looks like it has four elements, but it actually contains three: "
|
||
"\"fee\", \"fiefoo\" and \"fum\". Always adding the comma avoids this source "
|
||
"of error."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/design.rst:828
|
||
msgid ""
|
||
"Allowing the trailing comma may also make programmatic code generation "
|
||
"easier."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:3
|
||
msgid "Extending/Embedding FAQ"
|
||
msgstr "FAQ Extension/Intégration"
|
||
|
||
#: ../Doc/faq/extending.rst:16
|
||
msgid "Can I create my own functions in C?"
|
||
msgstr "Puis-je créer mes propres fonctions en C ?"
|
||
|
||
#: ../Doc/faq/extending.rst:18
|
||
msgid ""
|
||
"Yes, you can create built-in modules containing functions, variables, "
|
||
"exceptions and even new types in C. This is explained in the document :ref:"
|
||
"`extending-index`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:22
|
||
msgid "Most intermediate or advanced Python books will also cover this topic."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:26
|
||
msgid "Can I create my own functions in C++?"
|
||
msgstr "Puis-je créer mes propres fonctions en C++ ?"
|
||
|
||
#: ../Doc/faq/extending.rst:28
|
||
msgid ""
|
||
"Yes, using the C compatibility features found in C++. Place ``extern \"C"
|
||
"\" { ... }`` around the Python include files and put ``extern \"C\"`` before "
|
||
"each function that is going to be called by the Python interpreter. Global "
|
||
"or static C++ objects with constructors are probably not a good idea."
|
||
msgstr ""
|
||
"Oui, en utilisant les fonctionnalités de compatibilité C existantes en C++. "
|
||
"Placez ``extern \"C\" { ... }`` autour des fichiers Python inclus et mettez "
|
||
"``extern \"C\"`` avant chaque fonction qui va être appelée par "
|
||
"l'interpréteur Python. Les objets C++ globaux ou statiques avec les "
|
||
"constructeurs ne sont probablement pas une bonne idée."
|
||
|
||
#: ../Doc/faq/extending.rst:37
|
||
msgid "Writing C is hard; are there any alternatives?"
|
||
msgstr "Écrire directement en C est difficile ; existe-t-il des alternatives ?"
|
||
|
||
#: ../Doc/faq/extending.rst:39
|
||
msgid ""
|
||
"There are a number of alternatives to writing your own C extensions, "
|
||
"depending on what you're trying to do."
|
||
msgstr ""
|
||
"Il y a un certain nombre de solutions existantes qui vous permettent "
|
||
"d'écrire vos propres extensions C, selon ce que vous essayez de faire."
|
||
|
||
#: ../Doc/faq/extending.rst:44
|
||
msgid ""
|
||
"`Cython <http://cython.org>`_ and its relative `Pyrex <https://www.cosc."
|
||
"canterbury.ac.nz/greg.ewing/python/Pyrex/>`_ are compilers that accept a "
|
||
"slightly modified form of Python and generate the corresponding C code. "
|
||
"Cython and Pyrex make it possible to write an extension without having to "
|
||
"learn Python's C API."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:50
|
||
msgid ""
|
||
"If you need to interface to some C or C++ library for which no Python "
|
||
"extension currently exists, you can try wrapping the library's data types "
|
||
"and functions with a tool such as `SWIG <http://www.swig.org>`_. `SIP "
|
||
"<https://riverbankcomputing.com/software/sip/intro>`__, `CXX <http://cxx."
|
||
"sourceforge.net/>`_ `Boost <http://www.boost.org/libs/python/doc/index."
|
||
"html>`_, or `Weave <https://scipy.github.io/devdocs/tutorial/weave.html>`_ "
|
||
"are also alternatives for wrapping C++ libraries."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:61
|
||
msgid "How can I execute arbitrary Python statements from C?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:63
|
||
msgid ""
|
||
"The highest-level function to do this is :c:func:`PyRun_SimpleString` which "
|
||
"takes a single string argument to be executed in the context of the module "
|
||
"``__main__`` and returns 0 for success and -1 when an exception occurred "
|
||
"(including ``SyntaxError``). If you want more control, use :c:func:"
|
||
"`PyRun_String`; see the source for :c:func:`PyRun_SimpleString` in ``Python/"
|
||
"pythonrun.c``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:72
|
||
msgid "How can I evaluate an arbitrary Python expression from C?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:74
|
||
msgid ""
|
||
"Call the function :c:func:`PyRun_String` from the previous question with the "
|
||
"start symbol :c:data:`Py_eval_input`; it parses an expression, evaluates it "
|
||
"and returns its value."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:80
|
||
msgid "How do I extract C values from a Python object?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:82
|
||
msgid ""
|
||
"That depends on the object's type. If it's a tuple, :c:func:`PyTuple_Size` "
|
||
"returns its length and :c:func:`PyTuple_GetItem` returns the item at a "
|
||
"specified index. Lists have similar functions, :c:func:`PyListSize` and :c:"
|
||
"func:`PyList_GetItem`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:87
|
||
msgid ""
|
||
"For bytes, :c:func:`PyBytes_Size` returns its length and :c:func:"
|
||
"`PyBytes_AsStringAndSize` provides a pointer to its value and its length. "
|
||
"Note that Python bytes objects may contain null bytes so C's :c:func:"
|
||
"`strlen` should not be used."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:92
|
||
msgid ""
|
||
"To test the type of an object, first make sure it isn't *NULL*, and then "
|
||
"use :c:func:`PyBytes_Check`, :c:func:`PyTuple_Check`, :c:func:"
|
||
"`PyList_Check`, etc."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:95
|
||
msgid ""
|
||
"There is also a high-level API to Python objects which is provided by the so-"
|
||
"called 'abstract' interface -- read ``Include/abstract.h`` for further "
|
||
"details. It allows interfacing with any kind of Python sequence using calls "
|
||
"like :c:func:`PySequence_Length`, :c:func:`PySequence_GetItem`, etc. as well "
|
||
"as many other useful protocols such as numbers (:c:func:`PyNumber_Index` et "
|
||
"al.) and mappings in the PyMapping APIs."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:104
|
||
msgid "How do I use Py_BuildValue() to create a tuple of arbitrary length?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:106
|
||
msgid "You can't. Use :c:func:`PyTuple_Pack` instead."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:110
|
||
msgid "How do I call an object's method from C?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:112
|
||
msgid ""
|
||
"The :c:func:`PyObject_CallMethod` function can be used to call an arbitrary "
|
||
"method of an object. The parameters are the object, the name of the method "
|
||
"to call, a format string like that used with :c:func:`Py_BuildValue`, and "
|
||
"the argument values::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:121
|
||
msgid ""
|
||
"This works for any object that has methods -- whether built-in or user-"
|
||
"defined. You are responsible for eventually :c:func:`Py_DECREF`\\ 'ing the "
|
||
"return value."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:124
|
||
msgid ""
|
||
"To call, e.g., a file object's \"seek\" method with arguments 10, 0 "
|
||
"(assuming the file object pointer is \"f\")::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:135
|
||
msgid ""
|
||
"Note that since :c:func:`PyObject_CallObject` *always* wants a tuple for the "
|
||
"argument list, to call a function without arguments, pass \"()\" for the "
|
||
"format, and to call a function with one argument, surround the argument in "
|
||
"parentheses, e.g. \"(i)\"."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:142
|
||
msgid ""
|
||
"How do I catch the output from PyErr_Print() (or anything that prints to "
|
||
"stdout/stderr)?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:144
|
||
msgid ""
|
||
"In Python code, define an object that supports the ``write()`` method. "
|
||
"Assign this object to :data:`sys.stdout` and :data:`sys.stderr`. Call "
|
||
"print_error, or just allow the standard traceback mechanism to work. Then, "
|
||
"the output will go wherever your ``write()`` method sends it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:149
|
||
msgid "The easiest way to do this is to use the :class:`io.StringIO` class:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:161
|
||
msgid "A custom object to do the same would look like this:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:182
|
||
msgid "How do I access a module written in Python from C?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:184
|
||
msgid "You can get a pointer to the module object as follows::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:188
|
||
msgid ""
|
||
"If the module hasn't been imported yet (i.e. it is not yet present in :data:"
|
||
"`sys.modules`), this initializes the module; otherwise it simply returns the "
|
||
"value of ``sys.modules[\"<modulename>\"]``. Note that it doesn't enter the "
|
||
"module into any namespace -- it only ensures it has been initialized and is "
|
||
"stored in :data:`sys.modules`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:194
|
||
msgid ""
|
||
"You can then access the module's attributes (i.e. any name defined in the "
|
||
"module) as follows::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:199
|
||
msgid ""
|
||
"Calling :c:func:`PyObject_SetAttrString` to assign to variables in the "
|
||
"module also works."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:204
|
||
msgid "How do I interface to C++ objects from Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:206
|
||
msgid ""
|
||
"Depending on your requirements, there are many approaches. To do this "
|
||
"manually, begin by reading :ref:`the \"Extending and Embedding\" document "
|
||
"<extending-index>`. Realize that for the Python run-time system, there "
|
||
"isn't a whole lot of difference between C and C++ -- so the strategy of "
|
||
"building a new Python type around a C structure (pointer) type will also "
|
||
"work for C++ objects."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:212
|
||
msgid "For C++ libraries, see :ref:`c-wrapper-software`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:216
|
||
msgid "I added a module using the Setup file and the make fails; why?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:218
|
||
msgid ""
|
||
"Setup must end in a newline, if there is no newline there, the build process "
|
||
"fails. (Fixing this requires some ugly shell script hackery, and this bug "
|
||
"is so minor that it doesn't seem worth the effort.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:224
|
||
msgid "How do I debug an extension?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:226
|
||
msgid ""
|
||
"When using GDB with dynamically loaded extensions, you can't set a "
|
||
"breakpoint in your extension until your extension is loaded."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:229
|
||
msgid "In your ``.gdbinit`` file (or interactively), add the command:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:235
|
||
msgid "Then, when you run GDB:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:247
|
||
msgid ""
|
||
"I want to compile a Python module on my Linux system, but some files are "
|
||
"missing. Why?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:249
|
||
msgid ""
|
||
"Most packaged versions of Python don't include the :file:`/usr/lib/python2."
|
||
"{x}/config/` directory, which contains various files required for compiling "
|
||
"Python extensions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:253
|
||
msgid "For Red Hat, install the python-devel RPM to get the necessary files."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:255
|
||
msgid "For Debian, run ``apt-get install python-dev``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:259
|
||
msgid "How do I tell \"incomplete input\" from \"invalid input\"?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:261
|
||
msgid ""
|
||
"Sometimes you want to emulate the Python interactive interpreter's behavior, "
|
||
"where it gives you a continuation prompt when the input is incomplete (e.g. "
|
||
"you typed the start of an \"if\" statement or you didn't close your "
|
||
"parentheses or triple string quotes), but it gives you a syntax error "
|
||
"message immediately when the input is invalid."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:267
|
||
msgid ""
|
||
"In Python you can use the :mod:`codeop` module, which approximates the "
|
||
"parser's behavior sufficiently. IDLE uses this, for example."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:270
|
||
msgid ""
|
||
"The easiest way to do it in C is to call :c:func:`PyRun_InteractiveLoop` "
|
||
"(perhaps in a separate thread) and let the Python interpreter handle the "
|
||
"input for you. You can also set the :c:func:`PyOS_ReadlineFunctionPointer` "
|
||
"to point at your custom input function. See ``Modules/readline.c`` and "
|
||
"``Parser/myreadline.c`` for more hints."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:276
|
||
msgid ""
|
||
"However sometimes you have to run the embedded Python interpreter in the "
|
||
"same thread as your rest application and you can't allow the :c:func:"
|
||
"`PyRun_InteractiveLoop` to stop while waiting for user input. The one "
|
||
"solution then is to call :c:func:`PyParser_ParseString` and test for ``e."
|
||
"error`` equal to ``E_EOF``, which means the input is incomplete). Here's a "
|
||
"sample code fragment, untested, inspired by code from Alex Farber::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:309
|
||
msgid ""
|
||
"Another solution is trying to compile the received string with :c:func:"
|
||
"`Py_CompileString`. If it compiles without errors, try to execute the "
|
||
"returned code object by calling :c:func:`PyEval_EvalCode`. Otherwise save "
|
||
"the input for later. If the compilation fails, find out if it's an error or "
|
||
"just more input is required - by extracting the message string from the "
|
||
"exception tuple and comparing it to the string \"unexpected EOF while parsing"
|
||
"\". Here is a complete example using the GNU readline library (you may want "
|
||
"to ignore **SIGINT** while calling readline())::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:430
|
||
msgid "How do I find undefined g++ symbols __builtin_new or __pure_virtual?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:432
|
||
msgid ""
|
||
"To dynamically load g++ extension modules, you must recompile Python, relink "
|
||
"it using g++ (change LINKCC in the Python Modules Makefile), and link your "
|
||
"extension module using g++ (e.g., ``g++ -shared -o mymodule.so mymodule.o``)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:438
|
||
msgid ""
|
||
"Can I create an object class with some methods implemented in C and others "
|
||
"in Python (e.g. through inheritance)?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:440
|
||
msgid ""
|
||
"Yes, you can inherit from built-in classes such as :class:`int`, :class:"
|
||
"`list`, :class:`dict`, etc."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/extending.rst:443
|
||
msgid ""
|
||
"The Boost Python Library (BPL, http://www.boost.org/libs/python/doc/index."
|
||
"html) provides a way of doing this from C++ (i.e. you can inherit from an "
|
||
"extension class written in C++ using the BPL)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:5
|
||
msgid "General Python FAQ"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:13
|
||
msgid "General Information"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:16 ../Doc/faq/installed.rst:6
|
||
msgid "What is Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:18
|
||
msgid ""
|
||
"Python is an interpreted, interactive, object-oriented programming "
|
||
"language. It incorporates modules, exceptions, dynamic typing, very high "
|
||
"level dynamic data types, and classes. Python combines remarkable power "
|
||
"with very clear syntax. It has interfaces to many system calls and "
|
||
"libraries, as well as to various window systems, and is extensible in C or C+"
|
||
"+. It is also usable as an extension language for applications that need a "
|
||
"programmable interface. Finally, Python is portable: it runs on many Unix "
|
||
"variants, on the Mac, and on Windows 2000 and later."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:27
|
||
msgid ""
|
||
"To find out more, start with :ref:`tutorial-index`. The `Beginner's Guide "
|
||
"to Python <https://wiki.python.org/moin/BeginnersGuide>`_ links to other "
|
||
"introductory tutorials and resources for learning Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:33
|
||
msgid "What is the Python Software Foundation?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:35
|
||
msgid ""
|
||
"The Python Software Foundation is an independent non-profit organization "
|
||
"that holds the copyright on Python versions 2.1 and newer. The PSF's "
|
||
"mission is to advance open source technology related to the Python "
|
||
"programming language and to publicize the use of Python. The PSF's home "
|
||
"page is at https://www.python.org/psf/."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:41
|
||
msgid ""
|
||
"Donations to the PSF are tax-exempt in the US. If you use Python and find "
|
||
"it helpful, please contribute via `the PSF donation page <https://www.python."
|
||
"org/psf/donations/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:47
|
||
msgid "Are there copyright restrictions on the use of Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:49
|
||
msgid ""
|
||
"You can do anything you want with the source, as long as you leave the "
|
||
"copyrights in and display those copyrights in any documentation about Python "
|
||
"that you produce. If you honor the copyright rules, it's OK to use Python "
|
||
"for commercial use, to sell copies of Python in source or binary form "
|
||
"(modified or unmodified), or to sell products that incorporate Python in "
|
||
"some form. We would still like to know about all commercial use of Python, "
|
||
"of course."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:56
|
||
msgid ""
|
||
"See `the PSF license page <https://www.python.org/psf/license/>`_ to find "
|
||
"further explanations and a link to the full text of the license."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:59
|
||
msgid ""
|
||
"The Python logo is trademarked, and in certain cases permission is required "
|
||
"to use it. Consult `the Trademark Usage Policy <https://www.python.org/psf/"
|
||
"trademarks/>`__ for more information."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:65
|
||
msgid "Why was Python created in the first place?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:67
|
||
msgid ""
|
||
"Here's a *very* brief summary of what started it all, written by Guido van "
|
||
"Rossum:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:70
|
||
msgid ""
|
||
"I had extensive experience with implementing an interpreted language in the "
|
||
"ABC group at CWI, and from working with this group I had learned a lot about "
|
||
"language design. This is the origin of many Python features, including the "
|
||
"use of indentation for statement grouping and the inclusion of very-high-"
|
||
"level data types (although the details are all different in Python)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:77
|
||
msgid ""
|
||
"I had a number of gripes about the ABC language, but also liked many of its "
|
||
"features. It was impossible to extend the ABC language (or its "
|
||
"implementation) to remedy my complaints -- in fact its lack of extensibility "
|
||
"was one of its biggest problems. I had some experience with using Modula-2+ "
|
||
"and talked with the designers of Modula-3 and read the Modula-3 report. "
|
||
"Modula-3 is the origin of the syntax and semantics used for exceptions, and "
|
||
"some other Python features."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:85
|
||
msgid ""
|
||
"I was working in the Amoeba distributed operating system group at CWI. We "
|
||
"needed a better way to do system administration than by writing either C "
|
||
"programs or Bourne shell scripts, since Amoeba had its own system call "
|
||
"interface which wasn't easily accessible from the Bourne shell. My "
|
||
"experience with error handling in Amoeba made me acutely aware of the "
|
||
"importance of exceptions as a programming language feature."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:92
|
||
msgid ""
|
||
"It occurred to me that a scripting language with a syntax like ABC but with "
|
||
"access to the Amoeba system calls would fill the need. I realized that it "
|
||
"would be foolish to write an Amoeba-specific language, so I decided that I "
|
||
"needed a language that was generally extensible."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:97
|
||
msgid ""
|
||
"During the 1989 Christmas holidays, I had a lot of time on my hand, so I "
|
||
"decided to give it a try. During the next year, while still mostly working "
|
||
"on it in my own time, Python was used in the Amoeba project with increasing "
|
||
"success, and the feedback from colleagues made me add many early "
|
||
"improvements."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:103
|
||
msgid ""
|
||
"In February 1991, after just over a year of development, I decided to post "
|
||
"to USENET. The rest is in the ``Misc/HISTORY`` file."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:108
|
||
msgid "What is Python good for?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:110
|
||
msgid ""
|
||
"Python is a high-level general-purpose programming language that can be "
|
||
"applied to many different classes of problems."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:113
|
||
msgid ""
|
||
"The language comes with a large standard library that covers areas such as "
|
||
"string processing (regular expressions, Unicode, calculating differences "
|
||
"between files), Internet protocols (HTTP, FTP, SMTP, XML-RPC, POP, IMAP, CGI "
|
||
"programming), software engineering (unit testing, logging, profiling, "
|
||
"parsing Python code), and operating system interfaces (system calls, "
|
||
"filesystems, TCP/IP sockets). Look at the table of contents for :ref:"
|
||
"`library-index` to get an idea of what's available. A wide variety of third-"
|
||
"party extensions are also available. Consult `the Python Package Index "
|
||
"<https://pypi.python.org/pypi>`_ to find packages of interest to you."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:125
|
||
msgid "How does the Python version numbering scheme work?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:127
|
||
msgid ""
|
||
"Python versions are numbered A.B.C or A.B. A is the major version number -- "
|
||
"it is only incremented for really major changes in the language. B is the "
|
||
"minor version number, incremented for less earth-shattering changes. C is "
|
||
"the micro-level -- it is incremented for each bugfix release. See :pep:`6` "
|
||
"for more information about bugfix releases."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:133
|
||
msgid ""
|
||
"Not all releases are bugfix releases. In the run-up to a new major release, "
|
||
"a series of development releases are made, denoted as alpha, beta, or "
|
||
"release candidate. Alphas are early releases in which interfaces aren't yet "
|
||
"finalized; it's not unexpected to see an interface change between two alpha "
|
||
"releases. Betas are more stable, preserving existing interfaces but possibly "
|
||
"adding new modules, and release candidates are frozen, making no changes "
|
||
"except as needed to fix critical bugs."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:141
|
||
msgid ""
|
||
"Alpha, beta and release candidate versions have an additional suffix. The "
|
||
"suffix for an alpha version is \"aN\" for some small number N, the suffix "
|
||
"for a beta version is \"bN\" for some small number N, and the suffix for a "
|
||
"release candidate version is \"cN\" for some small number N. In other "
|
||
"words, all versions labeled 2.0aN precede the versions labeled 2.0bN, which "
|
||
"precede versions labeled 2.0cN, and *those* precede 2.0."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:148
|
||
msgid ""
|
||
"You may also find version numbers with a \"+\" suffix, e.g. \"2.2+\". These "
|
||
"are unreleased versions, built directly from the CPython development "
|
||
"repository. In practice, after a final minor release is made, the version "
|
||
"is incremented to the next minor version, which becomes the \"a0\" version, "
|
||
"e.g. \"2.4a0\"."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:153
|
||
msgid ""
|
||
"See also the documentation for :data:`sys.version`, :data:`sys.hexversion`, "
|
||
"and :data:`sys.version_info`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:158
|
||
msgid "How do I obtain a copy of the Python source?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:160
|
||
msgid ""
|
||
"The latest Python source distribution is always available from python.org, "
|
||
"at https://www.python.org/downloads/. The latest development sources can be "
|
||
"obtained via anonymous Mercurial access at https://hg.python.org/cpython."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:164
|
||
msgid ""
|
||
"The source distribution is a gzipped tar file containing the complete C "
|
||
"source, Sphinx-formatted documentation, Python library modules, example "
|
||
"programs, and several useful pieces of freely distributable software. The "
|
||
"source will compile and run out of the box on most UNIX platforms."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:169
|
||
msgid ""
|
||
"Consult the `Getting Started section of the Python Developer's Guide "
|
||
"<https://docs.python.org/devguide/setup.html>`__ for more information on "
|
||
"getting the source code and compiling it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:175
|
||
msgid "How do I get documentation on Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:179
|
||
msgid ""
|
||
"The standard documentation for the current stable version of Python is "
|
||
"available at https://docs.python.org/3/. PDF, plain text, and downloadable "
|
||
"HTML versions are also available at https://docs.python.org/3/download.html."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:183
|
||
msgid ""
|
||
"The documentation is written in reStructuredText and processed by `the "
|
||
"Sphinx documentation tool <http://sphinx-doc.org/>`__. The reStructuredText "
|
||
"source for the documentation is part of the Python source distribution."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:189
|
||
msgid "I've never programmed before. Is there a Python tutorial?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:191
|
||
msgid ""
|
||
"There are numerous tutorials and books available. The standard "
|
||
"documentation includes :ref:`tutorial-index`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:194
|
||
msgid ""
|
||
"Consult `the Beginner's Guide <https://wiki.python.org/moin/"
|
||
"BeginnersGuide>`_ to find information for beginning Python programmers, "
|
||
"including lists of tutorials."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:199
|
||
msgid "Is there a newsgroup or mailing list devoted to Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:201
|
||
msgid ""
|
||
"There is a newsgroup, :newsgroup:`comp.lang.python`, and a mailing list, "
|
||
"`python-list <https://mail.python.org/mailman/listinfo/python-list>`_. The "
|
||
"newsgroup and mailing list are gatewayed into each other -- if you can read "
|
||
"news it's unnecessary to subscribe to the mailing list. :newsgroup:`comp."
|
||
"lang.python` is high-traffic, receiving hundreds of postings every day, and "
|
||
"Usenet readers are often more able to cope with this volume."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:208
|
||
msgid ""
|
||
"Announcements of new software releases and events can be found in comp.lang."
|
||
"python.announce, a low-traffic moderated list that receives about five "
|
||
"postings per day. It's available as `the python-announce mailing list "
|
||
"<https://mail.python.org/mailman/listinfo/python-announce-list>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:213
|
||
msgid ""
|
||
"More info about other mailing lists and newsgroups can be found at https://"
|
||
"www.python.org/community/lists/."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:218
|
||
msgid "How do I get a beta test version of Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:220
|
||
msgid ""
|
||
"Alpha and beta releases are available from https://www.python.org/"
|
||
"downloads/. All releases are announced on the comp.lang.python and comp."
|
||
"lang.python.announce newsgroups and on the Python home page at https://www."
|
||
"python.org/; an RSS feed of news is available."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:225
|
||
msgid ""
|
||
"You can also access the development version of Python through Mercurial. "
|
||
"See https://docs.python.org/devguide/faq.html for details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:230
|
||
msgid "How do I submit bug reports and patches for Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:232
|
||
msgid ""
|
||
"To report a bug or submit a patch, please use the Roundup installation at "
|
||
"https://bugs.python.org/."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:235
|
||
msgid ""
|
||
"You must have a Roundup account to report bugs; this makes it possible for "
|
||
"us to contact you if we have follow-up questions. It will also enable "
|
||
"Roundup to send you updates as we act on your bug. If you had previously "
|
||
"used SourceForge to report bugs to Python, you can obtain your Roundup "
|
||
"password through Roundup's `password reset procedure <https://bugs.python."
|
||
"org/user?@template=forgotten>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:241
|
||
msgid ""
|
||
"For more information on how Python is developed, consult `the Python "
|
||
"Developer's Guide <https://docs.python.org/devguide/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:246
|
||
msgid "Are there any published articles about Python that I can reference?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:248
|
||
msgid "It's probably best to cite your favorite book about Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:250
|
||
msgid ""
|
||
"The very first article about Python was written in 1991 and is now quite "
|
||
"outdated."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:253
|
||
msgid ""
|
||
"Guido van Rossum and Jelke de Boer, \"Interactively Testing Remote Servers "
|
||
"Using the Python Programming Language\", CWI Quarterly, Volume 4, Issue 4 "
|
||
"(December 1991), Amsterdam, pp 283-303."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:259
|
||
msgid "Are there any books on Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:261
|
||
msgid ""
|
||
"Yes, there are many, and more are being published. See the python.org wiki "
|
||
"at https://wiki.python.org/moin/PythonBooks for a list."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:264
|
||
msgid ""
|
||
"You can also search online bookstores for \"Python\" and filter out the "
|
||
"Monty Python references; or perhaps search for \"Python\" and \"language\"."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:269
|
||
msgid "Where in the world is www.python.org located?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:271
|
||
msgid ""
|
||
"The Python project's infrastructure is located all over the world. `www."
|
||
"python.org <https://www.python.org>`_ is graciously hosted by `Rackspace "
|
||
"<https://www.rackspace.com>`_, with CDN caching provided by `Fastly <https://"
|
||
"www.fastly.com>`_. `Upfront Systems <http://www.upfrontsystems.co.za/>`_ "
|
||
"hosts `bugs.python.org <https://bugs.python.org>`_. Many other Python "
|
||
"services like `the Wiki <https://wiki.python.org>`_ are hosted by `Oregon "
|
||
"State University Open Source Lab <https://osuosl.org>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:282
|
||
msgid "Why is it called Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:284
|
||
msgid ""
|
||
"When he began implementing Python, Guido van Rossum was also reading the "
|
||
"published scripts from `\"Monty Python's Flying Circus\" <https://en."
|
||
"wikipedia.org/wiki/Monty_Python>`__, a BBC comedy series from the 1970s. "
|
||
"Van Rossum thought he needed a name that was short, unique, and slightly "
|
||
"mysterious, so he decided to call the language Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:292
|
||
msgid "Do I have to like \"Monty Python's Flying Circus\"?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:294
|
||
msgid "No, but it helps. :)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:298
|
||
msgid "Python in the real world"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:301
|
||
msgid "How stable is Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:303
|
||
msgid ""
|
||
"Very stable. New, stable releases have been coming out roughly every 6 to "
|
||
"18 months since 1991, and this seems likely to continue. Currently there "
|
||
"are usually around 18 months between major releases."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:307
|
||
msgid ""
|
||
"The developers issue \"bugfix\" releases of older versions, so the stability "
|
||
"of existing releases gradually improves. Bugfix releases, indicated by a "
|
||
"third component of the version number (e.g. 2.5.3, 2.6.2), are managed for "
|
||
"stability; only fixes for known problems are included in a bugfix release, "
|
||
"and it's guaranteed that interfaces will remain the same throughout a series "
|
||
"of bugfix releases."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:314
|
||
msgid ""
|
||
"The latest stable releases can always be found on the `Python download page "
|
||
"<https://www.python.org/downloads/>`_. There are two recommended production-"
|
||
"ready versions at this point in time, because at the moment there are two "
|
||
"branches of stable releases: 2.x and 3.x. Python 3.x may be less useful "
|
||
"than 2.x, since currently there is more third party software available for "
|
||
"Python 2 than for Python 3. Python 2 code will generally not run unchanged "
|
||
"in Python 3."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:323
|
||
msgid "How many people are using Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:325
|
||
msgid ""
|
||
"There are probably tens of thousands of users, though it's difficult to "
|
||
"obtain an exact count."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:328
|
||
msgid ""
|
||
"Python is available for free download, so there are no sales figures, and "
|
||
"it's available from many different sites and packaged with many Linux "
|
||
"distributions, so download statistics don't tell the whole story either."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:332
|
||
msgid ""
|
||
"The comp.lang.python newsgroup is very active, but not all Python users post "
|
||
"to the group or even read it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:337
|
||
msgid "Have any significant projects been done in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:339
|
||
msgid ""
|
||
"See https://www.python.org/about/success for a list of projects that use "
|
||
"Python. Consulting the proceedings for `past Python conferences <https://www."
|
||
"python.org/community/workshops/>`_ will reveal contributions from many "
|
||
"different companies and organizations."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:344
|
||
msgid ""
|
||
"High-profile Python projects include `the Mailman mailing list manager "
|
||
"<http://www.list.org>`_ and `the Zope application server <http://www.zope."
|
||
"org>`_. Several Linux distributions, most notably `Red Hat <https://www."
|
||
"redhat.com>`_, have written part or all of their installer and system "
|
||
"administration software in Python. Companies that use Python internally "
|
||
"include Google, Yahoo, and Lucasfilm Ltd."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:353
|
||
msgid "What new developments are expected for Python in the future?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:355
|
||
msgid ""
|
||
"See https://www.python.org/dev/peps/ for the Python Enhancement Proposals "
|
||
"(PEPs). PEPs are design documents describing a suggested new feature for "
|
||
"Python, providing a concise technical specification and a rationale. Look "
|
||
"for a PEP titled \"Python X.Y Release Schedule\", where X.Y is a version "
|
||
"that hasn't been publicly released yet."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:361
|
||
msgid ""
|
||
"New development is discussed on `the python-dev mailing list <https://mail."
|
||
"python.org/mailman/listinfo/python-dev/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:366
|
||
msgid "Is it reasonable to propose incompatible changes to Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:368
|
||
msgid ""
|
||
"In general, no. There are already millions of lines of Python code around "
|
||
"the world, so any change in the language that invalidates more than a very "
|
||
"small fraction of existing programs has to be frowned upon. Even if you can "
|
||
"provide a conversion program, there's still the problem of updating all "
|
||
"documentation; many books have been written about Python, and we don't want "
|
||
"to invalidate them all at a single stroke."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:375
|
||
msgid ""
|
||
"Providing a gradual upgrade path is necessary if a feature has to be "
|
||
"changed. :pep:`5` describes the procedure followed for introducing backward-"
|
||
"incompatible changes while minimizing disruption for users."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:381
|
||
msgid "Is Python a good language for beginning programmers?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:383 ../Doc/faq/library.rst:790
|
||
#: ../Doc/faq/programming.rst:17 ../Doc/faq/programming.rst:60
|
||
msgid "Yes."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:385
|
||
msgid ""
|
||
"It is still common to start students with a procedural and statically typed "
|
||
"language such as Pascal, C, or a subset of C++ or Java. Students may be "
|
||
"better served by learning Python as their first language. Python has a very "
|
||
"simple and consistent syntax and a large standard library and, most "
|
||
"importantly, using Python in a beginning programming course lets students "
|
||
"concentrate on important programming skills such as problem decomposition "
|
||
"and data type design. With Python, students can be quickly introduced to "
|
||
"basic concepts such as loops and procedures. They can probably even work "
|
||
"with user-defined objects in their very first course."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:395
|
||
msgid ""
|
||
"For a student who has never programmed before, using a statically typed "
|
||
"language seems unnatural. It presents additional complexity that the "
|
||
"student must master and slows the pace of the course. The students are "
|
||
"trying to learn to think like a computer, decompose problems, design "
|
||
"consistent interfaces, and encapsulate data. While learning to use a "
|
||
"statically typed language is important in the long term, it is not "
|
||
"necessarily the best topic to address in the students' first programming "
|
||
"course."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:403
|
||
msgid ""
|
||
"Many other aspects of Python make it a good first language. Like Java, "
|
||
"Python has a large standard library so that students can be assigned "
|
||
"programming projects very early in the course that *do* something. "
|
||
"Assignments aren't restricted to the standard four-function calculator and "
|
||
"check balancing programs. By using the standard library, students can gain "
|
||
"the satisfaction of working on realistic applications as they learn the "
|
||
"fundamentals of programming. Using the standard library also teaches "
|
||
"students about code reuse. Third-party modules such as PyGame are also "
|
||
"helpful in extending the students' reach."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:412
|
||
msgid ""
|
||
"Python's interactive interpreter enables students to test language features "
|
||
"while they're programming. They can keep a window with the interpreter "
|
||
"running while they enter their program's source in another window. If they "
|
||
"can't remember the methods for a list, they can do something like this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:441
|
||
msgid ""
|
||
"With the interpreter, documentation is never far from the student as they "
|
||
"are programming."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:444
|
||
msgid ""
|
||
"There are also good IDEs for Python. IDLE is a cross-platform IDE for "
|
||
"Python that is written in Python using Tkinter. PythonWin is a Windows-"
|
||
"specific IDE. Emacs users will be happy to know that there is a very good "
|
||
"Python mode for Emacs. All of these programming environments provide syntax "
|
||
"highlighting, auto-indenting, and access to the interactive interpreter "
|
||
"while coding. Consult `the Python wiki <https://wiki.python.org/moin/"
|
||
"PythonEditors>`_ for a full list of Python editing environments."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/general.rst:452
|
||
msgid ""
|
||
"If you want to discuss Python's use in education, you may be interested in "
|
||
"joining `the edu-sig mailing list <https://www.python.org/community/sigs/"
|
||
"current/edu-sig>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:5
|
||
msgid "Graphic User Interface FAQ"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:15
|
||
msgid "General GUI Questions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:18
|
||
msgid "What platform-independent GUI toolkits exist for Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:20
|
||
msgid ""
|
||
"Depending on what platform(s) you are aiming at, there are several. Some of "
|
||
"them haven't been ported to Python 3 yet. At least `Tkinter`_ and `Qt`_ are "
|
||
"known to be Python 3-compatible."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:27
|
||
msgid "Tkinter"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:29
|
||
msgid ""
|
||
"Standard builds of Python include an object-oriented interface to the Tcl/Tk "
|
||
"widget set, called :ref:`tkinter <Tkinter>`. This is probably the easiest "
|
||
"to install (since it comes included with most `binary distributions <https://"
|
||
"www.python.org/downloads/>`_ of Python) and use. For more info about Tk, "
|
||
"including pointers to the source, see the `Tcl/Tk home page <https://www.tcl."
|
||
"tk>`_. Tcl/Tk is fully portable to the Mac OS X, Windows, and Unix "
|
||
"platforms."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:38
|
||
msgid "wxWidgets"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:40
|
||
msgid ""
|
||
"wxWidgets (https://www.wxwidgets.org) is a free, portable GUI class library "
|
||
"written in C++ that provides a native look and feel on a number of "
|
||
"platforms, with Windows, Mac OS X, GTK, X11, all listed as current stable "
|
||
"targets. Language bindings are available for a number of languages "
|
||
"including Python, Perl, Ruby, etc."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:46
|
||
msgid ""
|
||
"wxPython (http://www.wxpython.org) is the Python binding for wxwidgets. "
|
||
"While it often lags slightly behind the official wxWidgets releases, it also "
|
||
"offers a number of features via pure Python extensions that are not "
|
||
"available in other language bindings. There is an active wxPython user and "
|
||
"developer community."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:52
|
||
msgid ""
|
||
"Both wxWidgets and wxPython are free, open source, software with permissive "
|
||
"licences that allow their use in commercial products as well as in freeware "
|
||
"or shareware."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:58
|
||
msgid "Qt"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:60
|
||
msgid ""
|
||
"There are bindings available for the Qt toolkit (using either `PyQt <https://"
|
||
"riverbankcomputing.com/software/pyqt/intro>`_ or `PySide <https://wiki.qt.io/"
|
||
"PySide>`_) and for KDE (`PyKDE4 <https://techbase.kde.org/Languages/Python/"
|
||
"Using_PyKDE_4>`__). PyQt is currently more mature than PySide, but you must "
|
||
"buy a PyQt license from `Riverbank Computing <https://www.riverbankcomputing."
|
||
"com/commercial/license-faq>`_ if you want to write proprietary "
|
||
"applications. PySide is free for all applications."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:67
|
||
msgid ""
|
||
"Qt 4.5 upwards is licensed under the LGPL license; also, commercial licenses "
|
||
"are available from `The Qt Company <https://www.qt.io/licensing/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:71
|
||
msgid "Gtk+"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:73
|
||
msgid ""
|
||
"The `GObject introspection bindings <https://wiki.gnome.org/Projects/"
|
||
"PyGObject>`_ for Python allow you to write GTK+ 3 applications. There is "
|
||
"also a `Python GTK+ 3 Tutorial <https://python-gtk-3-tutorial.readthedocs."
|
||
"org/en/latest/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:77
|
||
msgid ""
|
||
"The older PyGtk bindings for the `Gtk+ 2 toolkit <http://www.gtk.org>`_ have "
|
||
"been implemented by James Henstridge; see <http://www.pygtk.org>."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:81
|
||
msgid "FLTK"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:83
|
||
msgid ""
|
||
"Python bindings for `the FLTK toolkit <http://www.fltk.org>`_, a simple yet "
|
||
"powerful and mature cross-platform windowing system, are available from `the "
|
||
"PyFLTK project <http://pyfltk.sourceforge.net>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:89
|
||
msgid "FOX"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:91
|
||
msgid ""
|
||
"A wrapper for `the FOX toolkit <http://www.fox-toolkit.org/>`_ called `FXpy "
|
||
"<http://fxpy.sourceforge.net/>`_ is available. FOX supports both Unix "
|
||
"variants and Windows."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:97
|
||
msgid "OpenGL"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:99
|
||
msgid "For OpenGL bindings, see `PyOpenGL <http://pyopengl.sourceforge.net>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:103
|
||
msgid "What platform-specific GUI toolkits exist for Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:105
|
||
msgid ""
|
||
"By installing the `PyObjc Objective-C bridge <https://pythonhosted.org/"
|
||
"pyobjc/>`_, Python programs can use Mac OS X's Cocoa libraries."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:109
|
||
msgid ""
|
||
":ref:`Pythonwin <windows-faq>` by Mark Hammond includes an interface to the "
|
||
"Microsoft Foundation Classes and a Python programming environment that's "
|
||
"written mostly in Python using the MFC classes."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:115
|
||
msgid "Tkinter questions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:118
|
||
msgid "How do I freeze Tkinter applications?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:120
|
||
msgid ""
|
||
"Freeze is a tool to create stand-alone applications. When freezing Tkinter "
|
||
"applications, the applications will not be truly stand-alone, as the "
|
||
"application will still need the Tcl and Tk libraries."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:124
|
||
msgid ""
|
||
"One solution is to ship the application with the Tcl and Tk libraries, and "
|
||
"point to them at run-time using the :envvar:`TCL_LIBRARY` and :envvar:"
|
||
"`TK_LIBRARY` environment variables."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:128
|
||
msgid ""
|
||
"To get truly stand-alone applications, the Tcl scripts that form the library "
|
||
"have to be integrated into the application as well. One tool supporting that "
|
||
"is SAM (stand-alone modules), which is part of the Tix distribution (http://"
|
||
"tix.sourceforge.net/)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:133
|
||
msgid ""
|
||
"Build Tix with SAM enabled, perform the appropriate call to :c:func:"
|
||
"`Tclsam_init`, etc. inside Python's :file:`Modules/tkappinit.c`, and link "
|
||
"with libtclsam and libtksam (you might include the Tix libraries as well)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:140
|
||
msgid "Can I have Tk events handled while waiting for I/O?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:142
|
||
msgid ""
|
||
"On platforms other than Windows, yes, and you don't even need threads! But "
|
||
"you'll have to restructure your I/O code a bit. Tk has the equivalent of "
|
||
"Xt's :c:func:`XtAddInput()` call, which allows you to register a callback "
|
||
"function which will be called from the Tk mainloop when I/O is possible on a "
|
||
"file descriptor. See :ref:`tkinter-file-handlers`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:150
|
||
msgid "I can't get key bindings to work in Tkinter: why?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:152
|
||
msgid ""
|
||
"An often-heard complaint is that event handlers bound to events with the :"
|
||
"meth:`bind` method don't get handled even when the appropriate key is "
|
||
"pressed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/gui.rst:155
|
||
msgid ""
|
||
"The most common cause is that the widget to which the binding applies "
|
||
"doesn't have \"keyboard focus\". Check out the Tk documentation for the "
|
||
"focus command. Usually a widget is given the keyboard focus by clicking in "
|
||
"it (but not for labels; see the takefocus option)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/index.rst:5
|
||
msgid "Python Frequently Asked Questions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:3
|
||
msgid "\"Why is Python Installed on my Computer?\" FAQ"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:8
|
||
msgid ""
|
||
"Python is a programming language. It's used for many different "
|
||
"applications. It's used in some high schools and colleges as an introductory "
|
||
"programming language because Python is easy to learn, but it's also used by "
|
||
"professional software developers at places such as Google, NASA, and "
|
||
"Lucasfilm Ltd."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:13
|
||
msgid ""
|
||
"If you wish to learn more about Python, start with the `Beginner's Guide to "
|
||
"Python <https://wiki.python.org/moin/BeginnersGuide>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:18
|
||
msgid "Why is Python installed on my machine?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:20
|
||
msgid ""
|
||
"If you find Python installed on your system but don't remember installing "
|
||
"it, there are several possible ways it could have gotten there."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:23
|
||
msgid ""
|
||
"Perhaps another user on the computer wanted to learn programming and "
|
||
"installed it; you'll have to figure out who's been using the machine and "
|
||
"might have installed it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:26
|
||
msgid ""
|
||
"A third-party application installed on the machine might have been written "
|
||
"in Python and included a Python installation. There are many such "
|
||
"applications, from GUI programs to network servers and administrative "
|
||
"scripts."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:29
|
||
msgid ""
|
||
"Some Windows machines also have Python installed. At this writing we're "
|
||
"aware of computers from Hewlett-Packard and Compaq that include Python. "
|
||
"Apparently some of HP/Compaq's administrative tools are written in Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:32
|
||
msgid ""
|
||
"Many Unix-compatible operating systems, such as Mac OS X and some Linux "
|
||
"distributions, have Python installed by default; it's included in the base "
|
||
"installation."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:38
|
||
msgid "Can I delete Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:40
|
||
msgid "That depends on where Python came from."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:42
|
||
msgid ""
|
||
"If someone installed it deliberately, you can remove it without hurting "
|
||
"anything. On Windows, use the Add/Remove Programs icon in the Control Panel."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:45
|
||
msgid ""
|
||
"If Python was installed by a third-party application, you can also remove "
|
||
"it, but that application will no longer work. You should use that "
|
||
"application's uninstaller rather than removing Python directly."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/installed.rst:49
|
||
msgid ""
|
||
"If Python came with your operating system, removing it is not recommended. "
|
||
"If you remove it, whatever tools were written in Python will no longer run, "
|
||
"and some of them might be important to you. Reinstalling the whole system "
|
||
"would then be required to fix things again."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:5
|
||
msgid "Library and Extension FAQ"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:12
|
||
msgid "General Library Questions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:15
|
||
msgid "How do I find a module or application to perform task X?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/faq/library.rst:21
|
||
msgid ""
|
||
"For third-party packages, search the `Python Package Index <https://pypi."
|
||
"python.org/pypi>`_ 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 ""
|
||
|
||
#: ../Doc/faq/library.rst:28
|
||
msgid "Where is the math.py (socket.py, regex.py, etc.) source file?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/faq/library.rst:35
|
||
msgid "There are (at least) three kinds of modules in Python:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:37
|
||
msgid "modules written in Python (.py);"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:38
|
||
msgid ""
|
||
"modules written in C and dynamically loaded (.dll, .pyd, .so, .sl, etc);"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:39
|
||
msgid ""
|
||
"modules written in C and linked with the interpreter; to get a list of "
|
||
"these, type::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:47
|
||
msgid "How do I make a Python script executable on Unix?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/faq/library.rst:53
|
||
msgid ""
|
||
"The first is done by executing ``chmod +x scriptfile`` or perhaps ``chmod "
|
||
"755 scriptfile``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:56
|
||
msgid ""
|
||
"The second can be done in a number of ways. The most straightforward way is "
|
||
"to write ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/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 ""
|
||
|
||
#: ../Doc/faq/library.rst:84
|
||
msgid ""
|
||
"The minor disadvantage is that this defines the script's __doc__ string. "
|
||
"However, you can fix that by adding ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:92
|
||
msgid "Is there a curses/termcap package for Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:96
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:101
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:107
|
||
msgid ""
|
||
"For Windows: use `the consolelib module <http://effbot.org/zone/console-"
|
||
"index.htm>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:112
|
||
msgid "Is there an equivalent to C's onexit() in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:114
|
||
msgid ""
|
||
"The :mod:`atexit` module provides a register function that is similar to "
|
||
"C's :c:func:`onexit`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:119
|
||
msgid "Why don't my signal handlers work?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:121
|
||
msgid ""
|
||
"The most common problem is that the signal handler is declared with the "
|
||
"wrong argument list. It is called as ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:126
|
||
msgid "so it should be declared with two arguments::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:133
|
||
msgid "Common tasks"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:136
|
||
msgid "How do I test a Python program or component?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:138
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:142
|
||
msgid ""
|
||
"The :mod:`unittest` module is a fancier testing framework modelled on Java "
|
||
"and Smalltalk testing frameworks."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:145
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:153
|
||
msgid "The \"global main logic\" of your program may be as simple as ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:158
|
||
msgid "at the bottom of the main module of your program."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:160
|
||
msgid ""
|
||
"Once your program is organized as a tractable collection of functions 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 ""
|
||
|
||
#: ../Doc/faq/library.rst:168
|
||
msgid ""
|
||
"\"Support modules\" that are not intended to be the main module of a program "
|
||
"may include a self-test of the module. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:174
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:180
|
||
msgid "How do I create documentation from doc strings?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:182
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:189
|
||
msgid "How do I get a single keypress at a time?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:191
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:235
|
||
msgid "Threads"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:238
|
||
msgid "How do I program using threads?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:240
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:244
|
||
msgid ""
|
||
"Aahz has a set of slides from his threading tutorial that are helpful; see "
|
||
"http://www.pythoncraft.com/OSCON2001/."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:249
|
||
msgid "None of my threads seem to run: why?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:251
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:254
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:269
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:273
|
||
msgid "A simple fix is to add a tiny sleep to the start of the run function::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:286
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:294
|
||
msgid "How do I parcel out work among a bunch of worker threads?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:296
|
||
msgid ""
|
||
"The easiest way is to use the new :mod:`concurrent.futures` module, "
|
||
"especially the :mod:`~concurrent.futures.ThreadPoolExecutor` class."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:299
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:306
|
||
msgid "Here's a trivial example::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:344
|
||
msgid "When run, this will produce the following output:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:362
|
||
msgid ""
|
||
"Consult the module's documentation for more details; the :class:`~queue."
|
||
"Queue` class provides a featureful interface."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:367
|
||
msgid "What kinds of global value mutation are thread-safe?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:369
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:376
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:381
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:396
|
||
msgid "These aren't::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:403
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:410
|
||
msgid "Can't we get rid of the Global Interpreter Lock?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:414
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:419
|
||
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 <http://code.google.com/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 ""
|
||
|
||
#: ../Doc/faq/library.rst:427
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:435
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:441
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:450
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:455
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:460
|
||
msgid "Input and Output"
|
||
msgstr "Les entrées/sorties"
|
||
|
||
#: ../Doc/faq/library.rst:463
|
||
msgid "How do I delete a file? (And other file questions...)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:465
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:469
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:475
|
||
msgid "To rename a file, use ``os.rename(old_path, new_path)``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:477
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:482
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:488
|
||
msgid "How do I copy a file?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:490
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:495
|
||
msgid "How do I read (or write) binary data?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:497
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:501
|
||
msgid ""
|
||
"For example, the following code reads two 2-byte integers and one 4-byte "
|
||
"integer in big-endian format from a file::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:510
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:514
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:519
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:527
|
||
msgid "I can't seem to use os.read() on a pipe created with os.popen(); why?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:529
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:616
|
||
msgid "How do I access the serial (RS232) port?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:618
|
||
msgid "For Win32, POSIX (Linux, BSD, etc.), Jython:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:620
|
||
msgid "http://pyserial.sourceforge.net"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:622
|
||
msgid "For Unix, see a Usenet post by Mitch Chapman:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:624
|
||
msgid "https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:628
|
||
msgid "Why doesn't closing sys.stdout (stdin, stderr) really close it?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:630
|
||
msgid ""
|
||
"Python :term:`file objects <file object>` are a high-level layer of "
|
||
"abstraction on low-level C file descriptors."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:633
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:639
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:644
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:652
|
||
msgid "Or you can use the numeric constants 0, 1 and 2, respectively."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:656
|
||
msgid "Network/Internet Programming"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:659
|
||
msgid "What WWW tools are there for Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:661
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:667
|
||
msgid ""
|
||
"A summary of available frameworks is maintained by Paul Boddie at https://"
|
||
"wiki.python.org/moin/WebProgramming\\ ."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:670
|
||
msgid ""
|
||
"Cameron Laird maintains a useful set of pages about Python web technologies "
|
||
"at http://phaseit.net/claird/comp.lang.python/web_python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:675
|
||
msgid "How can I mimic CGI form submission (METHOD=POST)?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:677
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:680
|
||
msgid "Yes. Here's a simple example that uses urllib.request::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:695
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:703
|
||
msgid ":ref:`urllib-howto` for extensive examples."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:707
|
||
msgid "What module should I use to help with generating HTML?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:711
|
||
msgid ""
|
||
"You can find a collection of useful links on the `Web Programming wiki page "
|
||
"<https://wiki.python.org/moin/WebProgramming>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:716
|
||
msgid "How do I send mail from a Python script?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:718
|
||
msgid "Use the standard library module :mod:`smtplib`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:720
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:740
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:760
|
||
msgid "How do I avoid blocking in the connect() method of a socket?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:762
|
||
msgid ""
|
||
"The :mod:`select` module is commonly used to help with asynchronous I/O on "
|
||
"sockets."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:765
|
||
msgid ""
|
||
"To prevent the TCP connect from blocking, you can set the socket to non-"
|
||
"blocking mode. Then when you do the ``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 ""
|
||
|
||
#: ../Doc/faq/library.rst:772
|
||
msgid ""
|
||
"You can use the ``connect_ex()`` method to avoid creating an exception. It "
|
||
"will just return the errno value. To poll, you can call ``connect_ex()`` "
|
||
"again later -- ``0`` or ``errno.EISCONN`` indicate that you're connected -- "
|
||
"or you can pass this socket to select to check if it's writable."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:778
|
||
msgid ""
|
||
"The :mod:`asyncore` module presents a framework-like approach to the problem "
|
||
"of writing non-blocking networking code. The third-party `Twisted <https://"
|
||
"twistedmatrix.com/trac/>`_ library is a popular and feature-rich alternative."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:785
|
||
msgid "Databases"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:788
|
||
msgid "Are there any interfaces to database packages in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:792
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:797
|
||
msgid ""
|
||
"Support for most relational databases is available. See the "
|
||
"`DatabaseProgramming wiki page <https://wiki.python.org/moin/"
|
||
"DatabaseProgramming>`_ for details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:803
|
||
msgid "How do you implement persistent objects in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:805
|
||
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 ""
|
||
|
||
#: ../Doc/faq/library.rst:812
|
||
msgid "Mathematics and Numerics"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:815
|
||
msgid "How do I generate random numbers in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:817
|
||
msgid ""
|
||
"The standard module :mod:`random` implements a random number generator. "
|
||
"Usage is simple::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:823
|
||
msgid "This returns a random floating point number in the range [0, 1)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:825
|
||
msgid ""
|
||
"There are also many other specialized generators in this module, such as:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:827
|
||
msgid "``randrange(a, b)`` chooses an integer in the range [a, b)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:828
|
||
msgid "``uniform(a, b)`` chooses a floating point number in the range [a, b)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:829
|
||
msgid ""
|
||
"``normalvariate(mean, sdev)`` samples the normal (Gaussian) distribution."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:831
|
||
msgid "Some higher-level functions operate on sequences directly, such as:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:833
|
||
msgid "``choice(S)`` chooses random element from a given sequence"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:834
|
||
msgid "``shuffle(L)`` shuffles a list in-place, i.e. permutes it randomly"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/library.rst:836
|
||
msgid ""
|
||
"There's also a ``Random`` class you can instantiate to create independent "
|
||
"multiple random number generators."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:5
|
||
msgid "Programming FAQ"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:12
|
||
msgid "General Questions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:15
|
||
msgid ""
|
||
"Is there a source code level debugger with breakpoints, single-stepping, "
|
||
"etc.?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:19
|
||
msgid ""
|
||
"The pdb module is a simple but adequate console-mode debugger for Python. It "
|
||
"is part of the standard Python library, and is :mod:`documented in the "
|
||
"Library Reference Manual <pdb>`. You can also write your own debugger by "
|
||
"using the code for pdb as an example."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:24
|
||
msgid ""
|
||
"The IDLE interactive development environment, which is part of the standard "
|
||
"Python distribution (normally available as Tools/scripts/idle), includes a "
|
||
"graphical debugger."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:28
|
||
msgid ""
|
||
"PythonWin is a Python IDE that includes a GUI debugger based on pdb. The "
|
||
"Pythonwin debugger colors breakpoints and has quite a few cool features such "
|
||
"as debugging non-Pythonwin programs. Pythonwin is available as part of the "
|
||
"`Python for Windows Extensions <https://sourceforge.net/projects/pywin32/"
|
||
">`__ project and as a part of the ActivePython distribution (see https://www."
|
||
"activestate.com/activepython\\ )."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:35
|
||
msgid ""
|
||
"`Boa Constructor <http://boa-constructor.sourceforge.net/>`_ is an IDE and "
|
||
"GUI builder that uses wxWidgets. It offers visual frame creation and "
|
||
"manipulation, an object inspector, many views on the source like object "
|
||
"browsers, inheritance hierarchies, doc string generated html documentation, "
|
||
"an advanced debugger, integrated help, and Zope support."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:41
|
||
msgid ""
|
||
"`Eric <http://eric-ide.python-projects.org/>`_ is an IDE built on PyQt and "
|
||
"the Scintilla editing component."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:44
|
||
msgid ""
|
||
"Pydb is a version of the standard Python debugger pdb, modified for use with "
|
||
"DDD (Data Display Debugger), a popular graphical debugger front end. Pydb "
|
||
"can be found at http://bashdb.sourceforge.net/pydb/ and DDD can be found at "
|
||
"https://www.gnu.org/software/ddd."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:49
|
||
msgid ""
|
||
"There are a number of commercial Python IDEs that include graphical "
|
||
"debuggers. They include:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:52
|
||
msgid "Wing IDE (https://wingware.com/)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:53
|
||
msgid "Komodo IDE (https://komodoide.com/)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:54
|
||
msgid "PyCharm (https://www.jetbrains.com/pycharm/)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:58
|
||
msgid "Is there a tool to help find bugs or perform static analysis?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:62
|
||
msgid ""
|
||
"PyChecker is a static analysis tool that finds bugs in Python source code "
|
||
"and warns about code complexity and style. You can get PyChecker from "
|
||
"http://pychecker.sourceforge.net/."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:66
|
||
msgid ""
|
||
"`Pylint <https://www.pylint.org/>`_ is another tool that checks if a module "
|
||
"satisfies a coding standard, and also makes it possible to write plug-ins to "
|
||
"add a custom feature. In addition to the bug checking that PyChecker "
|
||
"performs, Pylint offers some additional features such as checking line "
|
||
"length, whether variable names are well-formed according to your coding "
|
||
"standard, whether declared interfaces are fully implemented, and more. "
|
||
"https://docs.pylint.org/ provides a full list of Pylint's features."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:76
|
||
msgid "How can I create a stand-alone binary from a Python script?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:78
|
||
msgid ""
|
||
"You don't need the ability to compile Python to C code if all you want is a "
|
||
"stand-alone program that users can download and run without having to "
|
||
"install the Python distribution first. There are a number of tools that "
|
||
"determine the set of modules required by a program and bind these modules "
|
||
"together with a Python binary to produce a single executable."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:84
|
||
msgid ""
|
||
"One is to use the freeze tool, which is included in the Python source tree "
|
||
"as ``Tools/freeze``. It converts Python byte code to C arrays; a C compiler "
|
||
"you can embed all your modules into a new program, which is then linked with "
|
||
"the standard Python modules."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:89
|
||
msgid ""
|
||
"It works by scanning your source recursively for import statements (in both "
|
||
"forms) and looking for the modules in the standard Python path as well as in "
|
||
"the source directory (for built-in modules). It then turns the bytecode for "
|
||
"modules written in Python into C code (array initializers that can be turned "
|
||
"into code objects using the marshal module) and creates a custom-made config "
|
||
"file that only contains those built-in modules which are actually used in "
|
||
"the program. It then compiles the generated C code and links it with the "
|
||
"rest of the Python interpreter to form a self-contained binary which acts "
|
||
"exactly like your script."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:98
|
||
msgid ""
|
||
"Obviously, freeze requires a C compiler. There are several other utilities "
|
||
"which don't. One is Thomas Heller's py2exe (Windows only) at"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:101
|
||
msgid "http://www.py2exe.org/"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:103
|
||
msgid ""
|
||
"Another tool is Anthony Tuininga's `cx_Freeze <http://cx-freeze.sourceforge."
|
||
"net/>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:107
|
||
msgid "Are there coding standards or a style guide for Python programs?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:109
|
||
msgid ""
|
||
"Yes. The coding style required for standard library modules is documented "
|
||
"as :pep:`8`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:114
|
||
msgid "Core Language"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:117
|
||
msgid "Why am I getting an UnboundLocalError when the variable has a value?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:119
|
||
msgid ""
|
||
"It can be a surprise to get the UnboundLocalError in previously working code "
|
||
"when it is modified by adding an assignment statement somewhere in the body "
|
||
"of a function."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:123
|
||
msgid "This code:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:131
|
||
msgid "works, but this code:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:138
|
||
msgid "results in an UnboundLocalError:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:145
|
||
msgid ""
|
||
"This is because when you make an assignment to a variable in a scope, that "
|
||
"variable becomes local to that scope and shadows any similarly named "
|
||
"variable in the outer scope. Since the last statement in foo assigns a new "
|
||
"value to ``x``, the compiler recognizes it as a local variable. "
|
||
"Consequently when the earlier ``print(x)`` attempts to print the "
|
||
"uninitialized local variable and an error results."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:152
|
||
msgid ""
|
||
"In the example above you can access the outer scope variable by declaring it "
|
||
"global:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:163
|
||
msgid ""
|
||
"This explicit declaration is required in order to remind you that (unlike "
|
||
"the superficially analogous situation with class and instance variables) you "
|
||
"are actually modifying the value of the variable in the outer scope:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:170
|
||
msgid ""
|
||
"You can do a similar thing in a nested scope using the :keyword:`nonlocal` "
|
||
"keyword:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:187
|
||
msgid "What are the rules for local and global variables in Python?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:189
|
||
msgid ""
|
||
"In Python, variables that are only referenced inside a function are "
|
||
"implicitly global. If a variable is assigned a value anywhere within the "
|
||
"function's body, it's assumed to be a local unless explicitly declared as "
|
||
"global."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:193
|
||
msgid ""
|
||
"Though a bit surprising at first, a moment's consideration explains this. "
|
||
"On one hand, requiring :keyword:`global` for assigned variables provides a "
|
||
"bar against unintended side-effects. On the other hand, if ``global`` was "
|
||
"required for all global references, you'd be using ``global`` all the time. "
|
||
"You'd have to declare as global every reference to a built-in function or to "
|
||
"a component of an imported module. This clutter would defeat the usefulness "
|
||
"of the ``global`` declaration for identifying side-effects."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:203
|
||
msgid ""
|
||
"Why do lambdas defined in a loop with different values all return the same "
|
||
"result?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:205
|
||
msgid ""
|
||
"Assume you use a for loop to define a few different lambdas (or even plain "
|
||
"functions), e.g.::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:212
|
||
msgid ""
|
||
"This gives you a list that contains 5 lambdas that calculate ``x**2``. You "
|
||
"might expect that, when called, they would return, respectively, ``0``, "
|
||
"``1``, ``4``, ``9``, and ``16``. However, when you actually try you will "
|
||
"see that they all return ``16``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:222
|
||
msgid ""
|
||
"This happens because ``x`` is not local to the lambdas, but is defined in "
|
||
"the outer scope, and it is accessed when the lambda is called --- not when "
|
||
"it is defined. At the end of the loop, the value of ``x`` is ``4``, so all "
|
||
"the functions now return ``4**2``, i.e. ``16``. You can also verify this by "
|
||
"changing the value of ``x`` and see how the results of the lambdas change::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:232
|
||
msgid ""
|
||
"In order to avoid this, you need to save the values in variables local to "
|
||
"the lambdas, so that they don't rely on the value of the global ``x``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:239
|
||
msgid ""
|
||
"Here, ``n=x`` creates a new variable ``n`` local to the lambda and computed "
|
||
"when the lambda is defined so that it has the same value that ``x`` had at "
|
||
"that point in the loop. This means that the value of ``n`` will be ``0`` in "
|
||
"the first lambda, ``1`` in the second, ``2`` in the third, and so on. "
|
||
"Therefore each lambda will now return the correct result::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:250
|
||
msgid ""
|
||
"Note that this behaviour is not peculiar to lambdas, but applies to regular "
|
||
"functions too."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:255
|
||
msgid "How do I share global variables across modules?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:257
|
||
msgid ""
|
||
"The canonical way to share information across modules within a single "
|
||
"program is to create a special module (often called config or cfg). Just "
|
||
"import the config module in all modules of your application; the module then "
|
||
"becomes available as a global name. Because there is only one instance of "
|
||
"each module, any changes made to the module object get reflected "
|
||
"everywhere. For example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:263
|
||
msgid "config.py::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:267
|
||
msgid "mod.py::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:272
|
||
msgid "main.py::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:278
|
||
msgid ""
|
||
"Note that using a module is also the basis for implementing the Singleton "
|
||
"design pattern, for the same reason."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:283
|
||
msgid "What are the \"best practices\" for using import in a module?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:285
|
||
msgid ""
|
||
"In general, don't use ``from modulename import *``. Doing so clutters the "
|
||
"importer's namespace, and makes it much harder for linters to detect "
|
||
"undefined names."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:289
|
||
msgid ""
|
||
"Import modules at the top of a file. Doing so makes it clear what other "
|
||
"modules your code requires and avoids questions of whether the module name "
|
||
"is in scope. Using one import per line makes it easy to add and delete "
|
||
"module imports, but using multiple imports per line uses less screen space."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:294
|
||
msgid "It's good practice if you import modules in the following order:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:296
|
||
msgid "standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:297
|
||
msgid ""
|
||
"third-party library modules (anything installed in Python's site-packages "
|
||
"directory) -- e.g. mx.DateTime, ZODB, PIL.Image, etc."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:299
|
||
msgid "locally-developed modules"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:301
|
||
msgid ""
|
||
"It is sometimes necessary to move imports to a function or class to avoid "
|
||
"problems with circular imports. Gordon McMillan says:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:304
|
||
msgid ""
|
||
"Circular imports are fine where both modules use the \"import <module>\" "
|
||
"form of import. They fail when the 2nd module wants to grab a name out of "
|
||
"the first (\"from module import name\") and the import is at the top level. "
|
||
"That's because names in the 1st are not yet available, because the first "
|
||
"module is busy importing the 2nd."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:310
|
||
msgid ""
|
||
"In this case, if the second module is only used in one function, then the "
|
||
"import can easily be moved into that function. By the time the import is "
|
||
"called, the first module will have finished initializing, and the second "
|
||
"module can do its import."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:315
|
||
msgid ""
|
||
"It may also be necessary to move imports out of the top level of code if "
|
||
"some of the modules are platform-specific. In that case, it may not even be "
|
||
"possible to import all of the modules at the top of the file. In this case, "
|
||
"importing the correct modules in the corresponding platform-specific code is "
|
||
"a good option."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:320
|
||
msgid ""
|
||
"Only move imports into a local scope, such as inside a function definition, "
|
||
"if it's necessary to solve a problem such as avoiding a circular import or "
|
||
"are trying to reduce the initialization time of a module. This technique is "
|
||
"especially helpful if many of the imports are unnecessary depending on how "
|
||
"the program executes. You may also want to move imports into a function if "
|
||
"the modules are only ever used in that function. Note that loading a module "
|
||
"the first time may be expensive because of the one time initialization of "
|
||
"the module, but loading a module multiple times is virtually free, costing "
|
||
"only a couple of dictionary lookups. Even if the module name has gone out "
|
||
"of scope, the module is probably available in :data:`sys.modules`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:333
|
||
msgid "Why are default values shared between objects?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:335
|
||
msgid ""
|
||
"This type of bug commonly bites neophyte programmers. Consider this "
|
||
"function::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:342
|
||
msgid ""
|
||
"The first time you call this function, ``mydict`` contains a single item. "
|
||
"The second time, ``mydict`` contains two items because when ``foo()`` begins "
|
||
"executing, ``mydict`` starts out with an item already in it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:346
|
||
msgid ""
|
||
"It is often expected that a function call creates new objects for default "
|
||
"values. This is not what happens. Default values are created exactly once, "
|
||
"when the function is defined. If that object is changed, like the "
|
||
"dictionary in this example, subsequent calls to the function will refer to "
|
||
"this changed object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:351
|
||
msgid ""
|
||
"By definition, immutable objects such as numbers, strings, tuples, and "
|
||
"``None``, are safe from change. Changes to mutable objects such as "
|
||
"dictionaries, lists, and class instances can lead to confusion."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:355
|
||
msgid ""
|
||
"Because of this feature, it is good programming practice to not use mutable "
|
||
"objects as default values. Instead, use ``None`` as the default value and "
|
||
"inside the function, check if the parameter is ``None`` and create a new "
|
||
"list/dictionary/whatever if it is. For example, don't write::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:363
|
||
msgid "but::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:369
|
||
msgid ""
|
||
"This feature can be useful. When you have a function that's time-consuming "
|
||
"to compute, a common technique is to cache the parameters and the resulting "
|
||
"value of each call to the function, and return the cached value if the same "
|
||
"value is requested again. This is called \"memoizing\", and can be "
|
||
"implemented like this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:384
|
||
msgid ""
|
||
"You could use a global variable containing a dictionary instead of the "
|
||
"default value; it's a matter of taste."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:389
|
||
msgid ""
|
||
"How can I pass optional or keyword parameters from one function to another?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:391
|
||
msgid ""
|
||
"Collect the arguments using the ``*`` and ``**`` specifiers in the "
|
||
"function's parameter list; this gives you the positional arguments as a "
|
||
"tuple and the keyword arguments as a dictionary. You can then pass these "
|
||
"arguments when calling another function by using ``*`` and ``**``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:410
|
||
msgid "What is the difference between arguments and parameters?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:412
|
||
msgid ""
|
||
":term:`Parameters <parameter>` are defined by the names that appear in a "
|
||
"function definition, whereas :term:`arguments <argument>` are the values "
|
||
"actually passed to a function when calling it. Parameters define what types "
|
||
"of arguments a function can accept. For example, given the function "
|
||
"definition::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:420
|
||
msgid ""
|
||
"*foo*, *bar* and *kwargs* are parameters of ``func``. However, when calling "
|
||
"``func``, for example::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:425
|
||
msgid "the values ``42``, ``314``, and ``somevar`` are arguments."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:429
|
||
msgid "Why did changing list 'y' also change list 'x'?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:431
|
||
msgid "If you wrote code like::"
|
||
msgstr "Si vous avez écrit du code comme : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:441
|
||
msgid ""
|
||
"you might be wondering why appending an element to ``y`` changed ``x`` too."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:443
|
||
msgid "There are two factors that produce this result:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:445
|
||
msgid ""
|
||
"Variables are simply names that refer to objects. Doing ``y = x`` doesn't "
|
||
"create a copy of the list -- it creates a new variable ``y`` that refers to "
|
||
"the same object ``x`` refers to. This means that there is only one object "
|
||
"(the list), and both ``x`` and ``y`` refer to it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:449
|
||
msgid ""
|
||
"Lists are :term:`mutable`, which means that you can change their content."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:451
|
||
msgid ""
|
||
"After the call to :meth:`~list.append`, the content of the mutable object "
|
||
"has changed from ``[]`` to ``[10]``. Since both the variables refer to the "
|
||
"same object, using either name accesses the modified value ``[10]``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:455
|
||
msgid "If we instead assign an immutable object to ``x``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:465
|
||
msgid ""
|
||
"we can see that in this case ``x`` and ``y`` are not equal anymore. This is "
|
||
"because integers are :term:`immutable`, and when we do ``x = x + 1`` we are "
|
||
"not mutating the int ``5`` by incrementing its value; instead, we are "
|
||
"creating a new object (the int ``6``) and assigning it to ``x`` (that is, "
|
||
"changing which object ``x`` refers to). After this assignment we have two "
|
||
"objects (the ints ``6`` and ``5``) and two variables that refer to them "
|
||
"(``x`` now refers to ``6`` but ``y`` still refers to ``5``)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:473
|
||
msgid ""
|
||
"Some operations (for example ``y.append(10)`` and ``y.sort()``) mutate the "
|
||
"object, whereas superficially similar operations (for example ``y = y + "
|
||
"[10]`` and ``sorted(y)``) create a new object. In general in Python (and in "
|
||
"all cases in the standard library) a method that mutates an object will "
|
||
"return ``None`` to help avoid getting the two types of operations confused. "
|
||
"So if you mistakenly write ``y.sort()`` thinking it will give you a sorted "
|
||
"copy of ``y``, you'll instead end up with ``None``, which will likely cause "
|
||
"your program to generate an easily diagnosed error."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:482
|
||
msgid ""
|
||
"However, there is one class of operations where the same operation sometimes "
|
||
"has different behaviors with different types: the augmented assignment "
|
||
"operators. For example, ``+=`` mutates lists but not tuples or ints "
|
||
"(``a_list += [1, 2, 3]`` is equivalent to ``a_list.extend([1, 2, 3])`` and "
|
||
"mutates ``a_list``, whereas ``some_tuple += (1, 2, 3)`` and ``some_int += "
|
||
"1`` create new objects)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:489
|
||
msgid "In other words:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:491
|
||
msgid ""
|
||
"If we have a mutable object (:class:`list`, :class:`dict`, :class:`set`, "
|
||
"etc.), we can use some specific operations to mutate it and all the "
|
||
"variables that refer to it will see the change."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:494
|
||
msgid ""
|
||
"If we have an immutable object (:class:`str`, :class:`int`, :class:`tuple`, "
|
||
"etc.), all the variables that refer to it will always see the same value, "
|
||
"but operations that transform that value into a new value always return a "
|
||
"new object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:499
|
||
msgid ""
|
||
"If you want to know if two variables refer to the same object or not, you "
|
||
"can use the :keyword:`is` operator, or the built-in function :func:`id`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:504
|
||
msgid "How do I write a function with output parameters (call by reference)?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:506
|
||
msgid ""
|
||
"Remember that arguments are passed by assignment in Python. Since "
|
||
"assignment just creates references to objects, there's no alias between an "
|
||
"argument name in the caller and callee, and so no call-by-reference per se. "
|
||
"You can achieve the desired effect in a number of ways."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:511
|
||
msgid "By returning a tuple of the results::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:522
|
||
msgid "This is almost always the clearest solution."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:524
|
||
msgid ""
|
||
"By using global variables. This isn't thread-safe, and is not recommended."
|
||
msgstr ""
|
||
"En utilisant des variables globales. Ce qui n'est pas thread-safe, et n'est "
|
||
"donc pas recommandé."
|
||
|
||
#: ../Doc/faq/programming.rst:526
|
||
msgid "By passing a mutable (changeable in-place) object::"
|
||
msgstr "En passant un objet mutable (modifiable sur place) ::"
|
||
|
||
#: ../Doc/faq/programming.rst:536
|
||
msgid "By passing in a dictionary that gets mutated::"
|
||
msgstr "En passant un dictionnaire, qui sera modifié : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:546
|
||
msgid "Or bundle up values in a class instance::"
|
||
msgstr "Ou regrouper les valeurs dans une instance de classe::"
|
||
|
||
#: ../Doc/faq/programming.rst:562
|
||
msgid "There's almost never a good reason to get this complicated."
|
||
msgstr ""
|
||
"Il n'y a pratiquement jamais de bonne raison de faire quelque chose d'aussi "
|
||
"compliqué."
|
||
|
||
#: ../Doc/faq/programming.rst:564
|
||
msgid "Your best choice is to return a tuple containing the multiple results."
|
||
msgstr ""
|
||
"Votre meilleure option est de renvoyer un *tuple* contenant les multiples "
|
||
"résultats."
|
||
|
||
#: ../Doc/faq/programming.rst:568
|
||
msgid "How do you make a higher order function in Python?"
|
||
msgstr "Comment construire une fonction d'ordre supérieur en Python ?"
|
||
|
||
#: ../Doc/faq/programming.rst:570
|
||
msgid ""
|
||
"You have two choices: you can use nested scopes or you can use callable "
|
||
"objects. For example, suppose you wanted to define ``linear(a,b)`` which "
|
||
"returns a function ``f(x)`` that computes the value ``a*x+b``. Using nested "
|
||
"scopes::"
|
||
msgstr ""
|
||
"Vous avez deux choix : vous pouvez utiliser les portées imbriquées ou vous "
|
||
"pouvez utiliser des objets appelables. Par exemple, supposons que vous "
|
||
"vouliez définir ``linear(a, b)`` qui retourne une fonction ``f(x)`` qui "
|
||
"calcule la valeur ``a*x+b``. En utilisant les portées imbriquées : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:579
|
||
msgid "Or using a callable object::"
|
||
msgstr "Ou en utilisant un objet appelable : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:589
|
||
msgid "In both cases, ::"
|
||
msgstr "dans les deux cas, ::"
|
||
|
||
#: ../Doc/faq/programming.rst:593
|
||
msgid "gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``."
|
||
msgstr "donne un objet appelable où ``taxes(10e6) == 0.3 * 10e6 + 2``."
|
||
|
||
#: ../Doc/faq/programming.rst:595
|
||
msgid ""
|
||
"The callable object approach has the disadvantage that it is a bit slower "
|
||
"and results in slightly longer code. However, note that a collection of "
|
||
"callables can share their signature via inheritance::"
|
||
msgstr ""
|
||
"L'approche par objet appelable a le désavantage d'être légèrement plus lente "
|
||
"et de produire un code légèrement plus long. Cependant, il faut noter qu'une "
|
||
"collection d'objet appelables peuvent partager leur signatures par "
|
||
"héritage : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:604
|
||
msgid "Object can encapsulate state for several methods::"
|
||
msgstr "Les objets peuvent encapsuler un état pour plusieurs méthodes::"
|
||
|
||
#: ../Doc/faq/programming.rst:622
|
||
msgid ""
|
||
"Here ``inc()``, ``dec()`` and ``reset()`` act like functions which share the "
|
||
"same counting variable."
|
||
msgstr ""
|
||
"Ici ``inc()``, ``dec()`` et ``reset()`` agissent comme des fonctions "
|
||
"partageant une même variable compteur."
|
||
|
||
#: ../Doc/faq/programming.rst:627
|
||
msgid "How do I copy an object in Python?"
|
||
msgstr "Comment copier un objet en Python?"
|
||
|
||
#: ../Doc/faq/programming.rst:629
|
||
msgid ""
|
||
"In general, try :func:`copy.copy` or :func:`copy.deepcopy` for the general "
|
||
"case. Not all objects can be copied, but most can."
|
||
msgstr ""
|
||
"En général, essayez :func:`copy.copy` ou :func:`copy.deepcopy` pour le cas "
|
||
"général. Tout les objets ne peuvent pas être copiés, mais la plupart le "
|
||
"peuvent."
|
||
|
||
#: ../Doc/faq/programming.rst:632
|
||
msgid ""
|
||
"Some objects can be copied more easily. Dictionaries have a :meth:`~dict."
|
||
"copy` method::"
|
||
msgstr ""
|
||
"Certains objects peuvent être copiés plus facilement. Les Dictionnaires ont "
|
||
"une méthode :meth:`~dict.copy` ::"
|
||
|
||
#: ../Doc/faq/programming.rst:637
|
||
msgid "Sequences can be copied by slicing::"
|
||
msgstr "Les séquences peuvent être copiées via la syntaxe des tranches::"
|
||
|
||
#: ../Doc/faq/programming.rst:643
|
||
msgid "How can I find the methods or attributes of an object?"
|
||
msgstr "Comment puis-je trouver les méthodes ou les attribues d'un objet?"
|
||
|
||
#: ../Doc/faq/programming.rst:645
|
||
msgid ""
|
||
"For an instance x of a user-defined class, ``dir(x)`` returns an "
|
||
"alphabetized list of the names containing the instance attributes and "
|
||
"methods and attributes defined by its class."
|
||
msgstr ""
|
||
"Pour une instance x d'une classe définie par un utilisateur, ``dir(x)`` "
|
||
"renvoie une liste alphabétique des noms contenants les attributs de "
|
||
"l'instance, et les attributs et méthodes définies par sa classe."
|
||
|
||
#: ../Doc/faq/programming.rst:651
|
||
msgid "How can my code discover the name of an object?"
|
||
msgstr "Comment mon code peut il découvrir le nom d'un objet?"
|
||
|
||
#: ../Doc/faq/programming.rst:653
|
||
msgid ""
|
||
"Generally speaking, it can't, because objects don't really have names. "
|
||
"Essentially, assignment always binds a name to a value; The same is true of "
|
||
"``def`` and ``class`` statements, but in that case the value is a callable. "
|
||
"Consider the following code::"
|
||
msgstr ""
|
||
"De façon générale, il ne peut pas, par ce que les objets n'ont pas "
|
||
"réellement de noms. Essentiellement, l'assignation attache un nom à une "
|
||
"valeur; C'est vrai aussi pour les instructions ``def`` et ``class``, à la "
|
||
"différence que dans ce cas la valeur est appelable. Par exemple, dans le "
|
||
"code suivant : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:669
|
||
msgid ""
|
||
"Arguably the class has a name: even though it is bound to two names and "
|
||
"invoked through the name B the created instance is still reported as an "
|
||
"instance of class A. However, it is impossible to say whether the "
|
||
"instance's name is a or b, since both names are bound to the same value."
|
||
msgstr ""
|
||
"Le fait que la classe ait un nom est discutable, bien qu'elles soit liée à "
|
||
"deux noms, et qu'elle soit appelée via le nom B, l'instance crée déclare "
|
||
"tout de même être une instance de la classe A. De même Il est impossible de "
|
||
"dire si le nom de l'instance est a ou b, les deux noms sont attachés à la "
|
||
"même valeur."
|
||
|
||
#: ../Doc/faq/programming.rst:674
|
||
msgid ""
|
||
"Generally speaking it should not be necessary for your code to \"know the "
|
||
"names\" of particular values. Unless you are deliberately writing "
|
||
"introspective programs, this is usually an indication that a change of "
|
||
"approach might be beneficial."
|
||
msgstr ""
|
||
"De façon général, il ne devrait pas être nécessaire pour votre application "
|
||
"de \"connaître le nom\" d'une valeur particulière. À moins que vous soyez "
|
||
"délibérément en train d'écrire un programme introspectif, c'est souvent une "
|
||
"indication qu'un changement d'approche pourrait être bénéfique."
|
||
|
||
#: ../Doc/faq/programming.rst:679
|
||
msgid ""
|
||
"In comp.lang.python, Fredrik Lundh once gave an excellent analogy in answer "
|
||
"to this question:"
|
||
msgstr ""
|
||
"Sur comp.lang.python, Fredrik Lundh a donné un jour une excellente analogie "
|
||
"pour répondre à cette question:"
|
||
|
||
#: ../Doc/faq/programming.rst:682
|
||
msgid ""
|
||
"The same way as you get the name of that cat you found on your porch: the "
|
||
"cat (object) itself cannot tell you its name, and it doesn't really care -- "
|
||
"so the only way to find out what it's called is to ask all your neighbours "
|
||
"(namespaces) if it's their cat (object)..."
|
||
msgstr ""
|
||
"C'est pareil que trouver le nom du chat qui traîne devant votre porte: Le "
|
||
"chat (objet) ne peux pas vous dire lui même son nom, et il s'en moque un peu "
|
||
"-- alors le meilleur moyen de savoir comment il s'appelle est de demander à "
|
||
"tous vos voisins (namespaces) si c'est leur chat (objet)…"
|
||
|
||
#: ../Doc/faq/programming.rst:687
|
||
msgid ""
|
||
"....and don't be surprised if you'll find that it's known by many names, or "
|
||
"no name at all!"
|
||
msgstr ""
|
||
"…et ne soyez pas surpris si vous découvrez qu'il est connus sous plusieurs "
|
||
"noms différents, ou pas de nom du tout!"
|
||
|
||
#: ../Doc/faq/programming.rst:692
|
||
msgid "What's up with the comma operator's precedence?"
|
||
msgstr "Qu'en est-il de la précédence de l'opérateur virgule ?"
|
||
|
||
#: ../Doc/faq/programming.rst:694
|
||
msgid "Comma is not an operator in Python. Consider this session::"
|
||
msgstr ""
|
||
"La virgule n'est pas un opérateur en Python. Observez la session suivante::"
|
||
|
||
#: ../Doc/faq/programming.rst:699
|
||
msgid ""
|
||
"Since the comma is not an operator, but a separator between expressions the "
|
||
"above is evaluated as if you had entered::"
|
||
msgstr ""
|
||
"Comme la virgule n'est pas un opérateur, mais un séparateur entre deux "
|
||
"expression, l'expression ci dessus, est évaluée de la même façon que si vous "
|
||
"aviez écrit::"
|
||
|
||
#: ../Doc/faq/programming.rst:704
|
||
msgid "not::"
|
||
msgstr "et non::"
|
||
|
||
#: ../Doc/faq/programming.rst:708
|
||
msgid ""
|
||
"The same is true of the various assignment operators (``=``, ``+=`` etc). "
|
||
"They are not truly operators but syntactic delimiters in assignment "
|
||
"statements."
|
||
msgstr ""
|
||
"Ceci est vrai pour tous les opérateurs d'assignations (``=``, ``+=`` etc). "
|
||
"Ce ne sont pas vraiment des opérateurs mais des délimiteurs syntaxiques dans "
|
||
"les instructions d'assignation."
|
||
|
||
#: ../Doc/faq/programming.rst:713
|
||
msgid "Is there an equivalent of C's \"?:\" ternary operator?"
|
||
msgstr "Existe-t-il un équivalent à l'opérateur ternaire \"?:\" du C ?"
|
||
|
||
#: ../Doc/faq/programming.rst:715
|
||
msgid "Yes, there is. The syntax is as follows::"
|
||
msgstr "Oui, il y en a un. Sa syntaxe est la suivante : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:722
|
||
msgid ""
|
||
"Before this syntax was introduced in Python 2.5, a common idiom was to use "
|
||
"logical operators::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:727
|
||
msgid ""
|
||
"However, this idiom is unsafe, as it can give wrong results when *on_true* "
|
||
"has a false boolean value. Therefore, it is always better to use the ``... "
|
||
"if ... else ...`` form."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:733
|
||
msgid "Is it possible to write obfuscated one-liners in Python?"
|
||
msgstr ""
|
||
"Est-il possible d'écrire des programmes obscurcis (*obfuscated*) d'une ligne "
|
||
"en Python ?"
|
||
|
||
#: ../Doc/faq/programming.rst:735
|
||
msgid ""
|
||
"Yes. Usually this is done by nesting :keyword:`lambda` within :keyword:"
|
||
"`lambda`. See the following three examples, due to Ulf Bartelt::"
|
||
msgstr ""
|
||
"Oui. Cela est généralement réalisé en imbriquant les :keyword:`lambda` dans "
|
||
"des :keyword:`lambda`. Observez les trois exemples suivants, contribués par "
|
||
"Ulf Bartelt::"
|
||
|
||
#: ../Doc/faq/programming.rst:762
|
||
msgid "Don't try this at home, kids!"
|
||
msgstr "Les enfants, ne faîtes pas ça chez vous !"
|
||
|
||
#: ../Doc/faq/programming.rst:766
|
||
msgid "Numbers and strings"
|
||
msgstr "Nombres et chaînes de caractères"
|
||
|
||
#: ../Doc/faq/programming.rst:769
|
||
msgid "How do I specify hexadecimal and octal integers?"
|
||
msgstr "Comment puis-je écrire des entiers hexadécimaux ou octaux ?"
|
||
|
||
#: ../Doc/faq/programming.rst:771
|
||
msgid ""
|
||
"To specify an octal digit, precede the octal value with a zero, and then a "
|
||
"lower or uppercase \"o\". For example, to set the variable \"a\" to the "
|
||
"octal value \"10\" (8 in decimal), type::"
|
||
msgstr ""
|
||
"Pour écrire un entier octal, faites précéder la valeur octale par un zéro, "
|
||
"puis un \"o\" majuscule ou minuscule. Par exemple assigner la valeur octale "
|
||
"\"10\" (8 en décimal) à la variable \"a\", tapez::"
|
||
|
||
#: ../Doc/faq/programming.rst:779
|
||
msgid ""
|
||
"Hexadecimal is just as easy. Simply precede the hexadecimal number with a "
|
||
"zero, and then a lower or uppercase \"x\". Hexadecimal digits can be "
|
||
"specified in lower or uppercase. For example, in the Python interpreter::"
|
||
msgstr ""
|
||
"L'hexadécimal est tout aussi simple, faîtes précéder le nombre hexadécimal "
|
||
"par un zéro, puis un \"x\" majuscule ou minuscule. Les nombres hexadécimaux "
|
||
"peuvent être écrit en majuscules ou en minuscules. Par exemple, dans "
|
||
"l'interpréteur Python::"
|
||
|
||
#: ../Doc/faq/programming.rst:792
|
||
msgid "Why does -22 // 10 return -3?"
|
||
msgstr "Pourquoi -22 // 10 donne-t-il -3 ?"
|
||
|
||
#: ../Doc/faq/programming.rst:794
|
||
msgid ""
|
||
"It's primarily driven by the desire that ``i % j`` have the same sign as "
|
||
"``j``. If you want that, and also want::"
|
||
msgstr ""
|
||
"Cela est principalement due à la volonté que ``i % j`` ait le même signe que "
|
||
"j. Si vous voulez cela, vous voulez aussi : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:799
|
||
msgid ""
|
||
"then integer division has to return the floor. C also requires that "
|
||
"identity to hold, and then compilers that truncate ``i // j`` need to make "
|
||
"``i % j`` have the same sign as ``i``."
|
||
msgstr ""
|
||
"Alors la division entière doit retourner l'entier inférieur. Le C demande "
|
||
"aussi à ce que cette égalité soit vérifiée, et donc les compilateur qui "
|
||
"tronquent ``i // j`` ont besoin que ``i % j`` ait le même signe que ``i``."
|
||
|
||
#: ../Doc/faq/programming.rst:803
|
||
msgid ""
|
||
"There are few real use cases for ``i % j`` when ``j`` is negative. When "
|
||
"``j`` is positive, there are many, and in virtually all of them it's more "
|
||
"useful for ``i % j`` to be ``>= 0``. If the clock says 10 now, what did it "
|
||
"say 200 hours ago? ``-190 % 12 == 2`` is useful; ``-190 % 12 == -10`` is a "
|
||
"bug waiting to bite."
|
||
msgstr ""
|
||
"Il y a peu de cas d'utilisation réels pour ``i%j`` quand ``j`` est négatif. "
|
||
"Quand ``j`` est positif, il y en a beaucoup, et dans pratiquement tous, il "
|
||
"est plus utile que ``i % j`` soit ``>=0``. Si l'horloge dit 10h maintenant, "
|
||
"que disait-elle il y a 200 heures? ``-190%12 == 2`` est utile; ``-192 % 12 "
|
||
"== -10`` est un bug qui attends pour mordre."
|
||
|
||
#: ../Doc/faq/programming.rst:811
|
||
msgid "How do I convert a string to a number?"
|
||
msgstr "Comment puis-je convertir une chaine de caractère en nombre?"
|
||
|
||
#: ../Doc/faq/programming.rst:813
|
||
msgid ""
|
||
"For integers, use the built-in :func:`int` type constructor, e.g. "
|
||
"``int('144') == 144``. Similarly, :func:`float` converts to floating-point, "
|
||
"e.g. ``float('144') == 144.0``."
|
||
msgstr ""
|
||
"Pour les entiers, utilisez la fonction built-in :func:`int` de type "
|
||
"constructeur, par exemple ``int('144') == 144``. De façon similaire, :func:"
|
||
"`float` convertit en valeur flottante, par exemple ``float('144') == 144.0``."
|
||
|
||
#: ../Doc/faq/programming.rst:817
|
||
msgid ""
|
||
"By default, these interpret the number as decimal, so that ``int('0144') == "
|
||
"144`` and ``int('0x144')`` raises :exc:`ValueError`. ``int(string, base)`` "
|
||
"takes the base to convert from as a second optional argument, so "
|
||
"``int('0x144', 16) == 324``. If the base is specified as 0, the number is "
|
||
"interpreted using Python's rules: a leading '0o' indicates octal, and '0x' "
|
||
"indicates a hex number."
|
||
msgstr ""
|
||
"Par défaut, ces fonctions interprètent les nombre en tant que décimaux, de "
|
||
"telles façons que ``int('0144') == 144`` et ``int('0x144')`` lève une :exc:"
|
||
"`ValueError`. ``int(string, base)`` prends la base depuis laquelle il faut "
|
||
"convertir dans le second argument, optionnel, donc ``int('0x144', 16) == "
|
||
"324``. Si la base donnée est 0, le nombre est interprété selon les règles "
|
||
"Python: un préfixe '0o' indique de l'octal, et '0x' indique de l'hexadécimal."
|
||
|
||
#: ../Doc/faq/programming.rst:823
|
||
msgid ""
|
||
"Do not use the built-in function :func:`eval` if all you need is to convert "
|
||
"strings to numbers. :func:`eval` will be significantly slower and it "
|
||
"presents a security risk: someone could pass you a Python expression that "
|
||
"might have unwanted side effects. For example, someone could pass "
|
||
"``__import__('os').system(\"rm -rf $HOME\")`` which would erase your home "
|
||
"directory."
|
||
msgstr ""
|
||
"N'utilisez pas la fonction built-in :func:`eval` si tout ce que vous avez "
|
||
"besoin est de convertir des chaines en nombres. :func:`eval` sera "
|
||
"significativement plus lent et implique des risque de sécurité: quelqu'un "
|
||
"pourrait vous envoyez une expression Python pouvant avoir des effets de bord "
|
||
"indésirables. Par exemple, quelqu'un pourrait passer ``__import__('os')."
|
||
"system(\"rm -rf $HOME\")`` ce qui aurait pour effet d'effacer votre "
|
||
"répertoire personnel."
|
||
|
||
#: ../Doc/faq/programming.rst:830
|
||
msgid ""
|
||
":func:`eval` also has the effect of interpreting numbers as Python "
|
||
"expressions, so that e.g. ``eval('09')`` gives a syntax error because Python "
|
||
"does not allow leading '0' in a decimal number (except '0')."
|
||
msgstr ""
|
||
":func:`eval` a aussi pour effet d'interpréter les nombres comme comme des "
|
||
"expression Python, ainsi ``eval('09')`` produit une erreur de syntaxe par ce "
|
||
"que Python ne permet pas les '0' en tête d'un nombre décimal (à l'exception "
|
||
"du nombre '0')."
|
||
|
||
#: ../Doc/faq/programming.rst:836
|
||
msgid "How do I convert a number to a string?"
|
||
msgstr "Comment convertir un nombre en chaine de caractère?"
|
||
|
||
#: ../Doc/faq/programming.rst:838
|
||
msgid ""
|
||
"To convert, e.g., the number 144 to the string '144', use the built-in type "
|
||
"constructor :func:`str`. If you want a hexadecimal or octal representation, "
|
||
"use the built-in functions :func:`hex` or :func:`oct`. For fancy "
|
||
"formatting, see the :ref:`f-strings` and :ref:`formatstrings` sections, e.g. "
|
||
"``\"{:04d}\".format(144)`` yields ``'0144'`` and ``\"{:.3f}\"."
|
||
"format(1.0/3.0)`` yields ``'0.333'``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:847
|
||
msgid "How do I modify a string in place?"
|
||
msgstr "Comment modifier une chaine de caractère \"en place\"?"
|
||
|
||
#: ../Doc/faq/programming.rst:849
|
||
msgid ""
|
||
"You can't, because strings are immutable. In most situations, you should "
|
||
"simply construct a new string from the various parts you want to assemble it "
|
||
"from. However, if you need an object with the ability to modify in-place "
|
||
"unicode data, try using an :class:`io.StringIO` object or the :mod:`array` "
|
||
"module::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:879
|
||
msgid "How do I use strings to call functions/methods?"
|
||
msgstr ""
|
||
"Comment utiliser des chaines de caractères pour appeler des fonctions/"
|
||
"méthodes?"
|
||
|
||
#: ../Doc/faq/programming.rst:881
|
||
msgid "There are various techniques."
|
||
msgstr "Il y a différentes techniques."
|
||
|
||
#: ../Doc/faq/programming.rst:883
|
||
msgid ""
|
||
"The best is to use a dictionary that maps strings to functions. The primary "
|
||
"advantage of this technique is that the strings do not need to match the "
|
||
"names of the functions. This is also the primary technique used to emulate "
|
||
"a case construct::"
|
||
msgstr ""
|
||
"La meilleure est d'utiliser un dictionnaire qui fait correspondre les "
|
||
"chaines de caractères à des fonctions. Le principal avantage de cette "
|
||
"technique est que les chaines n'ont pas besoin d'être égales aux noms de "
|
||
"fonctions. C'est aussi la principale façon d'imiter la construction \"case"
|
||
"\"::"
|
||
|
||
#: ../Doc/faq/programming.rst:898
|
||
msgid "Use the built-in function :func:`getattr`::"
|
||
msgstr "Utiliser la fonction :func:`getattr`::"
|
||
|
||
#: ../Doc/faq/programming.rst:903
|
||
msgid ""
|
||
"Note that :func:`getattr` works on any object, including classes, class "
|
||
"instances, modules, and so on."
|
||
msgstr ""
|
||
"Notez que :func:`getattr` marche sur n'importe quel objet, ceci inclue les "
|
||
"classes, les instances de classes, les modules et ainsi de suite."
|
||
|
||
#: ../Doc/faq/programming.rst:906
|
||
msgid "This is used in several places in the standard library, like this::"
|
||
msgstr ""
|
||
"Ceci est utilisé dans plusieurs endroit de la bibliothèque standard, de "
|
||
"cette façon::"
|
||
|
||
#: ../Doc/faq/programming.rst:919
|
||
msgid "Use :func:`locals` or :func:`eval` to resolve the function name::"
|
||
msgstr ""
|
||
"Utilisez :func:`locals` ou :func:`eval` pour résoudre le nom de fonction::"
|
||
|
||
#: ../Doc/faq/programming.rst:932
|
||
msgid ""
|
||
"Note: Using :func:`eval` is slow and dangerous. If you don't have absolute "
|
||
"control over the contents of the string, someone could pass a string that "
|
||
"resulted in an arbitrary function being executed."
|
||
msgstr ""
|
||
"Note: En utilisant :func:`eval` est lent est dangereux. Si vous n'avez pas "
|
||
"un contrôle absolu sur le contenu de la chaine de caractère, quelqu'un peut "
|
||
"passer une chaine de caractère pouvant résulter en l'exécution de code "
|
||
"arbitraire."
|
||
|
||
#: ../Doc/faq/programming.rst:937
|
||
msgid ""
|
||
"Is there an equivalent to Perl's chomp() for removing trailing newlines from "
|
||
"strings?"
|
||
msgstr ""
|
||
"Existe-t'il un équivalent à la fonction chomp() de Perl, pour retirer les "
|
||
"caractères de fin de ligne d'une chaine de caractère?"
|
||
|
||
#: ../Doc/faq/programming.rst:939
|
||
msgid ""
|
||
"You can use ``S.rstrip(\"\\r\\n\")`` to remove all occurrences of any line "
|
||
"terminator from the end of the string ``S`` without removing other trailing "
|
||
"whitespace. If the string ``S`` represents more than one line, with several "
|
||
"empty lines at the end, the line terminators for all the blank lines will be "
|
||
"removed::"
|
||
msgstr ""
|
||
"Vous pouvez utiliser ``S.rstrip(\"\\r\\n\")`` pour retirer toute occurrence "
|
||
"de tout marqueur de fin de ligne, à la fin d'une chaîne de caractère ``S``, "
|
||
"sans en retirer aucun espace. Si la chaîne ``S`` représente plus d'une "
|
||
"ligne, avec plusieurs lignes vides, les marqueurs de fin de de lignes de "
|
||
"chaque lignes vides seront retirés : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:951
|
||
msgid ""
|
||
"Since this is typically only desired when reading text one line at a time, "
|
||
"using ``S.rstrip()`` this way works well."
|
||
msgstr ""
|
||
"Du fait que ce soit principalement utile en lisant un texte ligne à ligne, "
|
||
"utiliser ``S.rstrip()`` devrait marcher correctement."
|
||
|
||
#: ../Doc/faq/programming.rst:956
|
||
msgid "Is there a scanf() or sscanf() equivalent?"
|
||
msgstr "Existe-t'il un équivalent à scanf() ou sscanf()?"
|
||
|
||
#: ../Doc/faq/programming.rst:958
|
||
msgid "Not as such."
|
||
msgstr "Pas exactement."
|
||
|
||
#: ../Doc/faq/programming.rst:960
|
||
msgid ""
|
||
"For simple input parsing, the easiest approach is usually to split the line "
|
||
"into whitespace-delimited words using the :meth:`~str.split` method of "
|
||
"string objects and then convert decimal strings to numeric values using :"
|
||
"func:`int` or :func:`float`. ``split()`` supports an optional \"sep\" "
|
||
"parameter which is useful if the line uses something other than whitespace "
|
||
"as a separator."
|
||
msgstr ""
|
||
"Pour une simple analyse de chaine, l'approche la plus simple est "
|
||
"généralement de découper la ligne en mots délimités par des espaces, en "
|
||
"utilisant la méthode :meth:`~str.split` des objets chaine de caractères, et "
|
||
"ensuite de convertir les chaines de décimales en valeurs numériques en "
|
||
"utilisant la fonction :func:`int` ou :func:`float`, ``split()`` supporte un "
|
||
"paramètre optionnel \"sep\" qui est utile si la ligne utilise autre chose "
|
||
"que des espaces comme séparateur."
|
||
|
||
#: ../Doc/faq/programming.rst:966
|
||
msgid ""
|
||
"For more complicated input parsing, regular expressions are more powerful "
|
||
"than C's :c:func:`sscanf` and better suited for the task."
|
||
msgstr ""
|
||
"Pour les analyses plus compliquées, les expressions rationnelles sont plus "
|
||
"puissantes que la fonction :c:func:`sscanf` de C et mieux adaptées à la "
|
||
"tâche."
|
||
|
||
#: ../Doc/faq/programming.rst:971
|
||
msgid "What does 'UnicodeDecodeError' or 'UnicodeEncodeError' error mean?"
|
||
msgstr ""
|
||
"Que signifient les erreurs 'UnicodeDecodeError' ou 'UnicodeEncodeError' ?"
|
||
|
||
#: ../Doc/faq/programming.rst:973
|
||
msgid "See the :ref:`unicode-howto`."
|
||
msgstr "Regardez :ref:`unicode-howto`."
|
||
|
||
#: ../Doc/faq/programming.rst:977
|
||
msgid "Performance"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:980
|
||
msgid "My program is too slow. How do I speed it up?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:982
|
||
msgid ""
|
||
"That's a tough one, in general. First, here are a list of things to "
|
||
"remember before diving further:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:985
|
||
msgid ""
|
||
"Performance characteristics vary across Python implementations. This FAQ "
|
||
"focusses on :term:`CPython`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:987
|
||
msgid ""
|
||
"Behaviour can vary across operating systems, especially when talking about I/"
|
||
"O or multi-threading."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:989
|
||
msgid ""
|
||
"You should always find the hot spots in your program *before* attempting to "
|
||
"optimize any code (see the :mod:`profile` module)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:991
|
||
msgid ""
|
||
"Writing benchmark scripts will allow you to iterate quickly when searching "
|
||
"for improvements (see the :mod:`timeit` module)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:993
|
||
msgid ""
|
||
"It is highly recommended to have good code coverage (through unit testing or "
|
||
"any other technique) before potentially introducing regressions hidden in "
|
||
"sophisticated optimizations."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:997
|
||
msgid ""
|
||
"That being said, there are many tricks to speed up Python code. Here are "
|
||
"some general principles which go a long way towards reaching acceptable "
|
||
"performance levels:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1001
|
||
msgid ""
|
||
"Making your algorithms faster (or changing to faster ones) can yield much "
|
||
"larger benefits than trying to sprinkle micro-optimization tricks all over "
|
||
"your code."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1005
|
||
msgid ""
|
||
"Use the right data structures. Study documentation for the :ref:`bltin-"
|
||
"types` and the :mod:`collections` module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1008
|
||
msgid ""
|
||
"When the standard library provides a primitive for doing something, it is "
|
||
"likely (although not guaranteed) to be faster than any alternative you may "
|
||
"come up with. This is doubly true for primitives written in C, such as "
|
||
"builtins and some extension types. For example, be sure to use either the :"
|
||
"meth:`list.sort` built-in method or the related :func:`sorted` function to "
|
||
"do sorting (and see the :ref:`sortinghowto` for examples of moderately "
|
||
"advanced usage)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1016
|
||
msgid ""
|
||
"Abstractions tend to create indirections and force the interpreter to work "
|
||
"more. If the levels of indirection outweigh the amount of useful work done, "
|
||
"your program will be slower. You should avoid excessive abstraction, "
|
||
"especially under the form of tiny functions or methods (which are also often "
|
||
"detrimental to readability)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1022
|
||
msgid ""
|
||
"If you have reached the limit of what pure Python can allow, there are tools "
|
||
"to take you further away. For example, `Cython <http://cython.org>`_ can "
|
||
"compile a slightly modified version of Python code into a C extension, and "
|
||
"can be used on many different platforms. Cython can take advantage of "
|
||
"compilation (and optional type annotations) to make your code significantly "
|
||
"faster than when interpreted. If you are confident in your C programming "
|
||
"skills, you can also :ref:`write a C extension module <extending-index>` "
|
||
"yourself."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1032
|
||
msgid ""
|
||
"The wiki page devoted to `performance tips <https://wiki.python.org/moin/"
|
||
"PythonSpeed/PerformanceTips>`_."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1038
|
||
msgid "What is the most efficient way to concatenate many strings together?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1040
|
||
msgid ""
|
||
":class:`str` and :class:`bytes` objects are immutable, therefore "
|
||
"concatenating many strings together is inefficient as each concatenation "
|
||
"creates a new object. In the general case, the total runtime cost is "
|
||
"quadratic in the total string length."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1045
|
||
msgid ""
|
||
"To accumulate many :class:`str` objects, the recommended idiom is to place "
|
||
"them into a list and call :meth:`str.join` at the end::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1053
|
||
msgid "(another reasonably efficient idiom is to use :class:`io.StringIO`)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1055
|
||
msgid ""
|
||
"To accumulate many :class:`bytes` objects, the recommended idiom is to "
|
||
"extend a :class:`bytearray` object using in-place concatenation (the ``+=`` "
|
||
"operator)::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1064
|
||
msgid "Sequences (Tuples/Lists)"
|
||
msgstr "Sequences (Tuples/Lists)"
|
||
|
||
#: ../Doc/faq/programming.rst:1067
|
||
msgid "How do I convert between tuples and lists?"
|
||
msgstr "Comment convertir les listes en tuples et inversement?"
|
||
|
||
#: ../Doc/faq/programming.rst:1069
|
||
msgid ""
|
||
"The type constructor ``tuple(seq)`` converts any sequence (actually, any "
|
||
"iterable) into a tuple with the same items in the same order."
|
||
msgstr ""
|
||
"Le constructeur de type ``tuple(seq)`` convertit toute séquence (en fait "
|
||
"tout itérable) en un tuple avec les mêmes éléments dans le même ordre…"
|
||
|
||
#: ../Doc/faq/programming.rst:1072
|
||
msgid ""
|
||
"For example, ``tuple([1, 2, 3])`` yields ``(1, 2, 3)`` and ``tuple('abc')`` "
|
||
"yields ``('a', 'b', 'c')``. If the argument is a tuple, it does not make a "
|
||
"copy but returns the same object, so it is cheap to call :func:`tuple` when "
|
||
"you aren't sure that an object is already a tuple."
|
||
msgstr ""
|
||
"Par exemple ``tuple([1, 2, 3])`` renvoi ``(1, 2, 3)`` et ``tuple('abc')`` "
|
||
"renvoi ``('a', 'b', 'c')``. Si l'argument est un tuple, cela ne crèe pas une "
|
||
"copie, mais renvoi le même objet, ce qui fait de :func:`tuple` un fonction "
|
||
"économique à appeler quand vous ne savez pas si votre objet est déjà un "
|
||
"tulpe."
|
||
|
||
#: ../Doc/faq/programming.rst:1077
|
||
msgid ""
|
||
"The type constructor ``list(seq)`` converts any sequence or iterable into a "
|
||
"list with the same items in the same order. For example, ``list((1, 2, "
|
||
"3))`` yields ``[1, 2, 3]`` and ``list('abc')`` yields ``['a', 'b', 'c']``. "
|
||
"If the argument is a list, it makes a copy just like ``seq[:]`` would."
|
||
msgstr ""
|
||
"Le constructeur de type ``list(seq)`` convertit toute séquence ou itérable "
|
||
"en liste contenant les mêmes éléments dans le même ordre. Par exemple, "
|
||
"``list((1,2,3))`` retourne ``[1,2,3]`` et ``list('abc')`` retourne "
|
||
"``['a','b','c']``. Si l'argument est une liste, il retourne une copie, de la "
|
||
"même façon que ``seq[:]``."
|
||
|
||
#: ../Doc/faq/programming.rst:1084
|
||
msgid "What's a negative index?"
|
||
msgstr "Qu'est-ce qu'un indexe négatif?"
|
||
|
||
#: ../Doc/faq/programming.rst:1086
|
||
msgid ""
|
||
"Python sequences are indexed with positive numbers and negative numbers. "
|
||
"For positive numbers 0 is the first index 1 is the second index and so "
|
||
"forth. For negative indices -1 is the last index and -2 is the penultimate "
|
||
"(next to last) index and so forth. Think of ``seq[-n]`` as the same as "
|
||
"``seq[len(seq)-n]``."
|
||
msgstr ""
|
||
"Les séquences Python sont indexées avec des nombres positifs aussi bien que "
|
||
"négatifs. Pour les nombres positifs, 0 est le premier index, 1 est le "
|
||
"second, et ainsi de suite. Pour les indexes négatifs, -1 est le dernier "
|
||
"index, -2 est le pénultième (avant dernier), et ainsi de suite. On peut "
|
||
"aussi dire que ``seq[-n]`` est équivalent à ``seq[len(seq)-n]``."
|
||
|
||
#: ../Doc/faq/programming.rst:1091
|
||
msgid ""
|
||
"Using negative indices can be very convenient. For example ``S[:-1]`` is "
|
||
"all of the string except for its last character, which is useful for "
|
||
"removing the trailing newline from a string."
|
||
msgstr ""
|
||
"Utiliser des indexes négatifs peut être très pratique. Par exemple "
|
||
"``S[:-1]`` indique la chaine entière a l'exception du dernier caractère, ce "
|
||
"qui est pratique pour retirer un caractère de fin de ligne en fin d'une "
|
||
"chaine."
|
||
|
||
#: ../Doc/faq/programming.rst:1097
|
||
msgid "How do I iterate over a sequence in reverse order?"
|
||
msgstr "Comment itérer à rebours sur une séquence?"
|
||
|
||
#: ../Doc/faq/programming.rst:1099
|
||
msgid ""
|
||
"Use the :func:`reversed` built-in function, which is new in Python 2.4::"
|
||
msgstr ""
|
||
"Utilisez la fonction embarquée :func:`reversed`, qui est apparue en Python "
|
||
"2.4::"
|
||
|
||
#: ../Doc/faq/programming.rst:1104
|
||
msgid ""
|
||
"This won't touch your original sequence, but build a new copy with reversed "
|
||
"order to iterate over."
|
||
msgstr ""
|
||
"Cela ne modifiera pas votre séquence initiale, mais construira à la place "
|
||
"une copie en ordre inverse pour itérer dessus."
|
||
|
||
#: ../Doc/faq/programming.rst:1107
|
||
msgid "With Python 2.3, you can use an extended slice syntax::"
|
||
msgstr "Avec Python 2.3 vous pouvez utiliser la syntaxe étendue de tranches::"
|
||
|
||
#: ../Doc/faq/programming.rst:1114
|
||
msgid "How do you remove duplicates from a list?"
|
||
msgstr "Comment retirer les doublons d'une liste?"
|
||
|
||
#: ../Doc/faq/programming.rst:1116
|
||
msgid "See the Python Cookbook for a long discussion of many ways to do this:"
|
||
msgstr ""
|
||
"Lisez le Python Cookbook pour trouver une longue discussion sur les "
|
||
"nombreuses façons de faire cela:"
|
||
|
||
#: ../Doc/faq/programming.rst:1118
|
||
msgid "https://code.activestate.com/recipes/52560/"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1120
|
||
msgid ""
|
||
"If you don't mind reordering the list, sort it and then scan from the end of "
|
||
"the list, deleting duplicates as you go::"
|
||
msgstr ""
|
||
"Si changer l'ordre de la liste ne vous dérange pas, commencez par trier "
|
||
"celle ci, puis parcourez la d'un bout à l'autre, en supprimant les doublons "
|
||
"trouvés en chemin::"
|
||
|
||
#: ../Doc/faq/programming.rst:1132
|
||
msgid ""
|
||
"If all elements of the list may be used as set keys (i.e. they are all :term:"
|
||
"`hashable`) this is often faster ::"
|
||
msgstr ""
|
||
"Si tous les éléments de la liste peuvent être utilisés comme des clés de "
|
||
"dictionnaire (càd, qu'elles sont toutes :term:`hachables <hashable>`) ceci "
|
||
"est souvent plus rapide : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1137
|
||
msgid ""
|
||
"This converts the list into a set, thereby removing duplicates, and then "
|
||
"back into a list."
|
||
msgstr ""
|
||
"Ceci convertis la liste en un ensemble, ce qui supprime automatiquement les "
|
||
"doublons, puis la transforme à nouveau en liste."
|
||
|
||
#: ../Doc/faq/programming.rst:1142
|
||
msgid "How do you make an array in Python?"
|
||
msgstr "Comment construire un tableau en Python?"
|
||
|
||
#: ../Doc/faq/programming.rst:1144
|
||
msgid "Use a list::"
|
||
msgstr "Utilisez une liste::"
|
||
|
||
#: ../Doc/faq/programming.rst:1148
|
||
msgid ""
|
||
"Lists are equivalent to C or Pascal arrays in their time complexity; the "
|
||
"primary difference is that a Python list can contain objects of many "
|
||
"different types."
|
||
msgstr ""
|
||
"Les listes ont un cout équivalent à celui des tableau C ou Pascal; la "
|
||
"principale différence est qu'une liste Python peut contenir des objets de "
|
||
"différents types."
|
||
|
||
#: ../Doc/faq/programming.rst:1151
|
||
msgid ""
|
||
"The ``array`` module also provides methods for creating arrays of fixed "
|
||
"types with compact representations, but they are slower to index than "
|
||
"lists. Also note that the Numeric extensions and others define array-like "
|
||
"structures with various characteristics as well."
|
||
msgstr ""
|
||
"Le module ``array`` fournit des méthodes pour créer des tableaux de types "
|
||
"fixes dans une représentation compacte, mais ils sont plus lents à indexer "
|
||
"que les listes. Notez aussi que l'extension ``Numeric`` et d'autres, "
|
||
"fournissent différentes structures de types tableaux, avec des "
|
||
"caractéristiques différentes."
|
||
|
||
#: ../Doc/faq/programming.rst:1156
|
||
msgid ""
|
||
"To get Lisp-style linked lists, you can emulate cons cells using tuples::"
|
||
msgstr ""
|
||
"Pour obtenir des listes chainées de type Lisp, vous pouvez émuler les \"cons "
|
||
"cells\" en utilisant des tuples::"
|
||
|
||
#: ../Doc/faq/programming.rst:1160
|
||
msgid ""
|
||
"If mutability is desired, you could use lists instead of tuples. Here the "
|
||
"analogue of lisp car is ``lisp_list[0]`` and the analogue of cdr is "
|
||
"``lisp_list[1]``. Only do this if you're sure you really need to, because "
|
||
"it's usually a lot slower than using Python lists."
|
||
msgstr ""
|
||
"Si vous voulez pouvoir modifier les éléments, utilisez une liste plutôt "
|
||
"qu'un tuple. Ici la version équivalente au \"car\" de Lisp est "
|
||
"``lisp_list[0]`` et l'équivalent à \"cdr\" est ``list_lip[1]``. Ne faîtes "
|
||
"ceci que si vous êtes réellement sûr d'en avoir besoin, cette méthode est en "
|
||
"générale bien plus lente que les listes Python."
|
||
|
||
#: ../Doc/faq/programming.rst:1169
|
||
msgid "How do I create a multidimensional list?"
|
||
msgstr "Comment puis-je créer une liste à plusieurs dimensions?"
|
||
|
||
#: ../Doc/faq/programming.rst:1171
|
||
msgid "You probably tried to make a multidimensional array like this::"
|
||
msgstr ""
|
||
"Vous avez probablement essayé de créer une liste à plusieurs dimensions de "
|
||
"cette façon::"
|
||
|
||
#: ../Doc/faq/programming.rst:1175
|
||
msgid "This looks correct if you print it:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1186
|
||
msgid "But when you assign a value, it shows up in multiple places:"
|
||
msgstr ""
|
||
"Mais quand vous assignez une valeur, elle apparait en de multiples endroits::"
|
||
|
||
#: ../Doc/faq/programming.rst:1198
|
||
msgid ""
|
||
"The reason is that replicating a list with ``*`` doesn't create copies, it "
|
||
"only creates references to the existing objects. The ``*3`` creates a list "
|
||
"containing 3 references to the same list of length two. Changes to one row "
|
||
"will show in all rows, which is almost certainly not what you want."
|
||
msgstr ""
|
||
"La raison en est que dupliquer une liste en utilisant ``*`` ne crée pas de "
|
||
"copies, cela crée seulement des références aux objets existants. Le ``*3`` "
|
||
"crée une liste contenant trois références à la même liste de longueur deux. "
|
||
"Un changement dans une colonne apparaîtra donc dans toutes les colonnes. Ce "
|
||
"qui n'est de façon quasi certaine, pas ce que vous souhaitez."
|
||
|
||
#: ../Doc/faq/programming.rst:1203
|
||
msgid ""
|
||
"The suggested approach is to create a list of the desired length first and "
|
||
"then fill in each element with a newly created list::"
|
||
msgstr ""
|
||
"L'approche suggérée est de créer une liste de la longueur désiré d'abords, "
|
||
"puis de remplir tous les éléments avec une chaîne nouvellement créée."
|
||
|
||
#: ../Doc/faq/programming.rst:1210
|
||
msgid ""
|
||
"This generates a list containing 3 different lists of length two. You can "
|
||
"also use a list comprehension::"
|
||
msgstr ""
|
||
"Cette liste générée contient trois listes différentes de longueur deux. Vous "
|
||
"pouvez aussi utilisez la notation de compréhension de listes."
|
||
|
||
#: ../Doc/faq/programming.rst:1216
|
||
msgid ""
|
||
"Or, you can use an extension that provides a matrix datatype; `NumPy <http://"
|
||
"www.numpy.org/>`_ is the best known."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1221
|
||
msgid "How do I apply a method to a sequence of objects?"
|
||
msgstr "Comment appliquer une méthode à une séquence d'objets?"
|
||
|
||
#: ../Doc/faq/programming.rst:1223
|
||
msgid "Use a list comprehension::"
|
||
msgstr "Utilisez une compréhension de liste::"
|
||
|
||
#: ../Doc/faq/programming.rst:1230
|
||
msgid ""
|
||
"Why does a_tuple[i] += ['item'] raise an exception when the addition works?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1232
|
||
msgid ""
|
||
"This is because of a combination of the fact that augmented assignment "
|
||
"operators are *assignment* operators, and the difference between mutable and "
|
||
"immutable objects in Python."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1236
|
||
msgid ""
|
||
"This discussion applies in general when augmented assignment operators are "
|
||
"applied to elements of a tuple that point to mutable objects, but we'll use "
|
||
"a ``list`` and ``+=`` as our exemplar."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1240
|
||
msgid "If you wrote::"
|
||
msgstr "Si vous écrivez : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1248
|
||
msgid ""
|
||
"The reason for the exception should be immediately clear: ``1`` is added to "
|
||
"the object ``a_tuple[0]`` points to (``1``), producing the result object, "
|
||
"``2``, but when we attempt to assign the result of the computation, ``2``, "
|
||
"to element ``0`` of the tuple, we get an error because we can't change what "
|
||
"an element of a tuple points to."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1254
|
||
msgid ""
|
||
"Under the covers, what this augmented assignment statement is doing is "
|
||
"approximately this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1263
|
||
msgid ""
|
||
"It is the assignment part of the operation that produces the error, since a "
|
||
"tuple is immutable."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1266
|
||
msgid "When you write something like::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1274
|
||
msgid ""
|
||
"The exception is a bit more surprising, and even more surprising is the fact "
|
||
"that even though there was an error, the append worked::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1280
|
||
msgid ""
|
||
"To see why this happens, you need to know that (a) if an object implements "
|
||
"an ``__iadd__`` magic method, it gets called when the ``+=`` augmented "
|
||
"assignment is executed, and its return value is what gets used in the "
|
||
"assignment statement; and (b) for lists, ``__iadd__`` is equivalent to "
|
||
"calling ``extend`` on the list and returning the list. That's why we say "
|
||
"that for lists, ``+=`` is a \"shorthand\" for ``list.extend``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1292
|
||
msgid "This is equivalent to::"
|
||
msgstr "C’est équivalent à ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1297
|
||
msgid ""
|
||
"The object pointed to by a_list has been mutated, and the pointer to the "
|
||
"mutated object is assigned back to ``a_list``. The end result of the "
|
||
"assignment is a no-op, since it is a pointer to the same object that "
|
||
"``a_list`` was previously pointing to, but the assignment still happens."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1302
|
||
msgid "Thus, in our tuple example what is happening is equivalent to::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1310
|
||
msgid ""
|
||
"The ``__iadd__`` succeeds, and thus the list is extended, but even though "
|
||
"``result`` points to the same object that ``a_tuple[0]`` already points to, "
|
||
"that final assignment still results in an error, because tuples are "
|
||
"immutable."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1316
|
||
msgid "Dictionaries"
|
||
msgstr "Dictionnaires"
|
||
|
||
#: ../Doc/faq/programming.rst:1319
|
||
msgid ""
|
||
"How can I get a dictionary to store and display its keys in a consistent "
|
||
"order?"
|
||
msgstr ""
|
||
"Comment puis-je faire stocker et afficher les clefs d'un dictionnaire dans "
|
||
"un ordre cohérent ?"
|
||
|
||
#: ../Doc/faq/programming.rst:1321
|
||
msgid "Use :class:`collections.OrderedDict`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1324
|
||
msgid ""
|
||
"I want to do a complicated sort: can you do a Schwartzian Transform in "
|
||
"Python?"
|
||
msgstr ""
|
||
"Je souhaite faire un tri compliqué: peut on faire une transformation de "
|
||
"Schwartz en Python?"
|
||
|
||
#: ../Doc/faq/programming.rst:1326
|
||
msgid ""
|
||
"The technique, attributed to Randal Schwartz of the Perl community, sorts "
|
||
"the elements of a list by a metric which maps each element to its \"sort "
|
||
"value\". In Python, use the ``key`` argument for the :meth:`list.sort` "
|
||
"method::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1335
|
||
msgid "How can I sort one list by values from another list?"
|
||
msgstr ""
|
||
"Comment puis-je trier une liste en fonction des valeurs d'une autre liste?"
|
||
|
||
#: ../Doc/faq/programming.rst:1337
|
||
msgid ""
|
||
"Merge them into an iterator of tuples, sort the resulting list, and then "
|
||
"pick out the element you want. ::"
|
||
msgstr ""
|
||
"Fusionnez les dans un itérateur de tuples, triez la liste obtenue, puis "
|
||
"choisissez l'élément que vous voulez. ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1351
|
||
msgid "An alternative for the last step is::"
|
||
msgstr "Une alternative pour la dernière étape est : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1356
|
||
msgid ""
|
||
"If you find this more legible, you might prefer to use this instead of the "
|
||
"final list comprehension. However, it is almost twice as slow for long "
|
||
"lists. Why? First, the ``append()`` operation has to reallocate memory, and "
|
||
"while it uses some tricks to avoid doing that each time, it still has to do "
|
||
"it occasionally, and that costs quite a bit. Second, the expression "
|
||
"\"result.append\" requires an extra attribute lookup, and third, there's a "
|
||
"speed reduction from having to make all those function calls."
|
||
msgstr ""
|
||
"Si vous trouvez cela plus lisible, vous préférez peut-être utiliser ceci à "
|
||
"la place de la compréhension de la liste finale. Toutefois, ceci est presque "
|
||
"deux fois plus lent pour les longues listes. Pourquoi? Tout d'abord, "
|
||
"``append ()`` doit réaffecter la mémoire, et si il utilise quelques astuces "
|
||
"pour éviter de le faire à chaque fois, il doit encore le faire de temps en "
|
||
"temps, ce qui coûte assez cher. Deuxièmement, l'expression \"result.append\" "
|
||
"exige une recherche d'attribut supplémentaire, et enfin, tous ces appels de "
|
||
"fonction impactent la vitesse d'exécution."
|
||
|
||
#: ../Doc/faq/programming.rst:1366
|
||
msgid "Objects"
|
||
msgstr "Objets"
|
||
|
||
#: ../Doc/faq/programming.rst:1369
|
||
msgid "What is a class?"
|
||
msgstr "Qu'est-ce qu'une classe?"
|
||
|
||
#: ../Doc/faq/programming.rst:1371
|
||
msgid ""
|
||
"A class is the particular object type created by executing a class "
|
||
"statement. Class objects are used as templates to create instance objects, "
|
||
"which embody both the data (attributes) and code (methods) specific to a "
|
||
"datatype."
|
||
msgstr ""
|
||
"Une classe est le type d'objet particulier créé par l'exécution d'une "
|
||
"déclaration de classe. Les objets de classe sont utilisés comme modèles pour "
|
||
"créer des objets, qui incarnent à la fois les données (attributs) et le code "
|
||
"(méthodes) spécifiques à un type de données."
|
||
|
||
#: ../Doc/faq/programming.rst:1375
|
||
msgid ""
|
||
"A class can be based on one or more other classes, called its base "
|
||
"class(es). It then inherits the attributes and methods of its base classes. "
|
||
"This allows an object model to be successively refined by inheritance. You "
|
||
"might have a generic ``Mailbox`` class that provides basic accessor methods "
|
||
"for a mailbox, and subclasses such as ``MboxMailbox``, ``MaildirMailbox``, "
|
||
"``OutlookMailbox`` that handle various specific mailbox formats."
|
||
msgstr ""
|
||
"Une classe peut être fondée sur une ou plusieurs autres classes, appelée sa "
|
||
"ou ses classes de base. Il hérite alors les attributs et les méthodes de ses "
|
||
"classes de base. Cela permet à un modèle d'objet d'être successivement "
|
||
"raffinés par héritage. Vous pourriez avoir une classe générique ``Mailbox`` "
|
||
"qui fournit des méthodes d'accès de base pour une boîte aux lettres, et sous-"
|
||
"classes telles que ``MboxMailbox``, ``MaildirMailbox``, ``OutlookMailbox`` "
|
||
"qui gèrent les différents formats de boîtes aux lettres spécifiques."
|
||
|
||
#: ../Doc/faq/programming.rst:1384
|
||
msgid "What is a method?"
|
||
msgstr "Qu'est-ce qu'une méthode?"
|
||
|
||
#: ../Doc/faq/programming.rst:1386
|
||
msgid ""
|
||
"A method is a function on some object ``x`` that you normally call as ``x."
|
||
"name(arguments...)``. Methods are defined as functions inside the class "
|
||
"definition::"
|
||
msgstr ""
|
||
"Une méthode est une fonction sur un objet ``x`` appelez normalement comme "
|
||
"``x.name(arguments…)``. Les méthodes sont définies comme des fonctions à "
|
||
"l'intérieur de la définition de classe::"
|
||
|
||
#: ../Doc/faq/programming.rst:1396
|
||
msgid "What is self?"
|
||
msgstr "Qu'est-ce que self?"
|
||
|
||
#: ../Doc/faq/programming.rst:1398
|
||
msgid ""
|
||
"Self is merely a conventional name for the first argument of a method. A "
|
||
"method defined as ``meth(self, a, b, c)`` should be called as ``x.meth(a, b, "
|
||
"c)`` for some instance ``x`` of the class in which the definition occurs; "
|
||
"the called method will think it is called as ``meth(x, a, b, c)``."
|
||
msgstr ""
|
||
"Self est simplement un nom conventionnel pour le premier argument d'une "
|
||
"méthode. Une méthode définie comme ``meth(self, a, b, c)`` doit être appelée "
|
||
"en tant que ``x.meth(a, b, c)``, pour une instance ``x`` de la classe dans "
|
||
"laquelle elle est définie, la méthode appelée considérera qu'elle est "
|
||
"appelée ``meth(x, a, b, c)``."
|
||
|
||
#: ../Doc/faq/programming.rst:1403
|
||
msgid "See also :ref:`why-self`."
|
||
msgstr "Voir aussi :ref:`why-self`."
|
||
|
||
#: ../Doc/faq/programming.rst:1407
|
||
msgid ""
|
||
"How do I check if an object is an instance of a given class or of a subclass "
|
||
"of it?"
|
||
msgstr ""
|
||
"Comment puis-je vérifier si un objet est une instance d'une classe donnée ou "
|
||
"d'une sous-classe de celui-ci?"
|
||
|
||
#: ../Doc/faq/programming.rst:1409
|
||
msgid ""
|
||
"Use the built-in function ``isinstance(obj, cls)``. You can check if an "
|
||
"object is an instance of any of a number of classes by providing a tuple "
|
||
"instead of a single class, e.g. ``isinstance(obj, (class1, class2, ...))``, "
|
||
"and can also check whether an object is one of Python's built-in types, e.g. "
|
||
"``isinstance(obj, str)`` or ``isinstance(obj, (int, float, complex))``."
|
||
msgstr ""
|
||
"Utilisez la fonction native ``isinstance(obj, cls)``. Vous pouvez vérifier "
|
||
"si un objet est une instance de n'importe lequel d'un certain nombre de "
|
||
"classes en fournissant un tuple à la place d'une seule classe, par exemple, "
|
||
"``isinstance(obj, (class1, class2, ...))``, et peut également vérifier si un "
|
||
"objet est l'un des types natifs de Python, par exemple, ``isinstance(obj, "
|
||
"str)`` ou ``isinstance(obj, (int, float, complex))``."
|
||
|
||
#: ../Doc/faq/programming.rst:1415
|
||
msgid ""
|
||
"Note that most programs do not use :func:`isinstance` on user-defined "
|
||
"classes very often. If you are developing the classes yourself, a more "
|
||
"proper object-oriented style is to define methods on the classes that "
|
||
"encapsulate a particular behaviour, instead of checking the object's class "
|
||
"and doing a different thing based on what class it is. For example, if you "
|
||
"have a function that does something::"
|
||
msgstr ""
|
||
"Notez que la plupart des programmes n'utilisent pas :func:`isInstance` sur "
|
||
"les classes définies par l'utilisateur, très souvent. Si vous développez "
|
||
"vous-même les classes, un style plus appropriée orientée objet est de "
|
||
"définir des méthodes sur les classes qui encapsulent un comportement "
|
||
"particulier, au lieu de vérifier la classe de l'objet et de faire quelque "
|
||
"chose de différent en fonction de sa classe. Par exemple, si vous avez une "
|
||
"fonction qui fait quelque chose : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1429
|
||
msgid ""
|
||
"A better approach is to define a ``search()`` method on all the classes and "
|
||
"just call it::"
|
||
msgstr ""
|
||
"Une meilleure approche est de définir une méthode ``search()`` sur toutes "
|
||
"les classes et qu'il suffit d'appeler::"
|
||
|
||
#: ../Doc/faq/programming.rst:1444
|
||
msgid "What is delegation?"
|
||
msgstr "Qu'est-ce que la délégation?"
|
||
|
||
#: ../Doc/faq/programming.rst:1446
|
||
msgid ""
|
||
"Delegation is an object oriented technique (also called a design pattern). "
|
||
"Let's say you have an object ``x`` and want to change the behaviour of just "
|
||
"one of its methods. You can create a new class that provides a new "
|
||
"implementation of the method you're interested in changing and delegates all "
|
||
"other methods to the corresponding method of ``x``."
|
||
msgstr ""
|
||
"La délégation est une technique orientée objet (aussi appelé un modèle de "
|
||
"conception). Disons que vous avez un objet ``x`` et que vous souhaitez "
|
||
"modifier le comportement d'une seule de ses méthodes. Vous pouvez créer une "
|
||
"nouvelle classe qui fournit une nouvelle implémentation de la méthode qui "
|
||
"vous intéresse dans l'évolution et les délégués de toutes les autres "
|
||
"méthodes la méthode correspondante de ``x``."
|
||
|
||
#: ../Doc/faq/programming.rst:1452
|
||
msgid ""
|
||
"Python programmers can easily implement delegation. For example, the "
|
||
"following class implements a class that behaves like a file but converts all "
|
||
"written data to uppercase::"
|
||
msgstr ""
|
||
"Les programmeurs Python peuvent facilement mettre en œuvre la délégation. "
|
||
"Par exemple, la classe suivante implémente une classe qui se comporte comme "
|
||
"un fichier, mais convertit toutes les données écrites en majuscules:"
|
||
|
||
#: ../Doc/faq/programming.rst:1467
|
||
msgid ""
|
||
"Here the ``UpperOut`` class redefines the ``write()`` method to convert the "
|
||
"argument string to uppercase before calling the underlying ``self.__outfile."
|
||
"write()`` method. All other methods are delegated to the underlying ``self."
|
||
"__outfile`` object. The delegation is accomplished via the ``__getattr__`` "
|
||
"method; consult :ref:`the language reference <attribute-access>` for more "
|
||
"information about controlling attribute access."
|
||
msgstr ""
|
||
"Ici, la classe ``UpperOut`` redéfinit la méthode ``write()`` pour convertir "
|
||
"la chaîne d'argument en majuscules avant d'appeler la méthode sous-jacentes "
|
||
"``self.__outfile.write()``. Toutes les autres méthodes sont déléguées à "
|
||
"l'objet sous-jacent ``self.__outfile``. La délégation se fait par la méthode "
|
||
"``__getattr__``, consulter :ref:`the language reference <attribute-access>` "
|
||
"pour plus d'informations sur le contrôle d'accès d'attribut."
|
||
|
||
#: ../Doc/faq/programming.rst:1474
|
||
msgid ""
|
||
"Note that for more general cases delegation can get trickier. When "
|
||
"attributes must be set as well as retrieved, the class must define a :meth:"
|
||
"`__setattr__` method too, and it must do so carefully. The basic "
|
||
"implementation of :meth:`__setattr__` is roughly equivalent to the "
|
||
"following::"
|
||
msgstr ""
|
||
"Notez que pour une utilisation plus générale de la délégation, les choses "
|
||
"peuvent se compliquer. Lorsque les attributs doivent être définis aussi bien "
|
||
"que récupérés, la classe doit définir une méthode :meth:`__setattr__` aussi, "
|
||
"et il doit le faire avec soin. La mise en œuvre basique de la méthode :meth:"
|
||
"`__setattr__` est à peu près équivalent à ce qui suit:"
|
||
|
||
#: ../Doc/faq/programming.rst:1485
|
||
msgid ""
|
||
"Most :meth:`__setattr__` implementations must modify ``self.__dict__`` to "
|
||
"store local state for self without causing an infinite recursion."
|
||
msgstr ""
|
||
"La plupart des implémentations de :meth:`__setattr__` doivent modifier "
|
||
"``self.__dict__`` pour stocker l'état locale de self sans provoquer une "
|
||
"récursion infinie."
|
||
|
||
#: ../Doc/faq/programming.rst:1490
|
||
msgid ""
|
||
"How do I call a method defined in a base class from a derived class that "
|
||
"overrides it?"
|
||
msgstr ""
|
||
"Comment appeler une méthode définie dans une classe de base depuis une "
|
||
"classe dérivée qui la surcharge?"
|
||
|
||
#: ../Doc/faq/programming.rst:1492
|
||
msgid "Use the built-in :func:`super` function::"
|
||
msgstr "Utiliser la fonction native :func:`super` : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1498
|
||
msgid ""
|
||
"For version prior to 3.0, you may be using classic classes: For a class "
|
||
"definition such as ``class Derived(Base): ...`` you can call method "
|
||
"``meth()`` defined in ``Base`` (or one of ``Base``'s base classes) as ``Base."
|
||
"meth(self, arguments...)``. Here, ``Base.meth`` is an unbound method, so "
|
||
"you need to provide the ``self`` argument."
|
||
msgstr ""
|
||
"Pour version antérieure à 3.0, vous pouvez utiliser des classes classiques : "
|
||
"Pour une définition de classe telle que ``class Derived(Base): ...`` vous "
|
||
"pouvez appeler la méthode ``meth()`` défini dans ``Base`` (ou l'une des "
|
||
"classes de base de ``Base``) en faisant ``Base.meth(self, arguments...)``. "
|
||
"Ici, ``Base.meth`` est une méthode non liée, vous devez donc fournir "
|
||
"l'argument ``self``."
|
||
|
||
#: ../Doc/faq/programming.rst:1506
|
||
msgid "How can I organize my code to make it easier to change the base class?"
|
||
msgstr ""
|
||
"Comment puis-je organiser mon code pour permettre de changer la classe de "
|
||
"base plus facilement?"
|
||
|
||
#: ../Doc/faq/programming.rst:1508
|
||
msgid ""
|
||
"You could define an alias for the base class, assign the real base class to "
|
||
"it before your class definition, and use the alias throughout your class. "
|
||
"Then all you have to change is the value assigned to the alias. "
|
||
"Incidentally, this trick is also handy if you want to decide dynamically (e."
|
||
"g. depending on availability of resources) which base class to use. "
|
||
"Example::"
|
||
msgstr ""
|
||
"Vous pouvez définir un alias pour la classe de base, lui attribuer la classe "
|
||
"de base réelle avant la définition de classe, et utiliser l'alias au long de "
|
||
"votre classe. Ensuite, tout ce que vous devez changer est la valeur "
|
||
"attribuée à l'alias. Incidemment, cette astuce est également utile si vous "
|
||
"voulez décider dynamiquement (par exemple en fonction de la disponibilité "
|
||
"des ressources) la classe de base à utiliser. Exemple::"
|
||
|
||
#: ../Doc/faq/programming.rst:1523
|
||
msgid "How do I create static class data and static class methods?"
|
||
msgstr ""
|
||
"Comment puis-je créer des données statiques de classe et des méthodes "
|
||
"statiques de classe?"
|
||
|
||
#: ../Doc/faq/programming.rst:1525
|
||
msgid ""
|
||
"Both static data and static methods (in the sense of C++ or Java) are "
|
||
"supported in Python."
|
||
msgstr ""
|
||
"Tant les données statiques que les méthodes statiques (dans le sens de C + + "
|
||
"ou Java) sont pris en charge en Python."
|
||
|
||
#: ../Doc/faq/programming.rst:1528
|
||
msgid ""
|
||
"For static data, simply define a class attribute. To assign a new value to "
|
||
"the attribute, you have to explicitly use the class name in the assignment::"
|
||
msgstr ""
|
||
"Pour les données statiques, il suffit de définir un attribut de classe. Pour "
|
||
"attribuer une nouvelle valeur à l'attribut, vous devez explicitement "
|
||
"utiliser le nom de classe dans l'affectation:"
|
||
|
||
#: ../Doc/faq/programming.rst:1540
|
||
msgid ""
|
||
"``c.count`` also refers to ``C.count`` for any ``c`` such that "
|
||
"``isinstance(c, C)`` holds, unless overridden by ``c`` itself or by some "
|
||
"class on the base-class search path from ``c.__class__`` back to ``C``."
|
||
msgstr ""
|
||
"``c.count`` se réfère également à ``C.count`` pour tout ``c`` telle que "
|
||
"``isInstance (c, C)`` est vrai, sauf remplacement par ``c`` lui-même ou par "
|
||
"une classe sur le chemin de recherche de classe de base de ``c.__class__`` "
|
||
"jusqu'à ``C``."
|
||
|
||
#: ../Doc/faq/programming.rst:1544
|
||
msgid ""
|
||
"Caution: within a method of C, an assignment like ``self.count = 42`` "
|
||
"creates a new and unrelated instance named \"count\" in ``self``'s own "
|
||
"dict. Rebinding of a class-static data name must always specify the class "
|
||
"whether inside a method or not::"
|
||
msgstr ""
|
||
"Attention: dans une méthode de C, une affectation comme ``self.count=42`` "
|
||
"crée une nouvelle instance et sans rapport avec le nom \"count\" dans dans "
|
||
"le dictionnaire de données de ``self``. La redéfinition d'une donnée "
|
||
"statique de classe doit toujours spécifier la classe que l'on soit à "
|
||
"l'intérieur d'une méthode ou non:"
|
||
|
||
#: ../Doc/faq/programming.rst:1551
|
||
msgid "Static methods are possible::"
|
||
msgstr "Les méthodes statiques sont possibles : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1559
|
||
msgid ""
|
||
"However, a far more straightforward way to get the effect of a static method "
|
||
"is via a simple module-level function::"
|
||
msgstr ""
|
||
"Cependant, d'une manière beaucoup plus simple pour obtenir l'effet d'une "
|
||
"méthode statique se fait par une simple fonction au niveau du module::"
|
||
|
||
#: ../Doc/faq/programming.rst:1565
|
||
msgid ""
|
||
"If your code is structured so as to define one class (or tightly related "
|
||
"class hierarchy) per module, this supplies the desired encapsulation."
|
||
msgstr ""
|
||
"Si votre code est structuré de manière à définir une classe (ou bien la "
|
||
"hiérarchie des classes connexes) par module, ceci fournira l'encapsulation "
|
||
"souhaitée."
|
||
|
||
#: ../Doc/faq/programming.rst:1570
|
||
msgid "How can I overload constructors (or methods) in Python?"
|
||
msgstr "Comment puis-je surcharger les constructeurs (ou méthodes) en Python?"
|
||
|
||
#: ../Doc/faq/programming.rst:1572
|
||
msgid ""
|
||
"This answer actually applies to all methods, but the question usually comes "
|
||
"up first in the context of constructors."
|
||
msgstr ""
|
||
"Cette réponse s'applique en fait à toutes les méthodes, mais la question "
|
||
"vient généralement en premier dans le contexte des constructeurs."
|
||
|
||
#: ../Doc/faq/programming.rst:1575
|
||
msgid "In C++ you'd write"
|
||
msgstr "In C++ you'd write"
|
||
|
||
#: ../Doc/faq/programming.rst:1584
|
||
msgid ""
|
||
"In Python you have to write a single constructor that catches all cases "
|
||
"using default arguments. For example::"
|
||
msgstr ""
|
||
"En Python, vous devez écrire un constructeur unique qui considère tous les "
|
||
"cas en utilisant des arguments par défaut. Par exemple::"
|
||
|
||
#: ../Doc/faq/programming.rst:1594
|
||
msgid "This is not entirely equivalent, but close enough in practice."
|
||
msgstr ""
|
||
"Ce n'est pas tout à fait équivalent, mais suffisamment proche dans la "
|
||
"pratique."
|
||
|
||
#: ../Doc/faq/programming.rst:1596
|
||
msgid "You could also try a variable-length argument list, e.g. ::"
|
||
msgstr ""
|
||
"Vous pouvez aussi utiliser une liste d'arguments de longueur variable, par "
|
||
"exemple : ::"
|
||
|
||
#: ../Doc/faq/programming.rst:1601
|
||
msgid "The same approach works for all method definitions."
|
||
msgstr "La même approche fonctionne pour toutes les définitions de méthode."
|
||
|
||
#: ../Doc/faq/programming.rst:1605
|
||
msgid "I try to use __spam and I get an error about _SomeClassName__spam."
|
||
msgstr ""
|
||
"J'essaie d'utiliser __spam et j'obtiens une erreur à propos de "
|
||
"_SomeClassName__spam."
|
||
|
||
#: ../Doc/faq/programming.rst:1607
|
||
msgid ""
|
||
"Variable names with double leading underscores are \"mangled\" to provide a "
|
||
"simple but effective way to define class private variables. Any identifier "
|
||
"of the form ``__spam`` (at least two leading underscores, at most one "
|
||
"trailing underscore) is textually replaced with ``_classname__spam``, where "
|
||
"``classname`` is the current class name with any leading underscores "
|
||
"stripped."
|
||
msgstr ""
|
||
"Les noms de variables avec le double de soulignement sont «déformés» pour "
|
||
"fournir un moyen simple mais efficace de définir variables privées à la "
|
||
"classe. Tout identificateur de la forme ``__spam`` (au moins deux traits de "
|
||
"soulignement préfixe, au plus un soulignement suffix) est textuellement "
|
||
"remplacé par ``_classname__spam``, où ``classname`` est le nom de la classe "
|
||
"en cours avec les traits de soulignement dépouillés."
|
||
|
||
#: ../Doc/faq/programming.rst:1613
|
||
msgid ""
|
||
"This doesn't guarantee privacy: an outside user can still deliberately "
|
||
"access the \"_classname__spam\" attribute, and private values are visible in "
|
||
"the object's ``__dict__``. Many Python programmers never bother to use "
|
||
"private variable names at all."
|
||
msgstr ""
|
||
"Cela ne garantit pas la privauté de l'accès : un utilisateur extérieur peut "
|
||
"encore délibérément acceder à l'attribut \"_classname__spam\", et les "
|
||
"valeurs privées sont visibles dans l'objet ``__dict__``. De nombreux "
|
||
"programmeurs Python ne prennent jamais la peine d'utiliser des noms de "
|
||
"variable privée."
|
||
|
||
#: ../Doc/faq/programming.rst:1620
|
||
msgid "My class defines __del__ but it is not called when I delete the object."
|
||
msgstr ""
|
||
"Ma classe définit __del__ mais il n'est pas appelé lorsque je supprime "
|
||
"l'objet."
|
||
|
||
#: ../Doc/faq/programming.rst:1622
|
||
msgid "There are several possible reasons for this."
|
||
msgstr "Il y a plusieurs raisons possibles pour cela."
|
||
|
||
#: ../Doc/faq/programming.rst:1624
|
||
msgid ""
|
||
"The del statement does not necessarily call :meth:`__del__` -- it simply "
|
||
"decrements the object's reference count, and if this reaches zero :meth:"
|
||
"`__del__` is called."
|
||
msgstr ""
|
||
"La commande del n'appelle pas forcément :meth:`__del__` - il décrémente "
|
||
"simplement le compteur de références de l'objet, et si celui ci arrive à "
|
||
"zéro :meth:`__del__` est appelée."
|
||
|
||
#: ../Doc/faq/programming.rst:1628
|
||
msgid ""
|
||
"If your data structures contain circular links (e.g. a tree where each child "
|
||
"has a parent reference and each parent has a list of children) the reference "
|
||
"counts will never go back to zero. Once in a while Python runs an algorithm "
|
||
"to detect such cycles, but the garbage collector might run some time after "
|
||
"the last reference to your data structure vanishes, so your :meth:`__del__` "
|
||
"method may be called at an inconvenient and random time. This is "
|
||
"inconvenient if you're trying to reproduce a problem. Worse, the order in "
|
||
"which object's :meth:`__del__` methods are executed is arbitrary. You can "
|
||
"run :func:`gc.collect` to force a collection, but there *are* pathological "
|
||
"cases where objects will never be collected."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1639
|
||
msgid ""
|
||
"Despite the cycle collector, it's still a good idea to define an explicit "
|
||
"``close()`` method on objects to be called whenever you're done with them. "
|
||
"The ``close()`` method can then remove attributes that refer to subobjecs. "
|
||
"Don't call :meth:`__del__` directly -- :meth:`__del__` should call "
|
||
"``close()`` and ``close()`` should make sure that it can be called more than "
|
||
"once for the same object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1646
|
||
msgid ""
|
||
"Another way to avoid cyclical references is to use the :mod:`weakref` "
|
||
"module, which allows you to point to objects without incrementing their "
|
||
"reference count. Tree data structures, for instance, should use weak "
|
||
"references for their parent and sibling references (if they need them!)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1659
|
||
msgid ""
|
||
"Finally, if your :meth:`__del__` method raises an exception, a warning "
|
||
"message is printed to :data:`sys.stderr`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1664
|
||
msgid "How do I get a list of all instances of a given class?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1666
|
||
msgid ""
|
||
"Python does not keep track of all instances of a class (or of a built-in "
|
||
"type). You can program the class's constructor to keep track of all "
|
||
"instances by keeping a list of weak references to each instance."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1672
|
||
msgid "Why does the result of ``id()`` appear to be not unique?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1674
|
||
msgid ""
|
||
"The :func:`id` builtin returns an integer that is guaranteed to be unique "
|
||
"during the lifetime of the object. Since in CPython, this is the object's "
|
||
"memory address, it happens frequently that after an object is deleted from "
|
||
"memory, the next freshly created object is allocated at the same position in "
|
||
"memory. This is illustrated by this example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1685
|
||
msgid ""
|
||
"The two ids belong to different integer objects that are created before, and "
|
||
"deleted immediately after execution of the ``id()`` call. To be sure that "
|
||
"objects whose id you want to examine are still alive, create another "
|
||
"reference to the object:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1698
|
||
msgid "Modules"
|
||
msgstr "Modules"
|
||
|
||
#: ../Doc/faq/programming.rst:1701
|
||
msgid "How do I create a .pyc file?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1703
|
||
msgid ""
|
||
"When a module is imported for the first time (or when the source file has "
|
||
"changed since the current compiled file was created) a ``.pyc`` file "
|
||
"containing the compiled code should be created in a ``__pycache__`` "
|
||
"subdirectory of the directory containing the ``.py`` file. The ``.pyc`` "
|
||
"file will have a filename that starts with the same name as the ``.py`` "
|
||
"file, and ends with ``.pyc``, with a middle component that depends on the "
|
||
"particular ``python`` binary that created it. (See :pep:`3147` for details.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1711
|
||
msgid ""
|
||
"One reason that a ``.pyc`` file may not be created is a permissions problem "
|
||
"with the directory containing the source file, meaning that the "
|
||
"``__pycache__`` subdirectory cannot be created. This can happen, for "
|
||
"example, if you develop as one user but run as another, such as if you are "
|
||
"testing with a web server."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1716
|
||
msgid ""
|
||
"Unless the :envvar:`PYTHONDONTWRITEBYTECODE` environment variable is set, "
|
||
"creation of a .pyc file is automatic if you're importing a module and Python "
|
||
"has the ability (permissions, free space, etc...) to create a "
|
||
"``__pycache__`` subdirectory and write the compiled module to that "
|
||
"subdirectory."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1721
|
||
msgid ""
|
||
"Running Python on a top level script is not considered an import and no ``."
|
||
"pyc`` will be created. For example, if you have a top-level module ``foo."
|
||
"py`` that imports another module ``xyz.py``, when you run ``foo`` (by typing "
|
||
"``python foo.py`` as a shell command), a ``.pyc`` will be created for "
|
||
"``xyz`` because ``xyz`` is imported, but no ``.pyc`` file will be created "
|
||
"for ``foo`` since ``foo.py`` isn't being imported."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1728
|
||
msgid ""
|
||
"If you need to create a ``.pyc`` file for ``foo`` -- that is, to create a ``."
|
||
"pyc`` file for a module that is not imported -- you can, using the :mod:"
|
||
"`py_compile` and :mod:`compileall` modules."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1732
|
||
msgid ""
|
||
"The :mod:`py_compile` module can manually compile any module. One way is to "
|
||
"use the ``compile()`` function in that module interactively::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1738
|
||
msgid ""
|
||
"This will write the ``.pyc`` to a ``__pycache__`` subdirectory in the same "
|
||
"location as ``foo.py`` (or you can override that with the optional parameter "
|
||
"``cfile``)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1742
|
||
msgid ""
|
||
"You can also automatically compile all files in a directory or directories "
|
||
"using the :mod:`compileall` module. You can do it from the shell prompt by "
|
||
"running ``compileall.py`` and providing the path of a directory containing "
|
||
"Python files to compile::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1751
|
||
msgid "How do I find the current module name?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1753
|
||
msgid ""
|
||
"A module can find out its own module name by looking at the predefined "
|
||
"global variable ``__name__``. If this has the value ``'__main__'``, the "
|
||
"program is running as a script. Many modules that are usually used by "
|
||
"importing them also provide a command-line interface or a self-test, and "
|
||
"only execute this code after checking ``__name__``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1768
|
||
msgid "How can I have modules that mutually import each other?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1770
|
||
msgid "Suppose you have the following modules:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1772
|
||
msgid "foo.py::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1777
|
||
msgid "bar.py::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1782
|
||
msgid "The problem is that the interpreter will perform the following steps:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1784
|
||
msgid "main imports foo"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1785
|
||
msgid "Empty globals for foo are created"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1786
|
||
msgid "foo is compiled and starts executing"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1787
|
||
msgid "foo imports bar"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1788
|
||
msgid "Empty globals for bar are created"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1789
|
||
msgid "bar is compiled and starts executing"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1790
|
||
msgid ""
|
||
"bar imports foo (which is a no-op since there already is a module named foo)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1791
|
||
msgid "bar.foo_var = foo.foo_var"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1793
|
||
msgid ""
|
||
"The last step fails, because Python isn't done with interpreting ``foo`` yet "
|
||
"and the global symbol dictionary for ``foo`` is still empty."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1796
|
||
msgid ""
|
||
"The same thing happens when you use ``import foo``, and then try to access "
|
||
"``foo.foo_var`` in global code."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1799
|
||
msgid "There are (at least) three possible workarounds for this problem."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1801
|
||
msgid ""
|
||
"Guido van Rossum recommends avoiding all uses of ``from <module> import ..."
|
||
"``, and placing all code inside functions. Initializations of global "
|
||
"variables and class variables should use constants or built-in functions "
|
||
"only. This means everything from an imported module is referenced as "
|
||
"``<module>.<name>``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1806
|
||
msgid ""
|
||
"Jim Roskind suggests performing steps in the following order in each module:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1808
|
||
msgid ""
|
||
"exports (globals, functions, and classes that don't need imported base "
|
||
"classes)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1810
|
||
msgid "``import`` statements"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1811
|
||
msgid ""
|
||
"active code (including globals that are initialized from imported values)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1813
|
||
msgid ""
|
||
"van Rossum doesn't like this approach much because the imports appear in a "
|
||
"strange place, but it does work."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1816
|
||
msgid ""
|
||
"Matthias Urlichs recommends restructuring your code so that the recursive "
|
||
"import is not necessary in the first place."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1819
|
||
msgid "These solutions are not mutually exclusive."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1823
|
||
msgid "__import__('x.y.z') returns <module 'x'>; how do I get z?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1825
|
||
msgid ""
|
||
"Consider using the convenience function :func:`~importlib.import_module` "
|
||
"from :mod:`importlib` instead::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1832
|
||
msgid ""
|
||
"When I edit an imported module and reimport it, the changes don't show up. "
|
||
"Why does this happen?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1834
|
||
msgid ""
|
||
"For reasons of efficiency as well as consistency, Python only reads the "
|
||
"module file on the first time a module is imported. If it didn't, in a "
|
||
"program consisting of many modules where each one imports the same basic "
|
||
"module, the basic module would be parsed and re-parsed many times. To force "
|
||
"re-reading of a changed module, do this::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1844
|
||
msgid ""
|
||
"Warning: this technique is not 100% fool-proof. In particular, modules "
|
||
"containing statements like ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1849
|
||
msgid ""
|
||
"will continue to work with the old version of the imported objects. If the "
|
||
"module contains class definitions, existing class instances will *not* be "
|
||
"updated to use the new class definition. This can result in the following "
|
||
"paradoxical behaviour:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/programming.rst:1862
|
||
msgid ""
|
||
"The nature of the problem is made clear if you print out the \"identity\" of "
|
||
"the class objects:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:7
|
||
msgid "Python on Windows FAQ"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:18
|
||
msgid "How do I run a Python program under Windows?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:20
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:0
|
||
msgid "|Python Development on XP|_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:27
|
||
msgid ""
|
||
"This series of screencasts aims to get you up and running with Python on "
|
||
"Windows XP. The knowledge is distilled into 1.5 hours and will get you up "
|
||
"and running with the right Python distribution, coding in your choice of "
|
||
"IDE, and debugging and writing solid code with unit-tests."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:36
|
||
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 Start menu; under Windows 7 the menu selection is :menuselection:"
|
||
"`Start --> Programs --> Accessories --> Command Prompt`. 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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:46
|
||
msgid ""
|
||
"The letter may be different, and there might be other things after it, so "
|
||
"you might just as easily see something like::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:51
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:55
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:60
|
||
msgid ""
|
||
"First, you need to make sure that your command window recognises the word "
|
||
"\"python\" as an instruction to start the interpreter. If you have opened a "
|
||
"command window, you should try entering the command ``python`` and hitting "
|
||
"return.::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:67
|
||
msgid "You should then see something like::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:73
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:83
|
||
msgid ""
|
||
"Many people use the interactive mode as a convenient yet highly programmable "
|
||
"calculator. When you want to end your interactive Python session, 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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:88
|
||
msgid ""
|
||
"You may also find that you have a Start-menu entry such as :menuselection:"
|
||
"`Start --> Programs --> Python 3.3 --> Python (command line)` that results "
|
||
"in you seeing the ``>>>`` prompt in a new window. If so, the window will "
|
||
"disappear after you 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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:94
|
||
msgid ""
|
||
"If the ``python`` command, instead of displaying the interpreter prompt "
|
||
"``>>>``, gives you a message like::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:0
|
||
msgid "|Adding Python to DOS Path|_"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:102
|
||
msgid ""
|
||
"Python is not added to the DOS path by default. This screencast will walk "
|
||
"you through the steps to add the correct entry to the `System Path`, "
|
||
"allowing Python to be executed from the command-line by all users."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:111
|
||
msgid "or::"
|
||
msgstr "ou : ::"
|
||
|
||
#: ../Doc/faq/windows.rst:115
|
||
msgid ""
|
||
"then you need to make sure that your computer knows where to find the Python "
|
||
"interpreter. To do this you will have to modify a setting called PATH, "
|
||
"which is a list of directories where Windows will look for programs."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:119
|
||
msgid ""
|
||
"You should arrange for Python's installation directory to be added to the "
|
||
"PATH of every command window as it starts. If you installed Python fairly "
|
||
"recently then the command ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:125
|
||
msgid ""
|
||
"will probably tell you where it is installed; the usual location is "
|
||
"something like ``C:\\Python33``. Otherwise you will be reduced to a search "
|
||
"of your whole disk ... use :menuselection:`Tools --> Find` or hit the :"
|
||
"guilabel:`Search` button and look for \"python.exe\". Supposing you "
|
||
"discover that Python is installed in the ``C:\\Python33`` directory (the "
|
||
"default at the time of writing), you should make sure that entering the "
|
||
"command ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:134
|
||
msgid ""
|
||
"starts up the interpreter as above (and don't forget you'll need a \":kbd:"
|
||
"`Ctrl-Z`\" and an \":kbd:`Enter`\" to get out of it). Once you have verified "
|
||
"the directory, you can add it to the system path to make it easier to start "
|
||
"Python by just running the ``python`` command. This is currently an option "
|
||
"in the installer as of CPython 3.3."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:140
|
||
msgid ""
|
||
"More information about environment variables can be found on the :ref:`Using "
|
||
"Python on Windows <setting-envvars>` page."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:144
|
||
msgid "How do I make Python scripts executable?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:146
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:154
|
||
msgid "Why does Python sometimes take so long to start?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:156
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:161
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:171
|
||
msgid "How do I make an executable from a Python script?"
|
||
msgstr "Comment construire un exécutable depuis un script Python ?"
|
||
|
||
#: ../Doc/faq/windows.rst:173
|
||
msgid ""
|
||
"See http://cx-freeze.sourceforge.net/ 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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:181
|
||
msgid "Is a ``*.pyd`` file the same as a DLL?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:183
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:190
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:199
|
||
msgid "How can I embed Python into a Windows application?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:201
|
||
msgid ""
|
||
"Embedding the Python interpreter in a Windows app can be summarized as "
|
||
"follows:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:203
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:209
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:215
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:222
|
||
msgid ""
|
||
"Borland note: convert :file:`python{NN}.lib` to OMF format using Coff2Omf."
|
||
"exe first."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:227
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:233
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:239
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:243
|
||
msgid ""
|
||
"In short, you can use the following code to initialize the Python "
|
||
"interpreter with your extension module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:254
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:257
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:262
|
||
msgid ""
|
||
"Problem 2: SWIG generates the following code when generating wrappers to "
|
||
"void functions:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:271
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:279
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:283
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:292
|
||
msgid "How do I keep editors from inserting tabs into my Python source?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:294
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:298
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:303
|
||
msgid ""
|
||
"If you suspect mixed tabs and spaces are causing problems in leading "
|
||
"whitespace, run Python with the :option:`-t` switch or run ``Tools/Scripts/"
|
||
"tabnanny.py`` to check a directory tree in batch mode."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:309
|
||
msgid "How do I check for a keypress without blocking?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:311
|
||
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 ""
|
||
|
||
#: ../Doc/faq/windows.rst:317
|
||
msgid "How do I emulate os.kill() in Windows?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:319
|
||
msgid ""
|
||
"Prior to Python 2.7 and 3.2, to terminate a process, you can use :mod:"
|
||
"`ctypes`::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:329
|
||
msgid ""
|
||
"In 2.7 and 3.2, :func:`os.kill` is implemented similar to the above "
|
||
"function, with the additional feature of being able to send :kbd:`Ctrl+C` "
|
||
"and :kbd:`Ctrl+Break` to console subprocesses which are designed to handle "
|
||
"those signals. See :func:`os.kill` for further details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:335
|
||
msgid "How do I extract the downloaded documentation on Windows?"
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:337
|
||
msgid ""
|
||
"Sometimes, when you download the documentation package to a Windows machine "
|
||
"using a web browser, the file extension of the saved file ends up being ."
|
||
"EXE. This is a mistake; the extension should be .TGZ."
|
||
msgstr ""
|
||
|
||
#: ../Doc/faq/windows.rst:341
|
||
msgid ""
|
||
"Simply rename the downloaded file to have the .TGZ extension, and WinZip "
|
||
"will be able to handle it. (If your copy of WinZip doesn't, get a newer one "
|
||
"from https://www.winzip.com.)"
|
||
msgstr ""
|