2.4.po

# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-24 07:20+0000\n"
"PO-Revision-Date: 2018-05-23 16:19+0000\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../whatsnew/2.4.rst:3
msgid "What's New in Python 2.4"
msgstr "Python 2.4 有什麼新功能"

#: ../../whatsnew/2.4.rst:0
msgid "Author"
msgstr "作者"

#: ../../whatsnew/2.4.rst:5
msgid "A.M. Kuchling"
msgstr "A.M. Kuchling"

#: ../../whatsnew/2.4.rst:14
msgid ""
"This article explains the new features in Python 2.4.1, released on March "
"30, 2005."
msgstr ""

#: ../../whatsnew/2.4.rst:17
msgid ""
"Python 2.4 is a medium-sized release.  It doesn't introduce as many changes "
"as the radical Python 2.2, but introduces more features than the "
"conservative 2.3 release.  The most significant new language features are "
"function decorators and generator expressions; most other changes are to the "
"standard library."
msgstr ""

#: ../../whatsnew/2.4.rst:22
msgid ""
"According to the CVS change logs, there were 481 patches applied and 502 "
"bugs fixed between Python 2.3 and 2.4.  Both figures are likely to be "
"underestimates."
msgstr ""

#: ../../whatsnew/2.4.rst:25
msgid ""
"This article doesn't attempt to provide a complete specification of every "
"single new feature, but instead provides a brief introduction to each "
"feature.  For full details, you should refer to the documentation for Python "
"2.4, such as the Python Library Reference and the Python Reference Manual.  "
"Often you will be referred to the PEP for a particular new feature for "
"explanations of the implementation and design rationale."
msgstr ""

#: ../../whatsnew/2.4.rst:36
msgid "PEP 218: Built-In Set Objects"
msgstr ""

#: ../../whatsnew/2.4.rst:38
msgid ""
"Python 2.3 introduced the :mod:`sets` module.  C implementations of set data "
"types have now been added to the Python core as two new built-in types, "
"``set(iterable)`` and ``frozenset(iterable)``.  They provide high speed "
"operations for membership testing, for eliminating duplicates from "
"sequences, and for mathematical operations like unions, intersections, "
"differences, and symmetric differences. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:45
msgid ""
">>> a = set('abracadabra')              # form a set from a string\n"
">>> 'z' in a                            # fast membership testing\n"
"False\n"
">>> a                                   # unique letters in a\n"
"set(['a', 'r', 'b', 'c', 'd'])\n"
">>> ''.join(a)                          # convert back into a string\n"
"'arbcd'\n"
"\n"
">>> b = set('alacazam')                 # form a second set\n"
">>> a - b                               # letters in a but not in b\n"
"set(['r', 'd', 'b'])\n"
">>> a | b                               # letters in either a or b\n"
"set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])\n"
">>> a & b                               # letters in both a and b\n"
"set(['a', 'c'])\n"
">>> a ^ b                               # letters in a or b but not both\n"
"set(['r', 'd', 'b', 'm', 'z', 'l'])\n"
"\n"
">>> a.add('z')                          # add a new element\n"
">>> a.update('wxy')                     # add multiple new elements\n"
">>> a\n"
"set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'x', 'z'])\n"
">>> a.remove('x')                       # take one element out\n"
">>> a\n"
"set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'z'])"
msgstr ""

#: ../../whatsnew/2.4.rst:71
msgid ""
"The :func:`frozenset` type is an immutable version of :func:`set`. Since it "
"is immutable and hashable, it may be used as a dictionary key or as a member "
"of another set."
msgstr ""

#: ../../whatsnew/2.4.rst:75
msgid ""
"The :mod:`sets` module remains in the standard library, and may be useful if "
"you wish to subclass the :class:`Set` or :class:`ImmutableSet` classes.  "
"There are currently no plans to deprecate the module."
msgstr ""

#: ../../whatsnew/2.4.rst:82
msgid ":pep:`218` - Adding a Built-In Set Object Type"
msgstr ""

#: ../../whatsnew/2.4.rst:83
msgid ""
"Originally proposed by Greg Wilson and ultimately implemented by Raymond "
"Hettinger."
msgstr ""

#: ../../whatsnew/2.4.rst:90
msgid "PEP 237: Unifying Long Integers and Integers"
msgstr ""

#: ../../whatsnew/2.4.rst:92
msgid ""
"The lengthy transition process for this PEP, begun in Python 2.2, takes "
"another step forward in Python 2.4.  In 2.3, certain integer operations that "
"would behave differently after int/long unification triggered :exc:"
"`FutureWarning` warnings and returned values limited to 32 or 64 bits "
"(depending on your platform).  In 2.4, these expressions no longer produce a "
"warning and instead produce a different result that's usually a long integer."
msgstr ""

#: ../../whatsnew/2.4.rst:99
msgid ""
"The problematic expressions are primarily left shifts and lengthy "
"hexadecimal and octal constants.  For example, ``2 << 32`` results in a "
"warning in 2.3, evaluating to 0 on 32-bit platforms.  In Python 2.4, this "
"expression now returns the correct answer, 8589934592."
msgstr ""

#: ../../whatsnew/2.4.rst:107
msgid ":pep:`237` - Unifying Long Integers and Integers"
msgstr ""

#: ../../whatsnew/2.4.rst:108
msgid ""
"Original PEP written by Moshe Zadka and GvR.  The changes for 2.4 were "
"implemented by  Kalle Svensson."
msgstr ""

#: ../../whatsnew/2.4.rst:115
msgid "PEP 289: Generator Expressions"
msgstr ""

#: ../../whatsnew/2.4.rst:117
msgid ""
"The iterator feature introduced in Python 2.2 and the :mod:`itertools` "
"module make it easier to write programs that loop through large data sets "
"without having the entire data set in memory at one time.  List "
"comprehensions don't fit into this picture very well because they produce a "
"Python list object containing all of the items.  This unavoidably pulls all "
"of the objects into memory, which can be a problem if your data set is very "
"large.  When trying to write a functionally styled program, it would be "
"natural to write something like::"
msgstr ""

#: ../../whatsnew/2.4.rst:125
msgid ""
"links = [link for link in get_all_links() if not link.followed]\n"
"for link in links:\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:129
msgid "instead of  ::"
msgstr ""

#: ../../whatsnew/2.4.rst:131
msgid ""
"for link in get_all_links():\n"
"    if link.followed:\n"
"        continue\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:136
msgid ""
"The first form is more concise and perhaps more readable, but if you're "
"dealing with a large number of link objects you'd have to write the second "
"form to avoid having all link objects in memory at the same time."
msgstr ""

#: ../../whatsnew/2.4.rst:140
msgid ""
"Generator expressions work similarly to list comprehensions but don't "
"materialize the entire list; instead they create a generator that will "
"return elements one by one.  The above example could be written as::"
msgstr ""

#: ../../whatsnew/2.4.rst:144
msgid ""
"links = (link for link in get_all_links() if not link.followed)\n"
"for link in links:\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:148
msgid ""
"Generator expressions always have to be written inside parentheses, as in "
"the above example.  The parentheses signalling a function call also count, "
"so if you want to create an iterator that will be immediately passed to a "
"function you could write::"
msgstr ""

#: ../../whatsnew/2.4.rst:153
msgid "print sum(obj.count for obj in list_all_objects())"
msgstr ""

#: ../../whatsnew/2.4.rst:155
msgid ""
"Generator expressions differ from list comprehensions in various small ways. "
"Most notably, the loop variable (*obj* in the above example) is not "
"accessible outside of the generator expression.  List comprehensions leave "
"the variable assigned to its last value; future versions of Python will "
"change this, making list comprehensions match generator expressions in this "
"respect."
msgstr ""

#: ../../whatsnew/2.4.rst:164
msgid ":pep:`289` - Generator Expressions"
msgstr ""

#: ../../whatsnew/2.4.rst:165
msgid ""
"Proposed by Raymond Hettinger and implemented by Jiwon Seo with early "
"efforts steered by Hye-Shik Chang."
msgstr ""

#: ../../whatsnew/2.4.rst:172
msgid "PEP 292: Simpler String Substitutions"
msgstr ""

#: ../../whatsnew/2.4.rst:174
msgid ""
"Some new classes in the standard library provide an alternative mechanism "
"for substituting variables into strings; this style of substitution may be "
"better for applications where untrained users need to edit templates."
msgstr ""

#: ../../whatsnew/2.4.rst:178
msgid "The usual way of substituting variables by name is the ``%`` operator::"
msgstr ""

#: ../../whatsnew/2.4.rst:180
msgid ""
">>> '%(page)i: %(title)s' % {'page':2, 'title': 'The Best of Times'}\n"
"'2: The Best of Times'"
msgstr ""

#: ../../whatsnew/2.4.rst:183
msgid ""
"When writing the template string, it can be easy to forget the ``i`` or "
"``s`` after the closing parenthesis.  This isn't a big problem if the "
"template is in a Python module, because you run the code, get an "
"\"Unsupported format character\" :exc:`ValueError`, and fix the problem.  "
"However, consider an application such as Mailman where template strings or "
"translations are being edited by users who aren't aware of the Python "
"language.  The format string's syntax is complicated to explain to such "
"users, and if they make a mistake, it's difficult to provide helpful "
"feedback to them."
msgstr ""

#: ../../whatsnew/2.4.rst:192
msgid ""
"PEP 292 adds a :class:`Template` class to the :mod:`string` module that uses "
"``$`` to indicate a substitution::"
msgstr ""

#: ../../whatsnew/2.4.rst:195
msgid ""
">>> import string\n"
">>> t = string.Template('$page: $title')\n"
">>> t.substitute({'page':2, 'title': 'The Best of Times'})\n"
"'2: The Best of Times'"
msgstr ""

#: ../../whatsnew/2.4.rst:200
msgid ""
"If a key is missing from the dictionary, the :meth:`substitute` method will "
"raise a :exc:`KeyError`.  There's also a :meth:`safe_substitute` method that "
"ignores missing keys::"
msgstr ""

#: ../../whatsnew/2.4.rst:204
msgid ""
">>> t = string.Template('$page: $title')\n"
">>> t.safe_substitute({'page':3})\n"
"'3: $title'"
msgstr ""

#: ../../whatsnew/2.4.rst:211
msgid ":pep:`292` - Simpler String Substitutions"
msgstr ""

