Admin Control Panel v2.0

✎ Editing: 2.3.html ← Back

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
 <title>What’s New in Python 2.3 &mdash; Python 2.7.5 documentation</title>
 
 <link rel="stylesheet" href="../_static/default.css" type="text/css" />
 <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
 
 <script type="text/javascript">
 var DOCUMENTATION_OPTIONS = {
 URL_ROOT: '../',
 VERSION: '2.7.5',
 COLLAPSE_INDEX: false,
 FILE_SUFFIX: '.html',
 HAS_SOURCE: true
 };
 </script>
 <script type="text/javascript" src="../_static/jquery.js"></script>
 <script type="text/javascript" src="../_static/underscore.js"></script>
 <script type="text/javascript" src="../_static/doctools.js"></script>
 <script type="text/javascript" src="../_static/sidebar.js"></script>
 <link rel="search" type="application/opensearchdescription+xml"
 title="Search within Python 2.7.5 documentation"
 href="../_static/opensearch.xml"/>
 <link rel="author" title="About these documents" href="../about.html" />
 <link rel="copyright" title="Copyright" href="../copyright.html" />
 <link rel="top" title="Python 2.7.5 documentation" href="../index.html" />
 <link rel="up" title="What’s New in Python" href="index.html" />
 <link rel="next" title="What’s New in Python 2.2" href="2.2.html" />
 <link rel="prev" title="What’s New in Python 2.4" href="2.4.html" />
 <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
 <script type="text/javascript" src="../_static/copybutton.js"></script>

</head>
 <body>
 <div class="related">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 accesskey="I">index</a></li>
 <li class="right" >
 <a href="../py-modindex.html" title="Python Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="2.2.html" title="What’s New in Python 2.2"
 accesskey="N">next</a> |</li>
 <li class="right" >
 <a href="2.4.html" title="What’s New in Python 2.4"
 accesskey="P">previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="http://www.python.org/">Python</a> &raquo;</li>
 <li>
 <a href="../index.html">Python 2.7.5 documentation</a> &raquo;
 </li>

<li><a href="index.html" accesskey="U">What&#8217;s New in Python</a> &raquo;</li> 
 </ul>
 </div>

<div class="document">
 <div class="documentwrapper">
 <div class="bodywrapper">
 <div class="body">
 
 <div class="section" id="what-s-new-in-python-2-3">
<h1>What&#8217;s New in Python 2.3<a class="headerlink" href="#what-s-new-in-python-2-3" title="Permalink to this headline">¶</a></h1>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Author:</th><td class="field-body">A.M. Kuchling</td>
</tr>
</tbody>
</table>
This article explains the new features in Python 2.3. Python 2.3 was released
on July 29, 2003.
The main themes for Python 2.3 are polishing some of the features added in 2.2,
adding various small but useful enhancements to the core language, and expanding
the standard library. The new object model introduced in the previous version
has benefited from 18 months of bugfixes and from optimization efforts that have
improved the performance of new-style classes. A few new built-in functions
have been added such as <a class="reference internal" href="../library/functions.html#sum" title="sum"><tt class="xref py py-func docutils literal">sum()</tt></a> and <a class="reference internal" href="../library/functions.html#enumerate" title="enumerate"><tt class="xref py py-func docutils literal">enumerate()</tt></a>. The <a class="reference internal" href="../reference/expressions.html#in"><tt class="xref std std-keyword docutils literal">in</tt></a>
operator can now be used for substring searches (e.g. <tt class="docutils literal">&quot;ab&quot; in &quot;abc&quot;</tt> returns
<a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a>).
Some of the many new library features include Boolean, set, heap, and date/time
data types, the ability to import modules from ZIP-format archives, metadata
support for the long-awaited Python catalog, an updated version of IDLE, and
modules for logging messages, wrapping text, parsing CSV files, processing
command-line options, using BerkeleyDB databases... the list of new and
enhanced modules is lengthy.
This article doesn&#8217;t attempt to provide a complete specification of the new
features, but instead provides a convenient overview. For full details, you
should refer to the documentation for Python 2.3, such as the Python Library
Reference and the Python Reference Manual. If you want to understand the
complete implementation and design rationale, refer to the PEP for a particular
new feature.
<div class="section" id="pep-218-a-standard-set-datatype">
<h2>PEP 218: A Standard Set Datatype<a class="headerlink" href="#pep-218-a-standard-set-datatype" title="Permalink to this headline">¶</a></h2>
The new <a class="reference internal" href="../library/sets.html#module-sets" title="sets: Implementation of sets of unique elements. (deprecated)"><tt class="xref py py-mod docutils literal">sets</tt></a> module contains an implementation of a set datatype. The
<tt class="xref py py-class docutils literal">Set</tt> class is for mutable sets, sets that can have members added and
removed. The <tt class="xref py py-class docutils literal">ImmutableSet</tt> class is for sets that can&#8217;t be modified,
and instances of <tt class="xref py py-class docutils literal">ImmutableSet</tt> can therefore be used as dictionary keys.
Sets are built on top of dictionaries, so the elements within a set must be
hashable.
Here&#8217;s a simple example:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import sets
&gt;&gt;&gt; S = sets.Set([1,2,3])
&gt;&gt;&gt; S
Set([1, 2, 3])
&gt;&gt;&gt; 1 in S
True
&gt;&gt;&gt; 0 in S
False
&gt;&gt;&gt; S.add(5)
&gt;&gt;&gt; S.remove(3)
&gt;&gt;&gt; S
Set([1, 2, 5])
&gt;&gt;&gt;
</pre></div>
</div>
The union and intersection of sets can be computed with the <tt class="xref py py-meth docutils literal">union()</tt> and
<tt class="xref py py-meth docutils literal">intersection()</tt> methods; an alternative notation uses the bitwise operators
<tt class="docutils literal">&amp;</tt> and <tt class="docutils literal">|</tt>. Mutable sets also have in-place versions of these methods,
<tt class="xref py py-meth docutils literal">union_update()</tt> and <tt class="xref py py-meth docutils literal">intersection_update()</tt>.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; S1 = sets.Set([1,2,3])
&gt;&gt;&gt; S2 = sets.Set([4,5,6])
&gt;&gt;&gt; S1.union(S2)
Set([1, 2, 3, 4, 5, 6])
&gt;&gt;&gt; S1 | S2 # Alternative notation
Set([1, 2, 3, 4, 5, 6])
&gt;&gt;&gt; S1.intersection(S2)
Set([])
&gt;&gt;&gt; S1 &amp; S2 # Alternative notation
Set([])
&gt;&gt;&gt; S1.union_update(S2)
&gt;&gt;&gt; S1
Set([1, 2, 3, 4, 5, 6])
&gt;&gt;&gt;
</pre></div>
</div>
It&#8217;s also possible to take the symmetric difference of two sets. This is the
set of all elements in the union that aren&#8217;t in the intersection. Another way
of putting it is that the symmetric difference contains all elements that are in
exactly one set. Again, there&#8217;s an alternative notation (<tt class="docutils literal">^</tt>), and an in-
place version with the ungainly name <tt class="xref py py-meth docutils literal">symmetric_difference_update()</tt>.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; S1 = sets.Set([1,2,3,4])
&gt;&gt;&gt; S2 = sets.Set([3,4,5,6])
&gt;&gt;&gt; S1.symmetric_difference(S2)
Set([1, 2, 5, 6])
&gt;&gt;&gt; S1 ^ S2
Set([1, 2, 5, 6])
&gt;&gt;&gt;
</pre></div>
</div>
There are also <tt class="xref py py-meth docutils literal">issubset()</tt> and <tt class="xref py py-meth docutils literal">issuperset()</tt> methods for checking
whether one set is a subset or superset of another:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; S1 = sets.Set([1,2,3])
&gt;&gt;&gt; S2 = sets.Set([2,3])
&gt;&gt;&gt; S2.issubset(S1)
True
&gt;&gt;&gt; S1.issubset(S2)
False
&gt;&gt;&gt; S1.issuperset(S2)
True
&gt;&gt;&gt;
</pre></div>
</div>
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0218">PEP 218</a> - Adding a Built-In Set Object Type</dt>
<dd>PEP written by Greg V. Wilson. Implemented by Greg V. Wilson, Alex Martelli, and
GvR.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-255-simple-generators">
<h2>PEP 255: Simple Generators<a class="headerlink" href="#pep-255-simple-generators" title="Permalink to this headline">¶</a></h2>
In Python 2.2, generators were added as an optional feature, to be enabled by a
<tt class="docutils literal">from __future__ import generators</tt> directive. In 2.3 generators no longer
need to be specially enabled, and are now always present; this means that
<a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> is now always a keyword. The rest of this section is a copy of
the description of generators from the &#8220;What&#8217;s New in Python 2.2&#8221; document; if
you read it back when Python 2.2 came out, you can skip the rest of this
section.
You&#8217;re doubtless familiar with how function calls work in Python or C. When you
call a function, it gets a private namespace where its local variables are
created. When the function reaches a <a class="reference internal" href="../reference/simple_stmts.html#return"><tt class="xref std std-keyword docutils literal">return</tt></a> statement, the local
variables are destroyed and the resulting value is returned to the caller. A
later call to the same function will get a fresh new set of local variables.
But, what if the local variables weren&#8217;t thrown away on exiting a function?
What if you could later resume the function where it left off? This is what
generators provide; they can be thought of as resumable functions.
Here&#8217;s the simplest example of a generator function:
<div class="highlight-python"><div class="highlight"><pre>def generate_ints(N):
 for i in range(N):
 yield i
</pre></div>
</div>
A new keyword, <a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a>, was introduced for generators. Any function
containing a <a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> statement is a generator function; this is
detected by Python&#8217;s bytecode compiler which compiles the function specially as
a result.
When you call a generator function, it doesn&#8217;t return a single value; instead it
returns a generator object that supports the iterator protocol. On executing
the <a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> statement, the generator outputs the value of <tt class="docutils literal">i</tt>,
similar to a <a class="reference internal" href="../reference/simple_stmts.html#return"><tt class="xref std std-keyword docutils literal">return</tt></a> statement. The big difference between
<a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> and a <a class="reference internal" href="../reference/simple_stmts.html#return"><tt class="xref std std-keyword docutils literal">return</tt></a> statement is that on reaching a
<a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> the generator&#8217;s state of execution is suspended and local
variables are preserved. On the next call to the generator&#8217;s <tt class="docutils literal">.next()</tt>
method, the function will resume executing immediately after the
<a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> statement. (For complicated reasons, the <a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a>
statement isn&#8217;t allowed inside the <a class="reference internal" href="../reference/compound_stmts.html#try"><tt class="xref std std-keyword docutils literal">try</tt></a> block of a <a class="reference internal" href="../reference/compound_stmts.html#try"><tt class="xref std std-keyword docutils literal">try</tt></a>...<a class="reference internal" href="../reference/compound_stmts.html#finally"><tt class="xref std std-keyword docutils literal">finally</tt></a> statement; read <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0255">PEP 255</a> for a full explanation of the
interaction between <a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> and exceptions.)
Here&#8217;s a sample usage of the <tt class="xref py py-func docutils literal">generate_ints()</tt> generator:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; gen = generate_ints(3)
&gt;&gt;&gt; gen
&lt;generator object at 0x8117f90&gt;
&gt;&gt;&gt; gen.next()
0
&gt;&gt;&gt; gen.next()
1
&gt;&gt;&gt; gen.next()
2
&gt;&gt;&gt; gen.next()
Traceback (most recent call last):
 File &quot;stdin&quot;, line 1, in ?
 File &quot;stdin&quot;, line 2, in generate_ints
StopIteration
</pre></div>
</div>
You could equally write <tt class="docutils literal">for i in generate_ints(5)</tt>, or <tt class="docutils literal">a,b,c =
generate_ints(3)</tt>.
Inside a generator function, the <a class="reference internal" href="../reference/simple_stmts.html#return"><tt class="xref std std-keyword docutils literal">return</tt></a> statement can only be used
without a value, and signals the end of the procession of values; afterwards the
generator cannot return any further values. <a class="reference internal" href="../reference/simple_stmts.html#return"><tt class="xref std std-keyword docutils literal">return</tt></a> with a value, such
as <tt class="docutils literal">return 5</tt>, is a syntax error inside a generator function. The end of the
generator&#8217;s results can also be indicated by raising <a class="reference internal" href="../library/exceptions.html#exceptions.StopIteration" title="exceptions.StopIteration"><tt class="xref py py-exc docutils literal">StopIteration</tt></a>
manually, or by just letting the flow of execution fall off the bottom of the
function.
You could achieve the effect of generators manually by writing your own class
and storing all the local variables of the generator as instance variables. For
example, returning a list of integers could be done by setting <tt class="docutils literal">self.count</tt> to
0, and having the <a class="reference internal" href="../library/functions.html#next" title="next"><tt class="xref py py-meth docutils literal">next()</tt></a> method increment <tt class="docutils literal">self.count</tt> and return it.
However, for a moderately complicated generator, writing a corresponding class
would be much messier. <tt class="file docutils literal">Lib/test/test_generators.py</tt> contains a number of
more interesting examples. The simplest one implements an in-order traversal of
a tree using generators recursively.
<div class="highlight-python"><div class="highlight"><pre># A recursive generator that generates Tree leaves in in-order.
def inorder(t):
 if t:
 for x in inorder(t.left):
 yield x
 yield t.label
 for x in inorder(t.right):
 yield x
