python-docs-fr/whatsnew/2.0.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2019-11-01 11:43+0100\n"
"Last-Translator: Melançon Victor <victor.melancon0@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.2.4\n"

#: whatsnew/2.0.rst:3
msgid "What's New in Python 2.0"
msgstr "Nouveautés de Python 2.0"

#: whatsnew/2.0.rst:0
msgid "Author"
msgstr "Auteur"

#: whatsnew/2.0.rst:5
msgid "A.M. Kuchling and Moshe Zadka"
msgstr "A.M. Kuchling et Moshe Zadka"

#: whatsnew/2.0.rst:13
msgid "Introduction"
msgstr "Introduction"

#: whatsnew/2.0.rst:15
msgid ""
"A new release of Python, version 2.0, was released on October 16, 2000. This "
"article covers the exciting new features in 2.0, highlights some other "
"useful changes, and points out a few incompatible changes that may require "
"rewriting code."
msgstr ""
"Une nouvelle version de Python, la version 2.0, est sortie le 16 octobre "
"2000. Cet article traite des nouvelles fonctionnalités intéressantes de "
"cette version, met en évidence d'autres changements utiles, et souligne "
"quelques incompatibilités qui peuvent nécessiter la réécriture du code."

#: whatsnew/2.0.rst:20
#, fuzzy
msgid ""
"Python's development never completely stops between releases, and a steady "
"flow of bug fixes and improvements are always being submitted. A host of "
"minor fixes, a few optimizations, additional docstrings, and better error "
"messages went into 2.0; to list them all would be impossible, but they're "
"certainly significant. Consult the publicly available CVS logs if you want "
"to see the full list.  This progress is due to the five developers working "
"for  PythonLabs are now getting paid to spend their days fixing bugs, and "
"also due to the improved communication resulting  from moving to SourceForge."
msgstr ""
"Le développement de Python ne s'arrête jamais complètement entre les "
"versions, et un flux constant de corrections de bogues et d'améliorations "
"sont soumis en permanence. Une foule de corrections mineures, quelques "
"optimisations, des *docstrings* supplémentaires, et de meilleurs messages "
"d'erreur sont apparus avec l'arrivée de la version 2.0; tous les énumérer "
"serait impossible, mais ils sont certainement significatif. Consultez les "
"journaux CVS publics disponibles pour obtenir la liste complète. Ce progrès "
"est dû aux cinq développeurs travaillant pour PythonLabs qui sont désormais "
"payés pour passer leurs journées à corriger les bugs, mais aussi en raison "
"de l'amélioration de la communication résultant du passage à SourceForge."

#: whatsnew/2.0.rst:33
msgid "What About Python 1.6?"
msgstr "À propos de Python 1.6."

#: whatsnew/2.0.rst:35
msgid ""
"Python 1.6 can be thought of as the Contractual Obligations Python release. "
"After the core development team left CNRI in May 2000, CNRI requested that a "
"1.6 release be created, containing all the work on Python that had been "
"performed at CNRI.  Python 1.6 therefore represents the state of the CVS "
"tree as of May 2000, with the most significant new feature being Unicode "
"support.  Development continued after May, of course, so the 1.6 tree "
"received a few fixes to ensure that it's forward-compatible with Python "
"2.0.  1.6 is therefore part of Python's evolution, and not a side branch."
msgstr ""
"Python 1.6 peut être vu comme la version des obligations contractuelles. "
"Après que l’équipe de développement eût quitté le CNRI en mai 2000, celui-ci "
"a demandé la création d’une version 1.6, contenant tout le travail sur "
"Python réalisé au CNRI. Python 1.6 représente de ce fait l’état de l’arbre "
"*CVS* tel qu’il était en mai 2000, la nouvelle fonctionnalité la plus "
"remarquable étant le support d’Unicode. Le développement a continué après "
"mai bien sûr, donc la branche 1.6 a reçu quelques corrections pour être sûr "
"qu’elle soit compatible avec Python 2.0. La version 1.6 fait donc partie de "
"l’évolution de Python, ce n’est pas une branche séparée."

#: whatsnew/2.0.rst:44
msgid ""
"So, should you take much interest in Python 1.6?  Probably not.  The "
"1.6final and 2.0beta1 releases were made on the same day (September 5, "
"2000), the plan being to finalize Python 2.0 within a month or so.  If you "
"have applications to maintain, there seems little point in breaking things "
"by moving to 1.6, fixing them, and then having another round of breakage "
"within a month by moving to 2.0; you're better off just going straight to "
"2.0.  Most of the really interesting features described in this document are "
"only in 2.0, because a lot of work was done between May and September."
msgstr ""
"Alors, devriez-vous vous intéresser à Python 1.6 ? Probablement pas. Les "
"versions *1.6final* et *2.0beta1* sont sorties le même jour (5 septembre "
"2000), le plan étant de finaliser Python 2.0 environ un mois plus tard. Si "
"vous avez des applications à maintenir, il n’y a pas vraiment d’intérêt à "
"casser des choses en migrant sur la version 1.6, les réparer, puis avoir de "
"nouveau des choses cassées à peine un mois plus tard en passant à la 2.0; il "
"vaut mieux partir directement de la 2.0. La plupart des fonctionnalités "
"vraiment intéressantes décrites dans ce document sont seulement dans la 2.0, "
"parce que beaucoup de travail a été réalisé entre mai et septembre."

#: whatsnew/2.0.rst:57
msgid "New Development Process"
msgstr "Nouveau processus de développement"

#: whatsnew/2.0.rst:59
msgid ""
"The most important change in Python 2.0 may not be to the code at all, but "
"to how Python is developed: in May 2000 the Python developers began using "
"the tools made available by SourceForge for storing  source code, tracking "
"bug reports, and managing the queue of patch submissions.  To report bugs or "
"submit patches for Python 2.0, use the bug tracking and patch manager tools "
"available from Python's project page, located at https://sourceforge.net/"
"projects/python/."
msgstr ""
"Le changement le plus important dans Python 2.0 ne concerne peut-être pas le "
"code, mais le développement de Python : en mai 2000, les développeurs Python "
"ont commencé à utiliser les outils mis à disposition par SourceForge pour "
"stocker le code source, suivre les rapports de bogues et gérer la file "
"d’attente des soumissions de correctifs. Pour signaler des bogues ou "
"soumettre des correctifs pour Python 2.0, utilisez les outils de suivi des "
"bogues et de gestion des correctifs disponibles sur la page du projet "
"Python, à l’adresse https://sourceforge.net/projects/python/."

#: whatsnew/2.0.rst:66
msgid ""
"The most important of the services now hosted at SourceForge is the Python "
"CVS tree, the version-controlled repository containing the source code for "
"Python. Previously, there were roughly 7 or so people who had write access "
"to the CVS tree, and all patches had to be inspected and checked in by one "
"of the people on this short list. Obviously, this wasn't very scalable.  By "
"moving the CVS tree to SourceForge, it became possible to grant write access "
"to more people; as of September 2000 there were 27 people able to check in "
"changes, a fourfold increase.  This makes possible large-scale changes that "
"wouldn't be attempted if they'd have to be filtered through the small group "
"of core developers.  For example, one day Peter Schneider-Kamp took it into "
"his head to drop K&R C compatibility and convert the C source for Python to "
"ANSI C. After getting approval on the python-dev mailing list, he launched "
"into a flurry of checkins that lasted about a week, other developers joined "
"in to help, and the job was done.  If there were only 5 people with write "
"access, probably that task would have been viewed as \"nice, but not worth "
"the time and effort needed\" and it would never have gotten done."
msgstr ""
"Le plus important des services maintenant hébergé chez SourceForge est "
"l’arborescence CVS Python, le référentiel sous contrôle de version contenant "
"le code source de Python. Auparavant, environ 7 personnes avaient un accès "
"en écriture à l’arborescence CVS et tous les correctifs devaient être "
"inspectés et archivés par l’une des personnes figurant sur cette liste "
"restreinte. Évidemment, ce n’était pas très évolutif. En déplaçant "
"l’arborescence CVS vers SourceForge, il est devenu possible d’accorder un "
"accès en écriture à davantage de personnes ; en septembre 2000, 27 personnes "
"pouvaient enregistrer les modifications, soit quatre fois plus. Cela rend "
"possible des modifications à grande échelle qui ne seraient pas tentées si "
"elles devaient être filtrées par le petit groupe de développeurs principaux. "
"Par exemple, un jour, Peter Schneider-Kamp a eu l’idée de supprimer la "
"compatibilité K&R C et de convertir le code source C de Python en ANSI C. "
"Après avoir obtenu l’approbation de la liste de diffusion *python-dev*, il "
"s’est lancé dans une série d’archives qui ont duré environ une semaine, "
"d’autres développeurs l'ont rejoint et le travail a été fait. S’il n’y avait "
"eut que 5 personnes ayant un accès en écriture, cette tâche aurait "
"probablement été considérée comme « agréable, mais ne valant pas le temps ni "
"les efforts nécessaires » et cela ne se serait jamais fait."

#: whatsnew/2.0.rst:83
msgid ""
"The shift to using SourceForge's services has resulted in a remarkable "
"increase in the speed of development.  Patches now get submitted, commented "
"on, revised by people other than the original submitter, and bounced back "
"and forth between people until the patch is deemed worth checking in.  Bugs "
"are tracked in one central location and can be assigned to a specific person "
"for fixing, and we can count the number of open bugs to measure progress.  "
"This didn't come without a cost: developers now have more e-mail to deal "
"with, more mailing lists to follow, and special tools had to be written for "
"the new environment. For example, SourceForge sends default patch and bug "
"notification e-mail messages that are completely unhelpful, so Ka-Ping Yee "
"wrote an HTML screen-scraper that sends more useful messages."
msgstr ""
"Le passage à l’utilisation des services de SourceForge a entraîné une "
"augmentation remarquable du rythme de développement. Les correctifs sont "
"maintenant soumis, commentés, révisés par des personnes autres que l’auteur "
"d’origine et échangés entre les personnes jusqu’à ce que le correctif soit "
"jugé utile. Les bogues sont suivis dans un emplacement central et peuvent "
"être attribués à une personne spécifique pour être corrigés. , et nous "
"pouvons compter le nombre de bogues ouverts pour mesurer les progrès. Cela "
"n’a pas coûté cher: les développeurs ont désormais plus de courrier "
"électronique à traiter, davantage de listes de diffusion à suivre et des "
"outils spéciaux ont dû être créés pour le nouvel environnement. Par exemple, "
"SourceForge envoie des messages électroniques de correctif et de "
"notification de bogues par défaut qui ne sont d’aucune utilité, Ka-Ping Yee "
"a donc créé un *scraper* HTML qui envoie des messages plus utiles."

