# 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: 2025-04-17 23:44+0000\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.17.0\n"

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

msgid "What's New in Python 2.0"

msgstr ""

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

msgid "Author"

msgstr ""

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

msgid "A.M. Kuchling and Moshe Zadka"

msgstr ""

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

msgid "Introduction"

msgstr ""

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

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

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

msgid "What About Python 1.6?"

msgstr ""

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

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

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

msgid "New Development Process"

msgstr ""

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

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

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

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

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

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

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

"2000, there are 25 PEPs, ranging from :pep:`201`, \"Lockstep Iteration\","

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

msgstr ""

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

msgid "Unicode"

msgstr ""

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

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

#: ../../whatsnew/2.0.rst:155

#, python-brace-format

msgid ""

"In Python source code, Unicode strings are written as ``u\"string\"``. "

"Arbitrary Unicode characters can be written using a new escape sequence, "

":samp:`\\\\u{HHHH}`, where *HHHH* is a 4-digit hexadecimal number from "

"0000 to FFFF. The existing :samp:`\\\\x{HH}` escape sequence can also be"

" used, and octal escapes can be used for characters up to U+01FF, which "

"is represented by ``\\777``."

msgstr ""

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

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

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

msgid ""

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

"to support Unicode:"

msgstr ""

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

msgid ""

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

"character *ch*."

msgstr ""

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

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

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

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

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

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

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

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

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

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

msgid ""

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

"encoding it as UTF-8::"

msgstr ""

#: ../../whatsnew/2.0.rst:232

msgid ""

"import codecs\n"

"\n"

"unistr = u'\\u0660\\u2000ab ...'\n"

"\n"

"(UTF8_encode, UTF8_decode,\n"

" UTF8_streamreader, UTF8_streamwriter) = codecs.lookup('UTF-8')\n"

"\n"

"output = UTF8_streamwriter( open( '/tmp/output', 'wb') )\n"

"output.write( unistr )\n"

"output.close()"

msgstr ""

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

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

msgstr ""

#: ../../whatsnew/2.0.rst:245

msgid ""

"input = UTF8_streamreader( open( '/tmp/output', 'rb') )\n"

"print repr(input.read())\n"

"input.close()"

msgstr ""

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

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

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

msgid "List Comprehensions"

msgstr ""

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

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

#: ../../whatsnew/2.0.rst:280

msgid ""

"# Given the list L, make a list of all strings\n"

"# containing the substring S.\n"

"sublist = filter( lambda s, substring=S:\n"

" string.find(s, substring) != -1,\n"

" L)"

msgstr ""

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

#: ../../whatsnew/2.0.rst:290

msgid "sublist = [ s for s in L if string.find(s, S) != -1 ]"

msgstr ""

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

msgid "List comprehensions have the form::"

msgstr ""

#: ../../whatsnew/2.0.rst:294

msgid ""

"[ expression for expr in sequence1\n"

" for expr2 in sequence2 ...\n"

" for exprN in sequenceN\n"

" if condition ]"

msgstr ""

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

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

msgid ""

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

"the following Python code::"

msgstr ""

#: ../../whatsnew/2.0.rst:310

msgid ""

"for expr1 in sequence1:\n"

" for expr2 in sequence2:\n"

" ...\n"

" for exprN in sequenceN:\n"

" if (condition):\n"

" # Append the value of\n"

" # the expression to the\n"

" # resulting list."

msgstr ""

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

#: ../../whatsnew/2.0.rst:324

msgid ""

"seq1 = 'abc'\n"

"seq2 = (1,2,3)\n"

">>> [ (x,y) for x in seq1 for y in seq2]\n"

"[('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1),\n"

"('c', 2), ('c', 3)]"

msgstr ""

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

#: ../../whatsnew/2.0.rst:334

msgid ""

"# Syntax error\n"

"[ x,y for x in seq1 for y in seq2]\n"

"# Correct\n"

"[ (x,y) for x in seq1 for y in seq2]"

msgstr ""

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

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

msgid "Augmented Assignment"

msgstr ""

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

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

#: ../../whatsnew/2.0.rst:367

msgid ""

"class Number:\n"

" def __init__(self, value):\n"

" self.value = value\n"

" def __iadd__(self, increment):\n"

" return Number( self.value + increment)\n"

"\n"

"n = Number(5)\n"

"n += 3\n"

"print n.value"

msgstr ""

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

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

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

msgid ""

">>> 'andrew'.capitalize()\n"

"'Andrew'\n"

">>> 'hostname'.replace('os', 'linux')\n"

"'hlinuxtname'\n"

">>> 'moshe'.find('sh')\n"

"2"

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:452

msgid ""

"instance = SomeClass()\n"

"instance.myself = instance"

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

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

msgid ""

"def f(*args, **kw):\n"

" # args is a tuple of positional args,\n"

" # kw is a dictionary of keyword args\n"

" ..."

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:526

msgid "print >> sys.stderr, \"Warning: action field not supplied\""

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

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

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

msgid ""

"a = []\n"

"b = []\n"

"a.append(a)\n"

"b.append(b)"

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:590

msgid ""

"def f():\n"

" print \"i=\",i\n"

" i = i + 1\n"

"f()"

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

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

msgid ""

"if dict.has_key( key ): return dict[key]\n"

"else:\n"

" dict[key] = []\n"

" return dict[key]"

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 :c: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, ``socket.connect( ('hostname', 25) )`` is the "

"correct form, passing a tuple representing an IP address, but "

"``socket.connect('hostname', 25)`` also works. :meth:`socket.connect_ex "