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

msgid "What's New in Python 2.5"

msgstr ""

#: ../Doc/whatsnew/2.5.rst

msgid "Author"

msgstr ""

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

msgid "A.M. Kuchling"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:12

msgid ""

"This article explains the new features in Python 2.5. The final release "

"of Python 2.5 is scheduled for August 2006; :pep:`356` describes the "

"planned release schedule."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:16

msgid ""

"The changes in Python 2.5 are an interesting mix of language and library "

"improvements. The library enhancements will be more important to Python's"

" user community, I think, because several widely-useful packages were "

"added. New modules include ElementTree for XML processing "

"(:mod:`xml.etree`), the SQLite database module (:mod:`sqlite`), and the "

":mod:`ctypes` module for calling C functions."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:23

msgid ""

"The language changes are of middling significance. Some pleasant new "

"features were added, but most of them aren't features that you'll use "

"every day. Conditional expressions were finally added to the language "

"using a novel syntax; see section :ref:`pep-308`. The new "

"':keyword:`with`' statement will make writing cleanup code easier "

"(section :ref:`pep-343`). Values can now be passed into generators "

"(section :ref:`pep-342`). Imports are now visible as either absolute or "

"relative (section :ref:`pep-328`). Some corner cases of exception "

"handling are handled better (section :ref:`pep-341`). All these "

"improvements are worthwhile, but they're improvements to one specific "

"language feature or another; none of them are broad modifications to "

"Python's semantics."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:34

msgid ""

"As well as the language and library additions, other improvements and "

"bugfixes were made throughout the source tree. A search through the SVN "

"change logs finds there were 353 patches applied and 458 bugs fixed "

"between Python 2.4 and 2.5. (Both figures are likely to be "

"underestimates.)"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:39

msgid ""

"This article doesn't try to be a complete specification of the new "

"features; instead changes are briefly introduced using helpful examples."

" For full details, you should always refer to the documentation for "

"Python 2.5 at https://docs.python.org. If you want to understand the "

"complete implementation and design rationale, refer to the PEP for a "

"particular new feature."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:45

msgid ""

"Comments, suggestions, and error reports for this document are welcome; "

"please e-mail them to the author or open a bug in the Python bug tracker."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:54

msgid "PEP 308: Conditional Expressions"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:56

msgid ""

"For a long time, people have been requesting a way to write conditional "

"expressions, which are expressions that return value A or value B "

"depending on whether a Boolean value is true or false. A conditional "

"expression lets you write a single assignment statement that has the same"

" effect as the following::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:66

msgid ""

"There have been endless tedious discussions of syntax on both python-dev "

"and comp.lang.python. A vote was even held that found the majority of "

"voters wanted conditional expressions in some form, but there was no "

"syntax that was preferred by a clear majority. Candidates included C's "

"``cond ? true_v : false_v``, ``if cond then true_v else false_v``, and 16"

" other variations."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:72

msgid "Guido van Rossum eventually chose a surprising syntax::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:76

msgid ""

"Evaluation is still lazy as in existing Boolean expressions, so the order"

" of evaluation jumps around a bit. The *condition* expression in the "

"middle is evaluated first, and the *true_value* expression is evaluated "

"only if the condition was true. Similarly, the *false_value* expression "

"is only evaluated when the condition is false."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:82

msgid ""

"This syntax may seem strange and backwards; why does the condition go in "

"the *middle* of the expression, and not in the front as in C's ``c ? x : "

"y``? The decision was checked by applying the new syntax to the modules "

"in the standard library and seeing how the resulting code read. In many "

"cases where a conditional expression is used, one value seems to be the "

"'common case' and one value is an 'exceptional case', used only on rarer "

"occasions when the condition isn't met. The conditional syntax makes "

"this pattern a bit more obvious::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:92

msgid ""

"I read the above statement as meaning \"here *contents* is usually "

"assigned a value of ``doc+'\\n'``; sometimes *doc* is empty, in which "

"special case an empty string is returned.\" I doubt I will use "

"conditional expressions very often where there isn't a clear common and "

"uncommon case."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:97

msgid ""

"There was some discussion of whether the language should require "

"surrounding conditional expressions with parentheses. The decision was "

"made to *not* require parentheses in the Python language's grammar, but "