#: whatsnew/2.0.rst:95
msgid ""
"The ease of adding code caused a few initial growing pains, such as code was "
"checked in before it was ready or without getting clear agreement from the "
"developer group.  The approval process that has emerged is somewhat similar "
"to that used by the Apache group. Developers can vote +1, +0, -0, or -1 on a "
"patch; +1 and -1 denote acceptance or rejection, while +0 and -0 mean the "
"developer is mostly indifferent to the change, though with a slight positive "
"or negative slant.  The most significant change from the Apache model is "
"that the voting is essentially advisory, letting Guido van Rossum, who has "
"Benevolent Dictator For Life status, know what the general opinion is. He "
"can still ignore the result of a vote, and approve or reject a change even "
"if the community disagrees with him."
msgstr ""
"La facilité d’ajout de code a provoqué quelques problèmes de croissance "
"initiaux, tels que le code a été archivé avant qu’il ne soit prêt ou sans "
"l’accord clair du groupe de développeurs. Le processus d’approbation qui a "
"émergé est quelque peu similaire à celui utilisé par le groupe Apache. Les "
"développeurs peuvent voter *+1*, *+0*, *-0* ou *-1* sur un patch; *+1* et "
"*-1* indiquent une acceptation ou un rejet, tandis que *+0* et *-0* "
"signifient que le développeur est généralement indifférent au changement, "
"bien qu’il présente une légère inclinaison positive ou négative. Le "
"changement le plus important par rapport au modèle Apache est que le vote "
"est essentiellement consultatif, permettant à Guido van Rossum, détenteur du "
"statut de « dictateur bienveillant à vie », de connaître l’opinion générale. "
"Il peut toujours ignorer le résultat d’un vote et approuver ou rejeter un "
"changement même si la communauté n’est pas d’accord avec lui."

#: whatsnew/2.0.rst:106
msgid ""
"Producing an actual patch is the last step in adding a new feature, and is "
"usually easy compared to the earlier task of coming up with a good design. "
"Discussions of new features can often explode into lengthy mailing list "
"threads, making the discussion hard to follow, and no one can read every "
"posting to python-dev.  Therefore, a relatively formal process has been set "
"up to write Python Enhancement Proposals (PEPs), modelled on the internet "
"RFC process.  PEPs are draft documents that describe a proposed new feature, "
"and are continually revised until the community reaches a consensus, either "
"accepting or rejecting the proposal.  Quoting from the introduction to :pep:"
"`1`, \"PEP Purpose and Guidelines\":"
msgstr ""

#: whatsnew/2.0.rst:120
msgid ""
"PEP stands for Python Enhancement Proposal.  A PEP is a design document "
"providing information to the Python community, or describing a new feature "
"for Python.  The PEP should provide a concise technical specification of the "
"feature and a rationale for the feature."
msgstr ""
"PEP signifie *Python Enhancement Proposition*. Une PEP est un document de "
"conception fournissant des informations à la communauté Python ou décrivant "
"une nouvelle fonctionnalité de Python. La PEP devrait fournir une "
"spécification technique concise de la fonctionnalité et une justification de "
"celle-ci."

#: whatsnew/2.0.rst:125
msgid ""
"We intend PEPs to be the primary mechanisms for proposing new features, for "
"collecting community input on an issue, and for documenting the design "
"decisions that have gone into Python.  The PEP author is responsible for "
"building consensus within the community and documenting dissenting opinions."
msgstr ""
"Nous souhaitons que les PEP soient les principaux mécanismes permettant de "
"proposer de nouvelles fonctionnalités, de recueillir les commentaires de la "
"communauté sur un problème et de documenter les décisions de conception "
"prises dans Python. L’auteur du PPE est chargé de créer un consensus au sein "
"de la communauté et de documenter les opinions divergentes."

#: whatsnew/2.0.rst:130
#, fuzzy
msgid ""
"Read the rest of :pep:`1` for the details of the PEP editorial process, "
"style, and format.  PEPs are kept in the Python CVS tree on SourceForge, "
"though they're not part of the Python 2.0 distribution, and are also "
"available in HTML form from https://peps.python.org/.  As of September 2000, "
"there are 25 PEPS, ranging from :pep:`201`, \"Lockstep Iteration\", to PEP "
"225, \"Elementwise/Objectwise Operators\"."
msgstr ""
"Lisez le reste de :pep:`1` pour plus de détails sur le processus éditorial, "
"le style et le format de PEP. Les PEP sont conservés dans l’arborescence CVS "
"Python de SourceForge, bien qu’ils ne fassent pas partie de la distribution "
"Python 2.0 et qu’ils soient également disponibles au format HTML à l’adresse "
"https://www.python.org/dev/peps/. En septembre 2000, il existait 25 PEPS, "
"allant de :pep:`201`, \"Lockstep Iteration\", à PEP 225, \"Elementwise/"
"Objectwise Operators\"."

#: whatsnew/2.0.rst:141
msgid "Unicode"
msgstr "Unicode"

#: whatsnew/2.0.rst:143
msgid ""
"The largest new feature in Python 2.0 is a new fundamental data type: "
"Unicode strings.  Unicode uses 16-bit numbers to represent characters "
"instead of the 8-bit number used by ASCII, meaning that 65,536 distinct "
"characters can be supported."
msgstr ""
"La plus grande nouveauté de Python 2.0 est un nouveau type de données "
"fondamental: les chaînes Unicode. Unicode utilise des nombres à 16 bits pour "
"représenter des caractères au lieu du nombre à 8 bits utilisé par ASCII, ce "
"qui signifie que 65 536 caractères distincts peuvent être pris en charge."

#: whatsnew/2.0.rst:148
msgid ""
"The final interface for Unicode support was arrived at through countless "
"often-stormy discussions on the python-dev mailing list, and mostly "
"implemented by Marc-André Lemburg, based on a Unicode string type "
"implementation by Fredrik Lundh.  A detailed explanation of the interface "
"was written up as :pep:`100`, \"Python Unicode Integration\". This article "
"will simply cover the most significant points about the Unicode interfaces."
msgstr ""
"La dernière interface de prise en charge Unicode a été mise au point après "
"de nombreuses discussions souvent houleuses sur la liste de diffusion "
"*python-dev*, et principalement implémentée par Marc-André Lemburg, basée "
"sur une implémentation de type chaîne Unicode de Fredrik Lundh. Une "
"explication détaillée de l’interface a été écrite ainsi :pep:"
"`100`, \"Intégration Python Unicode\". Cet article couvrira simplement les "
"points les plus significatifs sur les interfaces Unicode."

#: whatsnew/2.0.rst:155
msgid ""
"In Python source code, Unicode strings are written as ``u\"string\"``.  "
"Arbitrary Unicode characters can be written using a new escape sequence, "
"``\\uHHHH``, where *HHHH* is a 4-digit hexadecimal number from 0000 to "
"FFFF.  The existing ``\\xHHHH`` escape sequence can also be used, and octal "
"escapes can be used for characters up to U+01FF, which is represented by "
"``\\777``."
msgstr ""
"Dans le code source Python, les chaînes Unicode sont écrites sous la forme "
"``u\"string\"``. Les caractères Unicode arbitraires peuvent être écrits en "
"utilisant une nouvelle séquence d'échappement, ``\\uHHHH``, où *HHHH* est un "
"nombre hexadécimal à 4 chiffres de 0000 à FFFF. La séquence d'échappement "
"``\\xHHHH`` peut également être utilisée, et les échappements octaux peuvent "
"être utilisés pour les caractères allant jusqu'à U+01FF, représenté par "
"``\\777``."

#: whatsnew/2.0.rst:161
msgid ""
"Unicode strings, just like regular strings, are an immutable sequence type. "
"They can be indexed and sliced, but not modified in place. Unicode strings "
"have an ``encode( [encoding] )`` method that returns an 8-bit string in the "
"desired encoding.  Encodings are named by strings, such as ``'ascii'``, "
"``'utf-8'``, ``'iso-8859-1'``, or whatever.  A codec API is defined for "
"implementing and registering new encodings that are then available "
"throughout a Python program. If an encoding isn't specified, the default "
"encoding is usually 7-bit ASCII, though it can be changed for your Python "
"installation by calling the ``sys.setdefaultencoding(encoding)`` function in "
"a customized version of :file:`site.py`."
msgstr ""
"Les chaînes Unicode, tout comme les chaînes ordinaires, sont un type de "
"séquence immuable. Ils peuvent être indexés et tranchés, mais pas modifiés "
"en place. Les chaînes Unicode ont une méthode ``encoder([encoding])`` qui "
"renvoie une chaîne de 8 bits dans l’encodage souhaité. Les codages sont "
"nommés par des chaînes, telles que ``’ascii’``, ``’utf-8’``, "
"``’iso-8859-1’``, ou autre chose. Une API de codec est définie pour "
"l’implémentation et l’enregistrement de nouveaux codages disponibles dans "
"tout un programme Python. Si aucun codage n’est spécifié, le codage par "
"défaut est généralement du code ASCII 7-bits, bien qu’il puisse être modifié "
"pour votre installation Python en appelant la fonction ``sys."
"setdefaultencoding (encoding)`` dans une version personnalisée de :file:"
"`site.py`."

#: whatsnew/2.0.rst:172
msgid ""
"Combining 8-bit and Unicode strings always coerces to Unicode, using the "
"default ASCII encoding; the result of ``'a' + u'bc'`` is ``u'abc'``."
msgstr ""
"La combinaison de chaînes 8 bits et Unicode est toujours forcée en Unicode, "
"à l’aide du codage ASCII par défaut; le résultat de ``’a’ + u’bc’`` est "
"``u’abc’``."

#: whatsnew/2.0.rst:175
msgid ""
"New built-in functions have been added, and existing built-ins modified to "
"support Unicode:"
msgstr ""
"De nouvelles fonctions primitives ont été ajoutées, et des fonctions "
"existantes ont été modifiées pour supporter Unicode :"