#: ../../whatsnew/2.4.rst:212
msgid "Written and implemented  by Barry Warsaw."
msgstr ""

#: ../../whatsnew/2.4.rst:218
msgid "PEP 318: Decorators for Functions and Methods"
msgstr ""

#: ../../whatsnew/2.4.rst:220
msgid ""
"Python 2.2 extended Python's object model by adding static methods and class "
"methods, but it didn't extend Python's syntax to provide any new way of "
"defining static or class methods.  Instead, you had to write a :keyword:"
"`def` statement in the usual way, and pass the resulting method to a :func:"
"`staticmethod` or :func:`classmethod` function that would wrap up the "
"function as a method of the new type. Your code would look like this::"
msgstr ""

#: ../../whatsnew/2.4.rst:227
msgid ""
"class C:\n"
"   def meth (cls):\n"
"       ...\n"
"\n"
"   meth = classmethod(meth)   # Rebind name to wrapped-up class method"
msgstr ""

#: ../../whatsnew/2.4.rst:233
msgid ""
"If the method was very long, it would be easy to miss or forget the :func:"
"`classmethod` invocation after the function body."
msgstr ""

#: ../../whatsnew/2.4.rst:236
msgid ""
"The intention was always to add some syntax to make such definitions more "
"readable, but at the time of 2.2's release a good syntax was not obvious.  "
"Today a good syntax *still* isn't obvious but users are asking for easier "
"access to the feature; a new syntactic feature has been added to meet this "
"need."
msgstr ""

#: ../../whatsnew/2.4.rst:241
msgid ""
"The new feature is called \"function decorators\".  The name comes from the "
"idea that :func:`classmethod`, :func:`staticmethod`, and friends are storing "
"additional information on a function object; they're *decorating* functions "
"with more details."
msgstr ""

#: ../../whatsnew/2.4.rst:246
msgid ""
"The notation borrows from Java and uses the ``'@'`` character as an "
"indicator. Using the new syntax, the example above would be written::"
msgstr ""

#: ../../whatsnew/2.4.rst:249
msgid ""
"class C:\n"
"\n"
"   @classmethod\n"
"   def meth (cls):\n"
"       ..."
msgstr ""

#: ../../whatsnew/2.4.rst:256
msgid ""
"The ``@classmethod`` is shorthand for the ``meth=classmethod(meth)`` "
"assignment. More generally, if you have the following::"
msgstr ""

#: ../../whatsnew/2.4.rst:259
msgid ""
"@A\n"
"@B\n"
"@C\n"
"def f ():\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:265
msgid "It's equivalent to the following pre-decorator code::"
msgstr ""

#: ../../whatsnew/2.4.rst:267
msgid ""
"def f(): ...\n"
"f = A(B(C(f)))"
msgstr ""

#: ../../whatsnew/2.4.rst:270
msgid ""
"Decorators must come on the line before a function definition, one decorator "
"per line, and can't be on the same line as the def statement, meaning that "
"``@A def f(): ...`` is illegal.  You can only decorate function definitions, "
"either at the module level or inside a class; you can't decorate class "
"definitions."
msgstr ""

#: ../../whatsnew/2.4.rst:275
msgid ""
"A decorator is just a function that takes the function to be decorated as an "
"argument and returns either the same function or some new object.  The "
"return value of the decorator need not be callable (though it typically is), "
"unless further decorators will be applied to the result.  It's easy to write "
"your own decorators.  The following simple example just sets an attribute on "
"the function object::"
msgstr ""

#: ../../whatsnew/2.4.rst:282
msgid ""
">>> def deco(func):\n"
"...    func.attr = 'decorated'\n"
"...    return func\n"
"...\n"
">>> @deco\n"
"... def f(): pass\n"
"...\n"
">>> f\n"
"<function f at 0x402ef0d4>\n"
">>> f.attr\n"
"'decorated'\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:295
msgid ""
"As a slightly more realistic example, the following decorator checks that "
"the supplied argument is an integer::"
msgstr ""

#: ../../whatsnew/2.4.rst:298
msgid ""
"def require_int (func):\n"
"    def wrapper (arg):\n"
"        assert isinstance(arg, int)\n"
"        return func(arg)\n"
"\n"
"    return wrapper\n"
"\n"
"@require_int\n"
"def p1 (arg):\n"
"    print arg\n"
"\n"
"@require_int\n"
"def p2(arg):\n"
"    print arg*2"
msgstr ""

#: ../../whatsnew/2.4.rst:313
msgid ""
"An example in :pep:`318` contains a fancier version of this idea that lets "
"you both specify the required type and check the returned type."
msgstr ""

#: ../../whatsnew/2.4.rst:316
msgid ""
"Decorator functions can take arguments.  If arguments are supplied, your "
"decorator function is called with only those arguments and must return a new "
"decorator function; this function must take a single function and return a "
"function, as previously described.  In other words, ``@A @B @C(args)`` "
"becomes::"
msgstr ""

#: ../../whatsnew/2.4.rst:321
msgid ""
"def f(): ...\n"
"_deco = C(args)\n"
"f = A(B(_deco(f)))"
msgstr ""

#: ../../whatsnew/2.4.rst:325
msgid ""
"Getting this right can be slightly brain-bending, but it's not too difficult."
msgstr ""

#: ../../whatsnew/2.4.rst:327
msgid ""
"A small related change makes the :attr:`func_name <function.__name__>` "
"attribute of functions writable.  This attribute is used to display function "
"names in tracebacks, so decorators should change the name of any new "
"function that's constructed and returned."
msgstr ""

#: ../../whatsnew/2.4.rst:336
msgid ":pep:`318` - Decorators for Functions, Methods and Classes"
msgstr ""

#: ../../whatsnew/2.4.rst:337
msgid ""
"Written  by Kevin D. Smith, Jim Jewett, and Skip Montanaro.  Several people "
"wrote patches implementing function decorators, but the one that was "
"actually checked in was patch #979728, written by Mark Russell."
msgstr ""

#: ../../whatsnew/2.4.rst:341
msgid "https://wiki.python.org/moin/PythonDecoratorLibrary"
msgstr "https://wiki.python.org/moin/PythonDecoratorLibrary"

#: ../../whatsnew/2.4.rst:342
msgid "This Wiki page contains several examples of decorators."
msgstr ""

#: ../../whatsnew/2.4.rst:348
msgid "PEP 322: Reverse Iteration"
msgstr ""

#: ../../whatsnew/2.4.rst:350
msgid ""
"A new built-in function, ``reversed(seq)``, takes a sequence and returns an "
"iterator that loops over the elements of the sequence  in reverse order.   ::"
msgstr ""

#: ../../whatsnew/2.4.rst:353
msgid ""
">>> for i in reversed(xrange(1,4)):\n"
"...    print i\n"
"...\n"
"3\n"
"2\n"
"1"
msgstr ""

#: ../../whatsnew/2.4.rst:360
msgid ""
"Compared to extended slicing, such as ``range(1,4)[::-1]``, :func:`reversed` "
"is easier to read, runs faster, and uses substantially less memory."
msgstr ""

#: ../../whatsnew/2.4.rst:363
msgid ""
"Note that :func:`reversed` only accepts sequences, not arbitrary iterators.  "
"If you want to reverse an iterator, first convert it to  a list with :func:"
"`list`. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:367
msgid ""
">>> input = open('/etc/passwd', 'r')\n"
">>> for line in reversed(list(input)):\n"
"...   print line\n"
"...\n"
"root:*:0:0:System Administrator:/var/root:/bin/tcsh\n"
"  ..."
msgstr ""
">>> input = open('/etc/passwd', 'r')\n"
">>> for line in reversed(list(input)):\n"
"...   print line\n"
"...\n"
"root:*:0:0:System Administrator:/var/root:/bin/tcsh\n"
"  ..."

#: ../../whatsnew/2.4.rst:377
msgid ":pep:`322` - Reverse Iteration"
msgstr ""

#: ../../whatsnew/2.4.rst:378
msgid "Written and implemented by Raymond Hettinger."
msgstr ""

#: ../../whatsnew/2.4.rst:384
msgid "PEP 324: New subprocess Module"
msgstr ""

#: ../../whatsnew/2.4.rst:386
msgid ""
"The standard library provides a number of ways to execute a subprocess, "
"offering different features and different levels of complexity. ``os."
"system(command)`` is easy to use, but slow (it runs a shell process which "
"executes the command) and dangerous (you have to be careful about escaping "
"the shell's metacharacters).  The :mod:`!popen2` module offers classes that "
"can capture standard output and standard error from the subprocess, but the "
"naming is confusing.  The :mod:`subprocess` module cleans  this up, "
"providing a unified interface that offers all the features you might need."
msgstr ""

#: ../../whatsnew/2.4.rst:395
msgid ""
"Instead of :mod:`!popen2`'s collection of classes, :mod:`subprocess` "
"contains a single class called :class:`subprocess.Popen`  whose constructor "
"supports a number of different keyword arguments. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:399
msgid ""
"class Popen(args, bufsize=0, executable=None,\n"
"            stdin=None, stdout=None, stderr=None,\n"
"            preexec_fn=None, close_fds=False, shell=False,\n"
"            cwd=None, env=None, universal_newlines=False,\n"
"            startupinfo=None, creationflags=0):"
msgstr ""

#: ../../whatsnew/2.4.rst:405
msgid ""
"*args* is commonly a sequence of strings that will be the arguments to the "
"program executed as the subprocess.  (If the *shell* argument is true, "
"*args* can be a string which will then be passed on to the shell for "
"interpretation, just as :func:`os.system` does.)"
msgstr ""

#: ../../whatsnew/2.4.rst:410
msgid ""
"*stdin*, *stdout*, and *stderr* specify what the subprocess's input, output, "
"and error streams will be.  You can provide a file object or a file "
"descriptor, or you can use the constant ``subprocess.PIPE`` to create a pipe "
"between the subprocess and the parent."
msgstr ""

#: ../../whatsnew/2.4.rst:418
msgid "The constructor has a number of handy options:"
msgstr ""

#: ../../whatsnew/2.4.rst:420
msgid ""
"*close_fds* requests that all file descriptors be closed before running the "
"subprocess."
msgstr ""

#: ../../whatsnew/2.4.rst:423
msgid ""
"*cwd* specifies the working directory in which the subprocess will be "
"executed (defaulting to whatever the parent's working directory is)."
msgstr ""

