forked from AFPy/python-docs-fr
6221 lines
228 KiB
Plaintext
6221 lines
228 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 1990-2015, 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.5\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2015-12-20 13:15+0100\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"
|
|
|
|
#: faq/design.rst:3
|
|
msgid "Design and History FAQ"
|
|
msgstr "FAQ Histoire et Design"
|
|
|
|
#: faq/design.rst:6
|
|
msgid "Why does Python use indentation for grouping of statements?"
|
|
msgstr "Pourquoi Python utilise l'indentation pour grouper les instructions ?"
|
|
|
|
#: 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."
|
|
|
|
#: 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::"
|
|
|
|
#: 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``."
|
|
|
|
#: 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."
|
|
|
|
#: 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, rendant plus compliqué un "
|
|
"aperçu global du programme. Idéalement, une fonction doit être visible sur "
|
|
"un même é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."
|
|
|
|
#: 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 ?"
|
|
|
|
#: faq/design.rst:43
|
|
msgid "See the next question."
|
|
msgstr "Voir la question suivante."
|
|
|
|
#: faq/design.rst:47
|
|
msgid "Why are floating-point calculations so inaccurate?"
|
|
msgstr "Pourquoi les calculs à virgules flottantes sont si imprécis ?"
|
|
|
|
#: 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 ::"
|
|
|
|
#: 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 bogue dans Python. Ça ne l'est pas. Ceci n'a rien à "
|
|
"voir avec Python, mais avec la manière dont la plateforme C sous-jacente "
|
|
"gère les nombres à virgule flottante et enfin, les imprécisions introduites "
|
|
"lors de l'écriture des nombres en chaînes de caractères d'un nombre fixe de "
|
|
"chiffres."
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:76
|
|
msgid "which is exactly::"
|
|
msgstr "qui donne le résultat ::"
|
|
|
|
#: faq/design.rst:80
|
|
msgid ""
|
|
"The typical precision of 53 bits provides Python floats with 15-16 decimal "
|
|
"digits of accuracy."
|
|
msgstr ""
|
|
|
|
#: 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."
|
|
|
|
#: faq/design.rst:88
|
|
msgid "Why are Python strings immutable?"
|
|
msgstr "Pourquoi les chaînes de caractères Python sont-elles immuable ?"
|
|
|
|
#: faq/design.rst:90
|
|
msgid "There are several advantages."
|
|
msgstr "Il y a plusieurs avantages."
|
|
|
|
#: 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é. C'est aussi l'une des raisons pour lesquelles "
|
|
"on fait la distinction entre les tuples et les listes."
|
|
|
|
#: 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."
|
|
|
|
#: 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 ?"
|
|
|
|
#: 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."
|
|
|
|
#: 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 "
|
|
"codages C++ et Java préfixent les attributs d'instance par ``m_``. Cette "
|
|
"syntaxe explicite est ainsi utile également pour ces langages."
|
|
|
|
#: 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."
|
|
|
|
#: 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."
|
|
|
|
#: 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 ?"
|
|
|
|
#: 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 :"
|
|
|
|
#: faq/design.rst:155
|
|
msgid "where in Python you're forced to write this::"
|
|
msgstr "où en Python vous êtes forcé à écrire ceci ::"
|
|
|
|
#: 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 :"
|
|
|
|
#: 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é."
|
|
|
|
#: 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."
|
|
|
|
#: 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."
|
|
|
|
#: 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`` ::"
|
|
|
|
#: 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."
|
|
|
|
#: 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 "
|
|
"boucler au travers d'objets en utilisant la déclaration ``for``. Par "
|
|
"exemple, dans la version actuelle de Python, les fichiers objets supportent "
|
|
"le protocole d'itérateur, vous pouvez alors simplement écrire ::"
|
|
|
|
#: 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)) ?"
|
|
|
|
#: 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 "
|
|
"fonctionnalités fonctionnelles de Python (``map()``, ``apply()`` et autres)."
|
|
|
|
#: 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."
|
|
|
|
#: 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."
|
|
|
|
#: 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 ?"
|
|
|
|
#: 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 ::"
|
|
|
|
#: faq/design.rst:244
|
|
msgid "which gives the result::"
|
|
msgstr "qui donne le résultat ::"
|
|
|
|
#: faq/design.rst:248
|
|
msgid "There are two common arguments against this usage."
|
|
msgstr "Il y a deux arguments fréquents contre cet usage."
|
|
|
|
#: 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."
|
|
|
|
#: 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 ::"
|
|
|
|
#: 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)."
|
|
|
|
#: 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 autour d'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."
|
|
|
|
#: faq/design.rst:274
|
|
msgid "How fast are exceptions?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:300
|
|
msgid "Why isn't there a switch or case statement in Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:339
|
|
msgid ""
|
|
"Can't you emulate threads in the interpreter instead of relying on an OS-"
|
|
"specific thread implementation?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:351
|
|
msgid "Why can't lambda expressions contain statements?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:367
|
|
msgid "Can Python be compiled to machine code, C or some other language?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:369
|
|
msgid "Practical answer:"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:371
|
|
msgid ""
|
|
"`Cython <http://cython.org/>`_ and `Pyrex <http://www.cosc.canterbury.ac.nz/"
|
|
"greg.ewing/python/Pyrex/>`_ compile a modified version of Python with "
|
|
"optional annotations into C extensions. `Weave <http://docs.scipy.org/doc/"
|
|
"scipy-dev/reference/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 ""
|
|
|
|
#: faq/design.rst:378
|
|
msgid "Theoretical answer:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:399
|
|
msgid "How does Python manage memory?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:437
|
|
msgid "Why doesn't CPython use a more traditional garbage collection scheme?"
|
|
msgstr "Pourquoi Python utilise l'indentation pour grouper les instructions ?"
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:454
|
|
msgid "Why isn't all memory freed when CPython exits?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:468
|
|
msgid "Why are there separate tuple and list data types?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:491
|
|
msgid "How are lists implemented?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:507
|
|
msgid "How are dictionaries implemented?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:528
|
|
msgid "Why must dictionary keys be immutable?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:543
|
|
msgid "Some unacceptable solutions that have been proposed:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/design.rst:592
|
|
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 ""
|
|
|
|
#: faq/design.rst:596
|
|
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 ""
|
|
|
|
#: faq/design.rst:601
|
|
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 ""
|
|
|
|
#: faq/design.rst:608
|
|
msgid "Why doesn't list.sort() return the sorted list?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:610
|
|
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 ""
|
|
|
|
#: faq/design.rst:616
|
|
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 ""
|
|
|
|
#: faq/design.rst:626
|
|
msgid "How do you specify and enforce an interface spec in Python?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:628
|
|
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 ""
|
|
|
|
#: faq/design.rst:633
|
|
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 ""
|
|
|
|
#: faq/design.rst:640
|
|
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 ""
|
|
|
|
#: faq/design.rst:644
|
|
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 ""
|
|
|
|
#: faq/design.rst:652
|
|
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 ""
|
|
|
|
#: faq/design.rst:660
|
|
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 ""
|
|
|
|
#: faq/design.rst:668
|
|
msgid "Why is there no goto?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:670
|
|
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 ""
|
|
|
|
#: faq/design.rst:685
|
|
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 ""
|
|
|
|
#: faq/design.rst:690
|
|
msgid "Why can't raw strings (r-strings) end with a backslash?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:692
|
|
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 ""
|
|
|
|
#: faq/design.rst:696
|
|
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 ""
|
|
|
|
#: faq/design.rst:703
|
|
msgid ""
|
|
"If you're trying to build Windows pathnames, note that all Windows system "
|
|
"calls accept forward slashes too::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:708
|
|
msgid ""
|
|
"If you're trying to build a pathname for a DOS command, try e.g. one of ::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:716
|
|
msgid "Why doesn't Python have a \"with\" statement for attribute assignments?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:718
|
|
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 ""
|
|
|
|
#: faq/design.rst:726
|
|
msgid "In Python, such a construct would be ambiguous."
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:728
|
|
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 ""
|
|
|
|
#: faq/design.rst:733
|
|
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 ""
|
|
|
|
#: faq/design.rst:739
|
|
msgid "For instance, take the following incomplete snippet::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:745
|
|
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 ""
|
|
|
|
#: faq/design.rst:751
|
|
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 ""
|
|
|
|
#: faq/design.rst:758
|
|
msgid "write this::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:765
|
|
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 ""
|
|
|
|
#: faq/design.rst:771
|
|
msgid "Why are colons required for the if/while/def/class statements?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:773
|
|
msgid ""
|
|
"The colon is required primarily to enhance readability (one of the results "
|
|
"of the experimental ABC language). Consider this::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:779
|
|
msgid "versus ::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:784
|
|
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 ""
|
|
|
|
#: faq/design.rst:787
|
|
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 ""
|
|
|
|
#: faq/design.rst:793
|
|
msgid "Why does Python allow commas at the end of lists and tuples?"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:795
|
|
msgid ""
|
|
"Python lets you add a trailing comma at the end of lists, tuples, and "
|
|
"dictionaries::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:806
|
|
msgid "There are several reasons to allow this."
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:808
|
|
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 ""
|
|
|
|
#: faq/design.rst:813
|
|
msgid ""
|
|
"Accidentally omitting the comma can lead to errors that are hard to "
|
|
"diagnose. For example::"
|
|
msgstr ""
|
|
|
|
#: faq/design.rst:823
|
|
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 ""
|
|
|
|
#: faq/design.rst:826
|
|
msgid ""
|
|
"Allowing the trailing comma may also make programmatic code generation "
|
|
"easier."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:3
|
|
msgid "Extending/Embedding FAQ"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:16
|
|
msgid "Can I create my own functions in C?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:22
|
|
msgid "Most intermediate or advanced Python books will also cover this topic."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:26
|
|
msgid "Can I create my own functions in C++?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:37
|
|
msgid "Writing C is hard; are there any alternatives?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:44
|
|
msgid ""
|
|
"`Cython <http://cython.org>`_ and its relative `Pyrex <http://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 ""
|
|
|
|
#: 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 "
|
|
"<http://www.riverbankcomputing.co.uk/software/sip/intro>`__, `CXX <http://"
|
|
"cxx.sourceforge.net/>`_ `Boost <http://www.boost.org/libs/python/doc/index."
|
|
"html>`_, or `Weave <http://docs.scipy.org/doc/scipy-dev/reference/tutorial/"
|
|
"weave.html>`_ are also alternatives for wrapping C++ libraries."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:61
|
|
msgid "How can I execute arbitrary Python statements from C?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:72
|
|
msgid "How can I evaluate an arbitrary Python expression from C?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:80
|
|
msgid "How do I extract C values from a Python object?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:104
|
|
msgid "How do I use Py_BuildValue() to create a tuple of arbitrary length?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:106
|
|
msgid "You can't. Use :c:func:`PyTuple_Pack` instead."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:110
|
|
msgid "How do I call an object's method from C?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:142
|
|
msgid ""
|
|
"How do I catch the output from PyErr_Print() (or anything that prints to "
|
|
"stdout/stderr)?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/extending.rst:149
|
|
msgid "The easiest way to do this is to use the :class:`io.StringIO` class::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:159
|
|
msgid "A custom object to do the same would look like this::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:178
|
|
msgid "How do I access a module written in Python from C?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:180
|
|
msgid "You can get a pointer to the module object as follows::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:184
|
|
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 ""
|
|
|
|
#: faq/extending.rst:190
|
|
msgid ""
|
|
"You can then access the module's attributes (i.e. any name defined in the "
|
|
"module) as follows::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:195
|
|
msgid ""
|
|
"Calling :c:func:`PyObject_SetAttrString` to assign to variables in the "
|
|
"module also works."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:200
|
|
msgid "How do I interface to C++ objects from Python?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:202
|
|
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 ""
|
|
|
|
#: faq/extending.rst:208
|
|
msgid "For C++ libraries, see :ref:`c-wrapper-software`."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:212
|
|
msgid "I added a module using the Setup file and the make fails; why?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:214
|
|
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 ""
|
|
|
|
#: faq/extending.rst:220
|
|
msgid "How do I debug an extension?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:222
|
|
msgid ""
|
|
"When using GDB with dynamically loaded extensions, you can't set a "
|
|
"breakpoint in your extension until your extension is loaded."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:225
|
|
msgid "In your ``.gdbinit`` file (or interactively), add the command::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:229
|
|
msgid "Then, when you run GDB::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:239
|
|
msgid ""
|
|
"I want to compile a Python module on my Linux system, but some files are "
|
|
"missing. Why?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:241
|
|
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 ""
|
|
|
|
#: faq/extending.rst:245
|
|
msgid "For Red Hat, install the python-devel RPM to get the necessary files."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:247
|
|
msgid "For Debian, run ``apt-get install python-dev``."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:251
|
|
msgid ""
|
|
"What does \"SystemError: _PyImport_FixupExtension: module yourmodule not "
|
|
"loaded\" mean?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:253
|
|
msgid ""
|
|
"This means that you have created an extension module named \"yourmodule\", "
|
|
"but your module init function does not initialize with that name."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:256
|
|
msgid "Every module init function will have a line similar to::"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:260
|
|
msgid ""
|
|
"If the string passed to this function is not the same name as your extension "
|
|
"module, the :exc:`SystemError` exception will be raised."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:265
|
|
msgid "How do I tell \"incomplete input\" from \"invalid input\"?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:267
|
|
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 ""
|
|
|
|
#: faq/extending.rst:273
|
|
msgid ""
|
|
"In Python you can use the :mod:`codeop` module, which approximates the "
|
|
"parser's behavior sufficiently. IDLE uses this, for example."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:276
|
|
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 ""
|
|
|
|
#: faq/extending.rst:282
|
|
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 ""
|
|
|
|
#: faq/extending.rst:315
|
|
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 ""
|
|
|
|
#: faq/extending.rst:436
|
|
msgid "How do I find undefined g++ symbols __builtin_new or __pure_virtual?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:438
|
|
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 ""
|
|
|
|
#: faq/extending.rst:444
|
|
msgid ""
|
|
"Can I create an object class with some methods implemented in C and others "
|
|
"in Python (e.g. through inheritance)?"
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:446
|
|
msgid ""
|
|
"Yes, you can inherit from built-in classes such as :class:`int`, :class:"
|
|
"`list`, :class:`dict`, etc."
|
|
msgstr ""
|
|
|
|
#: faq/extending.rst:449
|
|
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 ""
|
|
|
|
#: faq/general.rst:5
|
|
msgid "General Python FAQ"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:13
|
|
msgid "General Information"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:16 faq/installed.rst:6
|
|
msgid "What is Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/general.rst:33
|
|
msgid "What is the Python Software Foundation?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/general.rst:47
|
|
msgid "Are there copyright restrictions on the use of Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/general.rst:65
|
|
msgid "Why was Python created in the first place?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:67
|
|
msgid ""
|
|
"Here's a *very* brief summary of what started it all, written by Guido van "
|
|
"Rossum:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/general.rst:108
|
|
msgid "What is Python good for?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/general.rst:125
|
|
msgid "How does the Python version numbering scheme work?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 Subversion trunk. In "
|
|
"practice, after a final minor release is made, the Subversion trunk is "
|
|
"incremented to the next minor version, which becomes the \"a0\" version, e."
|
|
"g. \"2.4a0\"."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:154
|
|
msgid ""
|
|
"See also the documentation for :data:`sys.version`, :data:`sys.hexversion`, "
|
|
"and :data:`sys.version_info`."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:159
|
|
msgid "How do I obtain a copy of the Python source?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:161
|
|
msgid ""
|
|
"The latest Python source distribution is always available from python.org, "
|
|
"at https://www.python.org/download/. The latest development sources can be "
|
|
"obtained via anonymous Mercurial access at https://hg.python.org/cpython."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:165
|
|
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 ""
|
|
|
|
#: faq/general.rst:170
|
|
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 ""
|
|
|
|
#: faq/general.rst:176
|
|
msgid "How do I get documentation on Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:180
|
|
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 ""
|
|
|
|
#: faq/general.rst:184
|
|
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 ""
|
|
|
|
#: faq/general.rst:190
|
|
msgid "I've never programmed before. Is there a Python tutorial?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:192
|
|
msgid ""
|
|
"There are numerous tutorials and books available. The standard "
|
|
"documentation includes :ref:`tutorial-index`."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:195
|
|
msgid ""
|
|
"Consult `the Beginner's Guide <https://wiki.python.org/moin/"
|
|
"BeginnersGuide>`_ to find information for beginning Python programmers, "
|
|
"including lists of tutorials."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:200
|
|
msgid "Is there a newsgroup or mailing list devoted to Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:202
|
|
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 ""
|
|
|
|
#: faq/general.rst:209
|
|
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 ""
|
|
|
|
#: faq/general.rst:214
|
|
msgid ""
|
|
"More info about other mailing lists and newsgroups can be found at https://"
|
|
"www.python.org/community/lists/."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:219
|
|
msgid "How do I get a beta test version of Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:221
|
|
msgid ""
|
|
"Alpha and beta releases are available from https://www.python.org/"
|
|
"download/. 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 ""
|
|
|
|
#: faq/general.rst:226
|
|
msgid ""
|
|
"You can also access the development version of Python through Mercurial. "
|
|
"See https://docs.python.org/devguide/faq.html for details."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:231
|
|
msgid "How do I submit bug reports and patches for Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:233
|
|
msgid ""
|
|
"To report a bug or submit a patch, please use the Roundup installation at "
|
|
"https://bugs.python.org/."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:236
|
|
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 ""
|
|
|
|
#: faq/general.rst:242
|
|
msgid ""
|
|
"For more information on how Python is developed, consult `the Python "
|
|
"Developer's Guide <https://docs.python.org/devguide/>`_."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:247
|
|
msgid "Are there any published articles about Python that I can reference?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:249
|
|
msgid "It's probably best to cite your favorite book about Python."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:251
|
|
msgid ""
|
|
"The very first article about Python was written in 1991 and is now quite "
|
|
"outdated."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:254
|
|
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 ""
|
|
|
|
#: faq/general.rst:260
|
|
msgid "Are there any books on Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:262
|
|
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 ""
|
|
|
|
#: faq/general.rst:265
|
|
msgid ""
|
|
"You can also search online bookstores for \"Python\" and filter out the "
|
|
"Monty Python references; or perhaps search for \"Python\" and \"language\"."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:270
|
|
msgid "Where in the world is www.python.org located?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:272
|
|
msgid ""
|
|
"The Python project's infrastructure is located all over the world. `www."
|
|
"python.org <https://www.python.org>`_ is graciously hosted by `Rackspace "
|
|
"<http://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 ""
|
|
|
|
#: faq/general.rst:283
|
|
msgid "Why is it called Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:285
|
|
msgid ""
|
|
"When he began implementing Python, Guido van Rossum was also reading the "
|
|
"published scripts from `\"Monty Python's Flying Circus\" <http://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 ""
|
|
|
|
#: faq/general.rst:293
|
|
msgid "Do I have to like \"Monty Python's Flying Circus\"?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:295
|
|
msgid "No, but it helps. :)"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:299
|
|
msgid "Python in the real world"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:302
|
|
msgid "How stable is Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:304
|
|
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 ""
|
|
|
|
#: faq/general.rst:308
|
|
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 ""
|
|
|
|
#: faq/general.rst:315
|
|
msgid ""
|
|
"The latest stable releases can always be found on the `Python download page "
|
|
"<https://www.python.org/download/>`_. 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 ""
|
|
|
|
#: faq/general.rst:324
|
|
msgid "How many people are using Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:326
|
|
msgid ""
|
|
"There are probably tens of thousands of users, though it's difficult to "
|
|
"obtain an exact count."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:329
|
|
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 ""
|
|
|
|
#: faq/general.rst:333
|
|
msgid ""
|
|
"The comp.lang.python newsgroup is very active, but not all Python users post "
|
|
"to the group or even read it."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:338
|
|
msgid "Have any significant projects been done in Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:340
|
|
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 ""
|
|
|
|
#: faq/general.rst:345
|
|
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 <http://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 ""
|
|
|
|
#: faq/general.rst:354
|
|
msgid "What new developments are expected for Python in the future?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:356
|
|
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 ""
|
|
|
|
#: faq/general.rst:362
|
|
msgid ""
|
|
"New development is discussed on `the python-dev mailing list <https://mail."
|
|
"python.org/mailman/listinfo/python-dev/>`_."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:367
|
|
msgid "Is it reasonable to propose incompatible changes to Python?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:369
|
|
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 ""
|
|
|
|
#: faq/general.rst:376
|
|
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 ""
|
|
|
|
#: faq/general.rst:382
|
|
msgid "Is Python a good language for beginning programmers?"
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:384 faq/library.rst:787 faq/programming.rst:17
|
|
#: faq/programming.rst:60
|
|
msgid "Yes."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:386
|
|
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 ""
|
|
|
|
#: faq/general.rst:396
|
|
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 ""
|
|
|
|
#: faq/general.rst:404
|
|
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 ""
|
|
|
|
#: faq/general.rst:413
|
|
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 ""
|
|
|
|
#: faq/general.rst:442
|
|
msgid ""
|
|
"With the interpreter, documentation is never far from the student as he's "
|
|
"programming."
|
|
msgstr ""
|
|
|
|
#: faq/general.rst:445
|
|
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 ""
|
|
|
|
#: faq/general.rst:453
|
|
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 ""
|
|
|
|
#: faq/gui.rst:5
|
|
msgid "Graphic User Interface FAQ"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:15
|
|
msgid "General GUI Questions"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:18
|
|
msgid "What platform-independent GUI toolkits exist for Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:27
|
|
msgid "Tkinter"
|
|
msgstr ""
|
|
|
|
#: 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/download/>`_ of Python) and use. For more info about Tk, "
|
|
"including pointers to the source, see the `Tcl/Tk home page <http://www.tcl."
|
|
"tk>`_. Tcl/Tk is fully portable to the Mac OS X, Windows, and Unix "
|
|
"platforms."
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:38
|
|
msgid "wxWidgets"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:40
|
|
msgid ""
|
|
"wxWidgets (http://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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:58
|
|
msgid "Qt"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:60
|
|
msgid ""
|
|
"There are bindings available for the Qt toolkit (using either `PyQt <http://"
|
|
"www.riverbankcomputing.co.uk/software/pyqt/intro>`_ or `PySide <http://www."
|
|
"pyside.org/>`_) and for KDE (`PyKDE <https://techbase.kde.org/Development/"
|
|
"Languages/Python>`__). PyQt is currently more mature than PySide, but you "
|
|
"must buy a PyQt license from `Riverbank Computing <http://www."
|
|
"riverbankcomputing.co.uk/software/pyqt/license>`_ if you want to write "
|
|
"proprietary applications. PySide is free for all applications."
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:67
|
|
msgid ""
|
|
"Qt 4.5 upwards is licensed under the LGPL license; also, commercial licenses "
|
|
"are available from `The Qt Company <http://www.qt.io/licensing/>`_."
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:71
|
|
msgid "Gtk+"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:73
|
|
msgid ""
|
|
"The `GObject introspection bindings <https://live.gnome.org/PyGObject>`_ for "
|
|
"Python allow you to write GTK+ 3 applications. There is also a `Python GTK+ "
|
|
"3 Tutorial <http://python-gtk-3-tutorial.readthedocs.org/en/latest/>`_."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:81
|
|
msgid "FLTK"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:89
|
|
msgid "FOX"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:97
|
|
msgid "OpenGL"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:99
|
|
msgid "For OpenGL bindings, see `PyOpenGL <http://pyopengl.sourceforge.net>`_."
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:103
|
|
msgid "What platform-specific GUI toolkits exist for Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:115
|
|
msgid "Tkinter questions"
|
|
msgstr ""
|
|
|
|
#: faq/gui.rst:118
|
|
msgid "How do I freeze Tkinter applications?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:140
|
|
msgid "Can I have Tk events handled while waiting for I/O?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/gui.rst:150
|
|
msgid "I can't get key bindings to work in Tkinter: why?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/index.rst:5
|
|
msgid "Python Frequently Asked Questions"
|
|
msgstr ""
|
|
|
|
#: faq/installed.rst:3
|
|
msgid "\"Why is Python Installed on my Computer?\" FAQ"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/installed.rst:18
|
|
msgid "Why is Python installed on my machine?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/installed.rst:38
|
|
msgid "Can I delete Python?"
|
|
msgstr ""
|
|
|
|
#: faq/installed.rst:40
|
|
msgid "That depends on where Python came from."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:5
|
|
msgid "Library and Extension FAQ"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:12
|
|
msgid "General Library Questions"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:15
|
|
msgid "How do I find a module or application to perform task X?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:28
|
|
msgid "Where is the math.py (socket.py, regex.py, etc.) source file?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:35
|
|
msgid "There are (at least) three kinds of modules in Python:"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:37
|
|
msgid "modules written in Python (.py);"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:38
|
|
msgid ""
|
|
"modules written in C and dynamically loaded (.dll, .pyd, .so, .sl, etc);"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:39
|
|
msgid ""
|
|
"modules written in C and linked with the interpreter; to get a list of "
|
|
"these, type::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:47
|
|
msgid "How do I make a Python script executable on Unix?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:53
|
|
msgid ""
|
|
"The first is done by executing ``chmod +x scriptfile`` or perhaps ``chmod "
|
|
"755 scriptfile``."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:56
|
|
msgid ""
|
|
"The second can be done in a number of ways. The most straightforward way is "
|
|
"to write ::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:92
|
|
msgid "Is there a curses/termcap package for Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:107
|
|
msgid ""
|
|
"For Windows: use `the consolelib module <http://effbot.org/zone/console-"
|
|
"index.htm>`_."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:112
|
|
msgid "Is there an equivalent to C's onexit() in Python?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:114
|
|
msgid ""
|
|
"The :mod:`atexit` module provides a register function that is similar to "
|
|
"C's :c:func:`onexit`."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:119
|
|
msgid "Why don't my signal handlers work?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:126
|
|
msgid "so it should be declared with two arguments::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:133
|
|
msgid "Common tasks"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:136
|
|
msgid "How do I test a Python program or component?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:142
|
|
msgid ""
|
|
"The :mod:`unittest` module is a fancier testing framework modelled on Java "
|
|
"and Smalltalk testing frameworks."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:153
|
|
msgid "The \"global main logic\" of your program may be as simple as ::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:158
|
|
msgid "at the bottom of the main module of your program."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:180
|
|
msgid "How do I create documentation from doc strings?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:189
|
|
msgid "How do I get a single keypress at a time?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:235
|
|
msgid "Threads"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:238
|
|
msgid "How do I program using threads?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:249
|
|
msgid "None of my threads seem to run: why?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/library.rst:268
|
|
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 ""
|
|
|
|
#: faq/library.rst:272
|
|
msgid "A simple fix is to add a tiny sleep to the start of the run function::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:284
|
|
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 ""
|
|
|
|
#: faq/library.rst:292
|
|
msgid "How do I parcel out work among a bunch of worker threads?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:294
|
|
msgid ""
|
|
"The easiest way is to use the new :mod:`concurrent.futures` module, "
|
|
"especially the :mod:`~concurrent.futures.ThreadPoolExecutor` class."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:297
|
|
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 ""
|
|
|
|
#: faq/library.rst:304
|
|
msgid "Here's a trivial example::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:342
|
|
msgid "When run, this will produce the following output:"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:360
|
|
msgid ""
|
|
"Consult the module's documentation for more details; the :class:`~queue."
|
|
"Queue` class provides a featureful interface."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:365
|
|
msgid "What kinds of global value mutation are thread-safe?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:367
|
|
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 ""
|
|
|
|
#: faq/library.rst:374
|
|
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 ""
|
|
|
|
#: faq/library.rst:379
|
|
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 ""
|
|
|
|
#: faq/library.rst:394
|
|
msgid "These aren't::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:401
|
|
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 ""
|
|
|
|
#: faq/library.rst:408
|
|
msgid "Can't we get rid of the Global Interpreter Lock?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:412
|
|
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 ""
|
|
|
|
#: faq/library.rst:417
|
|
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 ""
|
|
|
|
#: faq/library.rst:425
|
|
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 ""
|
|
|
|
#: faq/library.rst:433
|
|
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 ""
|
|
|
|
#: faq/library.rst:439
|
|
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 ""
|
|
|
|
#: faq/library.rst:448
|
|
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 ""
|
|
|
|
#: faq/library.rst:453
|
|
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 ""
|
|
|
|
#: faq/library.rst:458
|
|
msgid "Input and Output"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:461
|
|
msgid "How do I delete a file? (And other file questions...)"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:463
|
|
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 ""
|
|
|
|
#: faq/library.rst:467
|
|
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 ""
|
|
|
|
#: faq/library.rst:473
|
|
msgid "To rename a file, use ``os.rename(old_path, new_path)``."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:475
|
|
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 ""
|
|
|
|
#: faq/library.rst:480
|
|
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 ""
|
|
|
|
#: faq/library.rst:486
|
|
msgid "How do I copy a file?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:488
|
|
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 ""
|
|
|
|
#: faq/library.rst:493
|
|
msgid "How do I read (or write) binary data?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:495
|
|
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 ""
|
|
|
|
#: faq/library.rst:499
|
|
msgid ""
|
|
"For example, the following code reads two 2-byte integers and one 4-byte "
|
|
"integer in big-endian format from a file::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:508
|
|
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 ""
|
|
|
|
#: faq/library.rst:512
|
|
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 ""
|
|
|
|
#: faq/library.rst:517
|
|
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 ""
|
|
|
|
#: faq/library.rst:525
|
|
msgid "I can't seem to use os.read() on a pipe created with os.popen(); why?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:527
|
|
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 ""
|
|
|
|
#: faq/library.rst:614
|
|
msgid "How do I access the serial (RS232) port?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:616
|
|
msgid "For Win32, POSIX (Linux, BSD, etc.), Jython:"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:618
|
|
msgid "http://pyserial.sourceforge.net"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:620
|
|
msgid "For Unix, see a Usenet post by Mitch Chapman:"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:622
|
|
msgid "http://groups.google.com/groups?selm=34A04430.CF9@ohioee.com"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:626
|
|
msgid "Why doesn't closing sys.stdout (stdin, stderr) really close it?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:628
|
|
msgid ""
|
|
"Python :term:`file objects <file object>` are a high-level layer of "
|
|
"abstraction on low-level C file descriptors."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:631
|
|
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 ""
|
|
|
|
#: faq/library.rst:637
|
|
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 ""
|
|
|
|
#: faq/library.rst:642
|
|
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 ""
|
|
|
|
#: faq/library.rst:650
|
|
msgid "Or you can use the numeric constants 0, 1 and 2, respectively."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:654
|
|
msgid "Network/Internet Programming"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:657
|
|
msgid "What WWW tools are there for Python?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:659
|
|
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 ""
|
|
|
|
#: faq/library.rst:665
|
|
msgid ""
|
|
"A summary of available frameworks is maintained by Paul Boddie at https://"
|
|
"wiki.python.org/moin/WebProgramming\\ ."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:668
|
|
msgid ""
|
|
"Cameron Laird maintains a useful set of pages about Python web technologies "
|
|
"at http://phaseit.net/claird/comp.lang.python/web_python."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:673
|
|
msgid "How can I mimic CGI form submission (METHOD=POST)?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:675
|
|
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 ""
|
|
|
|
#: faq/library.rst:678
|
|
msgid "Yes. Here's a simple example that uses urllib.request::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:693
|
|
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 ""
|
|
|
|
#: faq/library.rst:701
|
|
msgid ":ref:`urllib-howto` for extensive examples."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:705
|
|
msgid "What module should I use to help with generating HTML?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:709
|
|
msgid ""
|
|
"You can find a collection of useful links on the `Web Programming wiki page "
|
|
"<https://wiki.python.org/moin/WebProgramming>`_."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:714
|
|
msgid "How do I send mail from a Python script?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:716
|
|
msgid "Use the standard library module :mod:`smtplib`."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:718
|
|
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 ""
|
|
|
|
#: faq/library.rst:738
|
|
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 ""
|
|
|
|
#: faq/library.rst:757
|
|
msgid "How do I avoid blocking in the connect() method of a socket?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:759
|
|
msgid ""
|
|
"The :mod:`select` module is commonly used to help with asynchronous I/O on "
|
|
"sockets."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:762
|
|
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 ""
|
|
|
|
#: faq/library.rst:769
|
|
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 ""
|
|
|
|
#: faq/library.rst:775
|
|
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 ""
|
|
|
|
#: faq/library.rst:782
|
|
msgid "Databases"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:785
|
|
msgid "Are there any interfaces to database packages in Python?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:789
|
|
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 ""
|
|
|
|
#: faq/library.rst:794
|
|
msgid ""
|
|
"Support for most relational databases is available. See the "
|
|
"`DatabaseProgramming wiki page <https://wiki.python.org/moin/"
|
|
"DatabaseProgramming>`_ for details."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:800
|
|
msgid "How do you implement persistent objects in Python?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:802
|
|
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 ""
|
|
|
|
#: faq/library.rst:809
|
|
msgid "Mathematics and Numerics"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:812
|
|
msgid "How do I generate random numbers in Python?"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:814
|
|
msgid ""
|
|
"The standard module :mod:`random` implements a random number generator. "
|
|
"Usage is simple::"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:820
|
|
msgid "This returns a random floating point number in the range [0, 1)."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:822
|
|
msgid ""
|
|
"There are also many other specialized generators in this module, such as:"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:824
|
|
msgid "``randrange(a, b)`` chooses an integer in the range [a, b)."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:825
|
|
msgid "``uniform(a, b)`` chooses a floating point number in the range [a, b)."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:826
|
|
msgid ""
|
|
"``normalvariate(mean, sdev)`` samples the normal (Gaussian) distribution."
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:828
|
|
msgid "Some higher-level functions operate on sequences directly, such as:"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:830
|
|
msgid "``choice(S)`` chooses random element from a given sequence"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:831
|
|
msgid "``shuffle(L)`` shuffles a list in-place, i.e. permutes it randomly"
|
|
msgstr ""
|
|
|
|
#: faq/library.rst:833
|
|
msgid ""
|
|
"There's also a ``Random`` class you can instantiate to create independent "
|
|
"multiple random number generators."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:5
|
|
msgid "Programming FAQ"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:12
|
|
msgid "General Questions"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:15
|
|
msgid ""
|
|
"Is there a source code level debugger with breakpoints, single-stepping, "
|
|
"etc.?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 <http://sourceforge.net/projects/pywin32/>`__ "
|
|
"project and as a part of the ActivePython distribution (see http://www."
|
|
"activestate.com/activepython\\ )."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:41
|
|
msgid ""
|
|
"`Eric <http://eric-ide.python-projects.org/>`_ is an IDE built on PyQt and "
|
|
"the Scintilla editing component."
|
|
msgstr ""
|
|
|
|
#: 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 "
|
|
"http://www.gnu.org/software/ddd."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:49
|
|
msgid ""
|
|
"There are a number of commercial Python IDEs that include graphical "
|
|
"debuggers. They include:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:52
|
|
msgid "Wing IDE (http://wingware.com/)"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:53
|
|
msgid "Komodo IDE (http://komodoide.com/)"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:54
|
|
msgid "PyCharm (https://www.jetbrains.com/pycharm/)"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:58
|
|
msgid "Is there a tool to help find bugs or perform static analysis?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:66
|
|
msgid ""
|
|
"`Pylint <http://www.logilab.org/projects/pylint>`_ 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. http://docs.pylint.org/ provides a full list of Pylint's features."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:76
|
|
msgid "How can I create a stand-alone binary from a Python script?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:101
|
|
msgid "http://www.py2exe.org/"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:103
|
|
msgid ""
|
|
"Another tool is Anthony Tuininga's `cx_Freeze <http://cx-freeze.sourceforge."
|
|
"net/>`_."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:107
|
|
msgid "Are there coding standards or a style guide for Python programs?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:109
|
|
msgid ""
|
|
"Yes. The coding style required for standard library modules is documented "
|
|
"as :pep:`8`."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:114
|
|
msgid "Core Language"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:117
|
|
msgid "Why am I getting an UnboundLocalError when the variable has a value?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:123
|
|
msgid "This code:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:131
|
|
msgid "works, but this code:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:138
|
|
msgid "results in an UnboundLocalError:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:152
|
|
msgid ""
|
|
"In the example above you can access the outer scope variable by declaring it "
|
|
"global:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:170
|
|
msgid ""
|
|
"You can do a similar thing in a nested scope using the :keyword:`nonlocal` "
|
|
"keyword:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:187
|
|
msgid "What are the rules for local and global variables in Python?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:203
|
|
msgid ""
|
|
"Why do lambdas defined in a loop with different values all return the same "
|
|
"result?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:205
|
|
msgid ""
|
|
"Assume you use a for loop to define a few different lambdas (or even plain "
|
|
"functions), e.g.::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:250
|
|
msgid ""
|
|
"Note that this behaviour is not peculiar to lambdas, but applies to regular "
|
|
"functions too."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:255
|
|
msgid "How do I share global variables across modules?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:263
|
|
msgid "config.py::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:267
|
|
msgid "mod.py::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:272
|
|
msgid "main.py::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:283
|
|
msgid "What are the \"best practices\" for using import in a module?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:294
|
|
msgid "It's good practice if you import modules in the following order:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:296
|
|
msgid "standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:299
|
|
msgid "locally-developed modules"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:333
|
|
msgid "Why are default values shared between objects?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:335
|
|
msgid ""
|
|
"This type of bug commonly bites neophyte programmers. Consider this "
|
|
"function::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:363
|
|
msgid "but::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:389
|
|
msgid ""
|
|
"How can I pass optional or keyword parameters from one function to another?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:410
|
|
msgid "What is the difference between arguments and parameters?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:420
|
|
msgid ""
|
|
"*foo*, *bar* and *kwargs* are parameters of ``func``. However, when calling "
|
|
"``func``, for example::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:425
|
|
msgid "the values ``42``, ``314``, and ``somevar`` are arguments."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:429
|
|
msgid "Why did changing list 'y' also change list 'x'?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:431
|
|
msgid "If you wrote code like::"
|
|
msgstr "In C++ you'd write"
|
|
|
|
#: faq/programming.rst:441
|
|
msgid ""
|
|
"you might be wondering why appending an element to ``y`` changed ``x`` too."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:443
|
|
msgid "There are two factors that produce this result:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:449
|
|
msgid ""
|
|
"Lists are :term:`mutable`, which means that you can change their content."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:455
|
|
msgid "If we instead assign an immutable object to ``x``::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:489
|
|
msgid "In other words:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:504
|
|
msgid "How do I write a function with output parameters (call by reference)?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:511
|
|
msgid "By returning a tuple of the results::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:522
|
|
msgid "This is almost always the clearest solution."
|
|
msgstr ""
|
|
|
|
#: 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é."
|
|
|
|
#: faq/programming.rst:526
|
|
msgid "By passing a mutable (changeable in-place) object::"
|
|
msgstr "En passant un objet mutable (modifiable par remplacement)::"
|
|
|
|
#: faq/programming.rst:536
|
|
msgid "By passing in a dictionary that gets mutated::"
|
|
msgstr "En utilisant un dictionnaire, qui est modifié (en place)."
|
|
|
|
#: faq/programming.rst:546
|
|
msgid "Or bundle up values in a class instance::"
|
|
msgstr "Ou regrouper les valeurs dans une instance de classe::"
|
|
|
|
#: 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é."
|
|
|
|
#: 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 résultats "
|
|
"multiples."
|
|
|
|
#: faq/programming.rst:568
|
|
msgid "How do you make a higher order function in Python?"
|
|
msgstr "Comment construire une fonction de grand ordre en Python?"
|
|
|
|
#: 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 appelable. Par exemple, supposons que vous "
|
|
"vouliez définir ``lineare (a, b)`` qui retourne une fonction ``f (x)`` qui "
|
|
"calcule la valeur ``a * x + b``. En utilisant les portées imbriquées::"
|
|
|
|
#: faq/programming.rst:579
|
|
msgid "Or using a callable object::"
|
|
msgstr "Ou en utilisant un objet appelable."
|
|
|
|
#: faq/programming.rst:589
|
|
msgid "In both cases, ::"
|
|
msgstr "dans les deux cas, ::"
|
|
|
|
#: faq/programming.rst:593
|
|
msgid "gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``."
|
|
msgstr "retourne un objet appelable tel que ``taxes(10e6) == 0.3 * 10e6 + 2``."
|
|
|
|
#: 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 appelables 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::"
|
|
|
|
#: faq/programming.rst:604
|
|
msgid "Object can encapsulate state for several methods::"
|
|
msgstr "Les objets peuvent encapsuler un état pour plusieurs méthodes::"
|
|
|
|
#: 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."
|
|
|
|
#: faq/programming.rst:627
|
|
msgid "How do I copy an object in Python?"
|
|
msgstr "Comment copier un objet en Python?"
|
|
|
|
#: 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 :funct:`copy.copy` ou :func:`copy.deepcopy` pour le cas "
|
|
"général. Tout les objets ne peuvent pas être copiés, mais la plupart peuvent."
|
|
|
|
#: 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` ::"
|
|
|
|
#: faq/programming.rst:637
|
|
msgid "Sequences can be copied by slicing::"
|
|
msgstr "Les séquences peuvent être copiées par tranches::"
|
|
|
|
#: 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?"
|
|
|
|
#: 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."
|
|
|
|
#: 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?"
|
|
|
|
#: 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 mots clés ``def`` et ``class``, à la "
|
|
"différence que la valeur est un objet appelable."
|
|
|
|
#: faq/programming.rst:670
|
|
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, même si elle a deux noms et "
|
|
"qu'elle est appelé 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."
|
|
|
|
#: faq/programming.rst:675
|
|
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 \"connaitre 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."
|
|
|
|
#: faq/programming.rst:680
|
|
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:"
|
|
|
|
#: faq/programming.rst:683
|
|
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 ""
|
|
"De la même manière que vous trouvez le nom du chat que vous avez trouvé dans "
|
|
"votre coure: le chat 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 est appelé est "
|
|
"de demander à tous vos voisins (namespaces) si c'est leur chat (object)…"
|
|
|
|
#: faq/programming.rst:688
|
|
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!"
|
|
|
|
#: faq/programming.rst:693
|
|
msgid "What's up with the comma operator's precedence?"
|
|
msgstr "Quel est le souci avec la précédente de l'opérateur virgule?"
|
|
|
|
#: faq/programming.rst:695
|
|
msgid "Comma is not an operator in Python. Consider this session::"
|
|
msgstr ""
|
|
"Virgule n'est pas un opérateur en Python. Observez la session suivante::"
|
|
|
|
#: faq/programming.rst:700
|
|
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::"
|
|
|
|
#: faq/programming.rst:705
|
|
msgid "not::"
|
|
msgstr "et non::"
|
|
|
|
#: faq/programming.rst:709
|
|
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 de 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."
|
|
|
|
#: faq/programming.rst:714
|
|
msgid "Is there an equivalent of C's \"?:\" ternary operator?"
|
|
msgstr "Existe-t'il un équivalent à l'opérateur \"?:\" ternaire du C?"
|
|
|
|
#: faq/programming.rst:716
|
|
msgid "Yes, there is. The syntax is as follows::"
|
|
msgstr ""
|
|
"Oui, cette fonctionnalité à été ajouté à partir de Python 2.5. La syntaxe "
|
|
"est la suivante::"
|
|
|
|
#: faq/programming.rst:723
|
|
msgid ""
|
|
"Before this syntax was introduced in Python 2.5, a common idiom was to use "
|
|
"logical operators::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:728
|
|
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 ""
|
|
|
|
#: faq/programming.rst:734
|
|
msgid "Is it possible to write obfuscated one-liners in Python?"
|
|
msgstr ""
|
|
"Est-il possible d'écrire des programmes volontairement difficile à "
|
|
"comprendre sur une seule ligne en Python?"
|
|
|
|
#: faq/programming.rst:736
|
|
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` les "
|
|
"uns dans les autres. Observez les trois exemples suivants, contribués par "
|
|
"Ulf Bartelt::"
|
|
|
|
#: faq/programming.rst:763
|
|
msgid "Don't try this at home, kids!"
|
|
msgstr "Les enfants, ne faîtes pas ça chez vous!"
|
|
|
|
#: faq/programming.rst:767
|
|
msgid "Numbers and strings"
|
|
msgstr "Nombres et chaines de caractères"
|
|
|
|
#: faq/programming.rst:770
|
|
msgid "How do I specify hexadecimal and octal integers?"
|
|
msgstr "Comment puis-je spécifier des entiers hexadécimaux ou octaux?"
|
|
|
|
#: faq/programming.rst:772
|
|
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 spécifier 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) à \"a\", tapez::"
|
|
|
|
#: faq/programming.rst:780
|
|
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::"
|
|
|
|
#: faq/programming.rst:793
|
|
msgid "Why does -22 // 10 return -3?"
|
|
msgstr "Pourquoi -22//10 retourne-t'il -3?"
|
|
|
|
#: faq/programming.rst:795
|
|
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::"
|
|
|
|
#: faq/programming.rst:800
|
|
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``."
|
|
|
|
#: faq/programming.rst:804
|
|
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."
|
|
|
|
#: faq/programming.rst:812
|
|
msgid "How do I convert a string to a number?"
|
|
msgstr "Comment puis-je convertir une chaine de caractère en nombre?"
|
|
|
|
#: faq/programming.rst:814
|
|
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``."
|
|
|
|
#: faq/programming.rst:818
|
|
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')`` remontent :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 '0' en tête indique octal, et '0x' indique un hexadécimal."
|
|
|
|
#: faq/programming.rst:824
|
|
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."
|
|
|
|
#: faq/programming.rst:831
|
|
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')."
|
|
|
|
#: faq/programming.rst:837
|
|
msgid "How do I convert a number to a string?"
|
|
msgstr "Comment convertir un nombre en chaine de caractère?"
|
|
|
|
#: faq/programming.rst:839
|
|
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:`string-formatting` section, e.g. ``\"{:04d}\"."
|
|
"format(144)`` yields ``'0144'`` and ``\"{:.3f}\".format(1.0/3.0)`` yields "
|
|
"``'0.333'``."
|
|
msgstr ""
|
|
"Pour convertir, par exemple, le nombre 144 en la chaîne '144 ', utilisez la "
|
|
"fonction intégrée: func: «str». Si vous voulez une représentation "
|
|
"hexadécimale ou octale, utilisez les fonctions intégrées :func:``hex`` ou: "
|
|
"func:``oct``. Pour une meilleure la mise en forme, voir la section :ref:"
|
|
"`string-formatting`, par exemple, ``\"{:04d) \".format (144)`` renvoit "
|
|
"``'0144'`` et ``\"{:.3f)\".format (1 / 3) donne ``'0,333' ``."
|
|
|
|
#: faq/programming.rst:847
|
|
msgid "How do I modify a string in place?"
|
|
msgstr "Comment modifier une chaine de caractère \"en place\"?"
|
|
|
|
#: 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 ""
|
|
|
|
#: 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?"
|
|
|
|
#: faq/programming.rst:881
|
|
msgid "There are various techniques."
|
|
msgstr "Il y a différentes techniques."
|
|
|
|
#: 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"
|
|
"\"::"
|
|
|
|
#: faq/programming.rst:898
|
|
msgid "Use the built-in function :func:`getattr`::"
|
|
msgstr "Utiliser la fonction :func:`getattr`::"
|
|
|
|
#: 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."
|
|
|
|
#: 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::"
|
|
|
|
#: 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::"
|
|
|
|
#: 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."
|
|
|
|
#: 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?"
|
|
|
|
#: 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 ""
|
|
"À partir de Python 2.2 vous pouvez utiliser ``S.rstrip(\"\r\n"
|
|
"\")`` pour retirer toute occurrence de n'importe quel terminateur de ligne à "
|
|
"la fin d'une chaine de caractère ``S``, sans retirer aucun espace de fin de "
|
|
"ligne. Si la chaine ``S`` représente plus d'une ligne, avec plusieurs lignes "
|
|
"vides, les terminateurs de lignes de toutes les lignes vides seront retirés::"
|
|
|
|
#: 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."
|
|
|
|
#: faq/programming.rst:956
|
|
msgid "Is there a scanf() or sscanf() equivalent?"
|
|
msgstr "Existe-t'il un équivalent à scanf() ou sscanf()?"
|
|
|
|
#: faq/programming.rst:958
|
|
msgid "Not as such."
|
|
msgstr "Pas exactement."
|
|
|
|
#: 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."
|
|
|
|
#: 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 `sscanf` de C et mieux adaptées à la tâche."
|
|
|
|
#: faq/programming.rst:971
|
|
msgid "What does 'UnicodeDecodeError' or 'UnicodeEncodeError' error mean?"
|
|
msgstr ""
|
|
"Que signifient les erreurs 'UnicodeDecodeError' ou 'UnicodeEncodeError'?"
|
|
|
|
#: faq/programming.rst:973
|
|
msgid "See the :ref:`unicode-howto`."
|
|
msgstr "Regardez le :ref:`unicode-howto`."
|
|
|
|
#: faq/programming.rst:977
|
|
msgid "Performance"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:980
|
|
msgid "My program is too slow. How do I speed it up?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:985
|
|
msgid ""
|
|
"Performance characteristics vary across Python implementations. This FAQ "
|
|
"focusses on :term:`CPython`."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:987
|
|
msgid ""
|
|
"Behaviour can vary across operating systems, especially when talking about I/"
|
|
"O or multi-threading."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:991
|
|
msgid ""
|
|
"Writing benchmark scripts will allow you to iterate quickly when searching "
|
|
"for improvements (see the :mod:`timeit` module)."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/programming.rst:1005
|
|
msgid ""
|
|
"Use the right data structures. Study documentation for the :ref:`bltin-"
|
|
"types` and the :mod:`collections` module."
|
|
msgstr ""
|
|
|
|
#: 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 `sorting mini-HOWTO <https://wiki.python.org/moin/"
|
|
"HowTo/Sorting>`_ for examples of moderately advanced usage)."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1017
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1023
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1033
|
|
msgid ""
|
|
"The wiki page devoted to `performance tips <https://wiki.python.org/moin/"
|
|
"PythonSpeed/PerformanceTips>`_."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1039
|
|
msgid "What is the most efficient way to concatenate many strings together?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1041
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1046
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1054
|
|
msgid "(another reasonably efficient idiom is to use :class:`io.StringIO`)"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1056
|
|
msgid ""
|
|
"To accumulate many :class:`bytes` objects, the recommended idiom is to "
|
|
"extend a :class:`bytearray` object using in-place concatenation (the ``+=`` "
|
|
"operator)::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1065
|
|
msgid "Sequences (Tuples/Lists)"
|
|
msgstr "Sequences (Tuples/Lists)"
|
|
|
|
#: faq/programming.rst:1068
|
|
msgid "How do I convert between tuples and lists?"
|
|
msgstr "Comment convertir les listes en tuples et inversement?"
|
|
|
|
#: faq/programming.rst:1070
|
|
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…"
|
|
|
|
#: faq/programming.rst:1073
|
|
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 en fait un fonction économique à "
|
|
"appeler quand vous ne savez pas si votre objet est déjà un tulpe."
|
|
|
|
#: faq/programming.rst:1078
|
|
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[:]``."
|
|
|
|
#: faq/programming.rst:1085
|
|
msgid "What's a negative index?"
|
|
msgstr "Qu'est-ce qu'un indexe négatif?"
|
|
|
|
#: faq/programming.rst:1087
|
|
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]``."
|
|
|
|
#: faq/programming.rst:1092
|
|
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."
|
|
|
|
#: faq/programming.rst:1098
|
|
msgid "How do I iterate over a sequence in reverse order?"
|
|
msgstr "Comment itérer à rebours sur une séquence?"
|
|
|
|
#: faq/programming.rst:1100
|
|
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::"
|
|
|
|
#: faq/programming.rst:1105
|
|
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."
|
|
|
|
#: faq/programming.rst:1108
|
|
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::"
|
|
|
|
#: faq/programming.rst:1115
|
|
msgid "How do you remove duplicates from a list?"
|
|
msgstr "Comment retirer les doublons d'une liste?"
|
|
|
|
#: faq/programming.rst:1117
|
|
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:"
|
|
|
|
#: faq/programming.rst:1119
|
|
msgid "http://code.activestate.com/recipes/52560/"
|
|
msgstr "http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52560"
|
|
|
|
#: faq/programming.rst:1121
|
|
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::"
|
|
|
|
#: faq/programming.rst:1133
|
|
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 (cad, elles sont toutes hashables) ceci est souvent plus "
|
|
"rapide::"
|
|
|
|
#: faq/programming.rst:1138
|
|
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."
|
|
|
|
#: faq/programming.rst:1143
|
|
msgid "How do you make an array in Python?"
|
|
msgstr "Comment construire un tableau en Python?"
|
|
|
|
#: faq/programming.rst:1145
|
|
msgid "Use a list::"
|
|
msgstr "Utilisez une liste::"
|
|
|
|
#: faq/programming.rst:1149
|
|
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."
|
|
|
|
#: faq/programming.rst:1152
|
|
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."
|
|
|
|
#: faq/programming.rst:1157
|
|
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::"
|
|
|
|
#: faq/programming.rst:1161
|
|
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."
|
|
|
|
#: faq/programming.rst:1170
|
|
msgid "How do I create a multidimensional list?"
|
|
msgstr "Comment puis-je créer une liste à plusieurs dimensions?"
|
|
|
|
#: faq/programming.rst:1172
|
|
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::"
|
|
|
|
#: faq/programming.rst:1176
|
|
msgid "This looks correct if you print it::"
|
|
msgstr "Cela semble correct quand vous essayer de l'afficher::"
|
|
|
|
#: faq/programming.rst:1181
|
|
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::"
|
|
|
|
#: faq/programming.rst:1187
|
|
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."
|
|
|
|
#: faq/programming.rst:1192
|
|
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."
|
|
|
|
#: faq/programming.rst:1199
|
|
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."
|
|
|
|
#: faq/programming.rst:1205
|
|
msgid ""
|
|
"Or, you can use an extension that provides a matrix datatype; `Numeric "
|
|
"Python <http://www.numpy.org/>`_ is the best known."
|
|
msgstr ""
|
|
"Ou, vous pouvez utiliser une extension qui fournis un type de donnée de type "
|
|
"matrice; `Numeric Python <http://numpy.scipy.org/>`_ étant le plus connu."
|
|
|
|
#: faq/programming.rst:1210
|
|
msgid "How do I apply a method to a sequence of objects?"
|
|
msgstr "Comment appliquer une méthode à une séquence d'objets?"
|
|
|
|
#: faq/programming.rst:1212
|
|
msgid "Use a list comprehension::"
|
|
msgstr "Utilisez une compréhension de liste::"
|
|
|
|
#: faq/programming.rst:1219
|
|
msgid ""
|
|
"Why does a_tuple[i] += ['item'] raise an exception when the addition works?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1221
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1225
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1229
|
|
msgid "If you wrote::"
|
|
msgstr "In C++ you'd write"
|
|
|
|
#: faq/programming.rst:1237
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1243
|
|
msgid ""
|
|
"Under the covers, what this augmented assignment statement is doing is "
|
|
"approximately this::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1252
|
|
msgid ""
|
|
"It is the assignment part of the operation that produces the error, since a "
|
|
"tuple is immutable."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1255
|
|
msgid "When you write something like::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1263
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1269
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1281
|
|
msgid "This is equivalent to::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1286
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1291
|
|
msgid "Thus, in our tuple example what is happening is equivalent to::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1299
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1305
|
|
msgid "Dictionaries"
|
|
msgstr "Dictionnaires"
|
|
|
|
#: faq/programming.rst:1308
|
|
msgid ""
|
|
"How can I get a dictionary to store and display its keys in a consistent "
|
|
"order?"
|
|
msgstr ""
|
|
"Comment puis-je faire afficher les éléments d'un dictionnaire dans un ordre "
|
|
"consistant?"
|
|
|
|
#: faq/programming.rst:1310
|
|
msgid "Use :class:`collections.OrderedDict`."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1313
|
|
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?"
|
|
|
|
#: faq/programming.rst:1315
|
|
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, just use the ``key`` argument for the ``sort()`` method::"
|
|
msgstr ""
|
|
"Cette technique, attribuée à Randal Schwartz de la communauté Perl, trie les "
|
|
"éléments d'une liste selon une mesure qui fait correspondre chaque élément à "
|
|
"une \"valeur de tri\". En Python, utilisez simplement l'argument ``key`` de "
|
|
"la méthode ``sort``::"
|
|
|
|
#: faq/programming.rst:1322
|
|
msgid ""
|
|
"The ``key`` argument is new in Python 2.4, for older versions this kind of "
|
|
"sorting is quite simple to do with list comprehensions. To sort a list of "
|
|
"strings by their uppercase values::"
|
|
msgstr ""
|
|
"L'argument ``key`` est apparus en Python 2.4, pour les anciennes versions de "
|
|
"Python, ce type de tri est relativement simple à faire avec des "
|
|
"compréhensions de liste. Pour trier une liste de chaines par leur valeur en "
|
|
"majuscule on peut faire::"
|
|
|
|
#: faq/programming.rst:1330
|
|
msgid ""
|
|
"To sort by the integer value of a subfield extending from positions 10-15 in "
|
|
"each string::"
|
|
msgstr ""
|
|
"Pour trier par la valeur d'un sous-champ allant des index 10 à 15 dans "
|
|
"chaque chaine chaine::"
|
|
|
|
#: faq/programming.rst:1337
|
|
msgid "For versions prior to 3.0, Isorted may also be computed by ::"
|
|
msgstr ""
|
|
"Pour les versions antérieures à 3.0, Isorted peut également être calculé par:"
|
|
|
|
#: faq/programming.rst:1348
|
|
msgid ""
|
|
"but since this method calls ``intfield()`` many times for each element of L, "
|
|
"it is slower than the Schwartzian Transform."
|
|
msgstr ""
|
|
"mais du fait que cette méthode appelle `` intfield () `` plusieurs fois pour "
|
|
"chaque élément de L, elle est plus lente que la transformée de Schwartz."
|
|
|
|
#: faq/programming.rst:1353
|
|
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?"
|
|
|
|
#: faq/programming.rst:1355
|
|
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, trier la liste obtenue, puis "
|
|
"choisissez l'élément que vous voulez. ::"
|
|
|
|
#: faq/programming.rst:1369
|
|
msgid "An alternative for the last step is::"
|
|
msgstr "Une alternative pour la dernière étape est la suivante::"
|
|
|
|
#: faq/programming.rst:1374
|
|
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."
|
|
|
|
#: faq/programming.rst:1384
|
|
msgid "Objects"
|
|
msgstr "Objets"
|
|
|
|
#: faq/programming.rst:1387
|
|
msgid "What is a class?"
|
|
msgstr "Qu'est-ce qu'une classe?"
|
|
|
|
#: faq/programming.rst:1389
|
|
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."
|
|
|
|
#: faq/programming.rst:1393
|
|
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."
|
|
|
|
#: faq/programming.rst:1402
|
|
msgid "What is a method?"
|
|
msgstr "Qu'est-ce qu'une méthode?"
|
|
|
|
#: faq/programming.rst:1404
|
|
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::"
|
|
|
|
#: faq/programming.rst:1414
|
|
msgid "What is self?"
|
|
msgstr "Qu'est-ce que self?"
|
|
|
|
#: faq/programming.rst:1416
|
|
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)``."
|
|
|
|
#: faq/programming.rst:1421
|
|
msgid "See also :ref:`why-self`."
|
|
msgstr "Voir aussi: ref:`why-self`."
|
|
|
|
#: faq/programming.rst:1425
|
|
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?"
|
|
|
|
#: faq/programming.rst:1427
|
|
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 intégrée ``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, (Classe1, classe2, ...))``, et peut également vérifier si "
|
|
"un objet est l'un des types intégrés à Python, par exemple, ``IsInstance "
|
|
"(obj, str) isInstance`` ou ``(obj, (int, float, complexes ))``."
|
|
|
|
#: faq/programming.rst:1433
|
|
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::"
|
|
|
|
#: faq/programming.rst:1447
|
|
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::"
|
|
|
|
#: faq/programming.rst:1462
|
|
msgid "What is delegation?"
|
|
msgstr "Qu'est-ce que la délégation?"
|
|
|
|
#: faq/programming.rst:1464
|
|
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``."
|
|
|
|
#: faq/programming.rst:1470
|
|
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:"
|
|
|
|
#: faq/programming.rst:1485
|
|
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."
|
|
|
|
#: faq/programming.rst:1492
|
|
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:"
|
|
|
|
#: faq/programming.rst:1503
|
|
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."
|
|
|
|
#: faq/programming.rst:1508
|
|
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?"
|
|
|
|
#: faq/programming.rst:1510
|
|
msgid "Use the built-in :func:`super` function::"
|
|
msgstr "Utiliser la fonction :func:`getattr`::"
|
|
|
|
#: faq/programming.rst:1516
|
|
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``."
|
|
|
|
#: faq/programming.rst:1524
|
|
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?"
|
|
|
|
#: faq/programming.rst:1526
|
|
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::"
|
|
|
|
#: faq/programming.rst:1541
|
|
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?"
|
|
|
|
#: faq/programming.rst:1543
|
|
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."
|
|
|
|
#: faq/programming.rst:1546
|
|
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:"
|
|
|
|
#: faq/programming.rst:1558
|
|
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``."
|
|
|
|
#: faq/programming.rst:1562
|
|
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:"
|
|
|
|
#: faq/programming.rst:1569
|
|
msgid "Static methods are possible::"
|
|
msgstr "Les méthodes statiques sont possibles depuis Python 2.2::"
|
|
|
|
#: faq/programming.rst:1577
|
|
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::"
|
|
|
|
#: faq/programming.rst:1583
|
|
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."
|
|
|
|
#: faq/programming.rst:1588
|
|
msgid "How can I overload constructors (or methods) in Python?"
|
|
msgstr "Comment puis-je surcharger les constructeurs (ou méthodes) en Python?"
|
|
|
|
#: faq/programming.rst:1590
|
|
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."
|
|
|
|
#: faq/programming.rst:1593
|
|
msgid "In C++ you'd write"
|
|
msgstr "In C++ you'd write"
|
|
|
|
#: faq/programming.rst:1602
|
|
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::"
|
|
|
|
#: faq/programming.rst:1612
|
|
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."
|
|
|
|
#: faq/programming.rst:1614
|
|
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 ::"
|
|
|
|
#: faq/programming.rst:1619
|
|
msgid "The same approach works for all method definitions."
|
|
msgstr "La même approche fonctionne pour toutes les définitions de méthode."
|
|
|
|
#: faq/programming.rst:1623
|
|
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."
|
|
|
|
#: faq/programming.rst:1625
|
|
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."
|
|
|
|
#: faq/programming.rst:1631
|
|
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."
|
|
|
|
#: faq/programming.rst:1638
|
|
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."
|
|
|
|
#: faq/programming.rst:1640
|
|
msgid "There are several possible reasons for this."
|
|
msgstr "Il y a plusieurs raisons possibles pour cela."
|
|
|
|
#: faq/programming.rst:1642
|
|
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."
|
|
|
|
#: faq/programming.rst:1646
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1657
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1664
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1677
|
|
msgid ""
|
|
"Finally, if your :meth:`__del__` method raises an exception, a warning "
|
|
"message is printed to :data:`sys.stderr`."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1682
|
|
msgid "How do I get a list of all instances of a given class?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1684
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1690
|
|
msgid "Why does the result of ``id()`` appear to be not unique?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1692
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1703
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1716
|
|
msgid "Modules"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1719
|
|
msgid "How do I create a .pyc file?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1721
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1729
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1734
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1739
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1746
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1750
|
|
msgid ""
|
|
"The :mod:`py_compile` module can manually compile any module. One way is to "
|
|
"use the ``compile()`` function in that module interactively::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1756
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1760
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1769
|
|
msgid "How do I find the current module name?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1771
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1786
|
|
msgid "How can I have modules that mutually import each other?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1788
|
|
msgid "Suppose you have the following modules:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1790
|
|
msgid "foo.py::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1795
|
|
msgid "bar.py::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1800
|
|
msgid "The problem is that the interpreter will perform the following steps:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1802
|
|
msgid "main imports foo"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1803
|
|
msgid "Empty globals for foo are created"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1804
|
|
msgid "foo is compiled and starts executing"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1805
|
|
msgid "foo imports bar"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1806
|
|
msgid "Empty globals for bar are created"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1807
|
|
msgid "bar is compiled and starts executing"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1808
|
|
msgid ""
|
|
"bar imports foo (which is a no-op since there already is a module named foo)"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1809
|
|
msgid "bar.foo_var = foo.foo_var"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1811
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1814
|
|
msgid ""
|
|
"The same thing happens when you use ``import foo``, and then try to access "
|
|
"``foo.foo_var`` in global code."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1817
|
|
msgid "There are (at least) three possible workarounds for this problem."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1819
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1824
|
|
msgid ""
|
|
"Jim Roskind suggests performing steps in the following order in each module:"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1826
|
|
msgid ""
|
|
"exports (globals, functions, and classes that don't need imported base "
|
|
"classes)"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1828
|
|
msgid "``import`` statements"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1829
|
|
msgid ""
|
|
"active code (including globals that are initialized from imported values)."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1831
|
|
msgid ""
|
|
"van Rossum doesn't like this approach much because the imports appear in a "
|
|
"strange place, but it does work."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1834
|
|
msgid ""
|
|
"Matthias Urlichs recommends restructuring your code so that the recursive "
|
|
"import is not necessary in the first place."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1837
|
|
msgid "These solutions are not mutually exclusive."
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1841
|
|
msgid "__import__('x.y.z') returns <module 'x'>; how do I get z?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1843
|
|
msgid ""
|
|
"Consider using the convenience function :func:`~importlib.import_module` "
|
|
"from :mod:`importlib` instead::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1850
|
|
msgid ""
|
|
"When I edit an imported module and reimport it, the changes don't show up. "
|
|
"Why does this happen?"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1852
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1862
|
|
msgid ""
|
|
"Warning: this technique is not 100% fool-proof. In particular, modules "
|
|
"containing statements like ::"
|
|
msgstr ""
|
|
|
|
#: faq/programming.rst:1867
|
|
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 ""
|
|
|
|
#: faq/programming.rst:1880
|
|
msgid ""
|
|
"The nature of the problem is made clear if you print out the \"identity\" of "
|
|
"the class objects:"
|
|
msgstr ""
|
|
|
|
#: faq/windows.rst:7
|
|
msgid "Python on Windows FAQ"
|
|
msgstr ""
|
|
|
|
#: faq/windows.rst:18
|
|
msgid "How do I run a Python program under Windows?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:0
|
|
msgid "|Python Development on XP|_"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:67
|
|
msgid "You should then see something like::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:94
|
|
msgid ""
|
|
"If the ``python`` command, instead of displaying the interpreter prompt "
|
|
"``>>>``, gives you a message like::"
|
|
msgstr ""
|
|
|
|
#: faq/windows.rst:0
|
|
msgid "|Adding Python to DOS Path|_"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:111
|
|
msgid "or::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:140
|
|
msgid ""
|
|
"More information about environment variables can be found on the :ref:`Using "
|
|
"Python on Windows <setting-envvars>` page."
|
|
msgstr ""
|
|
|
|
#: faq/windows.rst:144
|
|
msgid "How do I make Python scripts executable?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:154
|
|
msgid "Why does Python sometimes take so long to start?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:171
|
|
msgid "How do I make an executable from a Python script?"
|
|
msgstr "Comment construire un tableau en Python?"
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:181
|
|
msgid "Is a ``*.pyd`` file the same as a DLL?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:199
|
|
msgid "How can I embed Python into a Windows application?"
|
|
msgstr ""
|
|
|
|
#: faq/windows.rst:201
|
|
msgid ""
|
|
"Embedding the Python interpreter in a Windows app can be summarized as "
|
|
"follows:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:222
|
|
msgid ""
|
|
"Borland note: convert :file:`python{NN}.lib` to OMF format using Coff2Omf."
|
|
"exe first."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:243
|
|
msgid ""
|
|
"In short, you can use the following code to initialize the Python "
|
|
"interpreter with your extension module."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:262
|
|
msgid ""
|
|
"Problem 2: SWIG generates the following code when generating wrappers to "
|
|
"void functions:"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:292
|
|
msgid "How do I keep editors from inserting tabs into my Python source?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:309
|
|
msgid "How do I check for a keypress without blocking?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:317
|
|
msgid "How do I emulate os.kill() in Windows?"
|
|
msgstr ""
|
|
|
|
#: faq/windows.rst:319
|
|
msgid ""
|
|
"Prior to Python 2.7 and 3.2, to terminate a process, you can use :mod:"
|
|
"`ctypes`::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: faq/windows.rst:335
|
|
msgid "How do I extract the downloaded documentation on Windows?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 http://www.winzip.com.)"
|
|
msgstr ""
|