#: whatsnew/2.0.rst:178
msgid ""
"``unichr(ch)`` returns a Unicode string 1 character long, containing the "
"character *ch*."
msgstr ""
"``unichr(ch)`` renvoie une chaîne Unicode de longueur 1, contenant le "
"caractère *ch*."

#: whatsnew/2.0.rst:181
msgid ""
"``ord(u)``, where *u* is a 1-character regular or Unicode string, returns "
"the number of the character as an integer."
msgstr ""
"``ord(u)``, quand *u* est une chaîne normale ou Unicode de longueur 1, "
"renvoie un entier représentant le nombre de caractères."

#: whatsnew/2.0.rst:184
msgid ""
"``unicode(string [, encoding]  [, errors] )`` creates a Unicode string from "
"an 8-bit string.  ``encoding`` is a string naming the encoding to use. The "
"``errors`` parameter specifies the treatment of characters that are invalid "
"for the current encoding; passing ``'strict'`` as the value causes an "
"exception to be raised on any encoding error, while ``'ignore'`` causes "
"errors to be silently ignored and ``'replace'`` uses U+FFFD, the official "
"replacement character, in case of any problems."
msgstr ""
"``unicode(string [, encoding]  [, errors] )`` crée une chaîne Unicode à "
"partir d’une chaîne de 8 bits. ``encoding`` est une chaîne nommant le codage "
"à utiliser. Le paramètre ``errors`` spécifie le traitement des caractères "
"non valides pour l’ encodage en cours; en passant ``’strict’`` comme valeur, "
"une exception est générée pour toute erreur de codage, alors que "
"``’ignore’`` fait en sorte que les erreurs soient ignorées en silence et que "
"``’replace’`` utilise U+FFFD, caractère de remplacement officiel, en cas de "
"problème."

#: whatsnew/2.0.rst:192
msgid ""
"The ``exec`` statement, and various built-ins such as ``eval()``, "
"``getattr()``, and ``setattr()`` will also accept Unicode strings as well as "
"regular strings.  (It's possible that the process of fixing this missed some "
"built-ins; if you find a built-in function that accepts strings but doesn't "
"accept Unicode strings at all, please report it as a bug.)"
msgstr ""
"L’instruction ``exec`` et divers éléments intégrés tels que ``eval()``, "
"``getattr()`` et ``setattr()`` accepteront également les chaînes Unicode "
"ainsi que les chaînes ordinaires. (Il est possible que le processus de "
"résolution de ce problème ait échappé à certaines fonctions intégrées ; si "
"vous trouvez une fonction intégrée qui accepte les chaînes mais n’accepte "
"pas les chaînes Unicode, signalez-la comme un bogue.)"

#: whatsnew/2.0.rst:198
msgid ""
"A new module, :mod:`unicodedata`, provides an interface to Unicode character "
"properties.  For example, ``unicodedata.category(u'A')`` returns the 2-"
"character string 'Lu', the 'L' denoting it's a letter, and 'u' meaning that "
"it's uppercase. ``unicodedata.bidirectional(u'\\u0660')`` returns 'AN', "
"meaning that U+0660 is an Arabic number."
msgstr ""
"Un nouveau module, :mod:`unicodedata`, fournit une interface aux propriétés "
"de caractère Unicode. Par exemple, ``unicodedata.category(u'A')`` renvoie la "
"chaîne de 2 caractères « Lu », le « L » désignant une lettre et « u » "
"signifiant qu’il s’agit d’une majuscule. ``unicodedata."
"bidirectional(u'\\u0660')`` renvoie « AN », ce qui signifie que U+0660 est "
"un nombre arabe."

#: whatsnew/2.0.rst:204
msgid ""
"The :mod:`codecs` module contains functions to look up existing encodings "
"and register new ones.  Unless you want to implement a new encoding, you'll "
"most often use the ``codecs.lookup(encoding)`` function, which returns a 4-"
"element tuple: ``(encode_func, decode_func, stream_reader, stream_writer)``."
msgstr ""
"Le module :mod:`codecs` contient des fonctions pour rechercher les codages "
"existants et en enregistrer de nouveaux. À moins que vous ne souhaitiez "
"implémenter un nouvel encodage, vous utiliserez le plus souvent la fonction  "
"``codecs.lookup(encoding)``, qui renvoie un quadruplet : ``(encode_func, "
"decode_func, stream_reader, stream_writer)``."

#: whatsnew/2.0.rst:209
msgid ""
"*encode_func* is a function that takes a Unicode string, and returns a 2-"
"tuple ``(string, length)``.  *string* is an 8-bit string containing a "
"portion (perhaps all) of the Unicode string converted into the given "
"encoding, and *length* tells you how much of the Unicode string was "
"converted."
msgstr ""
"*encode_func* est une fonction qui prend une chaîne Unicode, et renvoie un n-"
"uplet de longueur 2 ``(string, length)``.  *string* est une chaîne de "
"caractères à 8 bits contenant une partie (ou la totalité) de la chaîne "
"Unicode convertie en codage donné, et *length* vous indique le nombre de "
"caractères de la chaîne qui ont été convertis."

#: whatsnew/2.0.rst:214
msgid ""
"*decode_func* is the opposite of *encode_func*, taking an 8-bit string and "
"returning a 2-tuple ``(ustring, length)``, consisting of the resulting "
"Unicode string *ustring* and the integer *length* telling how much of the 8-"
"bit string was consumed."
msgstr ""
"*decode_func* est l’opposé de *encode_func*, en prenant une chaîne de "
"caractères à 8 bits et le retour d’une paire ``(ustring, longueur)``, "
"composé de la chaîne Unicode résultante *ustring* et l’entier *length* "
"indiquant combien de caractères de la chaîne de caractères à 8 bits ont été "
"consommés."

#: whatsnew/2.0.rst:219
msgid ""
"*stream_reader* is a class that supports decoding input from a stream. "
"*stream_reader(file_obj)* returns an object that supports the :meth:`read`, :"
"meth:`readline`, and :meth:`readlines` methods.  These methods will all "
"translate from the given encoding and return Unicode strings."
msgstr ""
"*stream_reader* est une classe qui prend en charge le décodage de l’entrée "
"d’un flux. *stream_reader(file_obj)* renvoie un objet qui prend en charge "
"les méthodes :meth:`read`, :meth:`readline` et :meth:`readlines`.  Ces "
"méthodes se traduisent toutes à partir de l’encodage donné et retourneront "
"une chaînes de caractère Unicode."

#: whatsnew/2.0.rst:224
msgid ""
"*stream_writer*, similarly, is a class that supports encoding output to a "
"stream.  *stream_writer(file_obj)* returns an object that supports the :meth:"
"`write` and :meth:`writelines` methods.  These methods expect Unicode "
"strings, translating them to the given encoding on output."
msgstr ""
"De même, *stream_writer* est une classe qui prend en charge le codage de "
"sortie d’un flux.  *stream_writer(file_obj)* renvoie un objet qui prend en "
"charge les méthodes :meth:`write` et :meth:`writelines`.  Ces méthodes "
"prennent en entrée des chaînes Unicode, qu'elles renvoient, traduites à "
"l'encodage donné, sur la sortie."

#: whatsnew/2.0.rst:229
msgid ""
"For example, the following code writes a Unicode string into a file,  "
"encoding it as UTF-8::"
msgstr ""
"Par exemple, le code suivant écrit une chaîne Unicode dans un fichier, en "
"l’encodant en UTF-8 ::"

#: whatsnew/2.0.rst:243
msgid "The following code would then read UTF-8 input from the file::"
msgstr "Le code suivant lirait ensuite le texte UTF-8 du fichier ::"

#: whatsnew/2.0.rst:249
msgid ""
"Unicode-aware regular expressions are available through the :mod:`re` "
"module, which has a new underlying implementation called SRE written by "
"Fredrik Lundh of Secret Labs AB."
msgstr ""
"Des expressions rationnelles supportant l’Unicode sont disponibles dans le "
"module :mod:`re`, qui a une implémentation sous-jacente appelée SRE écrite "
"par Fredrik Lundh de Secret Labs AB."

#: whatsnew/2.0.rst:253
msgid ""
"A ``-U`` command line option was added which causes the Python compiler to "
"interpret all string literals as Unicode string literals. This is intended "
"to be used in testing and future-proofing your Python code, since some "
"future version of Python may drop support for 8-bit strings and provide only "
"Unicode strings."
msgstr ""
"Une option de ligne de commande ``-U`` a été ajoutée, ce qui fait que le "
"compilateur Python interprète toutes les chaînes de caractères comme des "
"chaînes de caractères Unicode. Ceci est destiné à être utilisé dans les "
"tests et rendre votre code Python compatible avec les versions futures, car "
"une version future de Python peut abandonner la prise en charge des chaînes "
"de caractères 8-bits et fournir uniquement des chaînes de caractères Unicode."

#: whatsnew/2.0.rst:262
msgid "List Comprehensions"
msgstr "Compréhensions de listes"

#: whatsnew/2.0.rst:264
msgid ""
"Lists are a workhorse data type in Python, and many programs manipulate a "
"list at some point.  Two common operations on lists are to loop over them, "
"and either pick out the elements that meet a certain criterion, or apply "
"some function to each element.  For example, given a list of strings, you "
"might want to pull out all the strings containing a given substring, or "
"strip off trailing whitespace from each line."
msgstr ""
"Les listes sont un type de données crucial dans Python, et de nombreux "
"programmes manipulent une liste à un moment donné.  Deux opérations communes "
"sur les listes sont de boucler sur elles, soit de choisir les éléments qui "
"répondent à un certain critère, ou d’appliquer une certaine fonction à "
"chaque élément. Par exemple, à partir d’une liste de chaînes de caractères, "
"vous pouvez retirer toutes les chaînes contenant une sous-chaîne donnée, ou "
"enlever les espaces de chaque ligne."