#: ../../whatsnew/2.4.rst:426
msgid "*env* is a dictionary specifying environment variables."
msgstr ""

#: ../../whatsnew/2.4.rst:428
msgid ""
"*preexec_fn* is a function that gets called before the child is started."
msgstr ""

#: ../../whatsnew/2.4.rst:430
msgid ""
"*universal_newlines* opens the child's input and output using Python's :term:"
"`universal newlines` feature."
msgstr ""

#: ../../whatsnew/2.4.rst:433
msgid ""
"Once you've created the :class:`Popen` instance,  you can call its :meth:"
"`wait` method to pause until the subprocess has exited, :meth:`poll` to "
"check if it's exited without pausing,  or ``communicate(data)`` to send the "
"string *data* to the subprocess's standard input.   ``communicate(data)``  "
"then reads any data that the subprocess has sent to its standard output  or "
"standard error, returning a tuple ``(stdout_data, stderr_data)``."
msgstr ""

#: ../../whatsnew/2.4.rst:440
msgid ""
":func:`call` is a shortcut that passes its arguments along to the :class:"
"`Popen` constructor, waits for the command to complete, and returns the "
"status code of the subprocess.  It can serve as a safer analog to :func:`os."
"system`::"
msgstr ""

#: ../../whatsnew/2.4.rst:444
msgid ""
"sts = subprocess.call(['dpkg', '-i', '/tmp/new-package.deb'])\n"
"if sts == 0:\n"
"    # Success\n"
"    ...\n"
"else:\n"
"    # dpkg returned an error\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:452
msgid ""
"The command is invoked without use of the shell.  If you really do want to  "
"use the shell, you can add ``shell=True`` as a keyword argument and provide "
"a string instead of a sequence::"
msgstr ""

#: ../../whatsnew/2.4.rst:456
msgid "sts = subprocess.call('dpkg -i /tmp/new-package.deb', shell=True)"
msgstr "sts = subprocess.call('dpkg -i /tmp/new-package.deb', shell=True)"

#: ../../whatsnew/2.4.rst:458
msgid ""
"The PEP takes various examples of shell and Python code and shows how they'd "
"be translated into Python code that uses :mod:`subprocess`.  Reading this "
"section of the PEP is highly recommended."
msgstr ""

#: ../../whatsnew/2.4.rst:465
msgid ":pep:`324` - subprocess - New process module"
msgstr ":pep:`324` - subprocess - 新的行程模組"

#: ../../whatsnew/2.4.rst:466
msgid ""
"Written and implemented by Peter Åstrand, with assistance from Fredrik Lundh "
"and others."
msgstr ""

#: ../../whatsnew/2.4.rst:473
msgid "PEP 327: Decimal Data Type"
msgstr ""

#: ../../whatsnew/2.4.rst:475
msgid ""
"Python has always supported floating-point (FP) numbers, based on the "
"underlying C :c:expr:`double` type, as a data type.  However, while most "
"programming languages provide a floating-point type, many people (even "
"programmers) are unaware that floating-point numbers don't represent certain "
"decimal fractions accurately.  The new :class:`Decimal` type can represent "
"these fractions accurately, up to a user-specified precision limit."
msgstr ""

#: ../../whatsnew/2.4.rst:484
msgid "Why is Decimal needed?"
msgstr ""

#: ../../whatsnew/2.4.rst:486
msgid ""
"The limitations arise from the representation used for floating-point "
"numbers. FP numbers are made up of three components:"
msgstr ""

#: ../../whatsnew/2.4.rst:489
msgid "The sign, which is positive or negative."
msgstr ""

#: ../../whatsnew/2.4.rst:491
msgid ""
"The mantissa, which is a single-digit binary number   followed by a "
"fractional part.  For example, ``1.01`` in base-2 notation is ``1 + 0/2 + "
"1/4``, or 1.25 in decimal notation."
msgstr ""

#: ../../whatsnew/2.4.rst:495
msgid ""
"The exponent, which tells where the decimal point is located in the number "
"represented."
msgstr ""

#: ../../whatsnew/2.4.rst:498
msgid ""
"For example, the number 1.25 has positive sign, a mantissa value of 1.01 (in "
"binary), and an exponent of 0 (the decimal point doesn't need to be "
"shifted). The number 5 has the same sign and mantissa, but the exponent is 2 "
"because the mantissa is multiplied by 4 (2 to the power of the exponent 2); "
"1.25 \\* 4 equals 5."
msgstr ""

#: ../../whatsnew/2.4.rst:504
msgid ""
"Modern systems usually provide floating-point support that conforms to a "
"standard called IEEE 754.  C's :c:expr:`double` type is usually implemented "
"as a 64-bit IEEE 754 number, which uses 52 bits of space for the mantissa.  "
"This means that numbers can only be specified to 52 bits of precision.  If "
"you're trying to represent numbers whose expansion repeats endlessly, the "
"expansion is cut off after 52 bits. Unfortunately, most software needs to "
"produce output in base 10, and common fractions in base 10 are often "
"repeating decimals in binary. For example, 1.1 decimal is binary "
"``1.0001100110011 ...``; .1 = 1/16 + 1/32 + 1/256 plus an infinite number of "
"additional terms.  IEEE 754 has to chop off that infinitely repeated decimal "
"after 52 digits, so the representation is slightly inaccurate."
msgstr ""

#: ../../whatsnew/2.4.rst:516
msgid "Sometimes you can see this inaccuracy when the number is printed::"
msgstr ""

#: ../../whatsnew/2.4.rst:518
msgid ""
">>> 1.1\n"
"1.1000000000000001"
msgstr ""

#: ../../whatsnew/2.4.rst:521
msgid ""
"The inaccuracy isn't always visible when you print the number because the FP-"
"to-decimal-string conversion is provided by the C library, and most C "
"libraries try to produce sensible output.  Even if it's not displayed, "
"however, the inaccuracy is still there and subsequent operations can magnify "
"the error."
msgstr ""

#: ../../whatsnew/2.4.rst:526
msgid ""
"For many applications this doesn't matter.  If I'm plotting points and "
"displaying them on my monitor, the difference between 1.1 and "
"1.1000000000000001 is too small to be visible.  Reports often limit output "
"to a certain number of decimal places, and if you round the number to two or "
"three or even eight decimal places, the error is never apparent.  However, "
"for applications where it does matter,  it's a lot of work to implement your "
"own custom arithmetic routines."
msgstr ""

#: ../../whatsnew/2.4.rst:534
msgid "Hence, the :class:`Decimal` type was created."
msgstr ""

#: ../../whatsnew/2.4.rst:538
msgid "The :class:`Decimal` type"
msgstr ":class:`Decimal` 型別"

#: ../../whatsnew/2.4.rst:540
msgid ""
"A new module, :mod:`decimal`, was added to Python's standard library.  It "
"contains two classes, :class:`Decimal` and :class:`Context`.  :class:"
"`Decimal` instances represent numbers, and :class:`Context` instances are "
"used to wrap up various settings such as the precision and default rounding "
"mode."
msgstr ""

#: ../../whatsnew/2.4.rst:545
msgid ""
":class:`Decimal` instances are immutable, like regular Python integers and "
"FP numbers; once it's been created, you can't change the value an instance "
"represents.  :class:`Decimal` instances can be created from integers or "
"strings::"
msgstr ""

#: ../../whatsnew/2.4.rst:550
msgid ""
">>> import decimal\n"
">>> decimal.Decimal(1972)\n"
"Decimal(\"1972\")\n"
">>> decimal.Decimal(\"1.1\")\n"
"Decimal(\"1.1\")"
msgstr ""

#: ../../whatsnew/2.4.rst:556
msgid ""
"You can also provide tuples containing the sign, the mantissa represented  "
"as a tuple of decimal digits, and the exponent::"
msgstr ""

#: ../../whatsnew/2.4.rst:559
msgid ""
">>> decimal.Decimal((1, (1, 4, 7, 5), -2))\n"
"Decimal(\"-14.75\")"
msgstr ""

#: ../../whatsnew/2.4.rst:562
msgid ""
"Cautionary note: the sign bit is a Boolean value, so 0 is positive and 1 is "
"negative."
msgstr ""

#: ../../whatsnew/2.4.rst:565
msgid ""
"Converting from floating-point numbers poses a bit of a problem: should the "
"FP number representing 1.1 turn into the decimal number for exactly 1.1, or "
"for 1.1 plus whatever inaccuracies are introduced? The decision was to dodge "
"the issue and leave such a conversion out of the API.  Instead, you should "
"convert the floating-point number into a string using the desired precision "
"and pass the string to the :class:`Decimal` constructor::"
msgstr ""

#: ../../whatsnew/2.4.rst:572
msgid ""
">>> f = 1.1\n"
">>> decimal.Decimal(str(f))\n"
"Decimal(\"1.1\")\n"
">>> decimal.Decimal('%.12f' % f)\n"
"Decimal(\"1.100000000000\")"
msgstr ""

#: ../../whatsnew/2.4.rst:578
msgid ""
"Once you have :class:`Decimal` instances, you can perform the usual "
"mathematical operations on them.  One limitation: exponentiation requires an "
"integer exponent::"
msgstr ""

#: ../../whatsnew/2.4.rst:582
msgid ""
">>> a = decimal.Decimal('35.72')\n"
">>> b = decimal.Decimal('1.73')\n"
">>> a+b\n"
"Decimal(\"37.45\")\n"
">>> a-b\n"
"Decimal(\"33.99\")\n"
">>> a*b\n"
"Decimal(\"61.7956\")\n"
">>> a/b\n"
"Decimal(\"20.64739884393063583815028902\")\n"
">>> a ** 2\n"
"Decimal(\"1275.9184\")\n"
">>> a**b\n"
"Traceback (most recent call last):\n"
"  ...\n"
"decimal.InvalidOperation: x ** (non-integer)"
msgstr ""

#: ../../whatsnew/2.4.rst:599
msgid ""
"You can combine :class:`Decimal` instances with integers, but not with "
"floating-point numbers::"
msgstr ""

#: ../../whatsnew/2.4.rst:602
msgid ""
">>> a + 4\n"
"Decimal(\"39.72\")\n"
">>> a + 4.5\n"
"Traceback (most recent call last):\n"
"  ...\n"
"TypeError: You can interact Decimal only with int, long or Decimal data "
"types.\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:610
msgid ""
":class:`Decimal` numbers can be used with the :mod:`math` and :mod:`cmath` "
"modules, but note that they'll be immediately converted to  floating-point "
"numbers before the operation is performed, resulting in a possible loss of "
"precision and accuracy.  You'll also get back a regular floating-point "
"number and not a :class:`Decimal`.   ::"
msgstr ""