"as a matter of style I think you should always use them. Consider these "

"two statements::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:108

msgid ""

"In the first version, I think a reader's eye might group the statement "

"into 'level = 1', 'if logging', 'else 0', and think that the condition "

"decides whether the assignment to *level* is performed. The second "

"version reads better, in my opinion, because it makes it clear that the "

"assignment is always performed and the choice is being made between two "

"values."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:114

msgid ""

"Another reason for including the brackets: a few odd combinations of list"

" comprehensions and lambdas could look like incorrect conditional "

"expressions. See :pep:`308` for some examples. If you put parentheses "

"around your conditional expressions, you won't run into this case."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:123

msgid ":pep:`308` - Conditional Expressions"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:123

msgid ""

"PEP written by Guido van Rossum and Raymond D. Hettinger; implemented by "

"Thomas Wouters."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:132

msgid "PEP 309: Partial Function Application"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:134

msgid ""

"The :mod:`functools` module is intended to contain tools for functional-"

"style programming."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:137

msgid ""

"One useful tool in this module is the :func:`partial` function. For "

"programs written in a functional style, you'll sometimes want to "

"construct variants of existing functions that have some of the parameters"

" filled in. Consider a Python function ``f(a, b, c)``; you could create "

"a new function ``g(b, c)`` that was equivalent to ``f(1, b, c)``. This "

"is called \"partial function application\"."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:144

msgid ""

":func:`partial` takes the arguments ``(function, arg1, arg2, ... "

"kwarg1=value1, kwarg2=value2)``. The resulting object is callable, so "

"you can just call it to invoke *function* with the filled-in arguments."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:148

msgid "Here's a small but realistic example::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:160

msgid ""

"Here's another example, from a program that uses PyGTK. Here a context-"

"sensitive pop-up menu is being constructed dynamically. The callback "

"provided for the menu option is a partially applied version of the "

":meth:`open_item` method, where the first argument has been provided. ::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:173

msgid ""

"Another function in the :mod:`functools` module is the "

"``update_wrapper(wrapper, wrapped)`` function that helps you write well-"

"behaved decorators. :func:`update_wrapper` copies the name, module, and "

"docstring attribute to a wrapper function so that tracebacks inside the "

"wrapped function are easier to understand. For example, you might "

"write::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:186

msgid ""

":func:`wraps` is a decorator that can be used inside your own decorators "

"to copy the wrapped function's information. An alternate version of the"

" previous example would be::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:201

msgid ":pep:`309` - Partial Function Application"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:201

msgid ""

"PEP proposed and written by Peter Harris; implemented by Hye-Shik Chang "

"and Nick Coghlan, with adaptations by Raymond Hettinger."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:210

msgid "PEP 314: Metadata for Python Software Packages v1.1"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:212

msgid ""

"Some simple dependency support was added to Distutils. The :func:`setup`"

" function now has ``requires``, ``provides``, and ``obsoletes`` keyword "

"parameters. When you build a source distribution using the ``sdist`` "

"command, the dependency information will be recorded in the :file:`PKG-"

"INFO` file."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:217

msgid ""

"Another new keyword parameter is ``download_url``, which should be set to"

" a URL for the package's source code. This means it's now possible to "

"look up an entry in the package index, determine the dependencies for a "

"package, and download the required packages. ::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:231

msgid ""

"Another new enhancement to the Python package index at https://pypi.org "

"is storing source and binary archives for a package. The new "

":command:`upload` Distutils command will upload a package to the "

"repository."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:236

msgid ""

"Before a package can be uploaded, you must be able to build a "

"distribution using the :command:`sdist` Distutils command. Once that "

"works, you can run ``python setup.py upload`` to add your package to the "

"PyPI archive. Optionally you can GPG-sign the package by supplying the "

":option:`!--sign` and :option:`!--identity` options."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:242

msgid "Package uploading was implemented by Martin von Löwis and Richard Jones."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:248

msgid ":pep:`314` - Metadata for Python Software Packages v1.1"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:248

msgid ""

"PEP proposed and written by A.M. Kuchling, Richard Jones, and Fred Drake;"

" implemented by Richard Jones and Fred Drake."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:257

msgid "PEP 328: Absolute and Relative Imports"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:259