#: whatsnew/2.0.rst:271
msgid ""
"The existing :func:`map` and :func:`filter` functions can be used for this "
"purpose, but they require a function as one of their arguments.  This is "
"fine if there's an existing built-in function that can be passed directly, "
"but if there isn't, you have to create a little function to do the required "
"work, and Python's scoping rules make the result ugly if the little function "
"needs additional information.  Take the first example in the previous "
"paragraph, finding all the strings in the list containing a given "
"substring.  You could write the following to do it::"
msgstr ""
"Les fonctions existantes :func:`map` et :func:`filter` peuvent être "
"utilisées à cette fin, mais elles nécessitent une fonction en leurs "
"arguments.  C’est très bien s’il y a une fonction intégrée existante qui "
"peut être passé directement, mais s’il n’y a pas, vous devez créer une "
"petite fonction pour faire le travail requis, et les règles de portée de "
"Python rendent le résultat laid si la petite fonction a besoin "
"d’informations supplémentaires.  Prenons le premier exemple du paragraphe "
"précédent, en trouvant toutes les chaînes de la liste contenant une sous-"
"chaîne donnée.  Vous pouvez écrire ce qui suit pour le faire ::"

#: whatsnew/2.0.rst:286
msgid ""
"Because of Python's scoping rules, a default argument is used so that the "
"anonymous function created by the :keyword:`lambda` expression knows what "
"substring is being searched for.  List comprehensions make this cleaner::"
msgstr ""
"En raison des règles de portée de Python, un argument par défaut est utilisé "
"de sorte que la fonction anonyme créée par l’expression :keyword:`lambda` "
"sait quelle sous-chaîne est recherchée.  Les listes en compréhension rendent "
"ceci plus propre ::"

#: whatsnew/2.0.rst:292
msgid "List comprehensions have the form::"
msgstr "Les compréhensions de liste sont de la forme suivante ::"

#: whatsnew/2.0.rst:299
msgid ""
"The :keyword:`!for`...\\ :keyword:`!in` clauses contain the sequences to be "
"iterated over.  The sequences do not have to be the same length, because "
"they are *not* iterated over in parallel, but from left to right; this is "
"explained more clearly in the following paragraphs.  The elements of the "
"generated list will be the successive values of *expression*.  The final :"
"keyword:`!if` clause is optional; if present, *expression* is only evaluated "
"and added to the result if *condition* is true."
msgstr ""
"Le :keyword:`!for`…\\ :keyword:`!in` clauses contiennent les séquences à "
"itérer.  Les séquences n’ont pas à être de la même longueur, parce qu’elles "
"ne sont *pas* itérées en parallèle, mais de gauche à droite; cela est "
"expliqué plus clairement dans les paragraphes suivants.  Les éléments de la "
"liste générée seront les valeurs successives de l’expression.  La clause "
"finale :keyword:`!if` clause est facultative ; si présent, l’*expression* "
"n’est évaluée et ajoutée au résultat que si la *condition* est vraie."

#: whatsnew/2.0.rst:307
msgid ""
"To make the semantics very clear, a list comprehension is equivalent to the "
"following Python code::"
msgstr ""
"Pour que la sémantique soit très claire, une compréhension de liste est "
"équivalente au code Python suivant ::"

#: whatsnew/2.0.rst:319
msgid ""
"This means that when there are multiple :keyword:`!for`...\\ :keyword:`!in` "
"clauses, the resulting list will be equal to the product of the lengths of "
"all the sequences.  If you have two lists of length 3, the output list is 9 "
"elements long::"
msgstr ""
"Cela signifie que lorsqu’il y a plusieurs :keyword:`!for`…\\ :keyword:`!in` "
"clauses, la liste résultante sera égale au produit des longueurs de toutes "
"les séquences.  Si vous avez deux listes de longueur 3, la liste de sortie "
"est de longueur 9 ::"

#: whatsnew/2.0.rst:330
msgid ""
"To avoid introducing an ambiguity into Python's grammar, if *expression* is "
"creating a tuple, it must be surrounded with parentheses.  The first list "
"comprehension below is a syntax error, while the second one is correct::"
msgstr ""
"Afin de ne pas introduire une ambiguïté dans la grammaire de Python, "
"*expression* doit être encadrée par des parenthèses si elle produit un n-"
"uplet. La première compréhension de liste ci-dessous n'est pas valide "
"syntaxiquement, tandis que la seconde l'est ::"

#: whatsnew/2.0.rst:339
msgid ""
"The idea of list comprehensions originally comes from the functional "
"programming language Haskell (https://www.haskell.org).  Greg Ewing argued "
"most effectively for adding them to Python and wrote the initial list "
"comprehension patch, which was then discussed for a seemingly endless time "
"on the python-dev mailing list and kept up-to-date by Skip Montanaro."
msgstr ""
"Le concept des liste en compréhension provient à l’origine du langage de "
"programmation fonctionnelle Haskell (https://www.haskell.org).  Greg Ewing a "
"plaidé le plus efficacement pour les ajouter à Python et a écrit le patch de "
"compréhension de liste initiale, qui a ensuite été discuté pendant un temps "
"apparemment sans fin sur la liste de diffusion *python-dev* et maintenu à "
"jour par Skip Montanaro."

#: whatsnew/2.0.rst:349
msgid "Augmented Assignment"
msgstr "Opérateurs d’affectation augmentées"

#: whatsnew/2.0.rst:351
msgid ""
"Augmented assignment operators, another long-requested feature, have been "
"added to Python 2.0.  Augmented assignment operators include ``+=``, ``-=``, "
"``*=``, and so forth.  For example, the statement ``a += 2`` increments the "
"value of the variable  ``a`` by 2, equivalent to the slightly lengthier ``a "
"= a + 2``."
msgstr ""
"Les opérateurs d’affectation soudées, une autre fonctionnalité demandée "
"depuis longtemps, ont été ajoutés à Python 2.0.  Les opérateurs "
"d’affectations augmentées comprennent  ``+=``, ``-=``, ``*=`` et ainsi de "
"suite. Par exemple, l’instruction ``a += 2`` incrémente la valeur de la "
"variable ``a`` par 2, équivalente à l’opération ``a = a + 2`` ."

#: whatsnew/2.0.rst:356
msgid ""
"The full list of supported assignment operators is ``+=``, ``-=``, ``*=``, "
"``/=``, ``%=``, ``**=``, ``&=``, ``|=``, ``^=``, ``>>=``, and ``<<=``.  "
"Python classes can override the augmented assignment operators by defining "
"methods named :meth:`__iadd__`, :meth:`__isub__`, etc.  For example, the "
"following :class:`Number` class stores a number and supports using += to "
"create a new instance with an incremented value."
msgstr ""
"La liste complète des opérateurs d’affectations pris en charge est  ``+=``, "
"``-=``, ``*=``, ``/=``, ``%=``, ``**=``, ``&=``, ``|=``, ``^=``, ``>>=``, et "
"``<<=``. Les classes Python peuvent remplacer les opérateurs d’affectations "
"augmentées en définissant des méthodes nommées :meth:`__iadd__`, :meth:"
"`__isub__`, etc.  Par exemple, la classe :class:`Number` stocke un nombre et "
"prend en charge l’utilisation de += en créant une nouvelle instance avec une "
"valeur incrémentée."

#: whatsnew/2.0.rst:377
msgid ""
"The :meth:`__iadd__` special method is called with the value of the "
"increment, and should return a new instance with an appropriately modified "
"value; this return value is bound as the new value of the variable on the "
"left-hand side."
msgstr ""
"La méthode spéciale :meth:`__iadd__` est appelée avec la valeur de "
"l’incrément, et doit renvoyer une nouvelle instance avec une valeur "
"correctement modifiée ; cette valeur de rendement est liée comme la nouvelle "
"valeur de la variable sur le côté gauche."

#: whatsnew/2.0.rst:381
msgid ""
"Augmented assignment operators were first introduced in the C programming "
"language, and most C-derived languages, such as :program:`awk`, C++, Java, "
"Perl, and PHP also support them.  The augmented assignment patch was "
"implemented by Thomas Wouters."
msgstr ""

#: whatsnew/2.0.rst:390
msgid "String Methods"
msgstr "Méthodes de chaînes de caractères"

#: whatsnew/2.0.rst:392
msgid ""
"Until now string-manipulation functionality was in the :mod:`string` module, "
"which was usually a front-end for the :mod:`strop` module written in C.  The "
"addition of Unicode posed a difficulty for the :mod:`strop` module, because "
"the functions would all need to be rewritten in order to accept either 8-bit "
"or Unicode strings.  For functions such as :func:`string.replace`, which "
"takes 3 string arguments, that means eight possible permutations, and "
"correspondingly complicated code."
msgstr ""

#: whatsnew/2.0.rst:400
msgid ""
"Instead, Python 2.0 pushes the problem onto the string type, making string "
"manipulation functionality available through methods on both 8-bit strings "
"and Unicode strings.   ::"
msgstr ""

#: whatsnew/2.0.rst:411
msgid ""
"One thing that hasn't changed, a noteworthy April Fools' joke "
"notwithstanding, is that Python strings are immutable. Thus, the string "
"methods return new strings, and do not modify the string on which they "
"operate."
msgstr ""

#: whatsnew/2.0.rst:415
msgid ""
"The old :mod:`string` module is still around for backwards compatibility, "
"but it mostly acts as a front-end to the new string methods."
msgstr ""

#: whatsnew/2.0.rst:418
msgid ""
"Two methods which have no parallel in pre-2.0 versions, although they did "
"exist in JPython for quite some time, are :meth:`startswith` and :meth:"
"`endswith`. ``s.startswith(t)`` is equivalent to ``s[:len(t)] == t``, while "
"``s.endswith(t)`` is equivalent to ``s[-len(t):] == t``."
msgstr ""

#: whatsnew/2.0.rst:423
msgid ""
"One other method which deserves special mention is :meth:`join`.  The :meth:"
"`join` method of a string receives one parameter, a sequence of strings, and "
"is equivalent to the :func:`string.join` function from the old :mod:`string` "
"module, with the arguments reversed. In other words, ``s.join(seq)`` is "
"equivalent to the old ``string.join(seq, s)``."
msgstr ""

#: whatsnew/2.0.rst:433
msgid "Garbage Collection of Cycles"
msgstr ""

#: whatsnew/2.0.rst:435
msgid ""
"The C implementation of Python uses reference counting to implement garbage "
"collection.  Every Python object maintains a count of the number of "
"references pointing to itself, and adjusts the count as references are "
"created or destroyed.  Once the reference count reaches zero, the object is "
"no longer accessible, since you need to have a reference to an object to "
"access it, and if the count is zero, no references exist any longer."
msgstr ""