#: ../../whatsnew/2.4.rst:616
msgid ""
">>> import math, cmath\n"
">>> d = decimal.Decimal('123456789012.345')\n"
">>> math.sqrt(d)\n"
"351364.18288201344\n"
">>> cmath.sqrt(-d)\n"
"351364.18288201344j"
msgstr ""

#: ../../whatsnew/2.4.rst:623
msgid ""
":class:`Decimal` instances have a :meth:`sqrt` method that returns a :class:"
"`Decimal`, but if you need other things such as trigonometric functions "
"you'll have to implement them. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:627
msgid ""
">>> d.sqrt()\n"
"Decimal(\"351364.1828820134592177245001\")"
msgstr ""

#: ../../whatsnew/2.4.rst:632
msgid "The :class:`Context` type"
msgstr ":class:`Context` 型別"

#: ../../whatsnew/2.4.rst:634
msgid ""
"Instances of the :class:`Context` class encapsulate several settings for "
"decimal operations:"
msgstr ""

#: ../../whatsnew/2.4.rst:637
msgid ":attr:`prec` is the precision, the number of decimal places."
msgstr ""

#: ../../whatsnew/2.4.rst:639
msgid ""
":attr:`rounding` specifies the rounding mode.  The :mod:`decimal` module has "
"constants for the various possibilities: :const:`ROUND_DOWN`, :const:"
"`ROUND_CEILING`,  :const:`ROUND_HALF_EVEN`, and various others."
msgstr ""

#: ../../whatsnew/2.4.rst:643
msgid ""
":attr:`traps` is a dictionary specifying what happens on encountering "
"certain error conditions: either  an exception is raised or  a value is "
"returned.  Some examples of error conditions are division by zero, loss of "
"precision, and overflow."
msgstr ""

#: ../../whatsnew/2.4.rst:648
msgid ""
"There's a thread-local default context available by calling :func:"
"`getcontext`; you can change the properties of this context to alter the "
"default precision, rounding, or trap handling.  The following example shows "
"the effect of changing the precision of the default context::"
msgstr ""

#: ../../whatsnew/2.4.rst:653
msgid ""
">>> decimal.getcontext().prec\n"
"28\n"
">>> decimal.Decimal(1) / decimal.Decimal(7)\n"
"Decimal(\"0.1428571428571428571428571429\")\n"
">>> decimal.getcontext().prec = 9\n"
">>> decimal.Decimal(1) / decimal.Decimal(7)\n"
"Decimal(\"0.142857143\")"
msgstr ""

#: ../../whatsnew/2.4.rst:661
msgid ""
"The default action for error conditions is selectable; the module can either "
"return a special value such as infinity or not-a-number, or exceptions can "
"be raised::"
msgstr ""

#: ../../whatsnew/2.4.rst:665
msgid ""
">>> decimal.Decimal(1) / decimal.Decimal(0)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"decimal.DivisionByZero: x / 0\n"
">>> decimal.getcontext().traps[decimal.DivisionByZero] = False\n"
">>> decimal.Decimal(1) / decimal.Decimal(0)\n"
"Decimal(\"Infinity\")\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:674
msgid ""
"The :class:`Context` instance also has various methods for formatting  "
"numbers such as :meth:`to_eng_string` and :meth:`to_sci_string`."
msgstr ""

#: ../../whatsnew/2.4.rst:677
msgid ""
"For more information, see the documentation for the :mod:`decimal` module, "
"which includes a quick-start tutorial and a reference."
msgstr ""

#: ../../whatsnew/2.4.rst:683
msgid ":pep:`327` - Decimal Data Type"
msgstr ""

#: ../../whatsnew/2.4.rst:684
msgid ""
"Written by Facundo Batista and implemented by Facundo Batista, Eric Price, "
"Raymond Hettinger, Aahz, and Tim Peters."
msgstr ""

#: ../../whatsnew/2.4.rst:687
msgid ""
"`http://www.lahey.com/float.htm <https://web.archive.org/web/20230604072523/"
"http://www.lahey.com/float.htm>`__"
msgstr ""
"`http://www.lahey.com/float.htm <https://web.archive.org/web/20230604072523/"
"http://www.lahey.com/float.htm>`__"

#: ../../whatsnew/2.4.rst:688
msgid ""
"The article uses Fortran code to illustrate many of the problems that "
"floating-point inaccuracy can cause."
msgstr ""

#: ../../whatsnew/2.4.rst:691
msgid "https://speleotrove.com/decimal/"
msgstr "https://speleotrove.com/decimal/"

#: ../../whatsnew/2.4.rst:692
msgid ""
"A description of a decimal-based representation.  This representation is "
"being proposed as a standard, and underlies the new Python decimal type.  "
"Much of this material was written by Mike Cowlishaw, designer of the Rexx "
"language."
msgstr ""

#: ../../whatsnew/2.4.rst:700
msgid "PEP 328: Multi-line Imports"
msgstr ""

#: ../../whatsnew/2.4.rst:702
msgid ""
"One language change is a small syntactic tweak aimed at making it easier to "
"import many names from a module.  In a ``from module import names`` "
"statement, *names* is a sequence of names separated by commas.  If the "
"sequence is  very long, you can either write multiple imports from the same "
"module, or you can use backslashes to escape the line endings like this::"
msgstr ""

#: ../../whatsnew/2.4.rst:708
msgid ""
"from SimpleXMLRPCServer import SimpleXMLRPCServer,\\\n"
"            SimpleXMLRPCRequestHandler,\\\n"
"            CGIXMLRPCRequestHandler,\\\n"
"            resolve_dotted_attribute"
msgstr ""

#: ../../whatsnew/2.4.rst:713
msgid ""
"The syntactic change in Python 2.4 simply allows putting the names within "
"parentheses.  Python ignores newlines within a parenthesized expression, so "
"the backslashes are no longer needed::"
msgstr ""

#: ../../whatsnew/2.4.rst:717
msgid ""
"from SimpleXMLRPCServer import (SimpleXMLRPCServer,\n"
"                                SimpleXMLRPCRequestHandler,\n"
"                                CGIXMLRPCRequestHandler,\n"
"                                resolve_dotted_attribute)"
msgstr ""

#: ../../whatsnew/2.4.rst:722
msgid ""
"The PEP also proposes that all :keyword:`import` statements be absolute "
"imports, with a leading ``.`` character to indicate a relative import.  This "
"part of the PEP was not implemented for Python 2.4, but was completed for "
"Python 2.5."
msgstr ""

#: ../../whatsnew/2.4.rst:729
msgid ":pep:`328` - Imports: Multi-Line and Absolute/Relative"
msgstr ""

#: ../../whatsnew/2.4.rst:730
msgid "Written by Aahz.  Multi-line imports were implemented by Dima Dorfman."
msgstr ""

#: ../../whatsnew/2.4.rst:736
msgid "PEP 331: Locale-Independent Float/String Conversions"
msgstr ""

#: ../../whatsnew/2.4.rst:738
msgid ""
"The :mod:`locale` modules lets Python software select various conversions "
"and display conventions that are localized to a particular country or "
"language. However, the module was careful to not change the numeric locale "
"because various functions in Python's implementation required that the "
"numeric locale remain set to the ``'C'`` locale.  Often this was because the "
"code was using the C library's :c:func:`atof` function."
msgstr ""

#: ../../whatsnew/2.4.rst:745
msgid ""
"Not setting the numeric locale caused trouble for extensions that used third-"
"party C libraries, however, because they wouldn't have the correct locale "
"set. The motivating example was GTK+, whose user interface widgets weren't "
"displaying numbers in the current locale."
msgstr ""

#: ../../whatsnew/2.4.rst:750
msgid ""
"The solution described in the PEP is to add three new functions to the "
"Python API that perform ASCII-only conversions, ignoring the locale setting:"
msgstr ""

#: ../../whatsnew/2.4.rst:753
msgid ""
"``PyOS_ascii_strtod(str, ptr)``  and ``PyOS_ascii_atof(str, ptr)`` both "
"convert a string to a C :c:expr:`double`."
msgstr ""

#: ../../whatsnew/2.4.rst:756
msgid ""
"``PyOS_ascii_formatd(buffer, buf_len, format, d)`` converts a :c:expr:"
"`double` to an ASCII string."
msgstr ""

#: ../../whatsnew/2.4.rst:759
msgid ""
"The code for these functions came from the GLib library (`https://developer-"
"old.gnome.org/glib/2.26/ <http://web.archive.org/web/20210306104320/https://"
"developer.gnome.org/glib/2.26/>`__), whose developers kindly relicensed the "
"relevant functions and donated them to the Python Software Foundation.  The :"
"mod:`locale` module  can now change the numeric locale, letting extensions "
"such as GTK+  produce the correct results."
msgstr ""

#: ../../whatsnew/2.4.rst:768
msgid ":pep:`331` - Locale-Independent Float/String Conversions"
msgstr ""

#: ../../whatsnew/2.4.rst:769
msgid "Written by Christian R. Reis, and implemented by Gustavo Carneiro."
msgstr ""

#: ../../whatsnew/2.4.rst:775
msgid "Other Language Changes"
msgstr "其他語言更動"

#: ../../whatsnew/2.4.rst:777
msgid ""
"Here are all of the changes that Python 2.4 makes to the core Python "
"language."
msgstr ""

#: ../../whatsnew/2.4.rst:779
msgid "Decorators for functions and methods were added (:pep:`318`)."
msgstr ""

#: ../../whatsnew/2.4.rst:781
msgid ""
"Built-in :func:`set` and :func:`frozenset` types were  added (:pep:`218`). "
"Other new built-ins include the ``reversed(seq)`` function (:pep:`322`)."
msgstr ""

#: ../../whatsnew/2.4.rst:784
msgid "Generator expressions were added (:pep:`289`)."
msgstr ""

#: ../../whatsnew/2.4.rst:786
msgid ""
"Certain numeric expressions no longer return values restricted to 32 or 64 "
"bits (:pep:`237`)."
msgstr ""