msgid ""

"The simpler part of PEP 328 was implemented in Python 2.4: parentheses "

"could now be used to enclose the names imported from a module using the "

"``from ... import ...`` statement, making it easier to import many "

"different names."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:263

msgid ""

"The more complicated part has been implemented in Python 2.5: importing a"

" module can be specified to use absolute or package-relative imports. "

"The plan is to move toward making absolute imports the default in future "

"versions of Python."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:267

msgid "Let's say you have a package directory like this::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:274

msgid ""

"This defines a package named :mod:`pkg` containing the :mod:`pkg.main` "

"and :mod:`pkg.string` submodules."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:277

msgid ""

"Consider the code in the :file:`main.py` module. What happens if it "

"executes the statement ``import string``? In Python 2.4 and earlier, it "

"will first look in the package's directory to perform a relative import, "

"finds :file:`pkg/string.py`, imports the contents of that file as the "

":mod:`pkg.string` module, and that module is bound to the name ``string``"

" in the :mod:`pkg.main` module's namespace."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:284

msgid ""

"That's fine if :mod:`pkg.string` was what you wanted. But what if you "

"wanted Python's standard :mod:`string` module? There's no clean way to "

"ignore :mod:`pkg.string` and look for the standard module; generally you "

"had to look at the contents of ``sys.modules``, which is slightly "

"unclean. Holger Krekel's :mod:`py.std` package provides a tidier way "

"to perform imports from the standard library, ``import py; "

"py.std.string.join()``, but that package isn't available on all Python "

"installations."

msgstr ""

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

msgid ""

"Reading code which relies on relative imports is also less clear, because"

" a reader may be confused about which module, :mod:`string` or "

":mod:`pkg.string`, is intended to be used. Python users soon learned not"

" to duplicate the names of standard library modules in the names of their"

" packages' submodules, but you can't protect against having your "

"submodule's name being used for a new module added in a future version of"

" Python."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:299

msgid ""

"In Python 2.5, you can switch :keyword:`import`'s behaviour to absolute "

"imports using a ``from __future__ import absolute_import`` directive. "

"This absolute-import behaviour will become the default in a future "

"version (probably Python 2.7). Once absolute imports are the default, "

"``import string`` will always find the standard library's version. It's "

"suggested that users should begin using absolute imports as much as "

"possible, so it's preferable to begin writing ``from pkg import string`` "

"in your code."

msgstr ""

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

msgid ""

"Relative imports are still possible by adding a leading period to the "

"module name when using the ``from ... import`` form::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:315

msgid ""

"This imports the :mod:`string` module relative to the current package, so"

" in :mod:`pkg.main` this will import *name1* and *name2* from "

":mod:`pkg.string`. Additional leading periods perform the relative import"

" starting from the parent of the current package. For example, code in "

"the :mod:`A.B.C` module can do::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:324

msgid ""

"Leading periods cannot be used with the ``import modname`` form of the "

"import statement, only the ``from ... import`` form."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:331

msgid ":pep:`328` - Imports: Multi-Line and Absolute/Relative"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:331

msgid "PEP written by Aahz; implemented by Thomas Wouters."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:333

msgid "https://pylib.readthedocs.io/"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:334

msgid "The py library by Holger Krekel, which contains the :mod:`py.std` package."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:342

msgid "PEP 338: Executing Modules as Scripts"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:344

msgid ""

"The :option:`-m` switch added in Python 2.4 to execute a module as a "

"script gained a few more abilities. Instead of being implemented in C "

"code inside the Python interpreter, the switch now uses an implementation"

" in a new module, :mod:`runpy`."

msgstr ""

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

msgid ""

"The :mod:`runpy` module implements a more sophisticated import mechanism "

"so that it's now possible to run modules in a package such as "

":mod:`pychecker.checker`. The module also supports alternative import "

"mechanisms such as the :mod:`zipimport` module. This means you can add a"

" .zip archive's path to ``sys.path`` and then use the :option:`-m` switch"

" to execute code from the archive."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:359

msgid ":pep:`338` - Executing modules as scripts"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:360

msgid "PEP written and implemented by Nick Coghlan."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:368

msgid "PEP 341: Unified try/except/finally"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:370

msgid ""

