# 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.6.rst:5

msgid "What's New in Python 2.6"

msgstr ""

#: ../../whatsnew/2.6.rst

msgid "Author"

msgstr ""

#: ../../whatsnew/2.6.rst:7

msgid "A.M. Kuchling (amk at amk.ca)"

msgstr ""

#: ../../whatsnew/2.6.rst:50

msgid ""

"This article explains the new features in Python 2.6, released on October"

" 1, 2008. The release schedule is described in :pep:`361`."

msgstr ""

#: ../../whatsnew/2.6.rst:53

msgid ""

"The major theme of Python 2.6 is preparing the migration path to Python "

"3.0, a major redesign of the language. Whenever possible, Python 2.6 "

"incorporates new features and syntax from 3.0 while remaining compatible "

"with existing code by not removing older features or syntax. When it's "

"not possible to do that, Python 2.6 tries to do what it can, adding "

"compatibility functions in a :mod:`future_builtins` module and a "

":option:`!-3` switch to warn about usages that will become unsupported in"

" 3.0."

msgstr ""

#: ../../whatsnew/2.6.rst:62

msgid ""

"Some significant new packages have been added to the standard library, "

"such as the :mod:`multiprocessing` and :mod:`json` modules, but there "

"aren't many new features that aren't related to Python 3.0 in some way."

msgstr ""

#: ../../whatsnew/2.6.rst:67

msgid ""

"Python 2.6 also sees a number of improvements and bugfixes throughout the"

" source. A search through the change logs finds there were 259 patches "

"applied and 612 bugs fixed between Python 2.5 and 2.6. Both figures are "

"likely to be underestimates."

msgstr ""

#: ../../whatsnew/2.6.rst:72

msgid ""

"This article doesn't attempt to provide a complete specification of the "

"new features, but instead provides a convenient overview. For full "

"details, you should refer to the documentation for Python 2.6. If you "

"want to understand the rationale for the design and implementation, refer"

" to the PEP for a particular new feature. Whenever possible, \"What's New"

" in Python\" links to the bug/patch item for each change."

msgstr ""

#: ../../whatsnew/2.6.rst:88

msgid "Python 3.0"

msgstr ""

#: ../../whatsnew/2.6.rst:90

msgid ""

"The development cycle for Python versions 2.6 and 3.0 was synchronized, "

"with the alpha and beta releases for both versions being made on the same"

" days. The development of 3.0 has influenced many features in 2.6."

msgstr ""

#: ../../whatsnew/2.6.rst:95

msgid ""

"Python 3.0 is a far-ranging redesign of Python that breaks compatibility "

"with the 2.x series. This means that existing Python code will need some"

" conversion in order to run on Python 3.0. However, not all the changes "

"in 3.0 necessarily break compatibility. In cases where new features "

"won't cause existing code to break, they've been backported to 2.6 and "

"are described in this document in the appropriate place. Some of the "

"3.0-derived features are:"

msgstr ""

#: ../../whatsnew/2.6.rst:104

msgid "A :meth:`__complex__` method for converting objects to a complex number."

msgstr ""

#: ../../whatsnew/2.6.rst:105

msgid "Alternate syntax for catching exceptions: ``except TypeError as exc``."

msgstr ""

#: ../../whatsnew/2.6.rst:106

msgid ""

"The addition of :func:`functools.reduce` as a synonym for the built-in "

":func:`reduce` function."

msgstr ""

#: ../../whatsnew/2.6.rst:109

msgid ""

"Python 3.0 adds several new built-in functions and changes the semantics "

"of some existing builtins. Functions that are new in 3.0 such as "

":func:`bin` have simply been added to Python 2.6, but existing builtins "

"haven't been changed; instead, the :mod:`future_builtins` module has "

"versions with the new 3.0 semantics. Code written to be compatible with "

"3.0 can do ``from future_builtins import hex, map`` as necessary."

msgstr ""

#: ../../whatsnew/2.6.rst:117

msgid ""

"A new command-line switch, :option:`!-3`, enables warnings about features"

" that will be removed in Python 3.0. You can run code with this switch "

"to see how much work will be necessary to port code to 3.0. The value of"

" this switch is available to Python code as the boolean variable "

":data:`sys.py3kwarning`, and to C extension code as "

":c:data:`!Py_Py3kWarningFlag`."

msgstr ""

#: ../../whatsnew/2.6.rst:126