#: ../../whatsnew/2.4.rst:789
msgid ""
"You can now put parentheses around the list of names in a ``from module "
"import names`` statement (:pep:`328`)."
msgstr ""

#: ../../whatsnew/2.4.rst:792
msgid ""
"The :meth:`dict.update` method now accepts the same argument forms as the :"
"class:`dict` constructor.  This includes any mapping, any iterable of key/"
"value pairs, and keyword arguments. (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:796
msgid ""
"The string methods :meth:`ljust`, :meth:`rjust`, and :meth:`center` now take "
"an optional argument for specifying a fill character other than a space. "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:800
msgid ""
"Strings also gained an :meth:`rsplit` method that works like the :meth:"
"`split` method but splits from the end of the string.   (Contributed by Sean "
"Reifschneider.) ::"
msgstr ""

#: ../../whatsnew/2.4.rst:804
msgid ""
">>> 'www.python.org'.split('.', 1)\n"
"['www', 'python.org']\n"
"'www.python.org'.rsplit('.', 1)\n"
"['www.python', 'org']"
msgstr ""

#: ../../whatsnew/2.4.rst:809
msgid ""
"Three keyword parameters, *cmp*, *key*, and *reverse*, were added to the :"
"meth:`sort` method of lists. These parameters make some common usages of :"
"meth:`sort` simpler. All of these parameters are optional."
msgstr ""

#: ../../whatsnew/2.4.rst:813
msgid ""
"For the *cmp* parameter, the value should be a comparison function that "
"takes two parameters and returns -1, 0, or +1 depending on how the "
"parameters compare. This function will then be used to sort the list.  "
"Previously this was the only parameter that could be provided to :meth:"
"`sort`."
msgstr ""

#: ../../whatsnew/2.4.rst:818
msgid ""
"*key* should be a single-parameter function that takes a list element and "
"returns a comparison key for the element.  The list is then sorted using the "
"comparison keys.  The following example sorts a list case-insensitively::"
msgstr ""

#: ../../whatsnew/2.4.rst:822
msgid ""
">>> L = ['A', 'b', 'c', 'D']\n"
">>> L.sort()                 # Case-sensitive sort\n"
">>> L\n"
"['A', 'D', 'b', 'c']\n"
">>> # Using 'key' parameter to sort list\n"
">>> L.sort(key=lambda x: x.lower())\n"
">>> L\n"
"['A', 'b', 'c', 'D']\n"
">>> # Old-fashioned way\n"
">>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))\n"
">>> L\n"
"['A', 'b', 'c', 'D']"
msgstr ""

#: ../../whatsnew/2.4.rst:835
msgid ""
"The last example, which uses the *cmp* parameter, is the old way to perform "
"a case-insensitive sort.  It works but is slower than using a *key* "
"parameter. Using *key* calls :meth:`lower` method once for each element in "
"the list while using *cmp* will call it twice for each comparison, so using "
"*key* saves on invocations of the :meth:`lower` method."
msgstr ""

#: ../../whatsnew/2.4.rst:841
msgid ""
"For simple key functions and comparison functions, it is often possible to "
"avoid a :keyword:`lambda` expression by using an unbound method instead.  "
"For example, the above case-insensitive sort is best written as::"
msgstr ""

#: ../../whatsnew/2.4.rst:845
msgid ""
">>> L.sort(key=str.lower)\n"
">>> L\n"
"['A', 'b', 'c', 'D']"
msgstr ""

#: ../../whatsnew/2.4.rst:849
msgid ""
"Finally, the *reverse* parameter takes a Boolean value.  If the value is "
"true, the list will be sorted into reverse order. Instead of ``L.sort(); L."
"reverse()``, you can now write ``L.sort(reverse=True)``."
msgstr ""

#: ../../whatsnew/2.4.rst:853
msgid ""
"The results of sorting are now guaranteed to be stable.  This means that two "
"entries with equal keys will be returned in the same order as they were "
"input. For example, you can sort a list of people by name, and then sort the "
"list by age, resulting in a list sorted by age where people with the same "
"age are in name-sorted order."
msgstr ""

#: ../../whatsnew/2.4.rst:859
msgid "(All changes to :meth:`sort` contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:861
msgid ""
"There is a new built-in function ``sorted(iterable)`` that works like the in-"
"place :meth:`list.sort` method but can be used in expressions.  The "
"differences are:"
msgstr ""

#: ../../whatsnew/2.4.rst:865
msgid "the input may be any iterable;"
msgstr ""

#: ../../whatsnew/2.4.rst:867
msgid "a newly formed copy is sorted, leaving the original intact; and"
msgstr ""

#: ../../whatsnew/2.4.rst:869
msgid "the expression returns the new sorted copy"
msgstr ""

#: ../../whatsnew/2.4.rst:873
msgid ""
">>> L = [9,7,8,3,2,4,1,6,5]\n"
">>> [10+i for i in sorted(L)]       # usable in a list comprehension\n"
"[11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
">>> L                               # original is left unchanged\n"
"[9,7,8,3,2,4,1,6,5]\n"
">>> sorted('Monty Python')          # any iterable may be an input\n"
"[' ', 'M', 'P', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y', 'y']\n"
"\n"
">>> # List the contents of a dict sorted by key values\n"
">>> colormap = dict(red=1, blue=2, green=3, black=4, yellow=5)\n"
">>> for k, v in sorted(colormap.iteritems()):\n"
"...     print k, v\n"
"...\n"
"black 4\n"
"blue 2\n"
"green 3\n"
"red 1\n"
"yellow 5"
msgstr ""

#: ../../whatsnew/2.4.rst:892 ../../whatsnew/2.4.rst:920
#: ../../whatsnew/2.4.rst:1213
msgid "(Contributed by Raymond Hettinger.)"
msgstr "（由 Raymond Hettinger 所貢獻。）"

#: ../../whatsnew/2.4.rst:894 ../../whatsnew/2.4.rst:1520
msgid ""
"Integer operations will no longer trigger an :exc:`OverflowWarning`. The :"
"exc:`OverflowWarning` warning will disappear in Python 2.5."
msgstr ""

#: ../../whatsnew/2.4.rst:897
msgid ""
"The interpreter gained a new switch, :option:`-m`, that takes a name, "
"searches for the corresponding  module on ``sys.path``, and runs the module "
"as a script. For example,  you can now run the Python profiler with ``python "
"-m profile``. (Contributed by Nick Coghlan.)"
msgstr ""

#: ../../whatsnew/2.4.rst:902
msgid ""
"The ``eval(expr, globals, locals)`` and ``execfile(filename, globals, "
"locals)`` functions and the ``exec`` statement now accept any mapping type "
"for the *locals* parameter.  Previously this had to be a regular Python "
"dictionary.  (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:907
msgid ""
"The :func:`zip` built-in function and :func:`itertools.izip` now return an "
"empty list if called with no arguments. Previously they raised a :exc:"
"`TypeError` exception.  This makes them more suitable for use with variable "
"length argument lists::"
msgstr ""

#: ../../whatsnew/2.4.rst:912
msgid ""
">>> def transpose(array):\n"
"...    return zip(*array)\n"
"...\n"
">>> transpose([(1,2,3), (4,5,6)])\n"
"[(1, 4), (2, 5), (3, 6)]\n"
">>> transpose([])\n"
"[]"
msgstr ""

#: ../../whatsnew/2.4.rst:922
msgid ""
"Encountering a failure while importing a module no longer leaves a partially "
"initialized module object in ``sys.modules``.  The incomplete module object "
"left behind would fool further imports of the same module into succeeding, "
"leading to confusing errors.   (Fixed by Tim Peters.)"
msgstr ""

#: ../../whatsnew/2.4.rst:927
msgid ""
":const:`None` is now a constant; code that binds a new value to  the name "
"``None`` is now a syntax error. (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:934
msgid "Optimizations"
msgstr "最佳化"

#: ../../whatsnew/2.4.rst:936
msgid ""
"The inner loops for list and tuple slicing were optimized and now run about "
"one-third faster.  The inner loops for dictionaries were also optimized, "
"resulting in performance boosts for :meth:`keys`, :meth:`values`, :meth:"
"`items`, :meth:`iterkeys`, :meth:`itervalues`, and :meth:`iteritems`. "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:942
msgid ""
"The machinery for growing and shrinking lists was optimized for speed and "
"for space efficiency.  Appending and popping from lists now runs faster due "
"to more efficient code paths and less frequent use of the underlying system :"
"c:func:`realloc`.  List comprehensions also benefit.   :meth:`list.extend` "
"was also optimized and no longer converts its argument into a temporary list "
"before extending the base list.  (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:949
msgid ""
":func:`list`, :func:`tuple`, :func:`map`, :func:`filter`, and :func:`zip` "
"now run several times faster with non-sequence arguments that supply a :meth:"
"`__len__` method.  (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:953
msgid ""
"The methods :meth:`list.__getitem__`, :meth:`dict.__getitem__`, and :meth:"
"`dict.__contains__` are now implemented as :class:`method_descriptor` "
"objects rather than :class:`wrapper_descriptor` objects.  This form of  "
"access doubles their performance and makes them more suitable for use as "
"arguments to functionals: ``map(mydict.__getitem__, keylist)``. (Contributed "
"by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:960
msgid ""
"Added a new opcode, ``LIST_APPEND``, that simplifies the generated bytecode "
"for list comprehensions and speeds them up by about a third.  (Contributed "
"by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:964
msgid ""
"The peephole bytecode optimizer has been improved to  produce shorter, "
"faster bytecode; remarkably, the resulting bytecode is  more readable.  "
"(Enhanced by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:968
msgid ""
"String concatenations in statements of the form ``s = s + \"abc\"`` and ``s "
"+= \"abc\"`` are now performed more efficiently in certain circumstances.  "
"This optimization won't be present in other Python implementations such as "
"Jython, so you shouldn't rely on it; using the :meth:`join` method of "
"strings is still recommended when you want to efficiently glue a large "
"number of strings together. (Contributed by Armin Rigo.)"
msgstr ""

#: ../../whatsnew/2.4.rst:975
msgid ""
"The net result of the 2.4 optimizations is that Python 2.4 runs the pystone "
"benchmark around 5% faster than Python 2.3 and 35% faster than Python 2.2. "
"(pystone is not a particularly good benchmark, but it's the most commonly "
"used measurement of Python's performance.  Your own applications may show "
"greater or smaller benefits from Python 2.4.)"
msgstr ""