"Until Python 2.5, the :keyword:`try` statement came in two flavours. You "

"could use a :keyword:`finally` block to ensure that code is always "

"executed, or one or more :keyword:`except` blocks to catch specific "

"exceptions. You couldn't combine both :keyword:`!except` blocks and a "

":keyword:`!finally` block, because generating the right bytecode for the "

"combined version was complicated and it wasn't clear what the semantics "

"of the combined statement should be."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:377

msgid ""

"Guido van Rossum spent some time working with Java, which does support "

"the equivalent of combining :keyword:`except` blocks and a "

":keyword:`finally` block, and this clarified what the statement should "

"mean. In Python 2.5, you can now write::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:393

msgid ""

"The code in *block-1* is executed. If the code raises an exception, the "

"various :keyword:`except` blocks are tested: if the exception is of class"

" :class:`Exception1`, *handler-1* is executed; otherwise if it's of class"

" :class:`Exception2`, *handler-2* is executed, and so forth. If no "

"exception is raised, the *else-block* is executed."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:399

msgid ""

"No matter what happened previously, the *final-block* is executed once "

"the code block is complete and any raised exceptions handled. Even if "

"there's an error in an exception handler or the *else-block* and a new "

"exception is raised, the code in the *final-block* is still run."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:407

msgid ":pep:`341` - Unifying try-except and try-finally"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:408

msgid "PEP written by Georg Brandl; implementation by Thomas Lee."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:416

msgid "PEP 342: New Generator Features"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:418

msgid ""

"Python 2.5 adds a simple way to pass values *into* a generator. As "

"introduced in Python 2.3, generators only produce output; once a "

"generator's code was invoked to create an iterator, there was no way to "

"pass any new information into the function when its execution is resumed."

" Sometimes the ability to pass in some information would be useful. "

"Hackish solutions to this include making the generator's code look at a "

"global variable and then changing the global variable's value, or passing"

" in some mutable object that callers then modify."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:426

msgid "To refresh your memory of basic generators, here's a simple example::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:434

msgid ""

"When you call ``counter(10)``, the result is an iterator that returns the"

" values from 0 up to 9. On encountering the :keyword:`yield` statement, "

"the iterator returns the provided value and suspends the function's "

"execution, preserving the local variables. Execution resumes on the "

"following call to the iterator's :meth:`next` method, picking up after "

"the :keyword:`!yield` statement."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:440

msgid ""

"In Python 2.3, :keyword:`yield` was a statement; it didn't return any "

"value. In 2.5, :keyword:`!yield` is now an expression, returning a value"

" that can be assigned to a variable or otherwise operated on::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:446

msgid ""

"I recommend that you always put parentheses around a :keyword:`yield` "

"expression when you're doing something with the returned value, as in the"

" above example. The parentheses aren't always necessary, but it's easier "

"to always add them instead of having to remember when they're needed."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:451

msgid ""

"(:pep:`342` explains the exact rules, which are that a :keyword:`yield`\\"

" -expression must always be parenthesized except when it occurs at the "

"top-level expression on the right-hand side of an assignment. This means"

" you can write ``val = yield i`` but have to use parentheses when there's"

" an operation, as in ``val = (yield i) + 12``.)"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:458

msgid ""

"Values are sent into a generator by calling its ``send(value)`` method. "

"The generator's code is then resumed and the :keyword:`yield` expression "

"returns the specified *value*. If the regular :meth:`next` method is "

"called, the :keyword:`!yield` returns :const:`None`."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:463

msgid ""

"Here's the previous example, modified to allow changing the value of the "

"internal counter. ::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:476

msgid "And here's an example of changing the counter::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:493

msgid ""

":keyword:`yield` will usually return :const:`None`, so you should always "

"check for this case. Don't just use its value in expressions unless "

"you're sure that the :meth:`send` method will be the only method used to "

"resume your generator function."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:498

msgid ""

"In addition to :meth:`send`, there are two other new methods on "

"generators:"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:500

msgid ""

"``throw(type, value=None, traceback=None)`` is used to raise an exception"

" inside the generator; the exception is raised by the :keyword:`yield` "

"expression where the generator's execution is paused."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:504

msgid ""

":meth:`close` raises a new :exc:`GeneratorExit` exception inside the "