#: whatsnew/2.0.rst:442
msgid ""
"Reference counting has some pleasant properties: it's easy to understand and "
"implement, and the resulting implementation is portable, fairly fast, and "
"reacts well with other libraries that implement their own memory handling "
"schemes.  The major problem with reference counting is that it sometimes "
"doesn't realise that objects are no longer accessible, resulting in a memory "
"leak.  This happens when there are cycles of references."
msgstr ""

#: whatsnew/2.0.rst:449
msgid ""
"Consider the simplest possible cycle,  a class instance which has a "
"reference to itself::"
msgstr ""

#: whatsnew/2.0.rst:455
msgid ""
"After the above two lines of code have been executed, the reference count of "
"``instance`` is 2; one reference is from the variable named ``'instance'``, "
"and the other is from the ``myself`` attribute of the instance."
msgstr ""

#: whatsnew/2.0.rst:459
msgid ""
"If the next line of code is ``del instance``, what happens?  The reference "
"count of ``instance`` is decreased by 1, so it has a reference count of 1; "
"the reference in the ``myself`` attribute still exists.  Yet the instance is "
"no longer accessible through Python code, and it could be deleted.  Several "
"objects can participate in a cycle if they have references to each other, "
"causing all of the objects to be leaked."
msgstr ""

#: whatsnew/2.0.rst:466
msgid ""
"Python 2.0 fixes this problem by periodically executing a cycle detection "
"algorithm which looks for inaccessible cycles and deletes the objects "
"involved. A new :mod:`gc` module provides functions to perform a garbage "
"collection, obtain debugging statistics, and tuning the collector's "
"parameters."
msgstr ""

#: whatsnew/2.0.rst:471
msgid ""
"Running the cycle detection algorithm takes some time, and therefore will "
"result in some additional overhead.  It is hoped that after we've gotten "
"experience with the cycle collection from using 2.0, Python 2.1 will be able "
"to minimize the overhead with careful tuning.  It's not yet obvious how much "
"performance is lost, because benchmarking this is tricky and depends "
"crucially on how often the program creates and destroys objects.  The "
"detection of cycles can be disabled when Python is compiled, if you can't "
"afford even a tiny speed penalty or suspect that the cycle collection is "
"buggy, by specifying the :option:`!--without-cycle-gc` switch when running "
"the :program:`configure` script."
msgstr ""

#: whatsnew/2.0.rst:482
msgid ""
"Several people tackled this problem and contributed to a solution.  An early "
"implementation of the cycle detection approach was written by Toby Kelsey.  "
"The current algorithm was suggested by Eric Tiedemann during a visit to "
"CNRI, and Guido van Rossum and Neil Schemenauer wrote two different "
"implementations, which were later integrated by Neil.  Lots of other people "
"offered suggestions along the way; the March 2000 archives of the python-dev "
"mailing list contain most of the relevant discussion, especially in the "
"threads titled \"Reference cycle collection for Python\" and \"Finalization "
"again\"."
msgstr ""

#: whatsnew/2.0.rst:495
msgid "Other Core Changes"
msgstr ""

#: whatsnew/2.0.rst:497
msgid ""
"Various minor changes have been made to Python's syntax and built-in "
"functions. None of the changes are very far-reaching, but they're handy "
"conveniences."
msgstr ""

#: whatsnew/2.0.rst:502
msgid "Minor Language Changes"
msgstr "Changements mineurs du langage"

#: whatsnew/2.0.rst:504
msgid ""
"A new syntax makes it more convenient to call a given function with a tuple "
"of arguments and/or a dictionary of keyword arguments. In Python 1.5 and "
"earlier, you'd use the :func:`apply` built-in function: ``apply(f, args, "
"kw)`` calls the function :func:`f` with the argument tuple *args* and the "
"keyword arguments in the dictionary *kw*.  :func:`apply`  is the same in "
"2.0, but thanks to a patch from Greg Ewing, ``f(*args, **kw)`` is a shorter "
"and clearer way to achieve the same effect.  This syntax is symmetrical with "
"the syntax for defining functions::"
msgstr ""

#: whatsnew/2.0.rst:518
msgid ""
"The ``print`` statement can now have its output directed to a file-like "
"object by following the ``print`` with  ``>> file``, similar to the "
"redirection operator in Unix shells. Previously you'd either have to use "
"the :meth:`write` method of the file-like object, which lacks the "
"convenience and simplicity of ``print``, or you could assign a new value to "
"``sys.stdout`` and then restore the old value.  For sending output to "
"standard error, it's much easier to write this::"
msgstr ""

#: whatsnew/2.0.rst:528
msgid ""
"Modules can now be renamed on importing them, using the syntax ``import "
"module as name`` or ``from module import name as othername``.  The patch was "
"submitted by Thomas Wouters."
msgstr ""

#: whatsnew/2.0.rst:532
msgid ""
"A new format style is available when using the ``%`` operator; '%r' will "
"insert the :func:`repr` of its argument.  This was also added from symmetry "
"considerations, this time for symmetry with the existing '%s' format style, "
"which inserts the :func:`str` of its argument.  For example, ``'%r %s' % "
"('abc', 'abc')`` returns a string containing ``'abc' abc``."
msgstr ""

#: whatsnew/2.0.rst:538
msgid ""
"Previously there was no way to implement a class that overrode Python's "
"built-in :keyword:`in` operator and implemented a custom version.  ``obj in "
"seq`` returns true if *obj* is present in the sequence *seq*; Python "
"computes this by simply trying every index of the sequence until either "
"*obj* is found or an :exc:`IndexError` is encountered.  Moshe Zadka "
"contributed a patch which adds a :meth:`__contains__` magic method for "
"providing a custom implementation for :keyword:`!in`. Additionally, new "
"built-in objects written in C can define what :keyword:`!in` means for them "
"via a new slot in the sequence protocol."
msgstr ""

#: whatsnew/2.0.rst:547
msgid ""
"Earlier versions of Python used a recursive algorithm for deleting objects. "
"Deeply nested data structures could cause the interpreter to fill up the C "
"stack and crash; Christian Tismer rewrote the deletion logic to fix this "
"problem.  On a related note, comparing recursive objects recursed infinitely "
"and crashed; Jeremy Hylton rewrote the code to no longer crash, producing a "
"useful result instead.  For example, after this code::"
msgstr ""

#: whatsnew/2.0.rst:559
msgid ""
"The comparison ``a==b`` returns true, because the two recursive data "
"structures are isomorphic. See the thread \"trashcan and PR#7\" in the April "
"2000 archives of the python-dev mailing list for the discussion leading up "
"to this implementation, and some useful relevant links.    Note that "
"comparisons can now also raise exceptions. In earlier versions of Python, a "
"comparison operation such as ``cmp(a,b)`` would always produce an answer, "
"even if a user-defined :meth:`__cmp__` method encountered an error, since "
"the resulting exception would simply be silently swallowed."
msgstr ""

#: whatsnew/2.0.rst:571
msgid ""
"Work has been done on porting Python to 64-bit Windows on the Itanium "
"processor, mostly by Trent Mick of ActiveState.  (Confusingly, ``sys."
"platform`` is still ``'win32'`` on Win64 because it seems that for ease of "
"porting, MS Visual C++ treats code as 32 bit on Itanium.) PythonWin also "
"supports Windows CE; see the Python CE page at https://pythonce.sourceforge."
"net/ for more information."
msgstr ""

#: whatsnew/2.0.rst:577
msgid ""
"Another new platform is Darwin/MacOS X; initial support for it is in Python "
"2.0. Dynamic loading works, if you specify \"configure --with-dyld --with-"
"suffix=.x\". Consult the README in the Python source distribution for more "
"instructions."
msgstr ""

#: whatsnew/2.0.rst:581
msgid ""
"An attempt has been made to alleviate one of Python's warts, the often-"
"confusing :exc:`NameError` exception when code refers to a local variable "
"before the variable has been assigned a value.  For example, the following "
"code raises an exception on the ``print`` statement in both 1.5.2 and 2.0; "
"in 1.5.2 a :exc:`NameError` exception is raised, while 2.0 raises a new :exc:"
"`UnboundLocalError` exception. :exc:`UnboundLocalError` is a subclass of :"
"exc:`NameError`, so any existing code that expects :exc:`NameError` to be "
"raised should still work. ::"
msgstr ""

#: whatsnew/2.0.rst:595
msgid ""
"Two new exceptions, :exc:`TabError` and :exc:`IndentationError`, have been "
"introduced.  They're both subclasses of :exc:`SyntaxError`, and are raised "
"when Python code is found to be improperly indented."
msgstr ""

#: whatsnew/2.0.rst:601
msgid "Changes to Built-in Functions"
msgstr "Changements concernant les fonctions primitives"

#: whatsnew/2.0.rst:603
msgid ""
"A new built-in, ``zip(seq1, seq2, ...)``, has been added.  :func:`zip` "
"returns a list of tuples where each tuple contains the i-th element from "
"each of the argument sequences.  The difference between :func:`zip` and "
"``map(None, seq1, seq2)`` is that :func:`map` pads the sequences with "
"``None`` if the sequences aren't all of the same length, while :func:`zip` "
"truncates the returned list to the length of the shortest argument sequence."
msgstr ""

#: whatsnew/2.0.rst:610
msgid ""
"The :func:`int` and :func:`long` functions now accept an optional \"base\" "
"parameter when the first argument is a string. ``int('123', 10)`` returns "
"123, while ``int('123', 16)`` returns 291.  ``int(123, 16)`` raises a :exc:"
"`TypeError` exception with the message \"can't convert non-string with "
"explicit base\"."
msgstr ""

#: whatsnew/2.0.rst:616
msgid ""
"A new variable holding more detailed version information has been added to "
"the :mod:`sys` module.  ``sys.version_info`` is a tuple ``(major, minor, "
"micro, level, serial)`` For example, in a hypothetical 2.0.1beta1, ``sys."
"version_info`` would be ``(2, 0, 1, 'beta', 1)``. *level* is a string such "
"as ``\"alpha\"``, ``\"beta\"``, or ``\"final\"`` for a final release."
msgstr ""

#: whatsnew/2.0.rst:622
msgid ""
"Dictionaries have an odd new method, ``setdefault(key, default)``, which "
"behaves similarly to the existing :meth:`get` method.  However, if the key "
"is missing, :meth:`setdefault` both returns the value of *default* as :meth:"
"`get` would do, and also inserts it into the dictionary as the value for "
"*key*.  Thus, the following lines of code::"
msgstr ""