msgid ""

"The 3\\ *xxx* series of PEPs, which contains proposals for Python 3.0. "

":pep:`3000` describes the development process for Python 3.0. Start with "

":pep:`3100` that describes the general goals for Python 3.0, and then "

"explore the higher-numbered PEPs that propose specific features."

msgstr ""

#: ../../whatsnew/2.6.rst:134

msgid "Changes to the Development Process"

msgstr ""

#: ../../whatsnew/2.6.rst:136

msgid ""

"While 2.6 was being developed, the Python development process underwent "

"two significant changes: we switched from SourceForge's issue tracker to "

"a customized Roundup installation, and the documentation was converted "

"from LaTeX to reStructuredText."

msgstr ""

#: ../../whatsnew/2.6.rst:143

msgid "New Issue Tracker: Roundup"

msgstr ""

#: ../../whatsnew/2.6.rst:145

msgid ""

"For a long time, the Python developers had been growing increasingly "

"annoyed by SourceForge's bug tracker. SourceForge's hosted solution "

"doesn't permit much customization; for example, it wasn't possible to "

"customize the life cycle of issues."

msgstr ""

#: ../../whatsnew/2.6.rst:150

msgid ""

"The infrastructure committee of the Python Software Foundation therefore "

"posted a call for issue trackers, asking volunteers to set up different "

"products and import some of the bugs and patches from SourceForge. Four "

"different trackers were examined: `Jira "

"<https://www.atlassian.com/software/jira/>`__, `Launchpad "

"<https://launchpad.net/>`__, `Roundup "

"<https://roundup.sourceforge.io/>`__, and `Trac "

"<https://trac.edgewall.org/>`__. The committee eventually settled on Jira"

" and Roundup as the two candidates. Jira is a commercial product that "

"offers no-cost hosted instances to free-software projects; Roundup is an "

"open-source project that requires volunteers to administer it and a "

"server to host it."

msgstr ""

#: ../../whatsnew/2.6.rst:164

msgid ""

"After posting a call for volunteers, a new Roundup installation was set "

"up at https://bugs.python.org. One installation of Roundup can host "

"multiple trackers, and this server now also hosts issue trackers for "

"Jython and for the Python web site. It will surely find other uses in "

"the future. Where possible, this edition of \"What's New in Python\" "

"links to the bug/patch item for each change."

msgstr ""

#: ../../whatsnew/2.6.rst:172

msgid ""

"Hosting of the Python bug tracker is kindly provided by `Upfront Systems "

"<https://upfrontsoftware.co.za>`__ of Stellenbosch, South Africa. Martin"

" von Löwis put a lot of effort into importing existing bugs and patches "

"from SourceForge; his scripts for this import operation are at "

"``https://svn.python.org/view/tracker/importer/`` and may be useful to "

"other projects wishing to move from SourceForge to Roundup."

msgstr ""

#: ../../whatsnew/2.6.rst:182

msgid "https://bugs.python.org"

msgstr ""

#: ../../whatsnew/2.6.rst:183

msgid "The Python bug tracker."

msgstr ""

#: ../../whatsnew/2.6.rst:185

msgid "https://bugs.jython.org:"

msgstr ""

#: ../../whatsnew/2.6.rst:186

msgid "The Jython bug tracker."

msgstr ""

#: ../../whatsnew/2.6.rst:188

msgid "https://roundup.sourceforge.io/"

msgstr ""

#: ../../whatsnew/2.6.rst:189

msgid "Roundup downloads and documentation."

msgstr ""

#: ../../whatsnew/2.6.rst:191

msgid "https://svn.python.org/view/tracker/importer/"

msgstr ""

#: ../../whatsnew/2.6.rst:192

msgid "Martin von Löwis's conversion scripts."

msgstr ""

#: ../../whatsnew/2.6.rst:195

msgid "New Documentation Format: reStructuredText Using Sphinx"

msgstr ""

#: ../../whatsnew/2.6.rst:197

msgid ""

"The Python documentation was written using LaTeX since the project "

"started around 1989. In the 1980s and early 1990s, most documentation "

"was printed out for later study, not viewed online. LaTeX was widely used"

" because it provided attractive printed output while remaining "

"straightforward to write once the basic rules of the markup were learned."

msgstr ""

#: ../../whatsnew/2.6.rst:204

msgid ""

"Today LaTeX is still used for writing publications destined for printing,"