#: ../../whatsnew/2.4.rst:991
msgid "New, Improved, and Deprecated Modules"
msgstr ""

#: ../../whatsnew/2.4.rst:993
msgid ""
"As usual, Python's standard library received a number of enhancements and "
"bug fixes.  Here's a partial list of the most notable changes, sorted "
"alphabetically by module name. Consult the :file:`Misc/NEWS` file in the "
"source tree for a more complete list of changes, or look through the CVS "
"logs for all the details."
msgstr ""

#: ../../whatsnew/2.4.rst:998
msgid ""
"The :mod:`!asyncore` module's :func:`!loop` function now has a *count* "
"parameter that lets you perform a limited number of passes through the "
"polling loop.  The default is still to loop forever."
msgstr ""

#: ../../whatsnew/2.4.rst:1002
msgid ""
"The :mod:`base64` module now has more complete :rfc:`3548` support for "
"Base64, Base32, and Base16 encoding and decoding, including optional case "
"folding and optional alternative alphabets. (Contributed by Barry Warsaw.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1006
msgid ""
"The :mod:`bisect` module now has an underlying C implementation for improved "
"performance. (Contributed by Dmitry Vasiliev.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1009
msgid ""
"The CJKCodecs collections of East Asian codecs, maintained by Hye-Shik "
"Chang, was integrated into 2.4.   The new encodings are:"
msgstr ""

#: ../../whatsnew/2.4.rst:1012
msgid "Chinese (PRC): gb2312, gbk, gb18030, big5hkscs, hz"
msgstr ""

#: ../../whatsnew/2.4.rst:1014
msgid "Chinese (ROC): big5, cp950"
msgstr ""

#: ../../whatsnew/2.4.rst:1016
msgid "Japanese: cp932, euc-jis-2004, euc-jp, euc-jisx0213, iso-2022-jp,"
msgstr ""

#: ../../whatsnew/2.4.rst:1017
msgid ""
"iso-2022-jp-1, iso-2022-jp-2, iso-2022-jp-3, iso-2022-jp-ext, iso-2022-"
"jp-2004, shift-jis, shift-jisx0213, shift-jis-2004"
msgstr ""

#: ../../whatsnew/2.4.rst:1020
msgid "Korean: cp949, euc-kr, johab, iso-2022-kr"
msgstr ""

#: ../../whatsnew/2.4.rst:1022
msgid ""
"Some other new encodings were added: HP Roman8,  ISO_8859-11, ISO_8859-16, "
"PCTP-154, and TIS-620."
msgstr ""

#: ../../whatsnew/2.4.rst:1025
msgid ""
"The UTF-8 and UTF-16 codecs now cope better with receiving partial input. "
"Previously the :class:`StreamReader` class would try to read more data, "
"making it impossible to resume decoding from the stream.  The :meth:`read` "
"method will now return as much data as it can and future calls will resume "
"decoding where previous ones left off.  (Implemented by Walter Dörwald.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1031
msgid ""
"There is a new :mod:`collections` module for  various specialized collection "
"datatypes.  Currently it contains just one type, :class:`deque`, a double-"
"ended queue that supports efficiently adding and removing elements from "
"either end::"
msgstr ""

#: ../../whatsnew/2.4.rst:1036
msgid ""
">>> from collections import deque\n"
">>> d = deque('ghi')        # make a new deque with three items\n"
">>> d.append('j')           # add a new entry to the right side\n"
">>> d.appendleft('f')       # add a new entry to the left side\n"
">>> d                       # show the representation of the deque\n"
"deque(['f', 'g', 'h', 'i', 'j'])\n"
">>> d.pop()                 # return and remove the rightmost item\n"
"'j'\n"
">>> d.popleft()             # return and remove the leftmost item\n"
"'f'\n"
">>> list(d)                 # list the contents of the deque\n"
"['g', 'h', 'i']\n"
">>> 'h' in d                # search the deque\n"
"True"
msgstr ""

#: ../../whatsnew/2.4.rst:1051
msgid ""
"Several modules, such as the :mod:`Queue` and :mod:`threading` modules, now "
"take advantage of :class:`collections.deque` for improved performance.  "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1055
msgid ""
"The :mod:`ConfigParser <configparser>` classes have been enhanced slightly. "
"The :meth:`~configparser.ConfigParser.read` method now returns a list of the "
"files that were successfully parsed, and the :meth:`~configparser."
"ConfigParser.set` method raises :exc:`TypeError` if passed a *value* "
"argument that isn't a string.   (Contributed by John Belmonte and David "
"Goodger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1060
msgid ""
"The :mod:`curses` module now supports the ncurses extension :func:"
"`use_default_colors`.  On platforms where the terminal supports "
"transparency, this makes it possible to use a transparent background. "
"(Contributed by Jörg Lehmann.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1065
msgid ""
"The :mod:`difflib` module now includes an :class:`HtmlDiff` class that "
"creates an HTML table showing a side by side comparison of two versions of a "
"text. (Contributed by Dan Gass.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1069
msgid ""
"The :mod:`email` package was updated to version 3.0,  which dropped various "
"deprecated APIs and removes support for Python versions earlier than 2.3.  "
"The 3.0 version of the package uses a new incremental parser for MIME "
"messages, available in the :mod:`email.FeedParser` module.  The new parser "
"doesn't require reading the entire message into memory, and doesn't raise "
"exceptions if a message is malformed; instead it records any problems in "
"the  :attr:`defect` attribute of the message.  (Developed by Anthony Baxter, "
"Barry Warsaw, Thomas Wouters, and others.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1078
msgid ""
"The :mod:`heapq` module has been converted to C.  The resulting tenfold "
"improvement in speed makes the module suitable for handling high volumes of "
"data.  In addition, the module has two new functions :func:`nlargest` and :"
"func:`nsmallest` that use heaps to find the N largest or smallest values in "
"a dataset without the expense of a full sort.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1084
msgid ""
"The :mod:`httplib <http>` module now contains constants for HTTP status "
"codes defined in various HTTP-related RFC documents.  Constants have names "
"such as :const:`OK`, :const:`CREATED`, :const:`CONTINUE`, and :const:"
"`MOVED_PERMANENTLY`; use pydoc to get a full list.  (Contributed by Andrew "
"Eland.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1090
msgid ""
"The :mod:`imaplib` module now supports IMAP's THREAD command (contributed by "
"Yves Dionne) and new :meth:`deleteacl` and :meth:`myrights` methods "
"(contributed by Arnaud Mazin)."
msgstr ""

#: ../../whatsnew/2.4.rst:1094
msgid ""
"The :mod:`itertools` module gained a ``groupby(iterable[, *func*])`` "
"function. *iterable* is something that can be iterated over to return a "
"stream of elements, and the optional *func* parameter is a function that "
"takes an element and returns a key value; if omitted, the key is simply the "
"element itself.  :func:`groupby` then groups the elements into subsequences "
"which have matching values of the key, and returns a series of 2-tuples "
"containing the key value and an iterator over the subsequence."
msgstr ""

#: ../../whatsnew/2.4.rst:1102
msgid ""
"Here's an example to make this clearer.  The *key* function simply returns "
"whether a number is even or odd, so the result of :func:`groupby` is to "
"return consecutive runs of odd or even numbers. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:1106
msgid ""
">>> import itertools\n"
">>> L = [2, 4, 6, 7, 8, 9, 11, 12, 14]\n"
">>> for key_val, it in itertools.groupby(L, lambda x: x % 2):\n"
"...    print key_val, list(it)\n"
"...\n"
"0 [2, 4, 6]\n"
"1 [7]\n"
"0 [8]\n"
"1 [9, 11]\n"
"0 [12, 14]\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:1118
msgid ""
":func:`groupby` is typically used with sorted input.  The logic for :func:"
"`groupby` is similar to the Unix ``uniq`` filter which makes it handy for "
"eliminating, counting, or identifying duplicate elements::"
msgstr ""

#: ../../whatsnew/2.4.rst:1122
msgid ""
">>> word = 'abracadabra'\n"
">>> letters = sorted(word)   # Turn string into a sorted list of letters\n"
">>> letters\n"
"['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']\n"
">>> for k, g in itertools.groupby(letters):\n"
"...    print k, list(g)\n"
"...\n"
"a ['a', 'a', 'a', 'a', 'a']\n"
"b ['b', 'b']\n"
"c ['c']\n"
"d ['d']\n"
"r ['r', 'r']\n"
">>> # List unique letters\n"
">>> [k for k, g in groupby(letters)]\n"
"['a', 'b', 'c', 'd', 'r']\n"
">>> # Count letter occurrences\n"
">>> [(k, len(list(g))) for k, g in groupby(letters)]\n"
"[('a', 5), ('b', 2), ('c', 1), ('d', 1), ('r', 2)]"
msgstr ""

#: ../../whatsnew/2.4.rst:1141
msgid "(Contributed by Hye-Shik Chang.)"
msgstr "（由 Hye-Shik Chang 所貢獻。）"

#: ../../whatsnew/2.4.rst:1143
msgid ""
":mod:`itertools` also gained a function named ``tee(iterator, N)`` that "
"returns *N* independent iterators that replicate *iterator*.  If *N* is "
"omitted, the default is 2. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:1147
msgid ""
">>> L = [1,2,3]\n"
">>> i1, i2 = itertools.tee(L)\n"
">>> i1,i2\n"
"(<itertools.tee object at 0x402c2080>, <itertools.tee object at "
"0x402c2090>)\n"
">>> list(i1)               # Run the first iterator to exhaustion\n"
"[1, 2, 3]\n"
">>> list(i2)               # Run the second iterator to exhaustion\n"
"[1, 2, 3]"
msgstr ""

#: ../../whatsnew/2.4.rst:1156
msgid ""
"Note that :func:`tee` has to keep copies of the values returned  by the "
"iterator; in the worst case, it may need to keep all of them.   This should "
"therefore be used carefully if the leading iterator can run far ahead of the "
"trailing iterator in a long stream of inputs. If the separation is large, "
"then you might as well use  :func:`list` instead.  When the iterators track "
"closely with one another, :func:`tee` is ideal.  Possible applications "
"include bookmarking, windowing, or lookahead iterators. (Contributed by "
"Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1165
msgid ""
"A number of functions were added to the :mod:`locale`  module, such as :func:"
"`bind_textdomain_codeset` to specify a particular encoding and a family of :"
"func:`!l\\*gettext` functions that return messages in the chosen encoding. "
"(Contributed by Gustavo Niemeyer.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1170
msgid ""
"Some keyword arguments were added to the :mod:`logging` package's :func:"
"`basicConfig` function to simplify log configuration.  The default behavior "
"is to log messages to standard error, but various keyword arguments can be "
"specified to log to a particular file, change the logging format, or set the "
"logging level. For example::"
msgstr ""