#: whatsnew/2.0.rst:633
msgid ""
"can be reduced to a single ``return dict.setdefault(key, [])`` statement."
msgstr ""

#: whatsnew/2.0.rst:635
msgid ""
"The interpreter sets a maximum recursion depth in order to catch runaway "
"recursion before filling the C stack and causing a core dump or GPF.. "
"Previously this limit was fixed when you compiled Python, but in 2.0 the "
"maximum recursion depth can be read and modified using :func:`sys."
"getrecursionlimit` and :func:`sys.setrecursionlimit`. The default value is "
"1000, and a rough maximum value for a given platform can be found by running "
"a new script, :file:`Misc/find_recursionlimit.py`."
msgstr ""

#: whatsnew/2.0.rst:647
msgid "Porting to 2.0"
msgstr ""

#: whatsnew/2.0.rst:649
msgid ""
"New Python releases try hard to be compatible with previous releases, and "
"the record has been pretty good.  However, some changes are considered "
"useful enough, usually because they fix initial design decisions that turned "
"out to be actively mistaken, that breaking backward compatibility can't "
"always be avoided. This section lists the changes in Python 2.0 that may "
"cause old Python code to break."
msgstr ""

#: whatsnew/2.0.rst:656
msgid ""
"The change which will probably break the most code is tightening up the "
"arguments accepted by some methods.  Some methods would take multiple "
"arguments and treat them as a tuple, particularly various list methods such "
"as :meth:`append` and :meth:`insert`. In earlier versions of Python, if "
"``L`` is a list, ``L.append( 1,2 )`` appends the tuple ``(1,2)`` to the "
"list.  In Python 2.0 this causes a :exc:`TypeError` exception to be raised, "
"with the message: 'append requires exactly 1 argument; 2 given'.  The fix is "
"to simply add an extra set of parentheses to pass both values as a tuple:  "
"``L.append( (1,2) )``."
msgstr ""

#: whatsnew/2.0.rst:665
msgid ""
"The earlier versions of these methods were more forgiving because they used "
"an old function in Python's C interface to parse their arguments; 2.0 "
"modernizes them to use :func:`PyArg_ParseTuple`, the current argument "
"parsing function, which provides more helpful error messages and treats "
"multi-argument calls as errors.  If you absolutely must use 2.0 but can't "
"fix your code, you can edit :file:`Objects/listobject.c` and define the "
"preprocessor symbol ``NO_STRICT_LIST_APPEND`` to preserve the old behaviour; "
"this isn't recommended."
msgstr ""

#: whatsnew/2.0.rst:673
msgid ""
"Some of the functions in the :mod:`socket` module are still forgiving in "
"this way.  For example, :func:`socket.connect( ('hostname', 25) )` is the "
"correct form, passing a tuple representing an IP address, but :func:`socket."
"connect( 'hostname', 25 )` also works. :func:`socket.connect_ex` and :func:"
"`socket.bind` are similarly easy-going.  2.0alpha1 tightened these functions "
"up, but because the documentation actually used the erroneous multiple "
"argument form, many people wrote code which would break with the stricter "
"checking.  GvR backed out the changes in the face of public reaction, so for "
"the :mod:`socket` module, the documentation was fixed and the multiple "
"argument form is simply marked as deprecated; it *will* be tightened up "
"again in a future Python version."
msgstr ""

#: whatsnew/2.0.rst:684
msgid ""
"The ``\\x`` escape in string literals now takes exactly 2 hex digits.  "
"Previously it would consume all the hex digits following the 'x' and take "
"the lowest 8 bits of the result, so ``\\x123456`` was equivalent to "
"``\\x56``."
msgstr ""

#: whatsnew/2.0.rst:688
msgid ""
"The :exc:`AttributeError` and :exc:`NameError` exceptions have a more "
"friendly error message, whose text will be something like ``'Spam' instance "
"has no attribute 'eggs'`` or ``name 'eggs' is not defined``.  Previously the "
"error message was just the missing attribute name ``eggs``, and code written "
"to take advantage of this fact will break in 2.0."
msgstr ""

#: whatsnew/2.0.rst:694
msgid ""
"Some work has been done to make integers and long integers a bit more "
"interchangeable.  In 1.5.2, large-file support was added for Solaris, to "
"allow reading files larger than 2 GiB; this made the :meth:`tell` method of "
"file objects return a long integer instead of a regular integer.  Some code "
"would subtract two file offsets and attempt to use the result to multiply a "
"sequence or slice a string, but this raised a :exc:`TypeError`.  In 2.0, "
"long integers can be used to multiply or slice a sequence, and it'll behave "
"as you'd intuitively expect it to; ``3L * 'abc'`` produces 'abcabcabc', and "
"``(0,1,2,3)[2L:4L]`` produces (2,3). Long integers can also be used in "
"various contexts where previously only integers were accepted, such as in "
"the :meth:`seek` method of file objects, and in the formats supported by the "
"``%`` operator (``%d``, ``%i``, ``%x``, etc.).  For example, ``\"%d\" % "
"2L**64`` will produce the string ``18446744073709551616``."
msgstr ""

#: whatsnew/2.0.rst:708
msgid ""
"The subtlest long integer change of all is that the :func:`str` of a long "
"integer no longer has a trailing 'L' character, though :func:`repr` still "
"includes it.  The 'L' annoyed many people who wanted to print long integers "
"that looked just like regular integers, since they had to go out of their "
"way to chop off the character.  This is no longer a problem in 2.0, but code "
"which does ``str(longval)[:-1]`` and assumes the 'L' is there, will now lose "
"the final digit."
msgstr ""

#: whatsnew/2.0.rst:716
msgid ""
"Taking the :func:`repr` of a float now uses a different formatting precision "
"than :func:`str`.  :func:`repr` uses ``%.17g`` format string for C's :func:"
"`sprintf`, while :func:`str` uses ``%.12g`` as before.  The effect is that :"
"func:`repr` may occasionally show more decimal places than  :func:`str`, for "
"certain numbers.  For example, the number 8.1 can't be represented exactly "
"in binary, so ``repr(8.1)`` is ``'8.0999999999999996'``, while str(8.1) is "
"``'8.1'``."
msgstr ""

#: whatsnew/2.0.rst:724
msgid ""
"The ``-X`` command-line option, which turned all standard exceptions into "
"strings instead of classes, has been removed; the standard exceptions will "
"now always be classes.  The :mod:`exceptions` module containing the standard "
"exceptions was translated from Python to a built-in C module, written by "
"Barry Warsaw and Fredrik Lundh."
msgstr ""

#: whatsnew/2.0.rst:740
msgid "Extending/Embedding Changes"
msgstr ""

#: whatsnew/2.0.rst:742
msgid ""
"Some of the changes are under the covers, and will only be apparent to "
"people writing C extension modules or embedding a Python interpreter in a "
"larger application.  If you aren't dealing with Python's C API, you can "
"safely skip this section."
msgstr ""

#: whatsnew/2.0.rst:747
msgid ""
"The version number of the Python C API was incremented, so C extensions "
"compiled for 1.5.2 must be recompiled in order to work with 2.0.  On "
"Windows, it's not possible for Python 2.0 to import a third party extension "
"built for Python 1.5.x due to how Windows DLLs work, so Python will raise an "
"exception and the import will fail."
msgstr ""

#: whatsnew/2.0.rst:753
msgid ""
"Users of Jim Fulton's ExtensionClass module will be pleased to find out that "
"hooks have been added so that ExtensionClasses are now supported by :func:"
"`isinstance` and :func:`issubclass`. This means you no longer have to "
"remember to write code such as ``if type(obj) == myExtensionClass``, but can "
"use the more natural ``if isinstance(obj, myExtensionClass)``."
msgstr ""

#: whatsnew/2.0.rst:759
msgid ""
"The :file:`Python/importdl.c` file, which was a mass of #ifdefs to support "
"dynamic loading on many different platforms, was cleaned up and reorganised "
"by Greg Stein.  :file:`importdl.c` is now quite small, and platform-specific "
"code has been moved into a bunch of :file:`Python/dynload_\\*.c` files.  "
"Another cleanup: there were also a number of :file:`my\\*.h` files in the "
"Include/ directory that held various portability hacks; they've been merged "
"into a single file, :file:`Include/pyport.h`."
msgstr ""

#: whatsnew/2.0.rst:767
msgid ""
"Vladimir Marangozov's long-awaited malloc restructuring was completed, to "
"make it easy to have the Python interpreter use a custom allocator instead "
"of C's standard :func:`malloc`.  For documentation, read the comments in :"
"file:`Include/pymem.h` and :file:`Include/objimpl.h`.  For the lengthy "
"discussions during which the interface was hammered out, see the web "
"archives of the 'patches' and 'python-dev' lists at python.org."
msgstr ""

#: whatsnew/2.0.rst:774
msgid ""
"Recent versions of the GUSI development environment for MacOS support POSIX "
"threads.  Therefore, Python's POSIX threading support now works on the "
"Macintosh.  Threading support using the user-space GNU ``pth`` library was "
"also contributed."
msgstr ""

#: whatsnew/2.0.rst:779
msgid ""
"Threading support on Windows was enhanced, too.  Windows supports thread "
"locks that use kernel objects only in case of contention; in the common case "
"when there's no contention, they use simpler functions which are an order of "
"magnitude faster.  A threaded version of Python 1.5.2 on NT is twice as slow "
"as an unthreaded version; with the 2.0 changes, the difference is only 10%.  "
"These improvements were contributed by Yakov Markovitch."
msgstr ""

#: whatsnew/2.0.rst:786
msgid ""
"Python 2.0's source now uses only ANSI C prototypes, so compiling Python now "
"requires an ANSI C compiler, and can no longer be done using a compiler that "
"only supports K&R C."
msgstr ""

#: whatsnew/2.0.rst:790
msgid ""
"Previously the Python virtual machine used 16-bit numbers in its bytecode, "
"limiting the size of source files.  In particular, this affected the maximum "
"size of literal lists and dictionaries in Python source; occasionally people "
"who are generating Python code would run into this limit.  A patch by "
"Charles G. Waldman raises the limit from ``2**16`` to ``2**32``."
msgstr ""