" but the landscape for programming tools has shifted. We no longer print"

" out reams of documentation; instead, we browse through it online and "

"HTML has become the most important format to support. Unfortunately, "

"converting LaTeX to HTML is fairly complicated and Fred L. Drake Jr., the"

" long-time Python documentation editor, spent a lot of time maintaining "

"the conversion process. Occasionally people would suggest converting the"

" documentation into SGML and later XML, but performing a good conversion "

"is a major task and no one ever committed the time required to finish the"

" job."

msgstr ""

#: ../../whatsnew/2.6.rst:215

msgid ""

"During the 2.6 development cycle, Georg Brandl put a lot of effort into "

"building a new toolchain for processing the documentation. The resulting"

" package is called Sphinx, and is available from https://www.sphinx-"

"doc.org/."

msgstr ""

#: ../../whatsnew/2.6.rst:220

msgid ""

"Sphinx concentrates on HTML output, producing attractively styled and "

"modern HTML; printed output is still supported through conversion to "

"LaTeX. The input format is reStructuredText, a markup syntax supporting "

"custom extensions and directives that is commonly used in the Python "

"community."

msgstr ""

#: ../../whatsnew/2.6.rst:226

msgid ""

"Sphinx is a standalone package that can be used for writing, and almost "

"two dozen other projects (`listed on the Sphinx web site <https://www"

".sphinx-doc.org/en/master/examples.html>`__) have adopted Sphinx as their"

" documentation tool."

msgstr ""

#: ../../whatsnew/2.6.rst:233

msgid "`Documenting Python <https://devguide.python.org/documenting/>`__"

msgstr ""

#: ../../whatsnew/2.6.rst:234

msgid "Describes how to write for Python's documentation."

msgstr ""

#: ../../whatsnew/2.6.rst:236

msgid "`Sphinx <https://www.sphinx-doc.org/>`__"

msgstr ""

#: ../../whatsnew/2.6.rst:237

msgid "Documentation and code for the Sphinx toolchain."

msgstr ""

#: ../../whatsnew/2.6.rst:239

msgid "`Docutils <https://docutils.sourceforge.io>`__"

msgstr ""

#: ../../whatsnew/2.6.rst:240

msgid "The underlying reStructuredText parser and toolset."

msgstr ""

#: ../../whatsnew/2.6.rst:246

msgid "PEP 343: The 'with' statement"

msgstr ""

#: ../../whatsnew/2.6.rst:248

msgid ""

"The previous version, Python 2.5, added the ':keyword:`with`' statement "

"as an optional feature, to be enabled by a ``from __future__ import "

"with_statement`` directive. In 2.6 the statement no longer needs to be "

"specially enabled; this means that :keyword:`!with` is now always a "

"keyword. The rest of this section is a copy of the corresponding section"

" from the \"What's New in Python 2.5\" document; if you're familiar with "

"the ':keyword:`!with`' statement from Python 2.5, you can skip this "

"section."

msgstr ""

#: ../../whatsnew/2.6.rst:257

msgid ""

"The ':keyword:`with`' statement clarifies code that previously would use "

"``try...finally`` blocks to ensure that clean-up code is executed. In "

"this section, I'll discuss the statement as it will commonly be used. In"

" the next section, I'll examine the implementation details and show how "

"to write objects for use with this statement."

msgstr ""

#: ../../whatsnew/2.6.rst:263

msgid ""

"The ':keyword:`with`' statement is a control-flow structure whose basic "

"structure is::"

msgstr ""

#: ../../whatsnew/2.6.rst:266

msgid ""

"with expression [as variable]:\n"

" with-block"

msgstr ""

#: ../../whatsnew/2.6.rst:269

msgid ""

"The expression is evaluated, and it should result in an object that "

"supports the context management protocol (that is, has "

":meth:`~object.__enter__` and :meth:`~object.__exit__` methods)."

msgstr ""

#: ../../whatsnew/2.6.rst:273

msgid ""

"The object's :meth:`~object.__enter__` is called before *with-block* is "

"executed and therefore can run set-up code. It also may return a value "

"that is bound to the name *variable*, if given. (Note carefully that "

"*variable* is *not* assigned the result of *expression*.)"

msgstr ""

#: ../../whatsnew/2.6.rst:278

msgid ""

"After execution of the *with-block* is finished, the object's "

":meth:`~object.__exit__` method is called, even if the block raised an "