"generator to terminate the iteration. On receiving this exception, the "

"generator's code must either raise :exc:`GeneratorExit` or "

":exc:`StopIteration`. Catching the :exc:`GeneratorExit` exception and "

"returning a value is illegal and will trigger a :exc:`RuntimeError`; if "

"the function raises some other exception, that exception is propagated to"

" the caller. :meth:`close` will also be called by Python's garbage "

"collector when the generator is garbage-collected."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:512

msgid ""

"If you need to run cleanup code when a :exc:`GeneratorExit` occurs, I "

"suggest using a ``try: ... finally:`` suite instead of catching "

":exc:`GeneratorExit`."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:515

msgid ""

"The cumulative effect of these changes is to turn generators from one-way"

" producers of information into both producers and consumers."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:518

msgid ""

"Generators also become *coroutines*, a more generalized form of "

"subroutines. Subroutines are entered at one point and exited at another "

"point (the top of the function, and a :keyword:`return` statement), but "

"coroutines can be entered, exited, and resumed at many different points "

"(the :keyword:`yield` statements). We'll have to figure out patterns for "

"using coroutines effectively in Python."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:524

msgid ""

"The addition of the :meth:`close` method has one side effect that isn't "

"obvious. :meth:`close` is called when a generator is garbage-collected, "

"so this means the generator's code gets one last chance to run before the"

" generator is destroyed. This last chance means that ``try...finally`` "

"statements in generators can now be guaranteed to work; the "

":keyword:`finally` clause will now always get a chance to run. The "

"syntactic restriction that you couldn't mix :keyword:`yield` statements "

"with a ``try...finally`` suite has therefore been removed. This seems "

"like a minor bit of language trivia, but using generators and "

"``try...finally`` is actually necessary in order to implement the "

":keyword:`with` statement described by PEP 343. I'll look at this new "

"statement in the following section."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:536

msgid ""

"Another even more esoteric effect of this change: previously, the "

":attr:`gi_frame` attribute of a generator was always a frame object. It's"

" now possible for :attr:`gi_frame` to be ``None`` once the generator has "

"been exhausted."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:549

msgid ":pep:`342` - Coroutines via Enhanced Generators"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:545

msgid ""

"PEP written by Guido van Rossum and Phillip J. Eby; implemented by "

"Phillip J. Eby. Includes examples of some fancier uses of generators as"

" coroutines."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:548

msgid ""

"Earlier versions of these features were proposed in :pep:`288` by "

"Raymond Hettinger and :pep:`325` by Samuele Pedroni."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:552

msgid "https://en.wikipedia.org/wiki/Coroutine"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:552

msgid "The Wikipedia entry for coroutines."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:554

msgid "http://www.sidhe.org/~dan/blog/archives/000178.html"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:555

msgid ""

"An explanation of coroutines from a Perl point of view, written by Dan "

"Sugalski."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:563

msgid "PEP 343: The 'with' statement"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:565

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

#: ../Doc/whatsnew/2.5.rst:571

msgid ""

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

"basic structure is::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:577

msgid ""

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

"supports the context management protocol (that is, has :meth:`__enter__` "

"and :meth:`__exit__` methods."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:581

msgid ""

"The object's :meth:`__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 ""

#: ../Doc/whatsnew/2.5.rst:586

msgid ""

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

":meth:`__exit__` method is called, even if the block raised an exception,"

" and can therefore run clean-up code."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:590

msgid ""

"To enable the statement in Python 2.5, you need to add the following "

"directive to your module::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:595

msgid "The statement will always be enabled in Python 2.6."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:597

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

#: ../Doc/whatsnew/2.5.rst:605

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

#: ../Doc/whatsnew/2.5.rst:611

msgid ""

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

":meth:`file.__enter__` returns *self*."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:614

msgid ""

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

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

msgstr ""

#: ../Doc/whatsnew/2.5.rst:622

msgid ""

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

"once the block is complete."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:625

msgid ""

"The new :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 ""

#: ../Doc/whatsnew/2.5.rst:644

msgid "Writing Context Managers"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:646

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

#: ../Doc/whatsnew/2.5.rst:652

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

msgstr ""

#: ../Doc/whatsnew/2.5.rst:654