#: whatsnew/2.0.rst:796
msgid ""
"Three new convenience functions intended for adding constants to a module's "
"dictionary at module initialization time were added: :func:"
"`PyModule_AddObject`, :func:`PyModule_AddIntConstant`, and :func:"
"`PyModule_AddStringConstant`.  Each of these functions takes a module "
"object, a null-terminated C string containing the name to be added, and a "
"third argument for the value to be assigned to the name.  This third "
"argument is, respectively, a Python object, a C long, or a C string."
msgstr ""

#: whatsnew/2.0.rst:804
msgid ""
"A wrapper API was added for Unix-style signal handlers. :func:`PyOS_getsig` "
"gets a signal handler and :func:`PyOS_setsig` will set a new handler."
msgstr ""

#: whatsnew/2.0.rst:811
msgid "Distutils: Making Modules Easy to Install"
msgstr ""

#: whatsnew/2.0.rst:813
msgid ""
"Before Python 2.0, installing modules was a tedious affair -- there was no "
"way to figure out automatically where Python is installed, or what compiler "
"options to use for extension modules.  Software authors had to go through an "
"arduous ritual of editing Makefiles and configuration files, which only "
"really work on Unix and leave Windows and MacOS unsupported.  Python users "
"faced wildly differing installation instructions which varied between "
"different extension packages, which made administering a Python installation "
"something of  a chore."
msgstr ""

#: whatsnew/2.0.rst:821
msgid ""
"The SIG for distribution utilities, shepherded by Greg Ward, has created the "
"Distutils, a system to make package installation much easier.  They form "
"the :mod:`distutils` package, a new part of Python's standard library. In "
"the best case, installing a Python module from source will require the same "
"steps: first you simply mean unpack the tarball or zip archive, and the run "
"\"``python setup.py install``\".  The platform will be automatically "
"detected, the compiler will be recognized, C extension modules will be "
"compiled, and the distribution installed into the proper directory.  "
"Optional command-line arguments provide more control over the installation "
"process, the distutils package offers many places to override defaults -- "
"separating the build from the install, building or installing in non-default "
"directories, and more."
msgstr ""

#: whatsnew/2.0.rst:833
msgid ""
"In order to use the Distutils, you need to write a :file:`setup.py` script.  "
"For the simple case, when the software contains only .py files, a minimal :"
"file:`setup.py` can be just a few lines long::"
msgstr ""

#: whatsnew/2.0.rst:841
msgid ""
"The :file:`setup.py` file isn't much more complicated if the software "
"consists of a few packages::"
msgstr ""

#: whatsnew/2.0.rst:848
msgid ""
"A C extension can be the most complicated case; here's an example taken from "
"the PyXML package::"
msgstr ""

#: whatsnew/2.0.rst:864
msgid ""
"The Distutils can also take care of creating source and binary "
"distributions. The \"sdist\" command, run by \"``python setup.py sdist``', "
"builds a source distribution such as :file:`foo-1.0.tar.gz`. Adding new "
"commands isn't difficult, \"bdist_rpm\" and \"bdist_wininst\" commands have "
"already been contributed to create an RPM distribution and a Windows "
"installer for the software, respectively.  Commands to create other "
"distribution formats such as Debian packages and Solaris :file:`.pkg` files "
"are in various stages of development."
msgstr ""

#: whatsnew/2.0.rst:873
msgid ""
"All this is documented in a new manual, *Distributing Python Modules*, that "
"joins the basic set of Python documentation."
msgstr ""

#: whatsnew/2.0.rst:880
msgid "XML Modules"
msgstr "Modules XML"

#: whatsnew/2.0.rst:882
msgid ""
"Python 1.5.2 included a simple XML parser in the form of the :mod:`xmllib` "
"module, contributed by Sjoerd Mullender.  Since 1.5.2's release, two "
"different interfaces for processing XML have become common: SAX2 (version 2 "
"of the Simple API for XML) provides an event-driven interface with some "
"similarities to :mod:`xmllib`, and the DOM (Document Object Model) provides "
"a tree-based interface, transforming an XML document into a tree of nodes "
"that can be traversed and modified.  Python 2.0 includes a SAX2 interface "
"and a stripped-down DOM interface as part of the :mod:`xml` package. Here we "
"will give a brief overview of these new interfaces; consult the Python "
"documentation or the source code for complete details. The Python XML SIG is "
"also working on improved documentation."
msgstr ""

#: whatsnew/2.0.rst:896
msgid "SAX2 Support"
msgstr "Support de SAX2"

#: whatsnew/2.0.rst:898
msgid ""
"SAX defines an event-driven interface for parsing XML.  To use SAX, you must "
"write a SAX handler class.  Handler classes inherit from various classes "
"provided by SAX, and override various methods that will then be called by "
"the XML parser.  For example, the :meth:`startElement` and :meth:"
"`endElement` methods are called for every starting and end tag encountered "
"by the parser, the :meth:`characters` method is called for every chunk of "
"character data, and so forth."
msgstr ""

#: whatsnew/2.0.rst:906
msgid ""
"The advantage of the event-driven approach is that the whole document "
"doesn't have to be resident in memory at any one time, which matters if you "
"are processing really huge documents.  However, writing the SAX handler "
"class can get very complicated if you're trying to modify the document "
"structure in some elaborate way."
msgstr ""

#: whatsnew/2.0.rst:912
msgid ""
"For example, this little example program defines a handler that prints a "
"message for every starting and ending tag, and then parses the file :file:"
"`hamlet.xml` using it::"
msgstr ""

#: whatsnew/2.0.rst:935
msgid ""
"For more information, consult the Python documentation, or the XML HOWTO at "
"http://pyxml.sourceforge.net/topics/howto/xml-howto.html."
msgstr ""

#: whatsnew/2.0.rst:940
msgid "DOM Support"
msgstr "Support du DOM"

#: whatsnew/2.0.rst:942
msgid ""
"The Document Object Model is a tree-based representation for an XML "
"document.  A top-level :class:`Document` instance is the root of the tree, "
"and has a single child which is the top-level :class:`Element` instance. "
"This :class:`Element` has children nodes representing character data and any "
"sub-elements, which may have further children of their own, and so forth.  "
"Using the DOM you can traverse the resulting tree any way you like, access "
"element and attribute values, insert and delete nodes, and convert the tree "
"back into XML."
msgstr ""

#: whatsnew/2.0.rst:950
msgid ""
"The DOM is useful for modifying XML documents, because you can create a DOM "
"tree, modify it by adding new nodes or rearranging subtrees, and then "
"produce a new XML document as output.  You can also construct a DOM tree "
"manually and convert it to XML, which can be a more flexible way of "
"producing XML output than simply writing ``<tag1>``...\\ ``</tag1>`` to a "
"file."
msgstr ""

#: whatsnew/2.0.rst:956
msgid ""
"The DOM implementation included with Python lives in the :mod:`xml.dom."
"minidom` module.  It's a lightweight implementation of the Level 1 DOM with "
"support for XML namespaces.  The  :func:`parse` and :func:`parseString` "
"convenience functions are provided for generating a DOM tree::"
msgstr ""

#: whatsnew/2.0.rst:964
msgid ""
"``doc`` is a :class:`Document` instance.  :class:`Document`, like all the "
"other DOM classes such as :class:`Element` and :class:`Text`, is a subclass "
"of the :class:`Node` base class.  All the nodes in a DOM tree therefore "
"support certain common methods, such as :meth:`toxml` which returns a string "
"containing the XML representation of the node and its children.  Each class "
"also has special methods of its own; for example, :class:`Element` and :"
"class:`Document` instances have a method to find all child elements with a "
"given tag name. Continuing from the previous 2-line example::"
msgstr ""

#: whatsnew/2.0.rst:977
msgid "For the *Hamlet* XML file, the above few lines output::"
msgstr ""

#: whatsnew/2.0.rst:982
msgid ""
"The root element of the document is available as ``doc.documentElement``, "
"and its children can be easily modified by deleting, adding, or removing "
"nodes::"
msgstr ""

#: whatsnew/2.0.rst:997
msgid ""
"Again, I will refer you to the Python documentation for a complete listing "
"of the different :class:`Node` classes and their various methods."
msgstr ""

#: whatsnew/2.0.rst:1002
msgid "Relationship to PyXML"
msgstr ""

#: whatsnew/2.0.rst:1004
msgid ""
"The XML Special Interest Group has been working on XML-related Python code "
"for a while.  Its code distribution, called PyXML, is available from the "
"SIG's web pages at https://www.python.org/community/sigs/current/xml-sig. "
"The PyXML distribution also used the package name ``xml``.  If you've "
"written programs that used PyXML, you're probably wondering about its "
"compatibility with the 2.0 :mod:`xml` package."
msgstr ""

#: whatsnew/2.0.rst:1010
msgid ""
"The answer is that Python 2.0's :mod:`xml` package isn't compatible with "
"PyXML, but can be made compatible by installing a recent version PyXML.  "
"Many applications can get by with the XML support that is included with "
"Python 2.0, but more complicated applications will require that the full "
"PyXML package will be installed.  When installed, PyXML versions 0.6.0 or "
"greater will replace the :mod:`xml` package shipped with Python, and will be "
"a strict superset of the standard package, adding a bunch of additional "
"features.  Some of the additional features in PyXML include:"
msgstr ""

#: whatsnew/2.0.rst:1019
msgid "4DOM, a full DOM implementation from FourThought, Inc."
msgstr ""

#: whatsnew/2.0.rst:1021
msgid "The xmlproc validating parser, written by Lars Marius Garshol."
msgstr ""

#: whatsnew/2.0.rst:1023
msgid "The :mod:`sgmlop` parser accelerator module, written by Fredrik Lundh."
msgstr ""

#: whatsnew/2.0.rst:1029
msgid "Module changes"
msgstr ""

#: whatsnew/2.0.rst:1031
msgid ""
"Lots of improvements and bugfixes were made to Python's extensive standard "
"library; some of the affected modules include :mod:`readline`, :mod:"
"`ConfigParser`, :mod:`cgi`, :mod:`calendar`, :mod:`posix`, :mod:`readline`, :"
"mod:`xmllib`, :mod:`aifc`, :mod:`chunk, wave`, :mod:`random`, :mod:`shelve`, "
"and :mod:`nntplib`.  Consult the CVS logs for the exact patch-by-patch "
"details."
msgstr ""