"exception, and can therefore run clean-up code."

msgstr ""

#: ../../whatsnew/2.6.rst:282

msgid ""

"Some standard Python objects now support the context management protocol "

"and can be used with the ':keyword:`with`' statement. File objects are "

"one example::"

msgstr ""

#: ../../whatsnew/2.6.rst:285

msgid ""

"with open('/etc/passwd', 'r') as f:\n"

" for line in f:\n"

" print line\n"

" ... more processing code ..."

msgstr ""

#: ../../whatsnew/2.6.rst:290

msgid ""

"After this statement has executed, the file object in *f* will have been "

"automatically closed, even if the :keyword:`for` loop raised an exception"

" part-way through the block."

msgstr ""

#: ../../whatsnew/2.6.rst:296

msgid ""

"In this case, *f* is the same object created by :func:`open`, because "

":meth:`~object.__enter__` returns *self*."

msgstr ""

#: ../../whatsnew/2.6.rst:299

msgid ""

"The :mod:`threading` module's locks and condition variables also support"

" the ':keyword:`with`' statement::"

msgstr ""

#: ../../whatsnew/2.6.rst:302

msgid ""

"lock = threading.Lock()\n"

"with lock:\n"

" # Critical section of code\n"

" ..."

msgstr ""

#: ../../whatsnew/2.6.rst:307

msgid ""

"The lock is acquired before the block is executed and always released "

"once the block is complete."

msgstr ""

#: ../../whatsnew/2.6.rst:310

msgid ""

"The :func:`localcontext` function in the :mod:`decimal` module makes it "

"easy to save and restore the current decimal context, which encapsulates "

"the desired precision and rounding characteristics for computations::"

msgstr ""

#: ../../whatsnew/2.6.rst:314

msgid ""

"from decimal import Decimal, Context, localcontext\n"

"\n"

"# Displays with default precision of 28 digits\n"

"v = Decimal('578')\n"

"print v.sqrt()\n"

"\n"

"with localcontext(Context(prec=16)):\n"

" # All code in this block uses a precision of 16 digits.\n"

" # The original context is restored on exiting the block.\n"

" print v.sqrt()"

msgstr ""

#: ../../whatsnew/2.6.rst:329

msgid "Writing Context Managers"

msgstr ""

#: ../../whatsnew/2.6.rst:331

msgid ""

"Under the hood, the ':keyword:`with`' statement is fairly complicated. "

"Most people will only use ':keyword:`!with`' in company with existing "

"objects and don't need to know these details, so you can skip the rest of"

" this section if you like. Authors of new objects will need to "

"understand the details of the underlying implementation and should keep "

"reading."

msgstr ""

#: ../../whatsnew/2.6.rst:337

msgid "A high-level explanation of the context management protocol is:"

msgstr ""

#: ../../whatsnew/2.6.rst:339

msgid ""

"The expression is evaluated and should result in an object called a "

"\"context manager\". The context manager must have "

":meth:`~object.__enter__` and :meth:`~object.__exit__` methods."

msgstr ""

#: ../../whatsnew/2.6.rst:343

msgid ""

"The context manager's :meth:`~object.__enter__` method is called. The "

"value returned is assigned to *VAR*. If no ``as VAR`` clause is present,"

" the value is simply discarded."

msgstr ""

#: ../../whatsnew/2.6.rst:347

msgid "The code in *BLOCK* is executed."

msgstr ""

#: ../../whatsnew/2.6.rst:349

msgid ""

"If *BLOCK* raises an exception, the context manager's "

":meth:`~object.__exit__` method is called with three arguments, the "

"exception details (``type, value, traceback``, the same values returned "

"by :func:`sys.exc_info`, which can also be ``None`` if no exception "

"occurred). The method's return value controls whether an exception is "

"re-raised: any false value re-raises the exception, and ``True`` will "

"result in suppressing it. You'll only rarely want to suppress the "

"exception, because if you do the author of the code containing the "

"':keyword:`with`' statement will never realize anything went wrong."

msgstr ""

#: ../../whatsnew/2.6.rst:358

msgid ""

"If *BLOCK* didn't raise an exception, the :meth:`~object.__exit__` "

"method is still called, but *type*, *value*, and *traceback* are all "

"``None``."

msgstr ""

#: ../../whatsnew/2.6.rst:361

msgid ""

"Let's think through an example. I won't present detailed code but will "

"only sketch the methods necessary for a database that supports "