</pre></div>
</div>
Two other examples in <tt class="file docutils literal">Lib/test/test_generators.py</tt> produce solutions for
the N-Queens problem (placing $N$ queens on an $NxN$ chess board so that no
queen threatens another) and the Knight&#8217;s Tour (a route that takes a knight to
every square of an $NxN$ chessboard without visiting any square twice).
The idea of generators comes from other programming languages, especially Icon
(<a class="reference external" href="http://www.cs.arizona.edu/icon/">http://www.cs.arizona.edu/icon/</a>), where the idea of generators is central. In
Icon, every expression and function call behaves like a generator. One example
from &#8220;An Overview of the Icon Programming Language&#8221; at
<a class="reference external" href="http://www.cs.arizona.edu/icon/docs/ipd266.htm">http://www.cs.arizona.edu/icon/docs/ipd266.htm</a> gives an idea of what this looks
like:
<div class="highlight-python"><pre>sentence := "Store it in the neighboring harbor"
if (i := find("or", sentence)) &gt; 5 then write(i)</pre>
</div>
In Icon the <tt class="xref py py-func docutils literal">find()</tt> function returns the indexes at which the substring
&#8220;or&#8221; is found: 3, 23, 33. In the <a class="reference internal" href="../reference/compound_stmts.html#if"><tt class="xref std std-keyword docutils literal">if</tt></a> statement, <tt class="docutils literal">i</tt> is first
assigned a value of 3, but 3 is less than 5, so the comparison fails, and Icon
retries it with the second value of 23. 23 is greater than 5, so the comparison
now succeeds, and the code prints the value 23 to the screen.
Python doesn&#8217;t go nearly as far as Icon in adopting generators as a central
concept. Generators are considered part of the core Python language, but
learning or using them isn&#8217;t compulsory; if they don&#8217;t solve any problems that
you have, feel free to ignore them. One novel feature of Python&#8217;s interface as
compared to Icon&#8217;s is that a generator&#8217;s state is represented as a concrete
object (the iterator) that can be passed around to other functions or stored in
a data structure.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0255">PEP 255</a> - Simple Generators</dt>
<dd>Written by Neil Schemenauer, Tim Peters, Magnus Lie Hetland. Implemented mostly
by Neil Schemenauer and Tim Peters, with other fixes from the Python Labs crew.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-263-source-code-encodings">
<h2>PEP 263: Source Code Encodings<a class="headerlink" href="#pep-263-source-code-encodings" title="Permalink to this headline">¶</a></h2>
Python source files can now be declared as being in different character set
encodings. Encodings are declared by including a specially formatted comment in
the first or second line of the source file. For example, a UTF-8 file can be
declared with:
<div class="highlight-python"><div class="highlight"><pre>#!/usr/bin/env python
# -*- coding: UTF-8 -*-
</pre></div>
</div>
Without such an encoding declaration, the default encoding used is 7-bit ASCII.
Executing or importing modules that contain string literals with 8-bit
characters and have no encoding declaration will result in a
<a class="reference internal" href="../library/exceptions.html#exceptions.DeprecationWarning" title="exceptions.DeprecationWarning"><tt class="xref py py-exc docutils literal">DeprecationWarning</tt></a> being signalled by Python 2.3; in 2.4 this will be a
syntax error.
The encoding declaration only affects Unicode string literals, which will be
converted to Unicode using the specified encoding. Note that Python identifiers
are still restricted to ASCII characters, so you can&#8217;t have variable names that
use characters outside of the usual alphanumerics.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0263">PEP 263</a> - Defining Python Source Code Encodings</dt>
<dd>Written by Marc-André Lemburg and Martin von Löwis; implemented by Suzuki Hisao
and Martin von Löwis.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-273-importing-modules-from-zip-archives">
<h2>PEP 273: Importing Modules from ZIP Archives<a class="headerlink" href="#pep-273-importing-modules-from-zip-archives" title="Permalink to this headline">¶</a></h2>
The new <a class="reference internal" href="../library/zipimport.html#module-zipimport" title="zipimport: support for importing Python modules from ZIP archives."><tt class="xref py py-mod docutils literal">zipimport</tt></a> module adds support for importing modules from a ZIP-
format archive. You don&#8217;t need to import the module explicitly; it will be
automatically imported if a ZIP archive&#8217;s filename is added to <tt class="docutils literal">sys.path</tt>.
For example:
<div class="highlight-python"><pre>amk@nyman:~/src/python$ unzip -l /tmp/example.zip
Archive: /tmp/example.zip
 Length Date Time Name
 -------- ---- ---- ----
 8467 11-26-02 22:30 jwzthreading.py
 -------- -------
 8467 1 file
amk@nyman:~/src/python$ ./python
Python 2.3 (#1, Aug 1 2003, 19:54:32)
&gt;&gt;&gt; import sys
&gt;&gt;&gt; sys.path.insert(0, '/tmp/example.zip') # Add .zip file to front of path
&gt;&gt;&gt; import jwzthreading
&gt;&gt;&gt; jwzthreading.__file__
'/tmp/example.zip/jwzthreading.py'
&gt;&gt;&gt;</pre>
</div>
An entry in <tt class="docutils literal">sys.path</tt> can now be the filename of a ZIP archive. The ZIP
archive can contain any kind of files, but only files named <tt class="file docutils literal">*.py</tt>,
<tt class="file docutils literal">*.pyc</tt>, or <tt class="file docutils literal">*.pyo</tt> can be imported. If an archive only contains
<tt class="file docutils literal">*.py</tt> files, Python will not attempt to modify the archive by adding the
corresponding <tt class="file docutils literal">*.pyc</tt> file, meaning that if a ZIP archive doesn&#8217;t contain
<tt class="file docutils literal">*.pyc</tt> files, importing may be rather slow.
A path within the archive can also be specified to only import from a
subdirectory; for example, the path <tt class="file docutils literal">/tmp/example.zip/lib/</tt> would only
import from the <tt class="file docutils literal">lib/</tt> subdirectory within the archive.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0273">PEP 273</a> - Import Modules from Zip Archives</dt>
<dd>Written by James C. Ahlstrom, who also provided an implementation. Python 2.3
follows the specification in <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0273">PEP 273</a>, but uses an implementation written by
Just van Rossum that uses the import hooks described in <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0302">PEP 302</a>. See section
<a class="reference internal" href="#section-pep302">PEP 302: New Import Hooks</a> for a description of the new import hooks.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-277-unicode-file-name-support-for-windows-nt">
<h2>PEP 277: Unicode file name support for Windows NT<a class="headerlink" href="#pep-277-unicode-file-name-support-for-windows-nt" title="Permalink to this headline">¶</a></h2>
On Windows NT, 2000, and XP, the system stores file names as Unicode strings.
Traditionally, Python has represented file names as byte strings, which is
inadequate because it renders some file names inaccessible.
Python now allows using arbitrary Unicode strings (within the limitations of the
file system) for all functions that expect file names, most notably the
<a class="reference internal" href="../library/functions.html#open" title="open"><tt class="xref py py-func docutils literal">open()</tt></a> built-in function. If a Unicode string is passed to
<a class="reference internal" href="../library/os.html#os.listdir" title="os.listdir"><tt class="xref py py-func docutils literal">os.listdir()</tt></a>, Python now returns a list of Unicode strings. A new
function, <a class="reference internal" href="../library/os.html#os.getcwdu" title="os.getcwdu"><tt class="xref py py-func docutils literal">os.getcwdu()</tt></a>, returns the current directory as a Unicode string.
Byte strings still work as file names, and on Windows Python will transparently
convert them to Unicode using the <tt class="docutils literal">mbcs</tt> encoding.
Other systems also allow Unicode strings as file names but convert them to byte
strings before passing them to the system, which can cause a <a class="reference internal" href="../library/exceptions.html#exceptions.UnicodeError" title="exceptions.UnicodeError"><tt class="xref py py-exc docutils literal">UnicodeError</tt></a>
to be raised. Applications can test whether arbitrary Unicode strings are
supported as file names by checking <a class="reference internal" href="../library/os.path.html#os.path.supports_unicode_filenames" title="os.path.supports_unicode_filenames"><tt class="xref py py-attr docutils literal">os.path.supports_unicode_filenames</tt></a>,
a Boolean value.
Under MacOS, <a class="reference internal" href="../library/os.html#os.listdir" title="os.listdir"><tt class="xref py py-func docutils literal">os.listdir()</tt></a> may now return Unicode filenames.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0277">PEP 277</a> - Unicode file name support for Windows NT</dt>
<dd>Written by Neil Hodgson; implemented by Neil Hodgson, Martin von Löwis, and Mark
Hammond.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-278-universal-newline-support">
<h2>PEP 278: Universal Newline Support<a class="headerlink" href="#pep-278-universal-newline-support" title="Permalink to this headline">¶</a></h2>
The three major operating systems used today are Microsoft Windows, Apple&#8217;s
Macintosh OS, and the various Unix derivatives. A minor irritation of cross-
platform work is that these three platforms all use different characters to
mark the ends of lines in text files. Unix uses the linefeed (ASCII character
10), MacOS uses the carriage return (ASCII character 13), and Windows uses a
two-character sequence of a carriage return plus a newline.
Python&#8217;s file objects can now support end of line conventions other than the
one followed by the platform on which Python is running. Opening a file with
the mode <tt class="docutils literal">'U'</tt> or <tt class="docutils literal">'rU'</tt> will open a file for reading in <a class="reference internal" href="../glossary.html#term-universal-newlines">universal
newlines</a> mode. All three line ending conventions will be translated to a
<tt class="docutils literal">'\n'</tt> in the strings returned by the various file methods such as
<tt class="xref py py-meth docutils literal">read()</tt> and <a class="reference internal" href="../library/readline.html#module-readline" title="readline: GNU readline support for Python. (Unix)"><tt class="xref py py-meth docutils literal">readline()</tt></a>.
Universal newline support is also used when importing modules and when executing
a file with the <a class="reference internal" href="../library/functions.html#execfile" title="execfile"><tt class="xref py py-func docutils literal">execfile()</tt></a> function. This means that Python modules can
be shared between all three operating systems without needing to convert the
line-endings.
This feature can be disabled when compiling Python by specifying the
--without-universal-newlines switch when running Python&#8217;s
configure script.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0278">PEP 278</a> - Universal Newline Support</dt>
<dd>Written and implemented by Jack Jansen.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-279-enumerate">
<h2>PEP 279: enumerate()<a class="headerlink" href="#pep-279-enumerate" title="Permalink to this headline">¶</a></h2>
A new built-in function, <a class="reference internal" href="../library/functions.html#enumerate" title="enumerate"><tt class="xref py py-func docutils literal">enumerate()</tt></a>, will make certain loops a bit
clearer. <tt class="docutils literal">enumerate(thing)</tt>, where thing is either an iterator or a
sequence, returns a iterator that will return <tt class="docutils literal">(0, thing[0])</tt>, <tt class="docutils literal">(1,
thing[1])</tt>, <tt class="docutils literal">(2, thing[2])</tt>, and so forth.
A common idiom to change every element of a list looks like this:
<div class="highlight-python"><div class="highlight"><pre>for i in range(len(L)):
 item = L[i]
 # ... compute some result based on item ...
 L[i] = result
</pre></div>
</div>
This can be rewritten using <a class="reference internal" href="../library/functions.html#enumerate" title="enumerate"><tt class="xref py py-func docutils literal">enumerate()</tt></a> as:
<div class="highlight-python"><div class="highlight"><pre>for i, item in enumerate(L):
 # ... compute some result based on item ...
 L[i] = result
</pre></div>
</div>
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0279">PEP 279</a> - The enumerate() built-in function</dt>
<dd>Written and implemented by Raymond D. Hettinger.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-282-the-logging-package">
<h2>PEP 282: The logging Package<a class="headerlink" href="#pep-282-the-logging-package" title="Permalink to this headline">¶</a></h2>
A standard package for writing logs, <a class="reference internal" href="../library/logging.html#module-logging" title="logging: Flexible event logging system for applications."><tt class="xref py py-mod docutils literal">logging</tt></a>, has been added to Python
2.3. It provides a powerful and flexible mechanism for generating logging
output which can then be filtered and processed in various ways. A
configuration file written in a standard format can be used to control the
logging behavior of a program. Python includes handlers that will write log
records to standard error or to a file or socket, send them to the system log,
or even e-mail them to a particular address; of course, it&#8217;s also possible to
write your own handler classes.
The <tt class="xref py py-class docutils literal">Logger</tt> class is the primary class. Most application code will deal
with one or more <tt class="xref py py-class docutils literal">Logger</tt> objects, each one used by a particular
subsystem of the application. Each <tt class="xref py py-class docutils literal">Logger</tt> is identified by a name, and
names are organized into a hierarchy using <tt class="docutils literal">.</tt> as the component separator.
For example, you might have <tt class="xref py py-class docutils literal">Logger</tt> instances named <tt class="docutils literal">server</tt>,
<tt class="docutils literal">server.auth</tt> and <tt class="docutils literal">server.network</tt>. The latter two instances are below
<tt class="docutils literal">server</tt> in the hierarchy. This means that if you turn up the verbosity for
<tt class="docutils literal">server</tt> or direct <tt class="docutils literal">server</tt> messages to a different handler, the changes
will also apply to records logged to <tt class="docutils literal">server.auth</tt> and <tt class="docutils literal">server.network</tt>.
There&#8217;s also a root <tt class="xref py py-class docutils literal">Logger</tt> that&#8217;s the parent of all other loggers.
For simple uses, the <a class="reference internal" href="../library/logging.html#module-logging" title="logging: Flexible event logging system for applications."><tt class="xref py py-mod docutils literal">logging</tt></a> package contains some convenience functions
that always use the root log:
<div class="highlight-python"><div class="highlight"><pre>import logging

logging.debug(&#39;Debugging information&#39;)
logging.info(&#39;Informational message&#39;)
logging.warning(&#39;Warning:config file %s not found&#39;, &#39;server.conf&#39;)
logging.error(&#39;Error occurred&#39;)
logging.critical(&#39;Critical error -- shutting down&#39;)
</pre></div>
</div>
This produces the following output:
<div class="highlight-python"><pre>WARNING:root:Warning:config file server.conf not found
ERROR:root:Error occurred
CRITICAL:root:Critical error -- shutting down</pre>
</div>
In the default configuration, informational and debugging messages are
suppressed and the output is sent to standard error. You can enable the display
of informational and debugging messages by calling the <tt class="xref py py-meth docutils literal">setLevel()</tt> method
on the root logger.
Notice the <tt class="xref py py-func docutils literal">warning()</tt> call&#8217;s use of string formatting operators; all of the
functions for logging messages take the arguments <tt class="docutils literal">(msg, arg1, arg2, ...)</tt> and
log the string resulting from <tt class="docutils literal">msg % (arg1, arg2, ...)</tt>.
There&#8217;s also an <tt class="xref py py-func docutils literal">exception()</tt> function that records the most recent
traceback. Any of the other functions will also record the traceback if you
specify a true value for the keyword argument exc_info.
<div class="highlight-python"><div class="highlight"><pre>def f():
 try: 1/0
 except: logging.exception(&#39;Problem recorded&#39;)

f()
</pre></div>
</div>
This produces the following output:
<div class="highlight-python"><pre>ERROR:root:Problem recorded
Traceback (most recent call last):
 File "t.py", line 6, in f
 1/0
ZeroDivisionError: integer division or modulo by zero</pre>
</div>
Slightly more advanced programs will use a logger other than the root logger.
The <tt class="xref py py-func docutils literal">getLogger(name)()</tt> function is used to get a particular log, creating
it if it doesn&#8217;t exist yet. <tt class="xref py py-func docutils literal">getLogger(None)()</tt> returns the root logger.
<div class="highlight-python"><pre>log = logging.getLogger('server')
 ...
log.info('Listening on port %i', port)
 ...
log.critical('Disk full')
 ...</pre>
</div>
Log records are usually propagated up the hierarchy, so a message logged to
<tt class="docutils literal">server.auth</tt> is also seen by <tt class="docutils literal">server</tt> and <tt class="docutils literal">root</tt>, but a <tt class="xref py py-class docutils literal">Logger</tt>
can prevent this by setting its <tt class="xref py py-attr docutils literal">propagate</tt> attribute to <a class="reference internal" href="../library/constants.html#False" title="False"><tt class="xref py py-const docutils literal">False</tt></a>.
There are more classes provided by the <a class="reference internal" href="../library/logging.html#module-logging" title="logging: Flexible event logging system for applications."><tt class="xref py py-mod docutils literal">logging</tt></a> package that can be
customized. When a <tt class="xref py py-class docutils literal">Logger</tt> instance is told to log a message, it
creates a <tt class="xref py py-class docutils literal">LogRecord</tt> instance that is sent to any number of different
<tt class="xref py py-class docutils literal">Handler</tt> instances. Loggers and handlers can also have an attached list
of filters, and each filter can cause the <tt class="xref py py-class docutils literal">LogRecord</tt> to be ignored or
can modify the record before passing it along. When they&#8217;re finally output,
<tt class="xref py py-class docutils literal">LogRecord</tt> instances are converted to text by a <tt class="xref py py-class docutils literal">Formatter</tt>
class. All of these classes can be replaced by your own specially-written
classes.
With all of these features the <a class="reference internal" href="../library/logging.html#module-logging" title="logging: Flexible event logging system for applications."><tt class="xref py py-mod docutils literal">logging</tt></a> package should provide enough
flexibility for even the most complicated applications. This is only an
incomplete overview of its features, so please see the package&#8217;s reference
documentation for all of the details. Reading <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0282">PEP 282</a> will also be helpful.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0282">PEP 282</a> - A Logging System</dt>
<dd>Written by Vinay Sajip and Trent Mick; implemented by Vinay Sajip.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-285-a-boolean-type">
<h2>PEP 285: A Boolean Type<a class="headerlink" href="#pep-285-a-boolean-type" title="Permalink to this headline">¶</a></h2>
A Boolean type was added to Python 2.3. Two new constants were added to the
<a class="reference internal" href="../library/__builtin__.html#module-__builtin__" title="__builtin__: The module that provides the built-in namespace."><tt class="xref py py-mod docutils literal">__builtin__</tt></a> module, <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> and <a class="reference internal" href="../library/constants.html#False" title="False"><tt class="xref py py-const docutils literal">False</tt></a>. (<a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> and
<a class="reference internal" href="../library/constants.html#False" title="False"><tt class="xref py py-const docutils literal">False</tt></a> constants were added to the built-ins in Python 2.2.1, but the
2.2.1 versions are simply set to integer values of 1 and 0 and aren&#8217;t a
different type.)
The type object for this new type is named <a class="reference internal" href="../library/functions.html#bool" title="bool"><tt class="xref py py-class docutils literal">bool</tt></a>; the constructor for it
takes any Python value and converts it to <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> or <a class="reference internal" href="../library/constants.html#False" title="False"><tt class="xref py py-const docutils literal">False</tt></a>.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; bool(1)
True
&gt;&gt;&gt; bool(0)
False
&gt;&gt;&gt; bool([])
False
&gt;&gt;&gt; bool( (1,) )
True
</pre></div>
</div>
Most of the standard library modules and built-in functions have been changed to
return Booleans.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; obj = []
&gt;&gt;&gt; hasattr(obj, &#39;append&#39;)
True
&gt;&gt;&gt; isinstance(obj, list)
True
&gt;&gt;&gt; isinstance(obj, tuple)
False
</pre></div>
</div>
Python&#8217;s Booleans were added with the primary goal of making code clearer. For
example, if you&#8217;re reading a function and encounter the statement <tt class="docutils literal">return 1</tt>,
you might wonder whether the <tt class="docutils literal">1</tt> represents a Boolean truth value, an index,
or a coefficient that multiplies some other quantity. If the statement is
<tt class="docutils literal">return True</tt>, however, the meaning of the return value is quite clear.
Python&#8217;s Booleans were not added for the sake of strict type-checking. A very
strict language such as Pascal would also prevent you performing arithmetic with
Booleans, and would require that the expression in an <a class="reference internal" href="../reference/compound_stmts.html#if"><tt class="xref std std-keyword docutils literal">if</tt></a> statement
always evaluate to a Boolean result. Python is not this strict and never will
be, as <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0285">PEP 285</a> explicitly says. This means you can still use any expression
in an <a class="reference internal" href="../reference/compound_stmts.html#if"><tt class="xref std std-keyword docutils literal">if</tt></a> statement, even ones that evaluate to a list or tuple or
some random object. The Boolean type is a subclass of the <a class="reference internal" href="../library/functions.html#int" title="int"><tt class="xref py py-class docutils literal">int</tt></a> class so
that arithmetic using a Boolean still works.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; True + 1
2
&gt;&gt;&gt; False + 1
1
&gt;&gt;&gt; False * 75
0
&gt;&gt;&gt; True * 75
75
</pre></div>
</div>
To sum up <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> and <a class="reference internal" href="../library/constants.html#False" title="False"><tt class="xref py py-const docutils literal">False</tt></a> in a sentence: they&#8217;re alternative
ways to spell the integer values 1 and 0, with the single difference that
<a class="reference internal" href="../library/functions.html#str" title="str"><tt class="xref py py-func docutils literal">str()</tt></a> and <a class="reference internal" href="../library/repr.html#module-repr" title="repr: Alternate repr() implementation with size limits."><tt class="xref py py-func docutils literal">repr()</tt></a> return the strings <tt class="docutils literal">'True'</tt> and <tt class="docutils literal">'False'</tt>
instead of <tt class="docutils literal">'1'</tt> and <tt class="docutils literal">'0'</tt>.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0285">PEP 285</a> - Adding a bool type</dt>
<dd>Written and implemented by GvR.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-293-codec-error-handling-callbacks">
<h2>PEP 293: Codec Error Handling Callbacks<a class="headerlink" href="#pep-293-codec-error-handling-callbacks" title="Permalink to this headline">¶</a></h2>
When encoding a Unicode string into a byte string, unencodable characters may be
encountered. So far, Python has allowed specifying the error processing as
either &#8220;strict&#8221; (raising <a class="reference internal" href="../library/exceptions.html#exceptions.UnicodeError" title="exceptions.UnicodeError"><tt class="xref py py-exc docutils literal">UnicodeError</tt></a>), &#8220;ignore&#8221; (skipping the
character), or &#8220;replace&#8221; (using a question mark in the output string), with
&#8220;strict&#8221; being the default behavior. It may be desirable to specify alternative
processing of such errors, such as inserting an XML character reference or HTML
entity reference into the converted string.
Python now has a flexible framework to add different processing strategies. New
error handlers can be added with <a class="reference internal" href="../library/codecs.html#codecs.register_error" title="codecs.register_error"><tt class="xref py py-func docutils literal">codecs.register_error()</tt></a>, and codecs then
can access the error handler with <a class="reference internal" href="../library/codecs.html#codecs.lookup_error" title="codecs.lookup_error"><tt class="xref py py-func docutils literal">codecs.lookup_error()</tt></a>. An equivalent C
API has been added for codecs written in C. The error handler gets the necessary
state information such as the string being converted, the position in the string
where the error was detected, and the target encoding. The handler can then
either raise an exception or return a replacement string.
Two additional error handlers have been implemented using this framework:
&#8220;backslashreplace&#8221; uses Python backslash quoting to represent unencodable
characters and &#8220;xmlcharrefreplace&#8221; emits XML character references.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0293">PEP 293</a> - Codec Error Handling Callbacks</dt>
<dd>Written and implemented by Walter Dörwald.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-301-package-index-and-metadata-for-distutils">
<h2>PEP 301: Package Index and Metadata for Distutils<a class="headerlink" href="#pep-301-package-index-and-metadata-for-distutils" title="Permalink to this headline">¶</a></h2>
Support for the long-requested Python catalog makes its first appearance in 2.3.
The heart of the catalog is the new Distutils register command.
Running <tt class="docutils literal">python setup.py register</tt> will collect the metadata describing a
package, such as its name, version, maintainer, description, &amp;c., and send it to
a central catalog server. The resulting catalog is available from
<a class="reference external" href="http://www.python.org/pypi">http://www.python.org/pypi</a>.
To make the catalog a bit more useful, a new optional classifiers keyword
argument has been added to the Distutils <tt class="xref py py-func docutils literal">setup()</tt> function. A list of
<a class="reference external" href="http://catb.org/~esr/trove/">Trove</a>-style strings can be supplied to help
classify the software.
Here&#8217;s an example <tt class="file docutils literal">setup.py</tt> with classifiers, written to be compatible
with older versions of the Distutils:
<div class="highlight-python"><div class="highlight"><pre>from distutils import core
kw = {&#39;name&#39;: &quot;Quixote&quot;,
 &#39;version&#39;: &quot;0.5.1&quot;,
 &#39;description&#39;: &quot;A highly Pythonic Web application framework&quot;,
 # ...
 }

if (hasattr(core, &#39;setup_keywords&#39;) and
 &#39;classifiers&#39; in core.setup_keywords):
 kw[&#39;classifiers&#39;] = \
 [&#39;Topic :: Internet :: WWW/HTTP :: Dynamic Content&#39;,
 &#39;Environment :: No Input/Output (Daemon)&#39;,
 &#39;Intended Audience :: Developers&#39;],

core.setup(**kw)
</pre></div>
</div>
The full list of classifiers can be obtained by running <tt class="docutils literal">python setup.py
register --list-classifiers</tt>.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0301">PEP 301</a> - Package Index and Metadata for Distutils</dt>
<dd>Written and implemented by Richard Jones.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-302-new-import-hooks">
<h2>PEP 302: New Import Hooks<a class="headerlink" href="#pep-302-new-import-hooks" title="Permalink to this headline">¶</a></h2>
While it&#8217;s been possible to write custom import hooks ever since the
<tt class="xref py py-mod docutils literal">ihooks</tt> module was introduced in Python 1.3, no one has ever been really
happy with it because writing new import hooks is difficult and messy. There
have been various proposed alternatives such as the <a class="reference internal" href="../library/imputil.html#module-imputil" title="imputil: Manage and augment the import process. (deprecated)"><tt class="xref py py-mod docutils literal">imputil</tt></a> and <tt class="xref py py-mod docutils literal">iu</tt>
modules, but none of them has ever gained much acceptance, and none of them were
easily usable from C code.
<a class="pep reference external" href="http://www.python.org/dev/peps/pep-0302">PEP 302</a> borrows ideas from its predecessors, especially from Gordon
McMillan&#8217;s <tt class="xref py py-mod docutils literal">iu</tt> module. Three new items are added to the <a class="reference internal" href="../library/sys.html#module-sys" title="sys: Access system-specific parameters and functions."><tt class="xref py py-mod docutils literal">sys</tt></a>
module:
<ul class="simple">
<li><tt class="docutils literal">sys.path_hooks</tt> is a list of callable objects; most often they&#8217;ll be
classes. Each callable takes a string containing a path and either returns an
importer object that will handle imports from this path or raises an
<a class="reference internal" href="../library/exceptions.html#exceptions.ImportError" title="exceptions.ImportError"><tt class="xref py py-exc docutils literal">ImportError</tt></a> exception if it can&#8217;t handle this path.</li>
<li><tt class="docutils literal">sys.path_importer_cache</tt> caches importer objects for each path, so
<tt class="docutils literal">sys.path_hooks</tt> will only need to be traversed once for each path.</li>
<li><tt class="docutils literal">sys.meta_path</tt> is a list of importer objects that will be traversed before
<tt class="docutils literal">sys.path</tt> is checked. This list is initially empty, but user code can add
objects to it. Additional built-in and frozen modules can be imported by an
object added to this list.</li>
</ul>
Importer objects must have a single method, <tt class="xref py py-meth docutils literal">find_module(fullname,
path=None)()</tt>. fullname will be a module or package name, e.g. <tt class="docutils literal">string</tt> or
<tt class="docutils literal">distutils.core</tt>. <tt class="xref py py-meth docutils literal">find_module()</tt> must return a loader object that has a
single method, <tt class="xref py py-meth docutils literal">load_module(fullname)()</tt>, that creates and returns the
corresponding module object.
Pseudo-code for Python&#8217;s new import logic, therefore, looks something like this
(simplified a bit; see <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0302">PEP 302</a> for the full details):
<div class="highlight-python"><pre>for mp in sys.meta_path:
 loader = mp(fullname)
 if loader is not None:
 &lt;module&gt; = loader.load_module(fullname)

for path in sys.path:
    for hook in sys.path_hooks:
        try:
            importer = hook(path)
        except ImportError:
            # ImportError, so try the other path hooks
            pass
        else:
            loader = importer.find_module(fullname)
            &lt;module&gt; = loader.load_module(fullname)

# Not found!
raise ImportError</pre>
</div>
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0302">PEP 302</a> - New Import Hooks</dt>
<dd>Written by Just van Rossum and Paul Moore. Implemented by Just van Rossum.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-305-comma-separated-files">
<h2>PEP 305: Comma-separated Files<a class="headerlink" href="#pep-305-comma-separated-files" title="Permalink to this headline">¶</a></h2>
Comma-separated files are a format frequently used for exporting data from
databases and spreadsheets. Python 2.3 adds a parser for comma-separated files.
Comma-separated format is deceptively simple at first glance:
<div class="highlight-python"><div class="highlight"><pre>Costs,150,200,3.95
</pre></div>
</div>
Read a line and call <tt class="docutils literal">line.split(',')</tt>: what could be simpler? But toss in
string data that can contain commas, and things get more complicated:
<div class="highlight-python"><div class="highlight"><pre>&quot;Costs&quot;,150,200,3.95,&quot;Includes taxes, shipping, and sundry items&quot;
</pre></div>
</div>
A big ugly regular expression can parse this, but using the new <a class="reference internal" href="../library/csv.html#module-csv" title="csv: Write and read tabular data to and from delimited files."><tt class="xref py py-mod docutils literal">csv</tt></a>
package is much simpler:
<div class="highlight-python"><div class="highlight"><pre>import csv

input = open(&#39;datafile&#39;, &#39;rb&#39;)
reader = csv.reader(input)
for line in reader:
 print line
</pre></div>
</div>
The <tt class="xref py py-func docutils literal">reader()</tt> function takes a number of different options. The field
separator isn&#8217;t limited to the comma and can be changed to any character, and so
can the quoting and line-ending characters.
Different dialects of comma-separated files can be defined and registered;
currently there are two dialects, both used by Microsoft Excel. A separate
<a class="reference internal" href="../library/csv.html#csv.writer" title="csv.writer"><tt class="xref py py-class docutils literal">csv.writer</tt></a> class will generate comma-separated files from a succession
of tuples or lists, quoting strings that contain the delimiter.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0305">PEP 305</a> - CSV File API</dt>
<dd>Written and implemented by Kevin Altis, Dave Cole, Andrew McNamara, Skip
Montanaro, Cliff Wells.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-307-pickle-enhancements">
<h2>PEP 307: Pickle Enhancements<a class="headerlink" href="#pep-307-pickle-enhancements" title="Permalink to this headline">¶</a></h2>
The <a class="reference internal" href="../library/pickle.html#module-pickle" title="pickle: Convert Python objects to streams of bytes and back."><tt class="xref py py-mod docutils literal">pickle</tt></a> and <a class="reference internal" href="../library/pickle.html#module-cPickle" title="cPickle: Faster version of pickle, but not subclassable."><tt class="xref py py-mod docutils literal">cPickle</tt></a> modules received some attention during the
2.3 development cycle. In 2.2, new-style classes could be pickled without
difficulty, but they weren&#8217;t pickled very compactly; <a class="pep reference external" href="http://www.python.org/dev/peps/pep-0307">PEP 307</a> quotes a trivial
example where a new-style class results in a pickled string three times longer
than that for a classic class.
The solution was to invent a new pickle protocol. The <a class="reference internal" href="../library/pickle.html#pickle.dumps" title="pickle.dumps"><tt class="xref py py-func docutils literal">pickle.dumps()</tt></a>
function has supported a text-or-binary flag for a long time. In 2.3, this
flag is redefined from a Boolean to an integer: 0 is the old text-mode pickle
format, 1 is the old binary format, and now 2 is a new 2.3-specific format. A
new constant, <a class="reference internal" href="../library/pickle.html#pickle.HIGHEST_PROTOCOL" title="pickle.HIGHEST_PROTOCOL"><tt class="xref py py-const docutils literal">pickle.HIGHEST_PROTOCOL</tt></a>, can be used to select the
fanciest protocol available.
Unpickling is no longer considered a safe operation. 2.2&#8217;s <a class="reference internal" href="../library/pickle.html#module-pickle" title="pickle: Convert Python objects to streams of bytes and back."><tt class="xref py py-mod docutils literal">pickle</tt></a>
provided hooks for trying to prevent unsafe classes from being unpickled
(specifically, a <tt class="xref py py-attr docutils literal">__safe_for_unpickling__</tt> attribute), but none of this
code was ever audited and therefore it&#8217;s all been ripped out in 2.3. You should
not unpickle untrusted data in any version of Python.
To reduce the pickling overhead for new-style classes, a new interface for
customizing pickling was added using three special methods:
<a class="reference internal" href="../library/pickle.html#object.__getstate__" title="object.__getstate__"><tt class="xref py py-meth docutils literal">__getstate__()</tt></a>, <a class="reference internal" href="../library/pickle.html#object.__setstate__" title="object.__setstate__"><tt class="xref py py-meth docutils literal">__setstate__()</tt></a>, and <a class="reference internal" href="../library/pickle.html#object.__getnewargs__" title="object.__getnewargs__"><tt class="xref py py-meth docutils literal">__getnewargs__()</tt></a>. Consult
<a class="pep reference external" href="http://www.python.org/dev/peps/pep-0307">PEP 307</a> for the full semantics of these methods.
As a way to compress pickles yet further, it&#8217;s now possible to use integer codes
instead of long strings to identify pickled classes. The Python Software
Foundation will maintain a list of standardized codes; there&#8217;s also a range of
codes for private use. Currently no codes have been specified.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="pep reference external" href="http://www.python.org/dev/peps/pep-0307">PEP 307</a> - Extensions to the pickle protocol</dt>
<dd>Written and implemented by Guido van Rossum and Tim Peters.</dd>
</dl>
</div>
</div>
<div class="section" id="extended-slices">
<h2>Extended Slices<a class="headerlink" href="#extended-slices" title="Permalink to this headline">¶</a></h2>
Ever since Python 1.4, the slicing syntax has supported an optional third &#8220;step&#8221;
or &#8220;stride&#8221; argument. For example, these are all legal Python syntax:
<tt class="docutils literal">L[1:10:2]</tt>, <tt class="docutils literal">L[:-1:1]</tt>, <tt class="docutils literal">L[::-1]</tt>. This was added to Python at the
request of the developers of Numerical Python, which uses the third argument
extensively. However, Python&#8217;s built-in list, tuple, and string sequence types
have never supported this feature, raising a <a class="reference internal" href="../library/exceptions.html#exceptions.TypeError" title="exceptions.TypeError"><tt class="xref py py-exc docutils literal">TypeError</tt></a> if you tried it.
Michael Hudson contributed a patch to fix this shortcoming.
For example, you can now easily extract the elements of a list that have even
indexes:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; L = range(10)
&gt;&gt;&gt; L[::2]
[0, 2, 4, 6, 8]
</pre></div>
</div>
Negative values also work to make a copy of the same list in reverse order:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; L[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
</pre></div>
</div>
This also works for tuples, arrays, and strings:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; s=&#39;abcd&#39;
&gt;&gt;&gt; s[::2]
&#39;ac&#39;
&gt;&gt;&gt; s[::-1]
&#39;dcba&#39;
</pre></div>
</div>
If you have a mutable sequence such as a list or an array you can assign to or
delete an extended slice, but there are some differences between assignment to
extended and regular slices. Assignment to a regular slice can be used to
change the length of the sequence:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; a = range(3)
&gt;&gt;&gt; a
[0, 1, 2]
&gt;&gt;&gt; a[1:3] = [4, 5, 6]
&gt;&gt;&gt; a
[0, 4, 5, 6]
</pre></div>
</div>
Extended slices aren&#8217;t this flexible. When assigning to an extended slice, the
list on the right hand side of the statement must contain the same number of
items as the slice it is replacing:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; a = range(4)
&gt;&gt;&gt; a
[0, 1, 2, 3]
&gt;&gt;&gt; a[::2]
[0, 2]
&gt;&gt;&gt; a[::2] = [0, -1]
&gt;&gt;&gt; a
[0, 1, -1, 3]
&gt;&gt;&gt; a[::2] = [0,1,2]
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in ?
ValueError: attempt to assign sequence of size 3 to extended slice of size 2
</pre></div>
</div>
Deletion is more straightforward:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; a = range(4)
&gt;&gt;&gt; a
[0, 1, 2, 3]
&gt;&gt;&gt; a[::2]
[0, 2]
&gt;&gt;&gt; del a[::2]
&gt;&gt;&gt; a
[1, 3]
</pre></div>
</div>
One can also now pass slice objects to the <a class="reference internal" href="../reference/datamodel.html#object.__getitem__" title="object.__getitem__"><tt class="xref py py-meth docutils literal">__getitem__()</tt></a> methods of the
built-in sequences:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; range(10).__getitem__(slice(0, 5, 2))
[0, 2, 4]
</pre></div>
</div>
Or use slice objects directly in subscripts:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; range(10)[slice(0, 5, 2)]
[0, 2, 4]
</pre></div>
</div>
To simplify implementing sequences that support extended slicing, slice objects
now have a method <tt class="xref py py-meth docutils literal">indices(length)()</tt> which, given the length of a sequence,
returns a <tt class="docutils literal">(start, stop, step)</tt> tuple that can be passed directly to
<a class="reference internal" href="../library/functions.html#range" title="range"><tt class="xref py py-func docutils literal">range()</tt></a>. <tt class="xref py py-meth docutils literal">indices()</tt> handles omitted and out-of-bounds indices in a
manner consistent with regular slices (and this innocuous phrase hides a welter
of confusing details!). The method is intended to be used like this:
<div class="highlight-python"><div class="highlight"><pre>class FakeSeq:
 ...
 def calc_item(self, i):
 ...
 def __getitem__(self, item):
 if isinstance(item, slice):
 indices = item.indices(len(self))
 return FakeSeq([self.calc_item(i) for i in range(*indices)])
 else:
 return self.calc_item(i)
</pre></div>
</div>
From this example you can also see that the built-in <a class="reference internal" href="../library/functions.html#slice" title="slice"><tt class="xref py py-class docutils literal">slice</tt></a> object is
now the type object for the slice type, and is no longer a function. This is
consistent with Python 2.2, where <a class="reference internal" href="../library/functions.html#int" title="int"><tt class="xref py py-class docutils literal">int</tt></a>, <a class="reference internal" href="../library/functions.html#str" title="str"><tt class="xref py py-class docutils literal">str</tt></a>, etc., underwent
the same change.
</div>
<div class="section" id="other-language-changes">
<h2>Other Language Changes<a class="headerlink" href="#other-language-changes" title="Permalink to this headline">¶</a></h2>
Here are all of the changes that Python 2.3 makes to the core Python language.
<ul>
<li>The <a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> statement is now always a keyword, as described in
section <a class="reference internal" href="#section-generators">PEP 255: Simple Generators</a> of this document.
</li>
<li>A new built-in function <a class="reference internal" href="../library/functions.html#enumerate" title="enumerate"><tt class="xref py py-func docutils literal">enumerate()</tt></a> was added, as described in section
<a class="reference internal" href="#section-enumerate">PEP 279: enumerate()</a> of this document.
</li>
<li>Two new constants, <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> and <a class="reference internal" href="../library/constants.html#False" title="False"><tt class="xref py py-const docutils literal">False</tt></a> were added along with the
built-in <a class="reference internal" href="../library/functions.html#bool" title="bool"><tt class="xref py py-class docutils literal">bool</tt></a> type, as described in section <a class="reference internal" href="#section-bool">PEP 285: A Boolean Type</a> of this
document.
</li>
<li>The <a class="reference internal" href="../library/functions.html#int" title="int"><tt class="xref py py-func docutils literal">int()</tt></a> type constructor will now return a long integer instead of
raising an <a class="reference internal" href="../library/exceptions.html#exceptions.OverflowError" title="exceptions.OverflowError"><tt class="xref py py-exc docutils literal">OverflowError</tt></a> when a string or floating-point number is too
large to fit into an integer. This can lead to the paradoxical result that
<tt class="docutils literal">isinstance(int(expression), int)</tt> is false, but that seems unlikely to cause
problems in practice.
</li>
<li>Built-in types now support the extended slicing syntax, as described in
section <a class="reference internal" href="#section-slices">Extended Slices</a> of this document.
</li>
<li>A new built-in function, <tt class="xref py py-func docutils literal">sum(iterable, start=0)()</tt>, adds up the numeric
items in the iterable object and returns their sum. <a class="reference internal" href="../library/functions.html#sum" title="sum"><tt class="xref py py-func docutils literal">sum()</tt></a> only accepts
numbers, meaning that you can&#8217;t use it to concatenate a bunch of strings.
(Contributed by Alex Martelli.)
</li>
<li><tt class="docutils literal">list.insert(pos, value)</tt> used to insert value at the front of the list
when pos was negative. The behaviour has now been changed to be consistent
with slice indexing, so when pos is -1 the value will be inserted before the
last element, and so forth.
</li>
<li><tt class="docutils literal">list.index(value)</tt>, which searches for value within the list and returns
its index, now takes optional start and stop arguments to limit the search
to only part of the list.
</li>
<li>Dictionaries have a new method, <tt class="xref py py-meth docutils literal">pop(key[, *default*])()</tt>, that returns
the value corresponding to key and removes that key/value pair from the
dictionary. If the requested key isn&#8217;t present in the dictionary, default is
returned if it&#8217;s specified and <a class="reference internal" href="../library/exceptions.html#exceptions.KeyError" title="exceptions.KeyError"><tt class="xref py py-exc docutils literal">KeyError</tt></a> raised if it isn&#8217;t.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; d = {1:2}
&gt;&gt;&gt; d
{1: 2}
&gt;&gt;&gt; d.pop(4)
Traceback (most recent call last):
 File &quot;stdin&quot;, line 1, in ?
KeyError: 4
&gt;&gt;&gt; d.pop(1)
2
&gt;&gt;&gt; d.pop(1)
Traceback (most recent call last):
 File &quot;stdin&quot;, line 1, in ?
KeyError: &#39;pop(): dictionary is empty&#39;
&gt;&gt;&gt; d
{}
&gt;&gt;&gt;
</pre></div>
</div>
There&#8217;s also a new class method, <tt class="xref py py-meth docutils literal">dict.fromkeys(iterable, value)()</tt>, that
creates a dictionary with keys taken from the supplied iterator iterable and
all values set to value, defaulting to <tt class="docutils literal">None</tt>.
(Patches contributed by Raymond Hettinger.)
Also, the <a class="reference internal" href="../library/stdtypes.html#dict" title="dict"><tt class="xref py py-func docutils literal">dict()</tt></a> constructor now accepts keyword arguments to simplify
creating small dictionaries:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; dict(red=1, blue=2, green=3, black=4)
{&#39;blue&#39;: 2, &#39;black&#39;: 4, &#39;green&#39;: 3, &#39;red&#39;: 1}
</pre></div>
</div>
(Contributed by Just van Rossum.)
</li>
<li>The <a class="reference internal" href="../reference/simple_stmts.html#assert"><tt class="xref std std-keyword docutils literal">assert</tt></a> statement no longer checks the <tt class="docutils literal">__debug__</tt> flag, so
you can no longer disable assertions by assigning to <tt class="docutils literal">__debug__</tt>. Running
Python with the <a class="reference internal" href="../using/cmdline.html#cmdoption-O">-O</a> switch will still generate code that doesn&#8217;t
execute any assertions.
</li>
<li>Most type objects are now callable, so you can use them to create new objects
such as functions, classes, and modules. (This means that the <a class="reference internal" href="../library/new.html#module-new" title="new: Interface to the creation of runtime implementation objects. (deprecated)"><tt class="xref py py-mod docutils literal">new</tt></a> module
can be deprecated in a future Python version, because you can now use the type
objects available in the <a class="reference internal" href="../library/types.html#module-types" title="types: Names for built-in types."><tt class="xref py py-mod docutils literal">types</tt></a> module.) For example, you can create a new
module object with the following code:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import types
&gt;&gt;&gt; m = types.ModuleType(&#39;abc&#39;,&#39;docstring&#39;)
&gt;&gt;&gt; m
&lt;module &#39;abc&#39; (built-in)&gt;
&gt;&gt;&gt; m.__doc__
&#39;docstring&#39;
</pre></div>
</div>
</li>
<li>A new warning, <a class="reference internal" href="../library/exceptions.html#exceptions.PendingDeprecationWarning" title="exceptions.PendingDeprecationWarning"><tt class="xref py py-exc docutils literal">PendingDeprecationWarning</tt></a> was added to indicate features
which are in the process of being deprecated. The warning will not be printed
by default. To check for use of features that will be deprecated in the future,
supply -Walways::PendingDeprecationWarning:: on the command line or
use <a class="reference internal" href="../library/warnings.html#warnings.filterwarnings" title="warnings.filterwarnings"><tt class="xref py py-func docutils literal">warnings.filterwarnings()</tt></a>.
</li>
<li>The process of deprecating string-based exceptions, as in <tt class="docutils literal">raise &quot;Error
occurred&quot;</tt>, has begun. Raising a string will now trigger
<a class="reference internal" href="../library/exceptions.html#exceptions.PendingDeprecationWarning" title="exceptions.PendingDeprecationWarning"><tt class="xref py py-exc docutils literal">PendingDeprecationWarning</tt></a>.
</li>
<li>Using <tt class="docutils literal">None</tt> as a variable name will now result in a <a class="reference internal" href="../library/exceptions.html#exceptions.SyntaxWarning" title="exceptions.SyntaxWarning"><tt class="xref py py-exc docutils literal">SyntaxWarning</tt></a>
warning. In a future version of Python, <tt class="docutils literal">None</tt> may finally become a keyword.
</li>
<li>The <tt class="xref py py-meth docutils literal">xreadlines()</tt> method of file objects, introduced in Python 2.1, is no
longer necessary because files now behave as their own iterator.
<tt class="xref py py-meth docutils literal">xreadlines()</tt> was originally introduced as a faster way to loop over all
the lines in a file, but now you can simply write <tt class="docutils literal">for line in file_obj</tt>.
File objects also have a new read-only <tt class="xref py py-attr docutils literal">encoding</tt> attribute that gives the
encoding used by the file; Unicode strings written to the file will be
automatically converted to bytes using the given encoding.
</li>
<li>The method resolution order used by new-style classes has changed, though
you&#8217;ll only notice the difference if you have a really complicated inheritance
hierarchy. Classic classes are unaffected by this change. Python 2.2
originally used a topological sort of a class&#8217;s ancestors, but 2.3 now uses the
C3 algorithm as described in the paper <a class="reference external" href="http://www.webcom.com/haahr/dylan/linearization-oopsla96.html">&#8220;A Monotonic Superclass Linearization
for Dylan&#8221;</a>. To
understand the motivation for this change, read Michele Simionato&#8217;s article
<a class="reference external" href="http://www.python.org/2.3/mro.html">&#8220;Python 2.3 Method Resolution Order&#8221;</a>, or
read the thread on python-dev starting with the message at
<a class="reference external" href="http://mail.python.org/pipermail/python-dev/2002-October/029035.html">http://mail.python.org/pipermail/python-dev/2002-October/029035.html</a>. Samuele
Pedroni first pointed out the problem and also implemented the fix by coding the
C3 algorithm.
</li>
<li>Python runs multithreaded programs by switching between threads after
executing N bytecodes. The default value for N has been increased from 10 to
100 bytecodes, speeding up single-threaded applications by reducing the
switching overhead. Some multithreaded applications may suffer slower response
time, but that&#8217;s easily fixed by setting the limit back to a lower number using
<tt class="xref py py-func docutils literal">sys.setcheckinterval(N)()</tt>. The limit can be retrieved with the new
<a class="reference internal" href="../library/sys.html#sys.getcheckinterval" title="sys.getcheckinterval"><tt class="xref py py-func docutils literal">sys.getcheckinterval()</tt></a> function.
</li>
<li>One minor but far-reaching change is that the names of extension types defined
by the modules included with Python now contain the module and a <tt class="docutils literal">'.'</tt> in
front of the type name. For example, in Python 2.2, if you created a socket and
printed its <tt class="xref py py-attr docutils literal">__class__</tt>, you&#8217;d get this output:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; s = socket.socket()
&gt;&gt;&gt; s.__class__
&lt;type &#39;socket&#39;&gt;
</pre></div>
</div>
In 2.3, you get this:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; s.__class__
&lt;type &#39;_socket.socket&#39;&gt;
</pre></div>
</div>
</li>
<li>One of the noted incompatibilities between old- and new-style classes has been
removed: you can now assign to the <tt class="xref py py-attr docutils literal">__name__</tt> and <tt class="xref py py-attr docutils literal">__bases__</tt>
attributes of new-style classes. There are some restrictions on what can be
assigned to <tt class="xref py py-attr docutils literal">__bases__</tt> along the lines of those relating to assigning to
an instance&#8217;s <tt class="xref py py-attr docutils literal">__class__</tt> attribute.
</li>
</ul>
<div class="section" id="string-changes">
<h3>String Changes<a class="headerlink" href="#string-changes" title="Permalink to this headline">¶</a></h3>
<ul>
<li>The <a class="reference internal" href="../reference/expressions.html#in"><tt class="xref std std-keyword docutils literal">in</tt></a> operator now works differently for strings. Previously, when
evaluating <tt class="docutils literal">X in Y</tt> where X and Y are strings, X could only be a single
character. That&#8217;s now changed; X can be a string of any length, and <tt class="docutils literal">X in Y</tt>
will return <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> if X is a substring of Y. If X is the empty
string, the result is always <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a>.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; &#39;ab&#39; in &#39;abcd&#39;
True
&gt;&gt;&gt; &#39;ad&#39; in &#39;abcd&#39;
False
&gt;&gt;&gt; &#39;&#39; in &#39;abcd&#39;
True
</pre></div>
</div>
Note that this doesn&#8217;t tell you where the substring starts; if you need that
information, use the <tt class="xref py py-meth docutils literal">find()</tt> string method.
</li>
<li>The <tt class="xref py py-meth docutils literal">strip()</tt>, <tt class="xref py py-meth docutils literal">lstrip()</tt>, and <tt class="xref py py-meth docutils literal">rstrip()</tt> string methods now have
an optional argument for specifying the characters to strip. The default is
still to remove all whitespace characters:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; &#39; abc &#39;.strip()
&#39;abc&#39;
&gt;&gt;&gt; &#39;&gt;&lt;&gt;&lt;abc&lt;&gt;&lt;&gt;&lt;&gt;&#39;.strip(&#39;&lt;&gt;&#39;)
&#39;abc&#39;
&gt;&gt;&gt; &#39;&gt;&lt;&gt;&lt;abc&lt;&gt;&lt;&gt;&lt;&gt;\n&#39;.strip(&#39;&lt;&gt;&#39;)
&#39;abc&lt;&gt;&lt;&gt;&lt;&gt;\n&#39;
&gt;&gt;&gt; u&#39;\u4000\u4001abc\u4000&#39;.strip(u&#39;\u4000&#39;)
u&#39;\u4001abc&#39;
&gt;&gt;&gt;
</pre></div>
</div>
(Suggested by Simon Brunning and implemented by Walter Dörwald.)
</li>
<li>The <tt class="xref py py-meth docutils literal">startswith()</tt> and <tt class="xref py py-meth docutils literal">endswith()</tt> string methods now accept negative
numbers for the start and end parameters.
</li>
<li>Another new string method is <tt class="xref py py-meth docutils literal">zfill()</tt>, originally a function in the
<a class="reference internal" href="../library/string.html#module-string" title="string: Common string operations."><tt class="xref py py-mod docutils literal">string</tt></a> module. <tt class="xref py py-meth docutils literal">zfill()</tt> pads a numeric string with zeros on the
left until it&#8217;s the specified width. Note that the <tt class="docutils literal">%</tt> operator is still more
flexible and powerful than <tt class="xref py py-meth docutils literal">zfill()</tt>.
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; &#39;45&#39;.zfill(4)
&#39;0045&#39;
&gt;&gt;&gt; &#39;12345&#39;.zfill(4)
&#39;12345&#39;
&gt;&gt;&gt; &#39;goofy&#39;.zfill(6)
&#39;0goofy&#39;
</pre></div>
</div>
(Contributed by Walter Dörwald.)
</li>
<li>A new type object, <a class="reference internal" href="../library/functions.html#basestring" title="basestring"><tt class="xref py py-class docutils literal">basestring</tt></a>, has been added. Both 8-bit strings and
Unicode strings inherit from this type, so <tt class="docutils literal">isinstance(obj, basestring)</tt> will
return <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> for either kind of string. It&#8217;s a completely abstract
type, so you can&#8217;t create <a class="reference internal" href="../library/functions.html#basestring" title="basestring"><tt class="xref py py-class docutils literal">basestring</tt></a> instances.
</li>
<li>Interned strings are no longer immortal and will now be garbage-collected in
the usual way when the only reference to them is from the internal dictionary of
interned strings. (Implemented by Oren Tirosh.)
</li>
</ul>
</div>
<div class="section" id="optimizations">
<h3>Optimizations<a class="headerlink" href="#optimizations" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li>The creation of new-style class instances has been made much faster; they&#8217;re
now faster than classic classes!</li>
<li>The <tt class="xref py py-meth docutils literal">sort()</tt> method of list objects has been extensively rewritten by Tim
Peters, and the implementation is significantly faster.</li>
<li>Multiplication of large long integers is now much faster thanks to an
implementation of Karatsuba multiplication, an algorithm that scales better than
the O(n*n) required for the grade-school multiplication algorithm. (Original
patch by Christopher A. Craig, and significantly reworked by Tim Peters.)</li>
<li>The <tt class="docutils literal">SET_LINENO</tt> opcode is now gone. This may provide a small speed
increase, depending on your compiler&#8217;s idiosyncrasies. See section
<a class="reference internal" href="#section-other">Other Changes and Fixes</a> for a longer explanation. (Removed by Michael Hudson.)</li>
<li><a class="reference internal" href="../library/functions.html#xrange" title="xrange"><tt class="xref py py-func docutils literal">xrange()</tt></a> objects now have their own iterator, making <tt class="docutils literal">for i in
xrange(n)</tt> slightly faster than <tt class="docutils literal">for i in range(n)</tt>. (Patch by Raymond
Hettinger.)</li>
<li>A number of small rearrangements have been made in various hotspots to improve
performance, such as inlining a function or removing some code. (Implemented
mostly by GvR, but lots of people have contributed single changes.)</li>
</ul>
The net result of the 2.3 optimizations is that Python 2.3 runs the pystone
benchmark around 25% faster than Python 2.2.
</div>
</div>
<div class="section" id="new-improved-and-deprecated-modules">
<h2>New, Improved, and Deprecated Modules<a class="headerlink" href="#new-improved-and-deprecated-modules" title="Permalink to this headline">¶</a></h2>
As usual, Python&#8217;s standard library received a number of enhancements and bug
fixes. Here&#8217;s a partial list of the most notable changes, sorted alphabetically
by module name. Consult the <tt class="file docutils literal">Misc/NEWS</tt> file in the source tree for a more
complete list of changes, or look through the CVS logs for all the details.
<ul>
<li>The <a class="reference internal" href="../library/array.html#module-array" title="array: Space efficient arrays of uniformly typed numeric values."><tt class="xref py py-mod docutils literal">array</tt></a> module now supports arrays of Unicode characters using the
<tt class="docutils literal">'u'</tt> format character. Arrays also now support using the <tt class="docutils literal">+=</tt> assignment
operator to add another array&#8217;s contents, and the <tt class="docutils literal">*=</tt> assignment operator to
repeat an array. (Contributed by Jason Orendorff.)
</li>
<li>The <a class="reference internal" href="../library/bsddb.html#module-bsddb" title="bsddb: Interface to Berkeley DB database library"><tt class="xref py py-mod docutils literal">bsddb</tt></a> module has been replaced by version 4.1.6 of the <a class="reference external" href="http://pybsddb.sourceforge.net">PyBSDDB</a> package, providing a more complete interface
to the transactional features of the BerkeleyDB library.
The old version of the module has been renamed to <tt class="xref py py-mod docutils literal">bsddb185</tt> and is no
longer built automatically; you&#8217;ll have to edit <tt class="file docutils literal">Modules/Setup</tt> to enable
it. Note that the new <a class="reference internal" href="../library/bsddb.html#module-bsddb" title="bsddb: Interface to Berkeley DB database library"><tt class="xref py py-mod docutils literal">bsddb</tt></a> package is intended to be compatible with
the old module, so be sure to file bugs if you discover any incompatibilities.
When upgrading to Python 2.3, if the new interpreter is compiled with a new
version of the underlying BerkeleyDB library, you will almost certainly have to
convert your database files to the new version. You can do this fairly easily
with the new scripts <tt class="file docutils literal">db2pickle.py</tt> and <tt class="file docutils literal">pickle2db.py</tt> which you
will find in the distribution&#8217;s <tt class="file docutils literal">Tools/scripts</tt> directory. If you&#8217;ve
already been using the PyBSDDB package and importing it as <tt class="xref py py-mod docutils literal">bsddb3</tt>, you
will have to change your <tt class="docutils literal">import</tt> statements to import it as <a class="reference internal" href="../library/bsddb.html#module-bsddb" title="bsddb: Interface to Berkeley DB database library"><tt class="xref py py-mod docutils literal">bsddb</tt></a>.
</li>
<li>The new <a class="reference internal" href="../library/bz2.html#module-bz2" title="bz2: Interface to compression and decompression routines compatible with bzip2."><tt class="xref py py-mod docutils literal">bz2</tt></a> module is an interface to the bz2 data compression library.
bz2-compressed data is usually smaller than corresponding <a class="reference internal" href="../library/zlib.html#module-zlib" title="zlib: Low-level interface to compression and decompression routines compatible with gzip."><tt class="xref py py-mod docutils literal">zlib</tt></a>-compressed data. (Contributed by Gustavo Niemeyer.)
</li>
<li>A set of standard date/time types has been added in the new <a class="reference internal" href="../library/datetime.html#module-datetime" title="datetime: Basic date and time types."><tt class="xref py py-mod docutils literal">datetime</tt></a>
module. See the following section for more details.
</li>
<li>The Distutils <tt class="xref py py-class docutils literal">Extension</tt> class now supports an extra constructor
argument named depends for listing additional source files that an extension
depends on. This lets Distutils recompile the module if any of the dependency
files are modified. For example, if <tt class="file docutils literal">sampmodule.c</tt> includes the header
file <tt class="file docutils literal">sample.h</tt>, you would create the <tt class="xref py py-class docutils literal">Extension</tt> object like
this:
<div class="highlight-python"><div class="highlight"><pre>ext = Extension(&quot;samp&quot;,
 sources=[&quot;sampmodule.c&quot;],
 depends=[&quot;sample.h&quot;])
</pre></div>
</div>
Modifying <tt class="file docutils literal">sample.h</tt> would then cause the module to be recompiled.
(Contributed by Jeremy Hylton.)
</li>
<li>Other minor changes to Distutils: it now checks for the <tt class="xref std std-envvar docutils literal">CC</tt>,
<tt class="xref std std-envvar docutils literal">CFLAGS</tt>, <tt class="xref std std-envvar docutils literal">CPP</tt>, <tt class="xref std std-envvar docutils literal">LDFLAGS</tt>, and <tt class="xref std std-envvar docutils literal">CPPFLAGS</tt>
environment variables, using them to override the settings in Python&#8217;s
configuration (contributed by Robert Weber).
</li>
<li>Previously the <a class="reference internal" href="../library/doctest.html#module-doctest" title="doctest: Test pieces of code within docstrings."><tt class="xref py py-mod docutils literal">doctest</tt></a> module would only search the docstrings of
public methods and functions for test cases, but it now also examines private
ones as well. The <tt class="xref py py-func docutils literal">DocTestSuite(()</tt> function creates a
<a class="reference internal" href="../library/unittest.html#unittest.TestSuite" title="unittest.TestSuite"><tt class="xref py py-class docutils literal">unittest.TestSuite</tt></a> object from a set of <a class="reference internal" href="../library/doctest.html#module-doctest" title="doctest: Test pieces of code within docstrings."><tt class="xref py py-mod docutils literal">doctest</tt></a> tests.
</li>
<li>The new <tt class="xref py py-func docutils literal">gc.get_referents(object)()</tt> function returns a list of all the
objects referenced by object.
</li>
<li>The <a class="reference internal" href="../library/getopt.html#module-getopt" title="getopt: Portable parser for command line options; support both short and long option names."><tt class="xref py py-mod docutils literal">getopt</tt></a> module gained a new function, <tt class="xref py py-func docutils literal">gnu_getopt()</tt>, that
supports the same arguments as the existing <a class="reference internal" href="../library/getopt.html#module-getopt" title="getopt: Portable parser for command line options; support both short and long option names."><tt class="xref py py-func docutils literal">getopt()</tt></a> function but uses
GNU-style scanning mode. The existing <a class="reference internal" href="../library/getopt.html#module-getopt" title="getopt: Portable parser for command line options; support both short and long option names."><tt class="xref py py-func docutils literal">getopt()</tt></a> stops processing options as
soon as a non-option argument is encountered, but in GNU-style mode processing
continues, meaning that options and arguments can be mixed. For example:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; getopt.getopt([&#39;-f&#39;, &#39;filename&#39;, &#39;output&#39;, &#39;-v&#39;], &#39;f:v&#39;)
([(&#39;-f&#39;, &#39;filename&#39;)], [&#39;output&#39;, &#39;-v&#39;])
&gt;&gt;&gt; getopt.gnu_getopt([&#39;-f&#39;, &#39;filename&#39;, &#39;output&#39;, &#39;-v&#39;], &#39;f:v&#39;)
([(&#39;-f&#39;, &#39;filename&#39;), (&#39;-v&#39;, &#39;&#39;)], [&#39;output&#39;])
</pre></div>
</div>
(Contributed by Peter Åstrand.)
</li>
<li>The <a class="reference internal" href="../library/grp.html#module-grp" title="grp: The group database (getgrnam() and friends). (Unix)"><tt class="xref py py-mod docutils literal">grp</tt></a>, <a class="reference internal" href="../library/pwd.html#module-pwd" title="pwd: The password database (getpwnam() and friends). (Unix)"><tt class="xref py py-mod docutils literal">pwd</tt></a>, and <a class="reference internal" href="../library/resource.html#module-resource" title="resource: An interface to provide resource usage information on the current process. (Unix)"><tt class="xref py py-mod docutils literal">resource</tt></a> modules now return enhanced
tuples:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import grp
&gt;&gt;&gt; g = grp.getgrnam(&#39;amk&#39;)
&gt;&gt;&gt; g.gr_name, g.gr_gid
(&#39;amk&#39;, 500)
</pre></div>
</div>
</li>
<li>The <a class="reference internal" href="../library/gzip.html#module-gzip" title="gzip: Interfaces for gzip compression and decompression using file objects."><tt class="xref py py-mod docutils literal">gzip</tt></a> module can now handle files exceeding 2 GiB.
</li>
<li>The new <a class="reference internal" href="../library/heapq.html#module-heapq" title="heapq: Heap queue algorithm (a.k.a. priority queue)."><tt class="xref py py-mod docutils literal">heapq</tt></a> module contains an implementation of a heap queue
algorithm. A heap is an array-like data structure that keeps items in a
partially sorted order such that, for every index k, <tt class="docutils literal">heap[k] &lt;=
heap[2*k+1]</tt> and <tt class="docutils literal">heap[k] &lt;= heap[2*k+2]</tt>. This makes it quick to remove the
smallest item, and inserting a new item while maintaining the heap property is
O(lg n). (See <a class="reference external" href="http://www.nist.gov/dads/HTML/priorityque.html">http://www.nist.gov/dads/HTML/priorityque.html</a> for more
information about the priority queue data structure.)
The <a class="reference internal" href="../library/heapq.html#module-heapq" title="heapq: Heap queue algorithm (a.k.a. priority queue)."><tt class="xref py py-mod docutils literal">heapq</tt></a> module provides <tt class="xref py py-func docutils literal">heappush()</tt> and <tt class="xref py py-func docutils literal">heappop()</tt> functions
for adding and removing items while maintaining the heap property on top of some
other mutable Python sequence type. Here&#8217;s an example that uses a Python list:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import heapq
&gt;&gt;&gt; heap = []
&gt;&gt;&gt; for item in [3, 7, 5, 11, 1]:
... heapq.heappush(heap, item)
...
&gt;&gt;&gt; heap
[1, 3, 5, 11, 7]
&gt;&gt;&gt; heapq.heappop(heap)
1
&gt;&gt;&gt; heapq.heappop(heap)
3
&gt;&gt;&gt; heap
[5, 7, 11]
</pre></div>
</div>
(Contributed by Kevin O&#8217;Connor.)
</li>
<li>The IDLE integrated development environment has been updated using the code
from the IDLEfork project (<a class="reference external" href="http://idlefork.sf.net">http://idlefork.sf.net</a>). The most notable feature is
that the code being developed is now executed in a subprocess, meaning that
there&#8217;s no longer any need for manual <tt class="docutils literal">reload()</tt> operations. IDLE&#8217;s core code
has been incorporated into the standard library as the <tt class="xref py py-mod docutils literal">idlelib</tt> package.
</li>
<li>The <a class="reference internal" href="../library/imaplib.html#module-imaplib" title="imaplib: IMAP4 protocol client (requires sockets)."><tt class="xref py py-mod docutils literal">imaplib</tt></a> module now supports IMAP over SSL. (Contributed by Piers
Lauder and Tino Lange.)
</li>
<li>The <a class="reference internal" href="../library/itertools.html#module-itertools" title="itertools: Functions creating iterators for efficient looping."><tt class="xref py py-mod docutils literal">itertools</tt></a> contains a number of useful functions for use with
iterators, inspired by various functions provided by the ML and Haskell
languages. For example, <tt class="docutils literal">itertools.ifilter(predicate, iterator)</tt> returns all
elements in the iterator for which the function <tt class="xref py py-func docutils literal">predicate()</tt> returns
<a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a>, and <tt class="docutils literal">itertools.repeat(obj, N)</tt> returns <tt class="docutils literal">obj</tt> N times.
There are a number of other functions in the module; see the package&#8217;s reference
documentation for details.
(Contributed by Raymond Hettinger.)
</li>
<li>Two new functions in the <a class="reference internal" href="../library/math.html#module-math" title="math: Mathematical functions (sin() etc.)."><tt class="xref py py-mod docutils literal">math</tt></a> module, <tt class="xref py py-func docutils literal">degrees(rads)()</tt> and
<tt class="xref py py-func docutils literal">radians(degs)()</tt>, convert between radians and degrees. Other functions in
the <a class="reference internal" href="../library/math.html#module-math" title="math: Mathematical functions (sin() etc.)."><tt class="xref py py-mod docutils literal">math</tt></a> module such as <a class="reference internal" href="../library/math.html#math.sin" title="math.sin"><tt class="xref py py-func docutils literal">math.sin()</tt></a> and <a class="reference internal" href="../library/math.html#math.cos" title="math.cos"><tt class="xref py py-func docutils literal">math.cos()</tt></a> have always
required input values measured in radians. Also, an optional base argument
was added to <a class="reference internal" href="../library/math.html#math.log" title="math.log"><tt class="xref py py-func docutils literal">math.log()</tt></a> to make it easier to compute logarithms for bases
other than <tt class="docutils literal">e</tt> and <tt class="docutils literal">10</tt>. (Contributed by Raymond Hettinger.)
</li>
<li>Several new POSIX functions (<tt class="xref py py-func docutils literal">getpgid()</tt>, <tt class="xref py py-func docutils literal">killpg()</tt>, <tt class="xref py py-func docutils literal">lchown()</tt>,
<tt class="xref py py-func docutils literal">loadavg()</tt>, <tt class="xref py py-func docutils literal">major()</tt>, <tt class="xref py py-func docutils literal">makedev()</tt>, <tt class="xref py py-func docutils literal">minor()</tt>, and
<tt class="xref py py-func docutils literal">mknod()</tt>) were added to the <a class="reference internal" href="../library/posix.html#module-posix" title="posix: The most common POSIX system calls (normally used via module os). (Unix)"><tt class="xref py py-mod docutils literal">posix</tt></a> module that underlies the
<a class="reference internal" href="../library/os.html#module-os" title="os: Miscellaneous operating system interfaces."><tt class="xref py py-mod docutils literal">os</tt></a> module. (Contributed by Gustavo Niemeyer, Geert Jansen, and Denis S.
Otkidach.)
</li>
<li>In the <a class="reference internal" href="../library/os.html#module-os" title="os: Miscellaneous operating system interfaces."><tt class="xref py py-mod docutils literal">os</tt></a> module, the <tt class="xref py py-func docutils literal">*stat()</tt> family of functions can now report
fractions of a second in a timestamp. Such time stamps are represented as
floats, similar to the value returned by <a class="reference internal" href="../library/time.html#time.time" title="time.time"><tt class="xref py py-func docutils literal">time.time()</tt></a>.
During testing, it was found that some applications will break if time stamps
are floats. For compatibility, when using the tuple interface of the
<tt class="xref py py-class docutils literal">stat_result</tt> time stamps will be represented as integers. When using
named fields (a feature first introduced in Python 2.2), time stamps are still
represented as integers, unless <a class="reference internal" href="../library/os.html#os.stat_float_times" title="os.stat_float_times"><tt class="xref py py-func docutils literal">os.stat_float_times()</tt></a> is invoked to enable
float return values:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; os.stat(&quot;/tmp&quot;).st_mtime
1034791200
&gt;&gt;&gt; os.stat_float_times(True)
&gt;&gt;&gt; os.stat(&quot;/tmp&quot;).st_mtime
1034791200.6335014
</pre></div>
</div>
In Python 2.4, the default will change to always returning floats.
Application developers should enable this feature only if all their libraries
work properly when confronted with floating point time stamps, or if they use
the tuple API. If used, the feature should be activated on an application level
instead of trying to enable it on a per-use basis.
</li>
<li>The <a class="reference internal" href="../library/optparse.html#module-optparse" title="optparse: Command-line option parsing library. (deprecated)"><tt class="xref py py-mod docutils literal">optparse</tt></a> module contains a new parser for command-line arguments
that can convert option values to a particular Python type and will
automatically generate a usage message. See the following section for more
details.
</li>
<li>The old and never-documented <tt class="xref py py-mod docutils literal">linuxaudiodev</tt> module has been deprecated,
and a new version named <a class="reference internal" href="../library/ossaudiodev.html#module-ossaudiodev" title="ossaudiodev: Access to OSS-compatible audio devices. (Linux, FreeBSD)"><tt class="xref py py-mod docutils literal">ossaudiodev</tt></a> has been added. The module was
renamed because the OSS sound drivers can be used on platforms other than Linux,
and the interface has also been tidied and brought up to date in various ways.
(Contributed by Greg Ward and Nicholas FitzRoy-Dale.)
</li>
<li>The new <a class="reference internal" href="../library/platform.html#module-platform" title="platform: Retrieves as much platform identifying data as possible."><tt class="xref py py-mod docutils literal">platform</tt></a> module contains a number of functions that try to
determine various properties of the platform you&#8217;re running on. There are
functions for getting the architecture, CPU type, the Windows OS version, and
even the Linux distribution version. (Contributed by Marc-André Lemburg.)
</li>
<li>The parser objects provided by the <tt class="xref py py-mod docutils literal">pyexpat</tt> module can now optionally
buffer character data, resulting in fewer calls to your character data handler
and therefore faster performance. Setting the parser object&#8217;s
<tt class="xref py py-attr docutils literal">buffer_text</tt> attribute to <a class="reference internal" href="../library/constants.html#True" title="True"><tt class="xref py py-const docutils literal">True</tt></a> will enable buffering.
</li>
<li>The <tt class="xref py py-func docutils literal">sample(population, k)()</tt> function was added to the <a class="reference internal" href="../library/random.html#module-random" title="random: Generate pseudo-random numbers with various common distributions."><tt class="xref py py-mod docutils literal">random</tt></a>
module. population is a sequence or <a class="reference internal" href="../library/functions.html#xrange" title="xrange"><tt class="xref py py-class docutils literal">xrange</tt></a> object containing the
elements of a population, and <tt class="xref py py-func docutils literal">sample()</tt> chooses k elements from the
population without replacing chosen elements. k can be any value up to
<tt class="docutils literal">len(population)</tt>. For example:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; days = [&#39;Mo&#39;, &#39;Tu&#39;, &#39;We&#39;, &#39;Th&#39;, &#39;Fr&#39;, &#39;St&#39;, &#39;Sn&#39;]
&gt;&gt;&gt; random.sample(days, 3) # Choose 3 elements
[&#39;St&#39;, &#39;Sn&#39;, &#39;Th&#39;]
&gt;&gt;&gt; random.sample(days, 7) # Choose 7 elements
[&#39;Tu&#39;, &#39;Th&#39;, &#39;Mo&#39;, &#39;We&#39;, &#39;St&#39;, &#39;Fr&#39;, &#39;Sn&#39;]
&gt;&gt;&gt; random.sample(days, 7) # Choose 7 again
[&#39;We&#39;, &#39;Mo&#39;, &#39;Sn&#39;, &#39;Fr&#39;, &#39;Tu&#39;, &#39;St&#39;, &#39;Th&#39;]
&gt;&gt;&gt; random.sample(days, 8) # Can&#39;t choose eight
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in ?
 File &quot;random.py&quot;, line 414, in sample
 raise ValueError, &quot;sample larger than population&quot;
ValueError: sample larger than population
&gt;&gt;&gt; random.sample(xrange(1,10000,2), 10) # Choose ten odd nos. under 10000
[3407, 3805, 1505, 7023, 2401, 2267, 9733, 3151, 8083, 9195]
</pre></div>
</div>
The <a class="reference internal" href="../library/random.html#module-random" title="random: Generate pseudo-random numbers with various common distributions."><tt class="xref py py-mod docutils literal">random</tt></a> module now uses a new algorithm, the Mersenne Twister,
implemented in C. It&#8217;s faster and more extensively studied than the previous
algorithm.
(All changes contributed by Raymond Hettinger.)
</li>
<li>The <a class="reference internal" href="../library/readline.html#module-readline" title="readline: GNU readline support for Python. (Unix)"><tt class="xref py py-mod docutils literal">readline</tt></a> module also gained a number of new functions:
<tt class="xref py py-func docutils literal">get_history_item()</tt>, <tt class="xref py py-func docutils literal">get_current_history_length()</tt>, and
<tt class="xref py py-func docutils literal">redisplay()</tt>.
</li>
<li>The <a class="reference internal" href="../library/rexec.html#module-rexec" title="rexec: Basic restricted execution framework. (deprecated)"><tt class="xref py py-mod docutils literal">rexec</tt></a> and <a class="reference internal" href="../library/bastion.html#module-Bastion" title="Bastion: Providing restricted access to objects. (deprecated)"><tt class="xref py py-mod docutils literal">Bastion</tt></a> modules have been declared dead, and
attempts to import them will fail with a <a class="reference internal" href="../library/exceptions.html#exceptions.RuntimeError" title="exceptions.RuntimeError"><tt class="xref py py-exc docutils literal">RuntimeError</tt></a>. New-style classes
provide new ways to break out of the restricted execution environment provided
by <a class="reference internal" href="../library/rexec.html#module-rexec" title="rexec: Basic restricted execution framework. (deprecated)"><tt class="xref py py-mod docutils literal">rexec</tt></a>, and no one has interest in fixing them or time to do so. If
you have applications using <a class="reference internal" href="../library/rexec.html#module-rexec" title="rexec: Basic restricted execution framework. (deprecated)"><tt class="xref py py-mod docutils literal">rexec</tt></a>, rewrite them to use something else.
(Sticking with Python 2.2 or 2.1 will not make your applications any safer
because there are known bugs in the <a class="reference internal" href="../library/rexec.html#module-rexec" title="rexec: Basic restricted execution framework. (deprecated)"><tt class="xref py py-mod docutils literal">rexec</tt></a> module in those versions. To
repeat: if you&#8217;re using <a class="reference internal" href="../library/rexec.html#module-rexec" title="rexec: Basic restricted execution framework. (deprecated)"><tt class="xref py py-mod docutils literal">rexec</tt></a>, stop using it immediately.)
</li>
<li>The <tt class="xref py py-mod docutils literal">rotor</tt> module has been deprecated because the algorithm it uses for
encryption is not believed to be secure. If you need encryption, use one of the
several AES Python modules that are available separately.
</li>
<li>The <a class="reference internal" href="../library/shutil.html#module-shutil" title="shutil: High-level file operations, including copying."><tt class="xref py py-mod docutils literal">shutil</tt></a> module gained a <tt class="xref py py-func docutils literal">move(src, dest)()</tt> function that
recursively moves a file or directory to a new location.
</li>
<li>Support for more advanced POSIX signal handling was added to the <a class="reference internal" href="../library/signal.html#module-signal" title="signal: Set handlers for asynchronous events."><tt class="xref py py-mod docutils literal">signal</tt></a>
but then removed again as it proved impossible to make it work reliably across
platforms.
</li>
<li>The <a class="reference internal" href="../library/socket.html#module-socket" title="socket: Low-level networking interface."><tt class="xref py py-mod docutils literal">socket</tt></a> module now supports timeouts. You can call the
<tt class="xref py py-meth docutils literal">settimeout(t)()</tt> method on a socket object to set a timeout of t seconds.
Subsequent socket operations that take longer than t seconds to complete will
abort and raise a <a class="reference internal" href="../library/socket.html#socket.timeout" title="socket.timeout"><tt class="xref py py-exc docutils literal">socket.timeout</tt></a> exception.
The original timeout implementation was by Tim O&#8217;Malley. Michael Gilfix
integrated it into the Python <a class="reference internal" href="../library/socket.html#module-socket" title="socket: Low-level networking interface."><tt class="xref py py-mod docutils literal">socket</tt></a> module and shepherded it through a
lengthy review. After the code was checked in, Guido van Rossum rewrote parts
of it. (This is a good example of a collaborative development process in
action.)
</li>
<li>On Windows, the <a class="reference internal" href="../library/socket.html#module-socket" title="socket: Low-level networking interface."><tt class="xref py py-mod docutils literal">socket</tt></a> module now ships with Secure Sockets Layer
(SSL) support.
</li>
<li>The value of the C <tt class="xref py py-const docutils literal">PYTHON_API_VERSION</tt> macro is now exposed at the
Python level as <tt class="docutils literal">sys.api_version</tt>. The current exception can be cleared by
calling the new <a class="reference internal" href="../library/sys.html#sys.exc_clear" title="sys.exc_clear"><tt class="xref py py-func docutils literal">sys.exc_clear()</tt></a> function.
</li>
<li>The new <a class="reference internal" href="../library/tarfile.html#module-tarfile" title="tarfile: Read and write tar-format archive files."><tt class="xref py py-mod docutils literal">tarfile</tt></a> module allows reading from and writing to
tar-format archive files. (Contributed by Lars Gustäbel.)
</li>
<li>The new <a class="reference internal" href="../library/textwrap.html#module-textwrap" title="textwrap: Text wrapping and filling"><tt class="xref py py-mod docutils literal">textwrap</tt></a> module contains functions for wrapping strings
containing paragraphs of text. The <tt class="xref py py-func docutils literal">wrap(text, width)()</tt> function takes a
string and returns a list containing the text split into lines of no more than
the chosen width. The <tt class="xref py py-func docutils literal">fill(text, width)()</tt> function returns a single
string, reformatted to fit into lines no longer than the chosen width. (As you
can guess, <tt class="xref py py-func docutils literal">fill()</tt> is built on top of <tt class="xref py py-func docutils literal">wrap()</tt>. For example:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import textwrap
&gt;&gt;&gt; paragraph = &quot;Not a whit, we defy augury: ... more text ...&quot;
&gt;&gt;&gt; textwrap.wrap(paragraph, 60)
[&quot;Not a whit, we defy augury: there&#39;s a special providence in&quot;,
 &quot;the fall of a sparrow. If it be now, &#39;tis not to come; if it&quot;,
 ...]
&gt;&gt;&gt; print textwrap.fill(paragraph, 35)
Not a whit, we defy augury: there&#39;s
a special providence in the fall of
a sparrow. If it be now, &#39;tis not
to come; if it be not to come, it
will be now; if it be not now, yet
it will come: the readiness is all.
&gt;&gt;&gt;
</pre></div>
</div>
The module also contains a <tt class="xref py py-class docutils literal">TextWrapper</tt> class that actually implements
the text wrapping strategy. Both the <tt class="xref py py-class docutils literal">TextWrapper</tt> class and the
<tt class="xref py py-func docutils literal">wrap()</tt> and <tt class="xref py py-func docutils literal">fill()</tt> functions support a number of additional keyword
arguments for fine-tuning the formatting; consult the module&#8217;s documentation
for details. (Contributed by Greg Ward.)
</li>
<li>The <a class="reference internal" href="../library/thread.html#module-thread" title="thread: Create multiple threads of control within one interpreter."><tt class="xref py py-mod docutils literal">thread</tt></a> and <a class="reference internal" href="../library/threading.html#module-threading" title="threading: Higher-level threading interface."><tt class="xref py py-mod docutils literal">threading</tt></a> modules now have companion modules,
<a class="reference internal" href="../library/dummy_thread.html#module-dummy_thread" title="dummy_thread: Drop-in replacement for the thread module."><tt class="xref py py-mod docutils literal">dummy_thread</tt></a> and <a class="reference internal" href="../library/dummy_threading.html#module-dummy_threading" title="dummy_threading: Drop-in replacement for the threading module."><tt class="xref py py-mod docutils literal">dummy_threading</tt></a>, that provide a do-nothing
implementation of the <a class="reference internal" href="../library/thread.html#module-thread" title="thread: Create multiple threads of control within one interpreter."><tt class="xref py py-mod docutils literal">thread</tt></a> module&#8217;s interface for platforms where
threads are not supported. The intention is to simplify thread-aware modules
(ones that don&#8217;t rely on threads to run) by putting the following code at the
top:
<div class="highlight-python"><div class="highlight"><pre>try:
 import threading as _threading
except ImportError:
 import dummy_threading as _threading
</pre></div>
</div>
In this example, <tt class="xref py py-mod docutils literal">_threading</tt> is used as the module name to make it clear
that the module being used is not necessarily the actual <a class="reference internal" href="../library/threading.html#module-threading" title="threading: Higher-level threading interface."><tt class="xref py py-mod docutils literal">threading</tt></a>
module. Code can call functions and use classes in <tt class="xref py py-mod docutils literal">_threading</tt> whether or
not threads are supported, avoiding an <a class="reference internal" href="../reference/compound_stmts.html#if"><tt class="xref std std-keyword docutils literal">if</tt></a> statement and making the
code slightly clearer. This module will not magically make multithreaded code
run without threads; code that waits for another thread to return or to do
something will simply hang forever.
</li>
<li>The <a class="reference internal" href="../library/time.html#module-time" title="time: Time access and conversions."><tt class="xref py py-mod docutils literal">time</tt></a> module&#8217;s <tt class="xref py py-func docutils literal">strptime()</tt> function has long been an annoyance
because it uses the platform C library&#8217;s <tt class="xref py py-func docutils literal">strptime()</tt> implementation, and
different platforms sometimes have odd bugs. Brett Cannon contributed a
portable implementation that&#8217;s written in pure Python and should behave
identically on all platforms.
</li>
<li>The new <a class="reference internal" href="../library/timeit.html#module-timeit" title="timeit: Measure the execution time of small code snippets."><tt class="xref py py-mod docutils literal">timeit</tt></a> module helps measure how long snippets of Python code
take to execute. The <tt class="file docutils literal">timeit.py</tt> file can be run directly from the
command line, or the module&#8217;s <tt class="xref py py-class docutils literal">Timer</tt> class can be imported and used
directly. Here&#8217;s a short example that figures out whether it&#8217;s faster to
convert an 8-bit string to Unicode by appending an empty Unicode string to it or
by using the <a class="reference internal" href="../library/functions.html#unicode" title="unicode"><tt class="xref py py-func docutils literal">unicode()</tt></a> function:
<div class="highlight-python"><div class="highlight"><pre>import timeit

timer1 = timeit.Timer(&#39;unicode(&quot;abc&quot;)&#39;)
timer2 = timeit.Timer(&#39;&quot;abc&quot; + u&quot;&quot;&#39;)

# Run three trials
print timer1.repeat(repeat=3, number=100000)
print timer2.repeat(repeat=3, number=100000)

# On my laptop this outputs:
# [0.36831796169281006, 0.37441694736480713, 0.35304892063140869]
# [0.17574405670166016, 0.18193507194519043, 0.17565798759460449]
</pre></div>
</div>
</li>
<li>The <a class="reference internal" href="../library/tix.html#module-Tix" title="Tix: Tk Extension Widgets for Tkinter"><tt class="xref py py-mod docutils literal">Tix</tt></a> module has received various bug fixes and updates for the
current version of the Tix package.
</li>
<li>The <a class="reference internal" href="../library/tkinter.html#module-Tkinter" title="Tkinter: Interface to Tcl/Tk for graphical user interfaces"><tt class="xref py py-mod docutils literal">Tkinter</tt></a> module now works with a thread-enabled version of Tcl.
Tcl&#8217;s threading model requires that widgets only be accessed from the thread in
which they&#8217;re created; accesses from another thread can cause Tcl to panic. For
certain Tcl interfaces, <a class="reference internal" href="../library/tkinter.html#module-Tkinter" title="Tkinter: Interface to Tcl/Tk for graphical user interfaces"><tt class="xref py py-mod docutils literal">Tkinter</tt></a> will now automatically avoid this when a
widget is accessed from a different thread by marshalling a command, passing it
to the correct thread, and waiting for the results. Other interfaces can&#8217;t be
handled automatically but <a class="reference internal" href="../library/tkinter.html#module-Tkinter" title="Tkinter: Interface to Tcl/Tk for graphical user interfaces"><tt class="xref py py-mod docutils literal">Tkinter</tt></a> will now raise an exception on such an
access so that you can at least find out about the problem. See
<a class="reference external" href="http://mail.python.org/pipermail/python-dev/2002-December/031107.html">http://mail.python.org/pipermail/python-dev/2002-December/031107.html</a> for a more
detailed explanation of this change. (Implemented by Martin von Löwis.)
</li>
<li>Calling Tcl methods through <tt class="xref py py-mod docutils literal">_tkinter</tt> no longer returns only strings.
Instead, if Tcl returns other objects those objects are converted to their
Python equivalent, if one exists, or wrapped with a <tt class="xref py py-class docutils literal">_tkinter.Tcl_Obj</tt>
object if no Python equivalent exists. This behavior can be controlled through
the <tt class="xref py py-meth docutils literal">wantobjects()</tt> method of <tt class="xref py py-class docutils literal">tkapp</tt> objects.
When using <tt class="xref py py-mod docutils literal">_tkinter</tt> through the <a class="reference internal" href="../library/tkinter.html#module-Tkinter" title="Tkinter: Interface to Tcl/Tk for graphical user interfaces"><tt class="xref py py-mod docutils literal">Tkinter</tt></a> module (as most Tkinter
applications will), this feature is always activated. It should not cause
compatibility problems, since Tkinter would always convert string results to
Python types where possible.
If any incompatibilities are found, the old behavior can be restored by setting
the <tt class="xref py py-attr docutils literal">wantobjects</tt> variable in the <a class="reference internal" href="../library/tkinter.html#module-Tkinter" title="Tkinter: Interface to Tcl/Tk for graphical user interfaces"><tt class="xref py py-mod docutils literal">Tkinter</tt></a> module to false before
creating the first <tt class="xref py py-class docutils literal">tkapp</tt> object.
<div class="highlight-python"><div class="highlight"><pre>import Tkinter
Tkinter.wantobjects = 0
</pre></div>
</div>
Any breakage caused by this change should be reported as a bug.
</li>
<li>The <a class="reference internal" href="../library/userdict.html#module-UserDict" title="UserDict: Class wrapper for dictionary objects."><tt class="xref py py-mod docutils literal">UserDict</tt></a> module has a new <tt class="xref py py-class docutils literal">DictMixin</tt> class which defines
all dictionary methods for classes that already have a minimum mapping
interface. This greatly simplifies writing classes that need to be
substitutable for dictionaries, such as the classes in the <a class="reference internal" href="../library/shelve.html#module-shelve" title="shelve: Python object persistence."><tt class="xref py py-mod docutils literal">shelve</tt></a>
module.
Adding the mix-in as a superclass provides the full dictionary interface
whenever the class defines <a class="reference internal" href="../reference/datamodel.html#object.__getitem__" title="object.__getitem__"><tt class="xref py py-meth docutils literal">__getitem__()</tt></a>, <a class="reference internal" href="../reference/datamodel.html#object.__setitem__" title="object.__setitem__"><tt class="xref py py-meth docutils literal">__setitem__()</tt></a>,
<a class="reference internal" href="../reference/datamodel.html#object.__delitem__" title="object.__delitem__"><tt class="xref py py-meth docutils literal">__delitem__()</tt></a>, and <tt class="xref py py-meth docutils literal">keys()</tt>. For example:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import UserDict
&gt;&gt;&gt; class SeqDict(UserDict.DictMixin):
... &quot;&quot;&quot;Dictionary lookalike implemented with lists.&quot;&quot;&quot;
... def __init__(self):
... self.keylist = []
... self.valuelist = []
... def __getitem__(self, key):
... try:
... i = self.keylist.index(key)
... except ValueError:
... raise KeyError
... return self.valuelist[i]
... def __setitem__(self, key, value):
... try:
... i = self.keylist.index(key)
... self.valuelist[i] = value
... except ValueError:
... self.keylist.append(key)
... self.valuelist.append(value)
... def __delitem__(self, key):
... try:
... i = self.keylist.index(key)
... except ValueError:
... raise KeyError
... self.keylist.pop(i)
... self.valuelist.pop(i)
... def keys(self):
... return list(self.keylist)
...
&gt;&gt;&gt; s = SeqDict()
&gt;&gt;&gt; dir(s) # See that other dictionary methods are implemented
[&#39;__cmp__&#39;, &#39;__contains__&#39;, &#39;__delitem__&#39;, &#39;__doc__&#39;, &#39;__getitem__&#39;,
 &#39;__init__&#39;, &#39;__iter__&#39;, &#39;__len__&#39;, &#39;__module__&#39;, &#39;__repr__&#39;,
 &#39;__setitem__&#39;, &#39;clear&#39;, &#39;get&#39;, &#39;has_key&#39;, &#39;items&#39;, &#39;iteritems&#39;,
 &#39;iterkeys&#39;, &#39;itervalues&#39;, &#39;keylist&#39;, &#39;keys&#39;, &#39;pop&#39;, &#39;popitem&#39;,
 &#39;setdefault&#39;, &#39;update&#39;, &#39;valuelist&#39;, &#39;values&#39;]
</pre></div>
</div>
(Contributed by Raymond Hettinger.)
</li>
<li>The DOM implementation in <a class="reference internal" href="../library/xml.dom.minidom.html#module-xml.dom.minidom" title="xml.dom.minidom: Minimal Document Object Model (DOM) implementation."><tt class="xref py py-mod docutils literal">xml.dom.minidom</tt></a> can now generate XML output
in a particular encoding by providing an optional encoding argument to the
<tt class="xref py py-meth docutils literal">toxml()</tt> and <tt class="xref py py-meth docutils literal">toprettyxml()</tt> methods of DOM nodes.
</li>
<li>The <a class="reference internal" href="../library/xmlrpclib.html#module-xmlrpclib" title="xmlrpclib: XML-RPC client access."><tt class="xref py py-mod docutils literal">xmlrpclib</tt></a> module now supports an XML-RPC extension for handling nil
data values such as Python&#8217;s <tt class="docutils literal">None</tt>. Nil values are always supported on
unmarshalling an XML-RPC response. To generate requests containing <tt class="docutils literal">None</tt>,
you must supply a true value for the allow_none parameter when creating a
<tt class="xref py py-class docutils literal">Marshaller</tt> instance.
</li>
<li>The new <a class="reference internal" href="../library/docxmlrpcserver.html#module-DocXMLRPCServer" title="DocXMLRPCServer: Self-documenting XML-RPC server implementation."><tt class="xref py py-mod docutils literal">DocXMLRPCServer</tt></a> module allows writing self-documenting XML-RPC
servers. Run it in demo mode (as a program) to see it in action. Pointing the
Web browser to the RPC server produces pydoc-style documentation; pointing
xmlrpclib to the server allows invoking the actual methods. (Contributed by
Brian Quinlan.)
</li>
<li>Support for internationalized domain names (RFCs 3454, 3490, 3491, and 3492)
has been added. The &#8220;idna&#8221; encoding can be used to convert between a Unicode
domain name and the ASCII-compatible encoding (ACE) of that name.
<div class="highlight-python"><pre>&gt;{}&gt;{}&gt; u"www.Alliancefrançaise.nu".encode("idna")
'www.xn--alliancefranaise-npb.nu'</pre>
</div>
The <a class="reference internal" href="../library/socket.html#module-socket" title="socket: Low-level networking interface."><tt class="xref py py-mod docutils literal">socket</tt></a> module has also been extended to transparently convert
Unicode hostnames to the ACE version before passing them to the C library.
Modules that deal with hostnames such as <a class="reference internal" href="../library/httplib.html#module-httplib" title="httplib: HTTP and HTTPS protocol client (requires sockets)."><tt class="xref py py-mod docutils literal">httplib</tt></a> and <a class="reference internal" href="../library/ftplib.html#module-ftplib" title="ftplib: FTP protocol client (requires sockets)."><tt class="xref py py-mod docutils literal">ftplib</tt></a>)
also support Unicode host names; <a class="reference internal" href="../library/httplib.html#module-httplib" title="httplib: HTTP and HTTPS protocol client (requires sockets)."><tt class="xref py py-mod docutils literal">httplib</tt></a> also sends HTTP <tt class="docutils literal">Host</tt>
headers using the ACE version of the domain name. <a class="reference internal" href="../library/urllib.html#module-urllib" title="urllib: Open an arbitrary network resource by URL (requires sockets)."><tt class="xref py py-mod docutils literal">urllib</tt></a> supports
Unicode URLs with non-ASCII host names as long as the <tt class="docutils literal">path</tt> part of the URL
is ASCII only.
To implement this change, the <a class="reference internal" href="../library/stringprep.html#module-stringprep" title="stringprep: String preparation, as per RFC 3453 (deprecated)"><tt class="xref py py-mod docutils literal">stringprep</tt></a> module, the <tt class="docutils literal">mkstringprep</tt>
tool and the <tt class="docutils literal">punycode</tt> encoding have been added.
</li>
</ul>
<div class="section" id="date-time-type">
<h3>Date/Time Type<a class="headerlink" href="#date-time-type" title="Permalink to this headline">¶</a></h3>
Date and time types suitable for expressing timestamps were added as the
<a class="reference internal" href="../library/datetime.html#module-datetime" title="datetime: Basic date and time types."><tt class="xref py py-mod docutils literal">datetime</tt></a> module. The types don&#8217;t support different calendars or many
fancy features, and just stick to the basics of representing time.
The three primary types are: <tt class="xref py py-class docutils literal">date</tt>, representing a day, month, and year;
<a class="reference internal" href="../library/time.html#module-time" title="time: Time access and conversions."><tt class="xref py py-class docutils literal">time</tt></a>, consisting of hour, minute, and second; and <a class="reference internal" href="../library/datetime.html#module-datetime" title="datetime: Basic date and time types."><tt class="xref py py-class docutils literal">datetime</tt></a>,
which contains all the attributes of both <tt class="xref py py-class docutils literal">date</tt> and <a class="reference internal" href="../library/time.html#module-time" title="time: Time access and conversions."><tt class="xref py py-class docutils literal">time</tt></a>.
There&#8217;s also a <tt class="xref py py-class docutils literal">timedelta</tt> class representing differences between two
points in time, and time zone logic is implemented by classes inheriting from
the abstract <tt class="xref py py-class docutils literal">tzinfo</tt> class.
You can create instances of <tt class="xref py py-class docutils literal">date</tt> and <a class="reference internal" href="../library/time.html#module-time" title="time: Time access and conversions."><tt class="xref py py-class docutils literal">time</tt></a> by either supplying
keyword arguments to the appropriate constructor, e.g.
<tt class="docutils literal">datetime.date(year=1972, month=10, day=15)</tt>, or by using one of a number of
class methods. For example, the <tt class="xref py py-meth docutils literal">date.today()</tt> class method returns the
current local date.
Once created, instances of the date/time classes are all immutable. There are a
number of methods for producing formatted strings from objects:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; import datetime
&gt;&gt;&gt; now = datetime.datetime.now()
&gt;&gt;&gt; now.isoformat()
&#39;2002-12-30T21:27:03.994956&#39;
&gt;&gt;&gt; now.ctime() # Only available on date, datetime
&#39;Mon Dec 30 21:27:03 2002&#39;
&gt;&gt;&gt; now.strftime(&#39;%Y %d %b&#39;)
&#39;2002 30 Dec&#39;
</pre></div>
</div>
The <tt class="xref py py-meth docutils literal">replace()</tt> method allows modifying one or more fields of a
<tt class="xref py py-class docutils literal">date</tt> or <a class="reference internal" href="../library/datetime.html#module-datetime" title="datetime: Basic date and time types."><tt class="xref py py-class docutils literal">datetime</tt></a> instance, returning a new instance:
<div class="highlight-python"><div class="highlight"><pre>&gt;&gt;&gt; d = datetime.datetime.now()
&gt;&gt;&gt; d
datetime.datetime(2002, 12, 30, 22, 15, 38, 827738)
&gt;&gt;&gt; d.replace(year=2001, hour = 12)
datetime.datetime(2001, 12, 30, 12, 15, 38, 827738)
&gt;&gt;&gt;
</pre></div>
</div>
Instances can be compared, hashed, and converted to strings (the result is the
same as that of <tt class="xref py py-meth docutils literal">isoformat()</tt>). <tt class="xref py py-class docutils literal">date</tt> and <a class="reference internal" href="../library/datetime.html#module-datetime" title="datetime: Basic date and time types."><tt class="xref py py-class docutils literal">datetime</tt></a>
instances can be subtracted from each other, and added to <tt class="xref py py-class docutils literal">timedelta</tt>
instances. The largest missing feature is that there&#8217;s no standard library
support for parsing strings and getting back a <tt class="xref py py-class docutils literal">date</tt> or
<a class="reference internal" href="../library/datetime.html#module-datetime" title="datetime: Basic date and time types."><tt class="xref py py-class docutils literal">datetime</tt></a>.
For more information, refer to the module&#8217;s reference documentation.
(Contributed by Tim Peters.)
</div>
<div class="section" id="the-optparse-module">
<h3>The optparse Module<a class="headerlink" href="#the-optparse-module" title="Permalink to this headline">¶</a></h3>
The <a class="reference internal" href="../library/getopt.html#module-getopt" title="getopt: Portable parser for command line options; support both short and long option names."><tt class="xref py py-mod docutils literal">getopt</tt></a> module provides simple parsing of command-line arguments. The
new <a class="reference internal" href="../library/optparse.html#module-optparse" title="optparse: Command-line option parsing library. (deprecated)"><tt class="xref py py-mod docutils literal">optparse</tt></a> module (originally named Optik) provides more elaborate
command-line parsing that follows the Unix conventions, automatically creates
the output for <a class="reference internal" href="../using/cmdline.html#cmdoption--help">--help</a>, and can perform different actions for different
options.
You start by creating an instance of <tt class="xref py py-class docutils literal">OptionParser</tt> and telling it what
your program&#8217;s options are.
<div class="highlight-python"><div class="highlight"><pre>import sys
from optparse import OptionParser

op = OptionParser()
op.add_option(&#39;-i&#39;, &#39;--input&#39;,
 action=&#39;store&#39;, type=&#39;string&#39;, dest=&#39;input&#39;,
 help=&#39;set input filename&#39;)
op.add_option(&#39;-l&#39;, &#39;--length&#39;,
 action=&#39;store&#39;, type=&#39;int&#39;, dest=&#39;length&#39;,
 help=&#39;set maximum length of output&#39;)
</pre></div>
</div>
Parsing a command line is then done by calling the <tt class="xref py py-meth docutils literal">parse_args()</tt> method.
<div class="highlight-python"><div class="highlight"><pre>options, args = op.parse_args(sys.argv[1:])
print options
print args
</pre></div>
</div>
This returns an object containing all of the option values, and a list of
strings containing the remaining arguments.
Invoking the script with the various arguments now works as you&#8217;d expect it to.
Note that the length argument is automatically converted to an integer.
<div class="highlight-python"><pre>$ ./python opt.py -i data arg1
&lt;Values at 0x400cad4c: {'input': 'data', 'length': None}&gt;
['arg1']
$ ./python opt.py --input=data --length=4
&lt;Values at 0x400cad2c: {'input': 'data', 'length': 4}&gt;
[]
$</pre>
</div>
The help message is automatically generated for you:
<div class="highlight-python"><pre>$ ./python opt.py --help
usage: opt.py [options]

options:
 -h, --help show this help message and exit
 -iINPUT, --input=INPUT
 set input filename
 -lLENGTH, --length=LENGTH
 set maximum length of output
$</pre>
</div>
See the module&#8217;s documentation for more details.
Optik was written by Greg Ward, with suggestions from the readers of the Getopt
SIG.
</div>
</div>
<div class="section" id="pymalloc-a-specialized-object-allocator">
<h2>Pymalloc: A Specialized Object Allocator<a class="headerlink" href="#pymalloc-a-specialized-object-allocator" title="Permalink to this headline">¶</a></h2>
Pymalloc, a specialized object allocator written by Vladimir Marangozov, was a
feature added to Python 2.1. Pymalloc is intended to be faster than the system
<tt class="xref c c-func docutils literal">malloc()</tt> and to have less memory overhead for allocation patterns typical
of Python programs. The allocator uses C&#8217;s <tt class="xref c c-func docutils literal">malloc()</tt> function to get large
pools of memory and then fulfills smaller memory requests from these pools.
In 2.1 and 2.2, pymalloc was an experimental feature and wasn&#8217;t enabled by
default; you had to explicitly enable it when compiling Python by providing the
--with-pymalloc option to the configure script. In 2.3,
pymalloc has had further enhancements and is now enabled by default; you&#8217;ll have
to supply --without-pymalloc to disable it.
This change is transparent to code written in Python; however, pymalloc may
expose bugs in C extensions. Authors of C extension modules should test their
code with pymalloc enabled, because some incorrect code may cause core dumps at
runtime.
There&#8217;s one particularly common error that causes problems. There are a number
of memory allocation functions in Python&#8217;s C API that have previously just been
aliases for the C library&#8217;s <tt class="xref c c-func docutils literal">malloc()</tt> and <tt class="xref c c-func docutils literal">free()</tt>, meaning that if
you accidentally called mismatched functions the error wouldn&#8217;t be noticeable.
When the object allocator is enabled, these functions aren&#8217;t aliases of
<tt class="xref c c-func docutils literal">malloc()</tt> and <tt class="xref c c-func docutils literal">free()</tt> any more, and calling the wrong function to
free memory may get you a core dump. For example, if memory was allocated using
<tt class="xref c c-func docutils literal">PyObject_Malloc()</tt>, it has to be freed using <tt class="xref c c-func docutils literal">PyObject_Free()</tt>, not
<tt class="xref c c-func docutils literal">free()</tt>. A few modules included with Python fell afoul of this and had to
be fixed; doubtless there are more third-party modules that will have the same
problem.
As part of this change, the confusing multiple interfaces for allocating memory
have been consolidated down into two API families. Memory allocated with one
family must not be manipulated with functions from the other family. There is
one family for allocating chunks of memory and another family of functions
specifically for allocating Python objects.
<ul class="simple">
<li>To allocate and free an undistinguished chunk of memory use the &#8220;raw memory&#8221;
family: <a class="reference internal" href="../c-api/memory.html#PyMem_Malloc" title="PyMem_Malloc"><tt class="xref c c-func docutils literal">PyMem_Malloc()</tt></a>, <a class="reference internal" href="../c-api/memory.html#PyMem_Realloc" title="PyMem_Realloc"><tt class="xref c c-func docutils literal">PyMem_Realloc()</tt></a>, and <a class="reference internal" href="../c-api/memory.html#PyMem_Free" title="PyMem_Free"><tt class="xref c c-func docutils literal">PyMem_Free()</tt></a>.</li>
<li>The &#8220;object memory&#8221; family is the interface to the pymalloc facility described
above and is biased towards a large number of &#8220;small&#8221; allocations:
<tt class="xref c c-func docutils literal">PyObject_Malloc()</tt>, <tt class="xref c c-func docutils literal">PyObject_Realloc()</tt>, and <tt class="xref c c-func docutils literal">PyObject_Free()</tt>.</li>
<li>To allocate and free Python objects, use the &#8220;object&#8221; family
<a class="reference internal" href="../c-api/allocation.html#PyObject_New" title="PyObject_New"><tt class="xref c c-func docutils literal">PyObject_New()</tt></a>, <a class="reference internal" href="../c-api/allocation.html#PyObject_NewVar" title="PyObject_NewVar"><tt class="xref c c-func docutils literal">PyObject_NewVar()</tt></a>, and <a class="reference internal" href="../c-api/allocation.html#PyObject_Del" title="PyObject_Del"><tt class="xref c c-func docutils literal">PyObject_Del()</tt></a>.</li>
</ul>
Thanks to lots of work by Tim Peters, pymalloc in 2.3 also provides debugging
features to catch memory overwrites and doubled frees in both extension modules
and in the interpreter itself. To enable this support, compile a debugging
version of the Python interpreter by running configure with
--with-pydebug.
To aid extension writers, a header file <tt class="file docutils literal">Misc/pymemcompat.h</tt> is
distributed with the source to Python 2.3 that allows Python extensions to use
the 2.3 interfaces to memory allocation while compiling against any version of
Python since 1.5.2. You would copy the file from Python&#8217;s source distribution
and bundle it with the source of your extension.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="reference external" href="http://svn.python.org/view/python/trunk/Objects/obmalloc.c">http://svn.python.org/view/python/trunk/Objects/obmalloc.c</a></dt>
<dd>For the full details of the pymalloc implementation, see the comments at
the top of the file <tt class="file docutils literal">Objects/obmalloc.c</tt> in the Python source code.
The above link points to the file within the python.org SVN browser.</dd>
</dl>
</div>
</div>
<div class="section" id="build-and-c-api-changes">
<h2>Build and C API Changes<a class="headerlink" href="#build-and-c-api-changes" title="Permalink to this headline">¶</a></h2>
Changes to Python&#8217;s build process and to the C API include:
<ul class="simple">
<li>The cycle detection implementation used by the garbage collection has proven
to be stable, so it&#8217;s now been made mandatory. You can no longer compile Python
without it, and the --with-cycle-gc switch to configure has
been removed.</li>
<li>Python can now optionally be built as a shared library
(<tt class="file docutils literal">libpython2.3.so</tt>) by supplying --enable-shared when running
Python&#8217;s configure script. (Contributed by Ondrej Palkovsky.)</li>
<li>The <tt class="xref c c-macro docutils literal">DL_EXPORT</tt> and <tt class="xref c c-macro docutils literal">DL_IMPORT</tt> macros are now deprecated.
Initialization functions for Python extension modules should now be declared
using the new macro <tt class="xref c c-macro docutils literal">PyMODINIT_FUNC</tt>, while the Python core will
generally use the <tt class="xref c c-macro docutils literal">PyAPI_FUNC</tt> and <tt class="xref c c-macro docutils literal">PyAPI_DATA</tt> macros.</li>
<li>The interpreter can be compiled without any docstrings for the built-in
functions and modules by supplying --without-doc-strings to the
configure script. This makes the Python executable about 10% smaller,
but will also mean that you can&#8217;t get help for Python&#8217;s built-ins. (Contributed
by Gustavo Niemeyer.)</li>
<li>The <tt class="xref c c-func docutils literal">PyArg_NoArgs()</tt> macro is now deprecated, and code that uses it
should be changed. For Python 2.2 and later, the method definition table can
specify the <a class="reference internal" href="../c-api/structures.html#METH_NOARGS" title="METH_NOARGS"><tt class="xref py py-const docutils literal">METH_NOARGS</tt></a> flag, signalling that there are no arguments,
and the argument checking can then be removed. If compatibility with pre-2.2
versions of Python is important, the code could use <tt class="docutils literal">PyArg_ParseTuple(args,
&quot;&quot;)</tt> instead, but this will be slower than using <a class="reference internal" href="../c-api/structures.html#METH_NOARGS" title="METH_NOARGS"><tt class="xref py py-const docutils literal">METH_NOARGS</tt></a>.</li>
<li><a class="reference internal" href="../c-api/arg.html#PyArg_ParseTuple" title="PyArg_ParseTuple"><tt class="xref c c-func docutils literal">PyArg_ParseTuple()</tt></a> accepts new format characters for various sizes of
unsigned integers: <tt class="docutils literal">B</tt> for <tt class="xref c c-type docutils literal">unsigned char</tt>, <tt class="docutils literal">H</tt> for <tt class="xref c c-type docutils literal">unsigned
short int</tt>, <tt class="docutils literal">I</tt> for <tt class="xref c c-type docutils literal">unsigned int</tt>, and <tt class="docutils literal">K</tt> for <tt class="xref c c-type docutils literal">unsigned
long long</tt>.</li>
<li>A new function, <tt class="xref c c-func docutils literal">PyObject_DelItemString(mapping, char *key)()</tt> was added
as shorthand for <tt class="docutils literal">PyObject_DelItem(mapping, PyString_New(key))</tt>.</li>
<li>File objects now manage their internal string buffer differently, increasing
it exponentially when needed. This results in the benchmark tests in
<tt class="file docutils literal">Lib/test/test_bufio.py</tt> speeding up considerably (from 57 seconds to 1.7
seconds, according to one measurement).</li>
<li>It&#8217;s now possible to define class and static methods for a C extension type by
setting either the <a class="reference internal" href="../c-api/structures.html#METH_CLASS" title="METH_CLASS"><tt class="xref py py-const docutils literal">METH_CLASS</tt></a> or <a class="reference internal" href="../c-api/structures.html#METH_STATIC" title="METH_STATIC"><tt class="xref py py-const docutils literal">METH_STATIC</tt></a> flags in a
method&#8217;s <a class="reference internal" href="../c-api/structures.html#PyMethodDef" title="PyMethodDef"><tt class="xref c c-type docutils literal">PyMethodDef</tt></a> structure.</li>
<li>Python now includes a copy of the Expat XML parser&#8217;s source code, removing any
dependence on a system version or local installation of Expat.</li>
<li>If you dynamically allocate type objects in your extension, you should be
aware of a change in the rules relating to the <tt class="xref py py-attr docutils literal">__module__</tt> and
<tt class="xref py py-attr docutils literal">__name__</tt> attributes. In summary, you will want to ensure the type&#8217;s
dictionary contains a <tt class="docutils literal">'__module__'</tt> key; making the module name the part of
the type name leading up to the final period will no longer have the desired
effect. For more detail, read the API reference documentation or the source.</li>
</ul>
<div class="section" id="port-specific-changes">
<h3>Port-Specific Changes<a class="headerlink" href="#port-specific-changes" title="Permalink to this headline">¶</a></h3>
Support for a port to IBM&#8217;s OS/2 using the EMX runtime environment was merged
into the main Python source tree. EMX is a POSIX emulation layer over the OS/2
system APIs. The Python port for EMX tries to support all the POSIX-like
capability exposed by the EMX runtime, and mostly succeeds; <tt class="xref py py-func docutils literal">fork()</tt> and
<a class="reference internal" href="../library/fcntl.html#module-fcntl" title="fcntl: The fcntl() and ioctl() system calls. (Unix)"><tt class="xref py py-func docutils literal">fcntl()</tt></a> are restricted by the limitations of the underlying emulation
layer. The standard OS/2 port, which uses IBM&#8217;s Visual Age compiler, also
gained support for case-sensitive import semantics as part of the integration of
the EMX port into CVS. (Contributed by Andrew MacIntyre.)
On MacOS, most toolbox modules have been weaklinked to improve backward
compatibility. This means that modules will no longer fail to load if a single
routine is missing on the current OS version. Instead calling the missing
routine will raise an exception. (Contributed by Jack Jansen.)
The RPM spec files, found in the <tt class="file docutils literal">Misc/RPM/</tt> directory in the Python
source distribution, were updated for 2.3. (Contributed by Sean Reifschneider.)
Other new platforms now supported by Python include AtheOS
(<a class="reference external" href="http://www.atheos.cx/">http://www.atheos.cx/</a>), GNU/Hurd, and OpenVMS.
</div>
</div>
<div class="section" id="other-changes-and-fixes">
<h2>Other Changes and Fixes<a class="headerlink" href="#other-changes-and-fixes" title="Permalink to this headline">¶</a></h2>
As usual, there were a bunch of other improvements and bugfixes scattered
throughout the source tree. A search through the CVS change logs finds there
were 523 patches applied and 514 bugs fixed between Python 2.2 and 2.3. Both
figures are likely to be underestimates.
Some of the more notable changes are:
<ul>
<li>If the <a class="reference internal" href="../using/cmdline.html#envvar-PYTHONINSPECT"><tt class="xref std std-envvar docutils literal">PYTHONINSPECT</tt></a> environment variable is set, the Python
interpreter will enter the interactive prompt after running a Python program, as
if Python had been invoked with the <a class="reference internal" href="../using/cmdline.html#cmdoption-i">-i</a> option. The environment
variable can be set before running the Python interpreter, or it can be set by
the Python program as part of its execution.
</li>
<li>The <tt class="file docutils literal">regrtest.py</tt> script now provides a way to allow &#8220;all resources
except foo.&#8221; A resource name passed to the <a class="reference internal" href="../using/cmdline.html#cmdoption-u">-u</a> option can now be
prefixed with a hyphen (<tt class="docutils literal">'-'</tt>) to mean &#8220;remove this resource.&#8221; For example,
the option &#8216;<tt class="docutils literal">-uall,-bsddb</tt>&#8216; could be used to enable the use of all resources
except <tt class="docutils literal">bsddb</tt>.
</li>
<li>The tools used to build the documentation now work under Cygwin as well as
Unix.
</li>
<li>The <tt class="docutils literal">SET_LINENO</tt> opcode has been removed. Back in the mists of time, this
opcode was needed to produce line numbers in tracebacks and support trace
functions (for, e.g., <a class="reference internal" href="../library/pdb.html#module-pdb" title="pdb: The Python debugger for interactive interpreters."><tt class="xref py py-mod docutils literal">pdb</tt></a>). Since Python 1.5, the line numbers in
tracebacks have been computed using a different mechanism that works with
&#8220;python -O&#8221;. For Python 2.3 Michael Hudson implemented a similar scheme to
determine when to call the trace function, removing the need for <tt class="docutils literal">SET_LINENO</tt>
entirely.
It would be difficult to detect any resulting difference from Python code, apart
from a slight speed up when Python is run without <a class="reference internal" href="../using/cmdline.html#cmdoption-O">-O</a>.
C extensions that access the <tt class="xref py py-attr docutils literal">f_lineno</tt> field of frame objects should
instead call <tt class="docutils literal">PyCode_Addr2Line(f-&gt;f_code, f-&gt;f_lasti)</tt>. This will have the
added effect of making the code work as desired under &#8220;python -O&#8221; in earlier
versions of Python.
A nifty new feature is that trace functions can now assign to the
<tt class="xref py py-attr docutils literal">f_lineno</tt> attribute of frame objects, changing the line that will be
executed next. A <tt class="docutils literal">jump</tt> command has been added to the <a class="reference internal" href="../library/pdb.html#module-pdb" title="pdb: The Python debugger for interactive interpreters."><tt class="xref py py-mod docutils literal">pdb</tt></a> debugger
taking advantage of this new feature. (Implemented by Richie Hindle.)
</li>
</ul>
</div>
<div class="section" id="porting-to-python-2-3">
<h2>Porting to Python 2.3<a class="headerlink" href="#porting-to-python-2-3" title="Permalink to this headline">¶</a></h2>
This section lists previously described changes that may require changes to your
code:
<ul>
<li><a class="reference internal" href="../reference/simple_stmts.html#yield"><tt class="xref std std-keyword docutils literal">yield</tt></a> is now always a keyword; if it&#8217;s used as a variable name in
your code, a different name must be chosen.
</li>
<li>For strings X and Y, <tt class="docutils literal">X in Y</tt> now works if X is more than one
character long.
</li>
<li>The <a class="reference internal" href="../library/functions.html#int" title="int"><tt class="xref py py-func docutils literal">int()</tt></a> type constructor will now return a long integer instead of
raising an <a class="reference internal" href="../library/exceptions.html#exceptions.OverflowError" title="exceptions.OverflowError"><tt class="xref py py-exc docutils literal">OverflowError</tt></a> when a string or floating-point number is too
large to fit into an integer.
</li>
<li>If you have Unicode strings that contain 8-bit characters, you must declare
the file&#8217;s encoding (UTF-8, Latin-1, or whatever) by adding a comment to the top
of the file. See section <a class="reference internal" href="#section-encodings">PEP 263: Source Code Encodings</a> for more information.
</li>
<li>Calling Tcl methods through <tt class="xref py py-mod docutils literal">_tkinter</tt> no longer returns only strings.
Instead, if Tcl returns other objects those objects are converted to their
Python equivalent, if one exists, or wrapped with a <tt class="xref py py-class docutils literal">_tkinter.Tcl_Obj</tt>
object if no Python equivalent exists.
</li>
<li>Large octal and hex literals such as <tt class="docutils literal">0xffffffff</tt> now trigger a
<a class="reference internal" href="../library/exceptions.html#exceptions.FutureWarning" title="exceptions.FutureWarning"><tt class="xref py py-exc docutils literal">FutureWarning</tt></a>. Currently they&#8217;re stored as 32-bit numbers and result in a
negative value, but in Python 2.4 they&#8217;ll become positive long integers.
There are a few ways to fix this warning. If you really need a positive number,
just add an <tt class="docutils literal">L</tt> to the end of the literal. If you&#8217;re trying to get a 32-bit
integer with low bits set and have previously used an expression such as <tt class="docutils literal">~(1
&lt;&lt; 31)</tt>, it&#8217;s probably clearest to start with all bits set and clear the
desired upper bits. For example, to clear just the top bit (bit 31), you could
write <tt class="docutils literal">0xffffffffL &amp;~(1L&lt;&lt;31)</tt>.
</li>
<li>You can no longer disable assertions by assigning to <tt class="docutils literal">__debug__</tt>.
</li>
<li>The Distutils <tt class="xref py py-func docutils literal">setup()</tt> function has gained various new keyword arguments
such as depends. Old versions of the Distutils will abort if passed unknown
keywords. A solution is to check for the presence of the new
<tt class="xref py py-func docutils literal">get_distutil_options()</tt> function in your <tt class="file docutils literal">setup.py</tt> and only uses the
new keywords with a version of the Distutils that supports them:
<div class="highlight-python"><pre>from distutils import core

kw = {'sources': 'foo.c', ...}
if hasattr(core, 'get_distutil_options'):
 kw['depends'] = ['foo.h']
ext = Extension(**kw)</pre>
</div>
</li>
<li>Using <tt class="docutils literal">None</tt> as a variable name will now result in a <a class="reference internal" href="../library/exceptions.html#exceptions.SyntaxWarning" title="exceptions.SyntaxWarning"><tt class="xref py py-exc docutils literal">SyntaxWarning</tt></a>
warning.
</li>
<li>Names of extension types defined by the modules included with Python now
contain the module and a <tt class="docutils literal">'.'</tt> in front of the type name.
</li>
</ul>
</div>
<div class="section" id="acknowledgements">
<h2>Acknowledgements<a class="headerlink" href="#acknowledgements" title="Permalink to this headline">¶</a></h2>
The author would like to thank the following people for offering suggestions,
corrections and assistance with various drafts of this article: Jeff Bauer,
Simon Brunning, Brett Cannon, Michael Chermside, Andrew Dalke, Scott David
Daniels, Fred L. Drake, Jr., David Fraser, Kelly Gerber, Raymond Hettinger,
Michael Hudson, Chris Lambert, Detlef Lannert, Martin von Löwis, Andrew
MacIntyre, Lalo Martins, Chad Netzer, Gustavo Niemeyer, Neal Norwitz, Hans
Nowak, Chris Reedy, Francesco Ricciardi, Vinay Sajip, Neil Schemenauer, Roman
Suzi, Jason Tishler, Just van Rossum.
</div>
</div>

</div>
 </div>
 </div>
 <div class="sphinxsidebar">
 <div class="sphinxsidebarwrapper">
 <h3><a href="../contents.html">Table Of Contents</a></h3>
 <ul>
<li><a class="reference internal" href="#">What&#8217;s New in Python 2.3</a><ul>
<li><a class="reference internal" href="#pep-218-a-standard-set-datatype">PEP 218: A Standard Set Datatype</a></li>
<li><a class="reference internal" href="#pep-255-simple-generators">PEP 255: Simple Generators</a></li>
<li><a class="reference internal" href="#pep-263-source-code-encodings">PEP 263: Source Code Encodings</a></li>
<li><a class="reference internal" href="#pep-273-importing-modules-from-zip-archives">PEP 273: Importing Modules from ZIP Archives</a></li>
<li><a class="reference internal" href="#pep-277-unicode-file-name-support-for-windows-nt">PEP 277: Unicode file name support for Windows NT</a></li>
<li><a class="reference internal" href="#pep-278-universal-newline-support">PEP 278: Universal Newline Support</a></li>
<li><a class="reference internal" href="#pep-279-enumerate">PEP 279: enumerate()</a></li>
<li><a class="reference internal" href="#pep-282-the-logging-package">PEP 282: The logging Package</a></li>
<li><a class="reference internal" href="#pep-285-a-boolean-type">PEP 285: A Boolean Type</a></li>
<li><a class="reference internal" href="#pep-293-codec-error-handling-callbacks">PEP 293: Codec Error Handling Callbacks</a></li>
<li><a class="reference internal" href="#pep-301-package-index-and-metadata-for-distutils">PEP 301: Package Index and Metadata for Distutils</a></li>
<li><a class="reference internal" href="#pep-302-new-import-hooks">PEP 302: New Import Hooks</a></li>
<li><a class="reference internal" href="#pep-305-comma-separated-files">PEP 305: Comma-separated Files</a></li>
<li><a class="reference internal" href="#pep-307-pickle-enhancements">PEP 307: Pickle Enhancements</a></li>
<li><a class="reference internal" href="#extended-slices">Extended Slices</a></li>
<li><a class="reference internal" href="#other-language-changes">Other Language Changes</a><ul>
<li><a class="reference internal" href="#string-changes">String Changes</a></li>
<li><a class="reference internal" href="#optimizations">Optimizations</a></li>
</ul>
</li>
<li><a class="reference internal" href="#new-improved-and-deprecated-modules">New, Improved, and Deprecated Modules</a><ul>
<li><a class="reference internal" href="#date-time-type">Date/Time Type</a></li>
<li><a class="reference internal" href="#the-optparse-module">The optparse Module</a></li>
</ul>
</li>
<li><a class="reference internal" href="#pymalloc-a-specialized-object-allocator">Pymalloc: A Specialized Object Allocator</a></li>
<li><a class="reference internal" href="#build-and-c-api-changes">Build and C API Changes</a><ul>
<li><a class="reference internal" href="#port-specific-changes">Port-Specific Changes</a></li>
</ul>
</li>
<li><a class="reference internal" href="#other-changes-and-fixes">Other Changes and Fixes</a></li>
<li><a class="reference internal" href="#porting-to-python-2-3">Porting to Python 2.3</a></li>
<li><a class="reference internal" href="#acknowledgements">Acknowledgements</a></li>
</ul>
</li>
</ul>

<h4>Previous topic</h4>
 <a href="2.4.html"
 title="previous chapter">What&#8217;s New in Python 2.4</a>
 <h4>Next topic</h4>
 <a href="2.2.html"
 title="next chapter">What&#8217;s New in Python 2.2</a>
<h3>This Page</h3>
<ul class="this-page-menu">
 <li><a href="../bugs.html">Report a Bug</a></li>
 <li><a href="../_sources/whatsnew/2.3.txt"
 rel="nofollow">Show Source</a></li>
</ul>

<div id="searchbox" style="display: none">
 <h3>Quick search</h3>
 <form class="search" action="../search.html" method="get">
 <input type="text" name="q" />
 <input type="submit" value="Go" />
 <input type="hidden" name="check_keywords" value="yes" />
 <input type="hidden" name="area" value="default" />
 </form>
 
 Enter search terms or a module, class or function name.
 
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
 </div>
 </div>
 <div class="clearer"></div>
 </div>
 <div class="related">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 >index</a></li>
 <li class="right" >
 <a href="../py-modindex.html" title="Python Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="2.2.html" title="What’s New in Python 2.2"
 >next</a> |</li>
 <li class="right" >
 <a href="2.4.html" title="What’s New in Python 2.4"
 >previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="http://www.python.org/">Python</a> &raquo;</li>
 <li>
 <a href="../index.html">Python 2.7.5 documentation</a> &raquo;
 </li>

<li><a href="index.html" >What&#8217;s New in Python</a> &raquo;</li> 
 </ul>
 </div>
 <div class="footer">
 &copy; <a href="../copyright.html">Copyright</a> 1990-2019, Python Software Foundation.
 
 The Python Software Foundation is a non-profit corporation.
 <a href="http://www.python.org/psf/donations/">Please donate.</a>
 
 Last updated on Jul 03, 2019.
 <a href="../bugs.html">Found a bug</a>?
 
 Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
 </div>

</body>
</html>

Cancel