#: whatsnew/2.0.rst:1037
msgid ""
"Brian Gallew contributed OpenSSL support for the :mod:`socket` module.  "
"OpenSSL is an implementation of the Secure Socket Layer, which encrypts the "
"data being sent over a socket.  When compiling Python, you can edit :file:"
"`Modules/Setup` to include SSL support, which adds an additional function to "
"the :mod:`socket` module: ``socket.ssl(socket, keyfile, certfile)``, which "
"takes a socket object and returns an SSL socket.  The :mod:`httplib` and :"
"mod:`urllib` modules were also changed to support ``https://`` URLs, though "
"no one has implemented FTP or SMTP over SSL."
msgstr ""

#: whatsnew/2.0.rst:1046
msgid ""
"The :mod:`httplib` module has been rewritten by Greg Stein to support "
"HTTP/1.1. Backward compatibility with the 1.5 version of :mod:`httplib` is "
"provided, though using HTTP/1.1 features such as pipelining will require "
"rewriting code to use a different set of interfaces."
msgstr ""

#: whatsnew/2.0.rst:1051
msgid ""
"The :mod:`Tkinter` module now supports Tcl/Tk version 8.1, 8.2, or 8.3, and "
"support for the older 7.x versions has been dropped.  The Tkinter module now "
"supports displaying Unicode strings in Tk widgets. Also, Fredrik Lundh "
"contributed an optimization which makes operations like ``create_line`` and "
"``create_polygon`` much faster, especially when using lots of coordinates."
msgstr ""

#: whatsnew/2.0.rst:1057
msgid ""
"The :mod:`curses` module has been greatly extended, starting from Oliver "
"Andrich's enhanced version, to provide many additional functions from "
"ncurses and SYSV curses, such as colour, alternative character set support, "
"pads, and mouse support.  This means the module is no longer 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 ""

#: whatsnew/2.0.rst:1064
msgid ""
"As mentioned in the earlier discussion of 2.0's Unicode support, the "
"underlying implementation of the regular expressions provided by the :mod:"
"`re` module has been changed.  SRE, a new regular expression engine written "
"by Fredrik Lundh and partially funded by Hewlett Packard, supports matching "
"against both 8-bit strings and Unicode strings."
msgstr ""

#: whatsnew/2.0.rst:1074
msgid "New modules"
msgstr "Nouveaux modules"

#: whatsnew/2.0.rst:1076
msgid ""
"A number of new modules were added.  We'll simply list them with brief "
"descriptions; consult the 2.0 documentation for the details of a particular "
"module."
msgstr ""

#: whatsnew/2.0.rst:1080
msgid ""
":mod:`atexit`:  For registering functions to be called before the Python "
"interpreter exits. Code that currently sets ``sys.exitfunc`` directly should "
"be changed to  use the :mod:`atexit` module instead, importing :mod:`atexit` "
"and calling :func:`atexit.register` with  the function to be called on exit. "
"(Contributed by Skip Montanaro.)"
msgstr ""

#: whatsnew/2.0.rst:1086
msgid ""
":mod:`codecs`, :mod:`encodings`, :mod:`unicodedata`:  Added as part of the "
"new Unicode support."
msgstr ""

#: whatsnew/2.0.rst:1089
msgid ""
":mod:`filecmp`: Supersedes the old :mod:`cmp`, :mod:`cmpcache` and :mod:"
"`dircmp` modules, which have now become deprecated. (Contributed by Gordon "
"MacMillan and Moshe Zadka.)"
msgstr ""

#: whatsnew/2.0.rst:1093
msgid ""
":mod:`gettext`: This module provides internationalization (I18N) and "
"localization (L10N) support for Python programs by providing an interface to "
"the GNU gettext message catalog library. (Integrated by Barry Warsaw, from "
"separate contributions by Martin  von Löwis, Peter Funk, and James "
"Henstridge.)"
msgstr ""

#: whatsnew/2.0.rst:1098
msgid ""
":mod:`linuxaudiodev`: Support for the :file:`/dev/audio` device on Linux, a "
"twin to the existing :mod:`sunaudiodev` module. (Contributed by Peter Bosch, "
"with fixes by Jeremy Hylton.)"
msgstr ""

#: whatsnew/2.0.rst:1102
msgid ""
":mod:`mmap`: An interface to memory-mapped files on both Windows and Unix.  "
"A file's contents can be mapped directly into memory, at which point it "
"behaves like a mutable string, so its contents can be read and modified.  "
"They can even be passed to functions that expect ordinary strings, such as "
"the :mod:`re` module. (Contributed by Sam Rushing, with some extensions by A."
"M. Kuchling.)"
msgstr ""

#: whatsnew/2.0.rst:1108
msgid ""
":mod:`pyexpat`: An interface to the Expat XML parser. (Contributed by Paul "
"Prescod.)"
msgstr ""

#: whatsnew/2.0.rst:1111
msgid ""
":mod:`robotparser`: Parse a :file:`robots.txt` file, which is used for "
"writing web spiders that politely avoid certain areas of a web site.  The "
"parser accepts the contents of a :file:`robots.txt` file, builds a set of "
"rules from it, and can then answer questions about the fetchability of a "
"given URL.  (Contributed by Skip Montanaro.)"
msgstr ""

#: whatsnew/2.0.rst:1117
msgid ""
":mod:`tabnanny`: A module/script to  check Python source code for ambiguous "
"indentation. (Contributed by Tim Peters.)"
msgstr ""

#: whatsnew/2.0.rst:1120
msgid ""
":mod:`UserString`: A base class useful for deriving objects that behave like "
"strings."
msgstr ""

#: whatsnew/2.0.rst:1123
msgid ""
":mod:`webbrowser`: A module that provides a platform independent way to "
"launch a web browser on a specific URL. For each platform, various browsers "
"are tried in a specific order. The user can alter which browser is launched "
"by setting the *BROWSER* environment variable.  (Originally inspired by Eric "
"S. Raymond's patch to :mod:`urllib` which added similar functionality, but "
"the final module comes from code originally  implemented by Fred Drake as :"
"file:`Tools/idle/BrowserControl.py`, and adapted for the standard library by "
"Fred.)"
msgstr ""

#: whatsnew/2.0.rst:1132
msgid ""
":mod:`_winreg`: An interface to the Windows registry.  :mod:`_winreg` is an "
"adaptation of functions that have been part of PythonWin since 1995, but has "
"now been added to the core  distribution, and enhanced to support Unicode. :"
"mod:`_winreg` was written by Bill Tutt and Mark Hammond."
msgstr ""

#: whatsnew/2.0.rst:1137
msgid ""
":mod:`zipfile`: A module for reading and writing ZIP-format archives.  These "
"are archives produced by :program:`PKZIP` on DOS/Windows or :program:`zip` "
"on Unix, not to be confused with :program:`gzip`\\ -format files (which are "
"supported by the :mod:`gzip` module) (Contributed by James C. Ahlstrom.)"
msgstr ""

#: whatsnew/2.0.rst:1142
msgid ""
":mod:`imputil`: A module that provides a simpler way for writing customized "
"import hooks, in comparison to the existing :mod:`ihooks` module.  "
"(Implemented by Greg Stein, with much discussion on python-dev along the "
"way.)"
msgstr ""

#: whatsnew/2.0.rst:1150
msgid "IDLE Improvements"
msgstr ""

#: whatsnew/2.0.rst:1152
msgid ""
"IDLE is the official Python cross-platform IDE, written using Tkinter. "
"Python 2.0 includes IDLE 0.6, which adds a number of new features and "
"improvements.  A partial list:"
msgstr ""

#: whatsnew/2.0.rst:1156
msgid ""
"UI improvements and optimizations, especially in the area of syntax "
"highlighting and auto-indentation."
msgstr ""

#: whatsnew/2.0.rst:1159
msgid ""
"The class browser now shows more information, such as the top level "
"functions in a module."
msgstr ""

#: whatsnew/2.0.rst:1162
msgid ""
"Tab width is now a user settable option. When opening an existing Python "
"file, IDLE automatically detects the indentation conventions, and adapts."
msgstr ""

#: whatsnew/2.0.rst:1165
msgid ""
"There is now support for calling browsers on various platforms, used to open "
"the Python documentation in a browser."
msgstr ""

#: whatsnew/2.0.rst:1168
msgid ""
"IDLE now has a command line, which is largely similar to  the vanilla Python "
"interpreter."
msgstr ""

#: whatsnew/2.0.rst:1171
msgid "Call tips were added in many places."
msgstr ""

#: whatsnew/2.0.rst:1173
msgid "IDLE can now be installed as a package."
msgstr ""

#: whatsnew/2.0.rst:1175
msgid "In the editor window, there is now a line/column bar at the bottom."
msgstr ""

#: whatsnew/2.0.rst:1177
msgid ""
"Three new keystroke commands: Check module (:kbd:`Alt-F5`), Import module (:"
"kbd:`F5`) and Run script (:kbd:`Ctrl-F5`)."
msgstr ""

#: whatsnew/2.0.rst:1184
msgid "Deleted and Deprecated Modules"
msgstr ""

#: whatsnew/2.0.rst:1186
msgid ""
"A few modules have been dropped because they're obsolete, or because there "
"are now better ways to do the same thing.  The :mod:`stdwin` module is gone; "
"it was for a platform-independent windowing toolkit that's no longer "
"developed."
msgstr ""

#: whatsnew/2.0.rst:1190
msgid ""
"A number of modules have been moved to the :file:`lib-old` subdirectory: :"
"mod:`cmp`, :mod:`cmpcache`, :mod:`dircmp`, :mod:`dump`,  :mod:`find`, :mod:"
"`grep`, :mod:`packmail`,  :mod:`poly`, :mod:`util`, :mod:`whatsound`, :mod:"
"`zmod`.  If you have code which relies on a module  that's been moved to :"
"file:`lib-old`, you can simply add that directory to ``sys.path``   to get "
"them back, but you're encouraged to update any code that uses these modules."
msgstr ""

#: whatsnew/2.0.rst:1199
msgid "Acknowledgements"
msgstr "Remerciements"

#: whatsnew/2.0.rst:1201
msgid ""
"The authors would like to thank the following people for offering "
"suggestions on various drafts of this article: David Bolen, Mark Hammond, "
"Gregg Hauser, Jeremy Hylton, Fredrik Lundh, Detlef Lannert, Aahz Maruch, "
"Skip Montanaro, Vladimir Marangozov, Tobias Polzin, Guido van Rossum, Neil "
"Schemenauer, and Russ Schmidt."
msgstr ""