"transactions."

msgstr ""

#: ../../whatsnew/2.6.rst:364

msgid ""

"(For people unfamiliar with database terminology: a set of changes to the"

" database are grouped into a transaction. Transactions can be either "

"committed, meaning that all the changes are written into the database, or"

" rolled back, meaning that the changes are all discarded and the database"

" is unchanged. See any database textbook for more information.)"

msgstr ""

#: ../../whatsnew/2.6.rst:370

msgid ""

"Let's assume there's an object representing a database connection. Our "

"goal will be to let the user write code like this::"

msgstr ""

#: ../../whatsnew/2.6.rst:373

msgid ""

"db_connection = DatabaseConnection()\n"

"with db_connection as cursor:\n"

" cursor.execute('insert into ...')\n"

" cursor.execute('delete from ...')\n"

" # ... more operations ..."

msgstr ""

#: ../../whatsnew/2.6.rst:379

msgid ""

"The transaction should be committed if the code in the block runs "

"flawlessly or rolled back if there's an exception. Here's the basic "

"interface for :class:`DatabaseConnection` that I'll assume::"

msgstr ""

#: ../../whatsnew/2.6.rst:383

msgid ""

"class DatabaseConnection:\n"

" # Database interface\n"

" def cursor(self):\n"

" \"Returns a cursor object and starts a new transaction\"\n"

" def commit(self):\n"

" \"Commits current transaction\"\n"

" def rollback(self):\n"

" \"Rolls back current transaction\""

msgstr ""

#: ../../whatsnew/2.6.rst:392

msgid ""

"The :meth:`~object.__enter__` method is pretty easy, having only to start"

" a new transaction. For this application the resulting cursor object "

"would be a useful result, so the method will return it. The user can "

"then add ``as cursor`` to their ':keyword:`with`' statement to bind the "

"cursor to a variable name. ::"

msgstr ""

#: ../../whatsnew/2.6.rst:397

msgid ""

"class DatabaseConnection:\n"

" ...\n"

" def __enter__(self):\n"

" # Code to start a new transaction\n"

" cursor = self.cursor()\n"

" return cursor"

msgstr ""

#: ../../whatsnew/2.6.rst:404

msgid ""

"The :meth:`~object.__exit__` method is the most complicated because it's "

"where most of the work has to be done. The method has to check if an "

"exception occurred. If there was no exception, the transaction is "

"committed. The transaction is rolled back if there was an exception."

msgstr ""

#: ../../whatsnew/2.6.rst:409

msgid ""

"In the code below, execution will just fall off the end of the function, "

"returning the default value of ``None``. ``None`` is false, so the "

"exception will be re-raised automatically. If you wished, you could be "

"more explicit and add a :keyword:`return` statement at the marked "

"location. ::"

msgstr ""

#: ../../whatsnew/2.6.rst:414

msgid ""

"class DatabaseConnection:\n"

" ...\n"

" def __exit__(self, type, value, tb):\n"

" if tb is None:\n"

" # No exception, so commit\n"

" self.commit()\n"

" else:\n"

" # Exception occurred, so rollback.\n"

" self.rollback()\n"

" # return False"

msgstr ""

#: ../../whatsnew/2.6.rst:429

msgid "The contextlib module"

msgstr ""

#: ../../whatsnew/2.6.rst:431

msgid ""

"The :mod:`contextlib` module provides some functions and a decorator that"

" are useful when writing objects for use with the ':keyword:`with`' "

"statement."

msgstr ""

#: ../../whatsnew/2.6.rst:434

msgid ""

"The decorator is called :func:`contextmanager`, and lets you write a "

"single generator function instead of defining a new class. The generator"

" should yield exactly one value. The code up to the :keyword:`yield` "

"will be executed as the :meth:`~object.__enter__` method, and the value "

"yielded will be the method's return value that will get bound to the "

"variable in the ':keyword:`with`' statement's :keyword:`!as` clause, if "

"any. The code after the :keyword:`!yield` will be executed in the "

":meth:`~object.__exit__` method. Any exception raised in the block will "

"be raised by the :keyword:`!yield` statement."

msgstr ""

#: ../../whatsnew/2.6.rst:443

msgid ""

"Using this decorator, our database example from the previous section "

"could be written as::"

msgstr ""

#: ../../whatsnew/2.6.rst:446

msgid ""

"from contextlib import contextmanager\n"