#: ../../whatsnew/2.4.rst:1176
msgid ""
"import logging\n"
"logging.basicConfig(filename='/var/log/application.log',\n"
"    level=0,  # Log all messages\n"
"    format='%(levelname):%(process):%(thread):%(message)')"
msgstr ""

#: ../../whatsnew/2.4.rst:1181
msgid ""
"Other additions to the :mod:`logging` package include a ``log(level, msg)`` "
"convenience method, as well as a :class:`TimedRotatingFileHandler` class "
"that rotates its log files at a timed interval.  The module already had :"
"class:`RotatingFileHandler`, which rotated logs once the file exceeded a "
"certain size.  Both classes derive from a new :class:`BaseRotatingHandler` "
"class that can be used to implement other rotating handlers."
msgstr ""

#: ../../whatsnew/2.4.rst:1188
msgid "(Changes implemented by Vinay Sajip.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1190
msgid ""
"The :mod:`marshal` module now shares interned strings on unpacking a  data "
"structure.  This may shrink the size of certain pickle strings, but the "
"primary effect is to make :file:`.pyc` files significantly smaller. "
"(Contributed by Martin von Löwis.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1195
msgid ""
"The :mod:`!nntplib` module's :class:`NNTP` class gained :meth:`description` "
"and :meth:`descriptions` methods to retrieve  newsgroup descriptions for a "
"single group or for a range of groups. (Contributed by Jürgen A. Erhard.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1199
msgid ""
"Two new functions were added to the :mod:`operator` module, "
"``attrgetter(attr)`` and ``itemgetter(index)``. Both functions return "
"callables that take a single argument and return the corresponding attribute "
"or item; these callables make excellent data extractors when used with :func:"
"`map` or :func:`sorted`.  For example::"
msgstr ""

#: ../../whatsnew/2.4.rst:1205
msgid ""
">>> L = [('c', 2), ('d', 1), ('a', 4), ('b', 3)]\n"
">>> map(operator.itemgetter(0), L)\n"
"['c', 'd', 'a', 'b']\n"
">>> map(operator.itemgetter(1), L)\n"
"[2, 1, 4, 3]\n"
">>> sorted(L, key=operator.itemgetter(1)) # Sort list by second tuple item\n"
"[('d', 1), ('c', 2), ('b', 3), ('a', 4)]"
msgstr ""

#: ../../whatsnew/2.4.rst:1215
msgid ""
"The :mod:`optparse` module was updated in various ways.  The module now "
"passes its messages through :func:`gettext.gettext`, making it possible to "
"internationalize Optik's help and error messages.  Help messages for options "
"can now include the string ``'%default'``, which will be replaced by the "
"option's default value.  (Contributed by Greg Ward.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1221
msgid ""
"The long-term plan is to deprecate the :mod:`!rfc822` module in some future "
"Python release in favor of the :mod:`email` package. To this end, the :func:"
"`email.Utils.formatdate <email.utils.formatdate>` function has been changed "
"to make it usable as a replacement for :func:`!rfc822.formatdate`.  You may "
"want to write new e-mail processing code with this in mind.  (Change "
"implemented by Anthony Baxter.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1227
msgid ""
"A new ``urandom(n)`` function was added to the :mod:`os` module, returning a "
"string containing *n* bytes of random data.  This function provides access "
"to platform-specific sources of randomness such as :file:`/dev/urandom` on "
"Linux or the Windows CryptoAPI.  (Contributed by Trevor Perrin.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1232
msgid ""
"Another new function: ``os.path.lexists(path)``  returns true if the file "
"specified by *path* exists, whether or not it's a symbolic link.  This "
"differs from the existing ``os.path.exists(path)`` function, which returns "
"false if *path* is a symlink that points to a destination that doesn't "
"exist. (Contributed by Beni Cherniavsky.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1238
msgid ""
"A new :func:`getsid` function was added to the :mod:`posix` module that "
"underlies the :mod:`os` module. (Contributed by J. Raynor.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1241
msgid ""
"The :mod:`poplib` module now supports POP over SSL.  (Contributed by Hector "
"Urtubia.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1244
msgid ""
"The :mod:`profile` module can now profile C extension functions. "
"(Contributed by Nick Bastin.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1247
msgid ""
"The :mod:`random` module has a new method called ``getrandbits(N)`` that "
"returns a long integer *N* bits in length.  The existing :meth:`randrange` "
"method now uses :meth:`getrandbits` where appropriate, making generation of "
"arbitrarily large random numbers more efficient.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1253
msgid ""
"The regular expression language accepted by the :mod:`re` module was "
"extended with simple conditional expressions, written as ``(?(group)A|B)``.  "
"*group* is either a numeric group ID or a group name defined with ``(?"
"P<group>...)`` earlier in the expression.  If the specified group matched, "
"the regular expression pattern *A* will be tested against the string; if the "
"group didn't match, the pattern *B* will be used instead. (Contributed by "
"Gustavo Niemeyer.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1260
msgid ""
"The :mod:`re` module is also no longer recursive, thanks to a massive amount "
"of work by Gustavo Niemeyer.  In a recursive regular expression engine, "
"certain patterns result in a large amount of C stack space being consumed, "
"and it was possible to overflow the stack. For example, if you matched a "
"30000-byte string of ``a`` characters against the expression ``(a|b)+``, one "
"stack frame was consumed per character.  Python 2.3 tried to check for stack "
"overflow and raise a :exc:`RuntimeError` exception, but certain patterns "
"could sidestep the checking and if you were unlucky Python could segfault. "
"Python 2.4's regular expression engine can match this pattern without "
"problems."
msgstr ""

#: ../../whatsnew/2.4.rst:1270
msgid ""
"The :mod:`signal` module now performs tighter error-checking on the "
"parameters to the :func:`signal.signal` function.  For example, you can't "
"set a handler on the :const:`SIGKILL` signal; previous versions of Python "
"would quietly accept this, but 2.4 will raise a :exc:`RuntimeError` "
"exception."
msgstr ""

#: ../../whatsnew/2.4.rst:1275
msgid ""
"Two new functions were added to the :mod:`socket` module. :func:`socketpair` "
"returns a pair of connected sockets and ``getservbyport(port)`` looks up the "
"service name for a given port number. (Contributed by Dave Cole and Barry "
"Warsaw.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1280
msgid ""
"The :func:`sys.exitfunc` function has been deprecated.  Code should be using "
"the existing :mod:`atexit` module, which correctly handles calling multiple "
"exit functions.  Eventually :func:`sys.exitfunc` will become a purely "
"internal interface, accessed only by :mod:`atexit`."
msgstr ""

#: ../../whatsnew/2.4.rst:1285
msgid ""
"The :mod:`tarfile` module now generates GNU-format tar files by default. "
"(Contributed by Lars Gustäbel.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1288
msgid ""
"The :mod:`threading` module now has an elegantly simple way to support "
"thread-local data.  The module contains a :class:`local` class whose "
"attribute values are local to different threads. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:1292
msgid ""
"import threading\n"
"\n"
"data = threading.local()\n"
"data.number = 42\n"
"data.url = ('www.python.org', 80)"
msgstr ""

#: ../../whatsnew/2.4.rst:1298
msgid ""
"Other threads can assign and retrieve their own values for the :attr:"
"`number` and :attr:`url` attributes.  You can subclass :class:`local` to "
"initialize attributes or to add methods. (Contributed by Jim Fulton.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1302
msgid ""
"The :mod:`timeit` module now automatically disables periodic garbage "
"collection during the timing loop.  This change makes consecutive timings "
"more comparable.  (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1306
msgid ""
"The :mod:`weakref` module now supports a wider variety of objects including "
"Python functions, class instances, sets, frozensets, deques, arrays, files, "
"sockets, and regular expression pattern objects. (Contributed by Raymond "
"Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1311
msgid ""
"The :mod:`xmlrpclib <xmlrpc.client>` module now supports a multi-call "
"extension for transmitting multiple XML-RPC calls in a single HTTP "
"operation. (Contributed by Brian Quinlan.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1315
msgid ""
"The :mod:`mpz`, :mod:`rotor`, and :mod:`xreadlines` modules have  been "
"removed."
msgstr ""

#: ../../whatsnew/2.4.rst:1324
msgid "cookielib"
msgstr "cookielib"

#: ../../whatsnew/2.4.rst:1326
msgid ""
"The :mod:`cookielib <http.cookiejar>` library supports client-side handling "
"for HTTP cookies, mirroring the :mod:`Cookie <http.cookies>` module's server-"
"side cookie support. Cookies are stored in cookie jars; the library "
"transparently stores cookies offered by the web server in the cookie jar, "
"and fetches the cookie from the jar when connecting to the server. As in web "
"browsers, policy objects control whether cookies are accepted or not."
msgstr ""

#: ../../whatsnew/2.4.rst:1333
msgid ""
"In order to store cookies across sessions, two implementations of cookie "
"jars are provided: one that stores cookies in the Netscape format so "
"applications can use the Mozilla or Lynx cookie files, and one that stores "
"cookies in the same format as the Perl libwww library."
msgstr ""

#: ../../whatsnew/2.4.rst:1338
msgid ""
":mod:`urllib2 <urllib.request>` has been changed to interact with :mod:"
"`cookielib <http.cookiejar>`: :class:`HTTPCookieProcessor` manages a cookie "
"jar that is used when accessing URLs."
msgstr ""

#: ../../whatsnew/2.4.rst:1342
msgid "This module was contributed by John J. Lee."
msgstr ""

#: ../../whatsnew/2.4.rst:1348
msgid "doctest"
msgstr "doctest"

#: ../../whatsnew/2.4.rst:1350
msgid ""
"The :mod:`doctest` module underwent considerable refactoring thanks to "
"Edward Loper and Tim Peters.  Testing can still be as simple as running :"
"func:`doctest.testmod`, but the refactorings allow customizing the module's "
"operation in various ways"
msgstr ""

