# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2017, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, 2017.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.6\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2018-12-25 10:27+0900\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"

"Generated-By: Babel 2.6.0\n"

#: ../Doc/whatsnew/2.0.rst:3

msgid "What's New in Python 2.0"

msgstr ""

#: ../Doc/whatsnew/2.0.rst

msgid "Author"

msgstr ""

#: ../Doc/whatsnew/2.0.rst:5

msgid "A.M. Kuchling and Moshe Zadka"

msgstr ""

#: ../Doc/whatsnew/2.0.rst:13

msgid "Introduction"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:20

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 ""

#: ../Doc/whatsnew/2.0.rst:33

msgid "What About Python 1.6?"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:57

msgid "New Development Process"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:130

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://www.python.org/dev/peps/. As of "

"September 2000, there are 25 PEPS, ranging from PEP 201, \"Lockstep "

"Iteration\", to PEP 225, \"Elementwise/Objectwise Operators\"."

msgstr ""

#: ../Doc/whatsnew/2.0.rst:141

msgid "Unicode"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:175

msgid ""

"New built-in functions have been added, and existing built-ins modified "

"to support Unicode:"

msgstr ""

#: ../Doc/whatsnew/2.0.rst:178

msgid ""

"``unichr(ch)`` returns a Unicode string 1 character long, containing the "

"character *ch*."

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:229

msgid ""

"For example, the following code writes a Unicode string into a file, "

"encoding it as UTF-8::"

msgstr ""

#: ../Doc/whatsnew/2.0.rst:243

msgid "The following code would then read UTF-8 input from the file::"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:262

msgid "List Comprehensions"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:292

msgid "List comprehensions have the form::"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:307

msgid ""

"To make the semantics very clear, a list comprehension is equivalent to "

"the following Python code::"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:349

msgid "Augmented Assignment"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:390

msgid "String Methods"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:433

msgid "Garbage Collection of Cycles"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:449

msgid ""

"Consider the simplest possible cycle, a class instance which has a "

"reference to itself::"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:495

msgid "Other Core Changes"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:502

msgid "Minor Language Changes"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:532

#, python-format

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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 "

"http://pythonce.sourceforge.net/ for more information."

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:601

msgid "Changes to Built-in Functions"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:633

msgid "can be reduced to a single ``return dict.setdefault(key, [])`` statement."

msgstr ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:647

msgid "Porting to 2.0"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:694

#, python-format

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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:716

#, python-format

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 ""

#: ../Doc/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 ""

#: ../Doc/whatsnew/2.0.rst:740

msgid "Extending/Embedding Changes"

msgstr ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""

#: ../Doc/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 ""