"\n"

"@contextmanager\n"

"def db_transaction(connection):\n"

" cursor = connection.cursor()\n"

" try:\n"

" yield cursor\n"

" except:\n"

" connection.rollback()\n"

" raise\n"

" else:\n"

" connection.commit()\n"

"\n"

"db = DatabaseConnection()\n"

"with db_transaction(db) as cursor:\n"

" ..."

msgstr ""

#: ../../whatsnew/2.6.rst:463

msgid ""

"The :mod:`contextlib` module also has a ``nested(mgr1, mgr2, ...)`` "

"function that combines a number of context managers so you don't need to "

"write nested ':keyword:`with`' statements. In this example, the single "

"':keyword:`!with`' statement both starts a database transaction and "

"acquires a thread lock::"

msgstr ""

#: ../../whatsnew/2.6.rst:468

msgid ""

"lock = threading.Lock()\n"

"with nested (db_transaction(db), lock) as (cursor, locked):\n"

" ..."

msgstr ""

#: ../../whatsnew/2.6.rst:472

msgid ""

"Finally, the :func:`closing` function returns its argument so that it can"

" be bound to a variable, and calls the argument's ``.close()`` method at "

"the end of the block. ::"

msgstr ""

#: ../../whatsnew/2.6.rst:476

msgid ""

"import urllib, sys\n"

"from contextlib import closing\n"

"\n"

"with closing(urllib.urlopen('http://www.yahoo.com')) as f:\n"

" for line in f:\n"

" sys.stdout.write(line)"

msgstr ""

#: ../../whatsnew/2.6.rst:486

msgid ":pep:`343` - The \"with\" statement"

msgstr ""

#: ../../whatsnew/2.6.rst:487

msgid ""

"PEP written by Guido van Rossum and Nick Coghlan; implemented by Mike "

"Bland, Guido van Rossum, and Neal Norwitz. The PEP shows the code "

"generated for a ':keyword:`with`' statement, which can be helpful in "

"learning how the statement works."

msgstr ""

#: ../../whatsnew/2.6.rst:492

msgid "The documentation for the :mod:`contextlib` module."

msgstr ""

#: ../../whatsnew/2.6.rst:499

msgid "PEP 366: Explicit Relative Imports From a Main Module"

msgstr ""

#: ../../whatsnew/2.6.rst:501

msgid ""

"Python's :option:`-m` switch allows running a module as a script. When "

"you ran a module that was located inside a package, relative imports "

"didn't work correctly."

msgstr ""

#: ../../whatsnew/2.6.rst:505

msgid ""

"The fix for Python 2.6 adds a :attr:`module.__package__` attribute. When "

"this attribute is present, relative imports will be relative to the value"

" of this attribute instead of the :attr:`~module.__name__` attribute."

msgstr ""

#: ../../whatsnew/2.6.rst:510

msgid ""

"PEP 302-style importers can then set :attr:`~module.__package__` as "

"necessary. The :mod:`runpy` module that implements the :option:`-m` "

"switch now does this, so relative imports will now work correctly in "

"scripts running from inside a package."

msgstr ""

#: ../../whatsnew/2.6.rst:520

msgid "PEP 370: Per-user ``site-packages`` Directory"

msgstr ""

#: ../../whatsnew/2.6.rst:522

msgid ""

"When you run Python, the module search path ``sys.path`` usually includes"

" a directory whose path ends in ``\"site-packages\"``. This directory is"

" intended to hold locally installed packages available to all users using"

" a machine or a particular site installation."

msgstr ""

#: ../../whatsnew/2.6.rst:527

msgid ""

"Python 2.6 introduces a convention for user-specific site directories. "

"The directory varies depending on the platform:"

msgstr ""

#: ../../whatsnew/2.6.rst:530

msgid "Unix and Mac OS X: :file:`~/.local/`"

msgstr ""

#: ../../whatsnew/2.6.rst:531

msgid "Windows: :file:`%APPDATA%/Python`"

msgstr ""

#: ../../whatsnew/2.6.rst:533

msgid ""

"Within this directory, there will be version-specific subdirectories, "

"such as :file:`lib/python2.6/site-packages` on Unix/Mac OS and "

":file:`Python26/site-packages` on Windows."

msgstr ""

#: ../../whatsnew/2.6.rst:537

msgid ""

"If you don't like the default directory, it can be overridden by an "