msgid ""

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

"\"context manager\". The context manager must have :meth:`__enter__` and"

" :meth:`__exit__` methods."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:658

msgid ""

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

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

" value is simply discarded."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:662

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

msgstr ""

#: ../Doc/whatsnew/2.5.rst:664

msgid ""

"If *BLOCK* raises an exception, the ``__exit__(type, value, traceback)`` "

"is called with the exception details, the same values returned by "

":func:`sys.exc_info`. The method's return value controls whether the "

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

#: ../Doc/whatsnew/2.5.rst:672

msgid ""

"If *BLOCK* didn't raise an exception, the :meth:`__exit__` method is "

"still called, but *type*, *value*, and *traceback* are all ``None``."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:675

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

#: ../Doc/whatsnew/2.5.rst:678

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

#: ../Doc/whatsnew/2.5.rst:684

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

#: ../Doc/whatsnew/2.5.rst:693

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

#: ../Doc/whatsnew/2.5.rst:706

msgid ""

"The :meth:`__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 ""

#: ../Doc/whatsnew/2.5.rst:718

msgid ""

"The :meth:`__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 ""

#: ../Doc/whatsnew/2.5.rst:723

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

#: ../Doc/whatsnew/2.5.rst:743

msgid "The contextlib module"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:745

msgid ""

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

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

"statement."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:748

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:`__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:`__exit__` "

"method. Any exception raised in the block will be raised by the "

":keyword:`!yield` statement."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:757

msgid ""

"Our database example from the previous section could be written using "

"this decorator as::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:777

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

#: ../Doc/whatsnew/2.5.rst:786

msgid ""

"Finally, the ``closing(object)`` function returns *object* so that it can"

" be bound to a variable, and calls ``object.close`` at the end of the "

"block. ::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:803

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

msgstr ""

#: ../Doc/whatsnew/2.5.rst:800

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

#: ../Doc/whatsnew/2.5.rst:805

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

msgstr ""

#: ../Doc/whatsnew/2.5.rst:813

msgid "PEP 352: Exceptions as New-Style Classes"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:815

msgid ""

"Exception classes can now be new-style classes, not just classic classes,"

" and the built-in :exc:`Exception` class and all the standard built-in "

"exceptions (:exc:`NameError`, :exc:`ValueError`, etc.) are now new-style "

"classes."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:819

msgid ""

"The inheritance hierarchy for exceptions has been rearranged a bit. In "

"2.5, the inheritance relationships are::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:828

msgid ""

"This rearrangement was done because people often want to catch all "

"exceptions that indicate program errors. :exc:`KeyboardInterrupt` and "

":exc:`SystemExit` aren't errors, though, and usually represent an "

"explicit action such as the user hitting :kbd:`Control-C` or code calling"

" :func:`sys.exit`. A bare ``except:`` will catch all exceptions, so you "

"commonly need to list :exc:`KeyboardInterrupt` and :exc:`SystemExit` in "

"order to re-raise them. The usual pattern is::"

msgstr ""

#: ../Doc/whatsnew/2.5.rst:843

msgid ""

"In Python 2.5, you can now write ``except Exception`` to achieve the same"

" result, catching all the exceptions that usually indicate errors but "

"leaving :exc:`KeyboardInterrupt` and :exc:`SystemExit` alone. As in "

"previous versions, a bare ``except:`` still catches all exceptions."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:848

msgid ""

"The goal for Python 3.0 is to require any class raised as an exception to"

" derive from :exc:`BaseException` or some descendant of "

":exc:`BaseException`, and future releases in the Python 2.x series may "

"begin to enforce this constraint. Therefore, I suggest you begin making "

"all your exception classes derive from :exc:`Exception` now. It's been "

"suggested that the bare ``except:`` form should be removed in Python 3.0,"

" but Guido van Rossum hasn't decided whether to do this or not."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:856

msgid ""

"Raising of strings as exceptions, as in the statement ``raise \"Error "

"occurred\"``, is deprecated in Python 2.5 and will trigger a warning. "

"The aim is to be able to remove the string-exception feature in a few "

"releases."

msgstr ""

#: ../Doc/whatsnew/2.5.rst:863

msgid ":pep:`352` - Required Superclass for Exceptions"

msgstr ""