#: ../../whatsnew/2.4.rst:1355
msgid ""
"The new :class:`DocTestFinder` class extracts the tests from a given  "
"object's docstrings::"
msgstr ""

#: ../../whatsnew/2.4.rst:1358
msgid ""
"def f (x, y):\n"
"    \"\"\">>> f(2,2)\n"
"4\n"
">>> f(3,2)\n"
"6\n"
"    \"\"\"\n"
"    return x*y\n"
"\n"
"finder = doctest.DocTestFinder()\n"
"\n"
"# Get list of DocTest instances\n"
"tests = finder.find(f)"
msgstr ""

#: ../../whatsnew/2.4.rst:1371
msgid ""
"The new :class:`DocTestRunner` class then runs individual tests and can "
"produce a summary of the results::"
msgstr ""

#: ../../whatsnew/2.4.rst:1374
msgid ""
"runner = doctest.DocTestRunner()\n"
"for t in tests:\n"
"    tried, failed = runner.run(t)\n"
"\n"
"runner.summarize(verbose=1)"
msgstr ""

#: ../../whatsnew/2.4.rst:1380
msgid "The above example produces the following output::"
msgstr ""

#: ../../whatsnew/2.4.rst:1382
msgid ""
"1 items passed all tests:\n"
"   2 tests in f\n"
"2 tests in 1 items.\n"
"2 passed and 0 failed.\n"
"Test passed."
msgstr ""

#: ../../whatsnew/2.4.rst:1388
msgid ""
":class:`DocTestRunner` uses an instance of the :class:`OutputChecker` class "
"to compare the expected output with the actual output.  This class takes a "
"number of different flags that customize its behaviour; ambitious users can "
"also write a completely new subclass of :class:`OutputChecker`."
msgstr ""

#: ../../whatsnew/2.4.rst:1393
msgid ""
"The default output checker provides a number of handy features. For example, "
"with the :const:`doctest.ELLIPSIS` option flag, an ellipsis (``...``) in the "
"expected output matches any substring,  making it easier to accommodate "
"outputs that vary in minor ways::"
msgstr ""

#: ../../whatsnew/2.4.rst:1398
msgid ""
"def o (n):\n"
"    \"\"\">>> o(1)\n"
"<__main__.C instance at 0x...>\n"
">>>\n"
"\"\"\""
msgstr ""

#: ../../whatsnew/2.4.rst:1404
msgid "Another special string, ``<BLANKLINE>``, matches a blank line::"
msgstr ""

#: ../../whatsnew/2.4.rst:1406
msgid ""
"def p (n):\n"
"    \"\"\">>> p(1)\n"
"<BLANKLINE>\n"
">>>\n"
"\"\"\""
msgstr ""

#: ../../whatsnew/2.4.rst:1412
msgid ""
"Another new capability is producing a diff-style display of the output by "
"specifying the :const:`doctest.REPORT_UDIFF` (unified diffs), :const:"
"`doctest.REPORT_CDIFF` (context diffs), or :const:`doctest.REPORT_NDIFF` "
"(delta-style) option flags.  For example::"
msgstr ""

#: ../../whatsnew/2.4.rst:1417
msgid ""
"def g (n):\n"
"    \"\"\">>> g(4)\n"
"here\n"
"is\n"
"a\n"
"lengthy\n"
">>>\"\"\"\n"
"    L = 'here is a rather lengthy list of words'.split()\n"
"    for word in L[:n]:\n"
"        print word"
msgstr ""

#: ../../whatsnew/2.4.rst:1428
msgid ""
"Running the above function's tests with :const:`doctest.REPORT_UDIFF` "
"specified, you get the following output:"
msgstr ""

#: ../../whatsnew/2.4.rst:1431
msgid ""
"**********************************************************************\n"
"File \"t.py\", line 15, in g\n"
"Failed example:\n"
"    g(4)\n"
"Differences (unified diff with -expected +actual):\n"
"    @@ -2,3 +2,3 @@\n"
"     is\n"
"     a\n"
"    -lengthy\n"
"    +rather\n"
"**********************************************************************"
msgstr ""

#: ../../whatsnew/2.4.rst:1449
msgid "Build and C API Changes"
msgstr ""

#: ../../whatsnew/2.4.rst:1451
msgid "Some of the changes to Python's build process and to the C API are:"
msgstr ""

#: ../../whatsnew/2.4.rst:1453
msgid ""
"Three new convenience macros were added for common return values from "
"extension functions: :c:macro:`Py_RETURN_NONE`, :c:macro:`Py_RETURN_TRUE`, "
"and :c:macro:`Py_RETURN_FALSE`. (Contributed by Brett Cannon.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1457
msgid ""
"Another new macro, :c:macro:`Py_CLEAR`,  decreases the reference count of "
"*obj* and sets *obj* to the null pointer.  (Contributed by Jim Fulton.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1460
msgid ""
"A new function, ``PyTuple_Pack(N, obj1, obj2, ..., objN)``, constructs "
"tuples from a variable length argument list of Python objects.  (Contributed "
"by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1464
msgid ""
"A new function, ``PyDict_Contains(d, k)``, implements fast dictionary "
"lookups without masking exceptions raised during the look-up process. "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1468
msgid ""
"The :c:expr:`Py_IS_NAN(X)` macro returns 1 if  its float or double argument "
"*X* is a NaN.   (Contributed by Tim Peters.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1471
msgid ""
"C code can avoid unnecessary locking by using the new :c:func:`!"
"PyEval_ThreadsInitialized` function to tell  if any thread operations have "
"been performed.  If this function  returns false, no lock operations are "
"needed. (Contributed by Nick Coghlan.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1476
msgid ""
"A new function, :c:func:`PyArg_VaParseTupleAndKeywords`, is the same as :c:"
"func:`PyArg_ParseTupleAndKeywords` but takes a  :c:type:`va_list` instead of "
"a number of arguments. (Contributed by Greg Chapman.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1480
msgid ""
"A new method flag, :c:macro:`METH_COEXIST`, allows a function defined in "
"slots to co-exist with a :c:type:`PyCFunction` having the same name.  This "
"can halve the access time for a method such as :meth:`set.__contains__`.  "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1485
msgid ""
"Python can now be built with additional profiling for the interpreter "
"itself, intended as an aid to people developing the Python core.  Providing :"
"option:`!--enable-profiling` to the :program:`configure` script will let you "
"profile the interpreter with :program:`gprof`, and providing the :option:`!--"
"with-tsc` switch enables profiling using the Pentium's Time-Stamp-Counter "
"register.  Note that the :option:`!--with-tsc` switch is slightly misnamed, "
"because the profiling feature also works on the PowerPC platform, though "
"that processor architecture doesn't call that register \"the TSC "
"register\".  (Contributed by Jeremy Hylton.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1495
msgid ""
"The :c:type:`!tracebackobject` type has been renamed to :c:type:"
"`PyTracebackObject`."
msgstr ""

#: ../../whatsnew/2.4.rst:1502
msgid "Port-Specific Changes"
msgstr ""

#: ../../whatsnew/2.4.rst:1504
msgid ""
"The Windows port now builds under MSVC++ 7.1 as well as version 6. "
"(Contributed by Martin von Löwis.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1511
msgid "Porting to Python 2.4"
msgstr ""

#: ../../whatsnew/2.4.rst:1513
msgid ""
"This section lists previously described changes that may require changes to "
"your code:"
msgstr ""

#: ../../whatsnew/2.4.rst:1516
msgid ""
"Left shifts and hexadecimal/octal constants that are too  large no longer "
"trigger a :exc:`FutureWarning` and return  a value limited to 32 or 64 bits; "
"instead they return a long integer."
msgstr ""

#: ../../whatsnew/2.4.rst:1523
msgid ""
"The :func:`zip` built-in function and :func:`itertools.izip` now return  an "
"empty list instead of raising a :exc:`TypeError` exception if called with no "
"arguments."
msgstr ""

#: ../../whatsnew/2.4.rst:1527
msgid ""
"You can no longer compare the :class:`date` and :class:`~datetime.datetime` "
"instances provided by the :mod:`datetime` module.  Two  instances of "
"different classes will now always be unequal, and  relative comparisons "
"(``<``, ``>``) will raise a :exc:`TypeError`."
msgstr ""

#: ../../whatsnew/2.4.rst:1532
msgid ""
":func:`!dircache.listdir` now passes exceptions to the caller instead of "
"returning empty lists."
msgstr ""

#: ../../whatsnew/2.4.rst:1535
msgid ""
":func:`LexicalHandler.startDTD` used to receive the public and system IDs in "
"the wrong order.  This has been corrected; applications relying on the wrong "
"order need to be fixed."
msgstr ""

#: ../../whatsnew/2.4.rst:1539
msgid ""
":func:`fcntl.ioctl` now warns if the *mutate*  argument is omitted and "
"relevant."
msgstr ""

#: ../../whatsnew/2.4.rst:1542
msgid ""
"The :mod:`tarfile` module now generates GNU-format tar files by default."
msgstr ""

#: ../../whatsnew/2.4.rst:1544
msgid ""
"Encountering a failure while importing a module no longer leaves a partially "
"initialized module object in ``sys.modules``."
msgstr ""

#: ../../whatsnew/2.4.rst:1547
msgid ""
":const:`None` is now a constant; code that binds a new value to  the name "
"``None`` is now a syntax error."
msgstr ""

#: ../../whatsnew/2.4.rst:1550
msgid ""
"The :func:`signals.signal` function now raises a :exc:`RuntimeError` "
"exception for certain illegal values; previously these errors would pass "
"silently.  For example, you can no longer set a handler on the :const:"
"`SIGKILL` signal."
msgstr ""

#: ../../whatsnew/2.4.rst:1560
msgid "Acknowledgements"
msgstr "致謝"

#: ../../whatsnew/2.4.rst:1562
msgid ""
"The author would like to thank the following people for offering "
"suggestions, corrections and assistance with various drafts of this article: "
"Koray Can, Hye-Shik Chang, Michael Dyck, Raymond Hettinger, Brian Hurt, "
"Hamish Lawson, Fredrik Lundh, Sean Reifschneider, Sadruddin Rejeb."
msgstr ""

#: ../../whatsnew/2.4.rst:415
msgid "universal newlines"
msgstr "universal newlines"

#: ../../whatsnew/2.4.rst:415
msgid "What's new"
msgstr "What's new（有什麼新功能）"