"environment variable. :envvar:`PYTHONUSERBASE` sets the root directory "

"used for all Python versions supporting this feature. On Windows, the "

"directory for application-specific data can be changed by setting the "

":envvar:`APPDATA` environment variable. You can also modify the "

":file:`site.py` file for your Python installation."

msgstr ""

#: ../../whatsnew/2.6.rst:544

msgid ""

"The feature can be disabled entirely by running Python with the "

":option:`-s` option or setting the :envvar:`PYTHONNOUSERSITE` environment"

" variable."

msgstr ""

#: ../../whatsnew/2.6.rst:550

msgid ":pep:`370` - Per-user ``site-packages`` Directory"

msgstr ""

#: ../../whatsnew/2.6.rst:551

msgid "PEP written and implemented by Christian Heimes."

msgstr ""

#: ../../whatsnew/2.6.rst:559

msgid "PEP 371: The ``multiprocessing`` Package"

msgstr ""

#: ../../whatsnew/2.6.rst:561

msgid ""

"The new :mod:`multiprocessing` package lets Python programs create new "

"processes that will perform a computation and return a result to the "

"parent. The parent and child processes can communicate using queues and "

"pipes, synchronize their operations using locks and semaphores, and can "

"share simple arrays of data."

msgstr ""

#: ../../whatsnew/2.6.rst:567

msgid ""

"The :mod:`multiprocessing` module started out as an exact emulation of "

"the :mod:`threading` module using processes instead of threads. That "

"goal was discarded along the path to Python 2.6, but the general approach"

" of the module is still similar. The fundamental class is the "

":class:`Process`, which is passed a callable object and a collection of "

"arguments. The :meth:`start` method sets the callable running in a "

"subprocess, after which you can call the :meth:`is_alive` method to check"

" whether the subprocess is still running and the :meth:`join` method to "

"wait for the process to exit."

msgstr ""

#: ../../whatsnew/2.6.rst:577

msgid ""

"Here's a simple example where the subprocess will calculate a factorial."

" The function doing the calculation is written strangely so that it "

"takes significantly longer when the input argument is a multiple of 4."

msgstr ""

#: ../../whatsnew/2.6.rst:584

msgid ""

"import time\n"

"from multiprocessing import Process, Queue\n"

"\n"

"\n"

"def factorial(queue, N):\n"

" \"Compute a factorial.\"\n"

" # If N is a multiple of 4, this function will take much longer.\n"

" if (N % 4) == 0:\n"

" time.sleep(.05 * N/4)\n"

"\n"

" # Calculate the result\n"

" fact = 1L\n"

" for i in range(1, N+1):\n"

" fact = fact * i\n"

"\n"

" # Put the result on the queue\n"

" queue.put(fact)\n"

"\n"

"if __name__ == '__main__':\n"

" queue = Queue()\n"

"\n"

" N = 5\n"

"\n"

" p = Process(target=factorial, args=(queue, N))\n"

" p.start()\n"

" p.join()\n"

"\n"

" result = queue.get()\n"

" print 'Factorial', N, '=', result"

msgstr ""

#: ../../whatsnew/2.6.rst:614

msgid ""

"A :class:`~queue.Queue` is used to communicate the result of the "

"factorial. The :class:`~queue.Queue` object is stored in a global "

"variable. The child process will use the value of the variable when the "

"child was created; because it's a :class:`~queue.Queue`, parent and child"

" can use the object to communicate. (If the parent were to change the "

"value of the global variable, the child's value would be unaffected, and "

"vice versa.)"

msgstr ""

#: ../../whatsnew/2.6.rst:622

msgid ""

"Two other classes, :class:`Pool` and :class:`Manager`, provide higher-"

"level interfaces. :class:`Pool` will create a fixed number of worker "

"processes, and requests can then be distributed to the workers by calling"

" :meth:`apply` or :meth:`apply_async` to add a single request, and "

":meth:`map` or :meth:`map_async` to add a number of requests. The "

"following code uses a :class:`Pool` to spread requests across 5 worker "

"processes and retrieve a list of results::"

msgstr ""

#: ../../whatsnew/2.6.rst:630

msgid ""

"from multiprocessing import Pool\n"

"\n"

"def factorial(N, dictionary):\n"

" \"Compute a factorial.\"\n"

" ...\n"

"p = Pool(5)\n"

"result = p.map(factorial, range(1, 1000, 10))\n"

"for v in result:\n"

" print v"

msgstr ""

#: ../../whatsnew/2.6.rst:640

msgid "This produces the following output::"

msgstr ""

#: ../../whatsnew/2.6.rst:642

msgid ""

"1\n"

"39916800\n"

"51090942171709440000\n"

"8222838654177922817725562880000000\n"

"33452526613163807108170062053440751665152000000000\n"

"..."

msgstr ""

#: ../../whatsnew/2.6.rst:649

msgid ""

"The other high-level interface, the :class:`Manager` class, creates a "

"separate server process that can hold master copies of Python data "

"structures. Other processes can then access and modify these data "

"structures using proxy objects. The following example creates a shared "

"dictionary by calling the :meth:`dict` method; the worker processes then "

"insert values into the dictionary. (Locking is not done for you "

"automatically, which doesn't matter in this example. :class:`Manager`'s "

"methods also include :meth:`Lock`, :meth:`RLock`, and :meth:`Semaphore` "

"to create shared locks.)"

msgstr ""

#: ../../whatsnew/2.6.rst:661

msgid ""

"import time\n"

"from multiprocessing import Pool, Manager\n"

"\n"

"def factorial(N, dictionary):\n"

" \"Compute a factorial.\"\n"

" # Calculate the result\n"

" fact = 1L\n"

" for i in range(1, N+1):\n"

" fact = fact * i\n"

"\n"

" # Store result in dictionary\n"

" dictionary[N] = fact\n"

"\n"

"if __name__ == '__main__':\n"

" p = Pool(5)\n"

" mgr = Manager()\n"

" d = mgr.dict() # Create shared dictionary\n"

"\n"

" # Run tasks using the pool\n"

" for N in range(1, 1000, 10):\n"

" p.apply_async(factorial, (N, d))\n"

"\n"

" # Mark pool as closed -- no more tasks can be added.\n"

" p.close()\n"

"\n"

" # Wait for tasks to exit\n"

" p.join()\n"

"\n"

" # Output results\n"

" for k, v in sorted(d.items()):\n"

" print k, v"

msgstr ""

#: ../../whatsnew/2.6.rst:693

msgid "This will produce the output::"

msgstr ""

#: ../../whatsnew/2.6.rst:695

msgid ""

"1 1\n"

"11 39916800\n"

"21 51090942171709440000\n"

"31 8222838654177922817725562880000000\n"

"41 33452526613163807108170062053440751665152000000000\n"

"51 15511187532873822802242430164693032110632597200169861120000..."

msgstr ""

#: ../../whatsnew/2.6.rst:704

msgid "The documentation for the :mod:`multiprocessing` module."

msgstr ""

#: ../../whatsnew/2.6.rst:706

msgid ":pep:`371` - Addition of the multiprocessing package"

msgstr ""

#: ../../whatsnew/2.6.rst:707

msgid ""

"PEP written by Jesse Noller and Richard Oudkerk; implemented by Richard "

"Oudkerk and Jesse Noller."

msgstr ""

#: ../../whatsnew/2.6.rst:716

msgid "PEP 3101: Advanced String Formatting"

msgstr ""

#: ../../whatsnew/2.6.rst:718

msgid ""

"In Python 3.0, the ``%`` operator is supplemented by a more powerful "

"string formatting method, :meth:`format`. Support for the "

":meth:`str.format` method has been backported to Python 2.6."

msgstr ""

#: ../../whatsnew/2.6.rst:722

#, python-brace-format

msgid ""

"In 2.6, both 8-bit and Unicode strings have a ``.format()`` method that "

"treats the string as a template and takes the arguments to be formatted. "

"The formatting template uses curly brackets (``{``, ``}``) as special "

"characters::"

msgstr ""

#: ../../whatsnew/2.6.rst:726

#, python-brace-format

msgid ""

">>> # Substitute positional argument 0 into the string.\n"

">>> \"User ID: {0}\".format(\"root\")\n"

"'User ID: root'\n"

">>> # Use the named keyword arguments\n"

">>> \"User ID: {uid} Last seen: {last_login}\".format(\n"

"... uid=\"root\",\n"

"... last_login = \"5 Mar 2008 07:20\")\n"

"'User ID: root Last seen: 5 Mar 2008 07:20'"

msgstr ""

#: ../../whatsnew/2.6.rst:735

msgid "Curly brackets can be escaped by doubling them::"

msgstr ""