\documentclass{howto} % $Id$ \title{What's New in Python 2.3} \release{0.03} \author{A.M. Kuchling} \authoraddress{\email{amk@amk.ca}} \begin{document} \maketitle \tableofcontents % Optik (or whatever it gets called) % % MacOS framework-related changes (section of its own, probably) % % xreadlines obsolete; files are their own iterator %\section{Introduction \label{intro}} {\large This article is a draft, and is currently up to date for some random version of the CVS tree from early November 2002. Please send any additions, comments or errata to the author.} This article explains the new features in Python 2.3. The tentative release date of Python 2.3 is currently scheduled for some undefined time before the end of 2002. This article doesn't attempt to provide a complete specification of the new features, but instead provides a convenient overview. For full details, you should refer to the documentation for Python 2.3, such as the \citetitle[http://www.python.org/doc/2.3/lib/lib.html]{Python Library Reference} and the \citetitle[http://www.python.org/doc/2.3/ref/ref.html]{Python Reference Manual}. If you want to understand the complete implementation and design rationale for a change, refer to the PEP for a particular new feature. %====================================================================== \section{PEP 218: A Standard Set Datatype} The new \module{sets} module contains an implementation of a set datatype. The \class{Set} class is for mutable sets, sets that can have members added and removed. The \class{ImmutableSet} class is for sets that can't be modified, and can be used as dictionary keys. Sets are built on top of dictionaries, so the elements within a set must be hashable. As a simple example, \begin{verbatim} >>> import sets >>> S = sets.Set([1,2,3]) >>> S Set([1, 2, 3]) >>> 1 in S True >>> 0 in S False >>> S.add(5) >>> S.remove(3) >>> S Set([1, 2, 5]) >>> \end{verbatim} The union and intersection of sets can be computed with the \method{union()} and \method{intersection()} methods, or, alternatively, using the bitwise operators \samp{\&} and \samp{|}. Mutable sets also have in-place versions of these methods, \method{union_update()} and \method{intersection_update()}. \begin{verbatim} >>> S1 = sets.Set([1,2,3]) >>> S2 = sets.Set([4,5,6]) >>> S1.union(S2) Set([1, 2, 3, 4, 5, 6]) >>> S1 | S2 # Alternative notation Set([1, 2, 3, 4, 5, 6]) >>> S1.intersection(S2) Set([]) >>> S1 & S2 # Alternative notation Set([]) >>> S1.union_update(S2) Set([1, 2, 3, 4, 5, 6]) >>> S1 Set([1, 2, 3, 4, 5, 6]) >>> \end{verbatim} It's also possible to take the symmetric difference of two sets. This is the set of all elements in the union that aren't in the intersection. An alternative way of expressing the symmetric difference is that it contains all elements that are in exactly one set. Again, there's an in-place version, with the ungainly name \method{symmetric_difference_update()}. \begin{verbatim} >>> S1 = sets.Set([1,2,3,4]) >>> S2 = sets.Set([3,4,5,6]) >>> S1.symmetric_difference(S2) Set([1, 2, 5, 6]) >>> S1 ^ S2 Set([1, 2, 5, 6]) >>> \end{verbatim} There are also methods, \method{issubset()} and \method{issuperset()}, for checking whether one set is a strict subset or superset of another: \begin{verbatim} >>> S1 = sets.Set([1,2,3]) >>> S2 = sets.Set([2,3]) >>> S2.issubset(S1) True >>> S1.issubset(S2) False >>> S1.issuperset(S2) True >>> \end{verbatim} \begin{seealso} \seepep{218}{Adding a Built-In Set Object Type}{PEP written by Greg V. Wilson. Implemented by Greg V. Wilson, Alex Martelli, and GvR.} \end{seealso} %====================================================================== \section{PEP 255: Simple Generators\label{section-generators}} In Python 2.2, generators were added as an optional feature, to be enabled by a \code{from __future__ import generators} directive. In 2.3 generators no longer need to be specially enabled, and are now always present; this means that \keyword{yield} is now always a keyword. The rest of this section is a copy of the description of generators from the ``What's New in Python 2.2'' document; if you read it when 2.2 came out, you can skip the rest of this section. You'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 \keyword{return} 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'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's the simplest example of a generator function: \begin{verbatim} def generate_ints(N): for i in range(N): yield i \end{verbatim} A new keyword, \keyword{yield}, was introduced for generators. Any function containing a \keyword{yield} statement is a generator function; this is detected by Python's bytecode compiler which compiles the function specially as a result. When you call a generator function, it doesn't return a single value; instead it returns a generator object that supports the iterator protocol. On executing the \keyword{yield} statement, the generator outputs the value of \code{i}, similar to a \keyword{return} statement. The big difference between \keyword{yield} and a \keyword{return} statement is that on reaching a \keyword{yield} the generator's state of execution is suspended and local variables are preserved. On the next call to the generator's \code{.next()} method, the function will resume executing immediately after the \keyword{yield} statement. (For complicated reasons, the \keyword{yield} statement isn't allowed inside the \keyword{try} block of a \code{try...finally} statement; read \pep{255} for a full explanation of the interaction between \keyword{yield} and exceptions.) Here's a sample usage of the \function{generate_ints} generator: \begin{verbatim} >>> gen = generate_ints(3) >>> gen >>> gen.next() 0 >>> gen.next() 1 >>> gen.next() 2 >>> gen.next() Traceback (most recent call last): File "stdin", line 1, in ? File "stdin", line 2, in generate_ints StopIteration \end{verbatim} You could equally write \code{for i in generate_ints(5)}, or \code{a,b,c = generate_ints(3)}. Inside a generator function, the \keyword{return} 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. \keyword{return} with a value, such as \code{return 5}, is a syntax error inside a generator function. The end of the generator's results can also be indicated by raising \exception{StopIteration} 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 \code{self.count} to 0, and having the \method{next()} method increment \code{self.count} and return it. However, for a moderately complicated generator, writing a corresponding class would be much messier. \file{Lib/test/test_generators.py} contains a number of more interesting examples. The simplest one implements an in-order traversal of a tree using generators recursively. \begin{verbatim} # 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 \end{verbatim} Two other examples in \file{Lib/test/test_generators.py} produce solutions for the N-Queens problem (placing $N$ queens on an $NxN$ chess board so that no queen threatens another) and the Knight'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 (\url{http://www.cs.arizona.edu/icon/}), where the idea of generators is central. In Icon, every expression and function call behaves like a generator. One example from ``An Overview of the Icon Programming Language'' at \url{http://www.cs.arizona.edu/icon/docs/ipd266.htm} gives an idea of what this looks like: \begin{verbatim} sentence := "Store it in the neighboring harbor" if (i := find("or", sentence)) > 5 then write(i) \end{verbatim} In Icon the \function{find()} function returns the indexes at which the substring ``or'' is found: 3, 23, 33. In the \keyword{if} statement, \code{i} 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't go nearly as far as Icon in adopting generators as a central concept. Generators are considered a new part of the core Python language, but learning or using them isn't compulsory; if they don't solve any problems that you have, feel free to ignore them. One novel feature of Python's interface as compared to Icon's is that a generator's state is represented as a concrete object (the iterator) that can be passed around to other functions or stored in a data structure. \begin{seealso} \seepep{255}{Simple Generators}{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.} \end{seealso} %====================================================================== \section{PEP 263: Source Code Encodings \label{section-encodings}} 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: \begin{verbatim} #!/usr/bin/env python # -*- coding: UTF-8 -*- \end{verbatim} Without such an encoding declaration, the default encoding used is ISO-8859-1, also known as Latin1. The encoding declaration only affects Unicode string literals; the text in the source code will be converted to Unicode using the specified encoding. Note that Python identifiers are still restricted to ASCII characters, so you can't have variable names that use characters outside of the usual alphanumerics. \begin{seealso} \seepep{263}{Defining Python Source Code Encodings}{Written by Marc-Andr\'e Lemburg and Martin von L\"owis; implemented by SUZUKI Hisao and Martin von L\"owis.} \end{seealso} %====================================================================== \section{PEP 277: Unicode file name support for Windows NT} 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, in particular the \function{open()} built-in. If a Unicode string is passed to \function{os.listdir}, Python now returns a list of Unicode strings. A new function, \function{os.getcwdu()}, returns the current directory as a Unicode string. Byte strings still work as file names, and Python will transparently convert them to Unicode using the \code{mbcs} encoding. Other systems also allow Unicode strings as file names, but convert them to byte strings before passing them to the system which may cause a \exception{UnicodeError} to be raised. Applications can test whether arbitrary Unicode strings are supported as file names by checking \member{os.path.unicode_file_names}, a Boolean value. \begin{seealso} \seepep{277}{Unicode file name support for Windows NT}{Written by Neil Hodgson; implemented by Neil Hodgson, Martin von L\"owis, and Mark Hammond.} \end{seealso} %====================================================================== \section{PEP 278: Universal Newline Support} The three major operating systems used today are Microsoft Windows, Apple's Macintosh OS, and the various \UNIX\ derivatives. A minor irritation is that these three platforms all use different characters to mark the ends of lines in text files. \UNIX\ uses character 10, the ASCII linefeed, while MacOS uses character 13, the ASCII carriage return, and Windows uses a two-character sequence of a carriage return plus a newline. Python'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 \samp{U} or \samp{rU} will open a file for reading in universal newline mode. All three line ending conventions will be translated to a \samp{\e n} in the strings returned by the various file methods such as \method{read()} and \method{readline()}. Universal newline support is also used when importing modules and when executing a file with the \function{execfile()} 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 at compile-time by specifying \longprogramopt{without-universal-newlines} when running Python's \file{configure} script. \begin{seealso} \seepep{278}{Universal Newline Support}{Written and implemented by Jack Jansen.} \end{seealso} %====================================================================== \section{PEP 279: The \function{enumerate()} Built-in Function\label{section-enumerate}} A new built-in function, \function{enumerate()}, will make certain loops a bit clearer. \code{enumerate(thing)}, where \var{thing} is either an iterator or a sequence, returns a iterator that will return \code{(0, \var{thing[0]})}, \code{(1, \var{thing[1]})}, \code{(2, \var{thing[2]})}, and so forth. Fairly often you'll see code to change every element of a list that looks like this: \begin{verbatim} for i in range(len(L)): item = L[i] # ... compute some result based on item ... L[i] = result \end{verbatim} This can be rewritten using \function{enumerate()} as: \begin{verbatim} for i, item in enumerate(L): # ... compute some result based on item ... L[i] = result \end{verbatim} \begin{seealso} \seepep{279}{The enumerate() built-in function}{Written by Raymond D. Hettinger.} \end{seealso} %====================================================================== \section{PEP 285: The \class{bool} Type\label{section-bool}} A Boolean type was added to Python 2.3. Two new constants were added to the \module{__builtin__} module, \constant{True} and \constant{False}. The type object for this new type is named \class{bool}; the constructor for it takes any Python value and converts it to \constant{True} or \constant{False}. \begin{verbatim} >>> bool(1) True >>> bool(0) False >>> bool([]) False >>> bool( (1,) ) True \end{verbatim} Most of the standard library modules and built-in functions have been changed to return Booleans. \begin{verbatim} >>> obj = [] >>> hasattr(obj, 'append') True >>> isinstance(obj, list) True >>> isinstance(obj, tuple) False \end{verbatim} Python's Booleans were added with the primary goal of making code clearer. For example, if you're reading a function and encounter the statement \code{return 1}, you might wonder whether the \samp{1} represents a truth value, or whether it's an index, or whether it's a coefficient that multiplies some other quantity. If the statement is \code{return True}, however, the meaning of the return value is quite clearly a truth value. Python'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 \keyword{if} statement always evaluate to a Boolean. Python is not this strict, and it never will be. (\pep{285} explicitly says so.) So you can still use any expression in an \keyword{if}, even ones that evaluate to a list or tuple or some random object, and the Boolean type is a subclass of the \class{int} class, so arithmetic using a Boolean still works. \begin{verbatim} >>> True + 1 2 >>> False + 1 1 >>> False * 75 0 >>> True * 75 75 \end{verbatim} To sum up \constant{True} and \constant{False} in a sentence: they're alternative ways to spell the integer values 1 and 0, with the single difference that \function{str()} and \function{repr()} return the strings \samp{True} and \samp{False} instead of \samp{1} and \samp{0}. \begin{seealso} \seepep{285}{Adding a bool type}{Written and implemented by GvR.} \end{seealso} %====================================================================== \section{PEP 293: Codec Error Handling Callbacks} 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 ``strict'' (raising \exception{UnicodeError}), ``ignore'' (skip the character), or ``replace'' (with question mark), defaulting to ``strict''. It may be desirable to specify an alternative processing of the error, e.g. by inserting an XML character reference or HTML entity reference into the converted string. Python now has a flexible framework to add additional processing strategies. New error handlers can be added with \function{codecs.register_error}. Codecs then can access the error handler with \function{codecs.lookup_error}. 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: ``backslashreplace'' uses Python backslash quoting to represent the unencodable character, and ``xmlcharrefreplace'' emits XML character references. \begin{seealso} \seepep{293}{Codec Error Handling Callbacks}{Written and implemented by Walter D\"orwald.} \end{seealso} %====================================================================== \section{Extended Slices\label{section-slices}} Ever since Python 1.4, the slicing syntax has supported an optional third ``step'' or ``stride'' argument. For example, these are all legal Python syntax: \code{L[1:10:2]}, \code{L[:-1:1]}, \code{L[::-1]}. This was added to Python included at the request of the developers of Numerical Python. However, the built-in sequence types of lists, tuples, and strings have never supported this feature, and you got a \exception{TypeError} if you tried it. Michael Hudson contributed a patch that was applied to Python 2.3 and fixed this shortcoming. For example, you can now easily extract the elements of a list that have even indexes: \begin{verbatim} >>> L = range(10) >>> L[::2] [0, 2, 4, 6, 8] \end{verbatim} Negative values also work, so you can make a copy of the same list in reverse order: \begin{verbatim} >>> L[::-1] [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] \end{verbatim} This also works for strings: \begin{verbatim} >>> s='abcd' >>> s[::2] 'ac' >>> s[::-1] 'dcba' \end{verbatim} as well as tuples and arrays. If you have a mutable sequence (i.e. a list or an array) you can assign to or delete an extended slice, but there are some differences in assignment to extended and regular slices. Assignment to a regular slice can be used to change the length of the sequence: \begin{verbatim} >>> a = range(3) >>> a [0, 1, 2] >>> a[1:3] = [4, 5, 6] >>> a [0, 4, 5, 6] \end{verbatim} but 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: \begin{verbatim} >>> a = range(4) >>> a [0, 1, 2, 3] >>> a[::2] [0, 2] >>> a[::2] = range(0, -2, -1) >>> a [0, 1, -1, 3] >>> a[::2] = range(3) Traceback (most recent call last): File "", line 1, in ? ValueError: attempt to assign list of size 3 to extended slice of size 2 \end{verbatim} Deletion is more straightforward: \begin{verbatim} >>> a = range(4) >>> a[::2] [0, 2] >>> del a[::2] >>> a [1, 3] \end{verbatim} One can also now pass slice objects to builtin sequences \method{__getitem__} methods: \begin{verbatim} >>> range(10).__getitem__(slice(0, 5, 2)) [0, 2, 4] \end{verbatim} or use them directly in subscripts: \begin{verbatim} >>> range(10)[slice(0, 5, 2)] [0, 2, 4] \end{verbatim} To make implementing sequences that support extended slicing in Python easier, slice ojects now have a method \method{indices} which given the length of a sequence returns \code{(start, stop, step)} handling 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: \begin{verbatim} class FakeSeq: ... def calc_item(self, i): ... def __getitem__(self, item): if isinstance(item, slice): return FakeSeq([self.calc_item(i) in range(*item.indices(len(self)))]) else: return self.calc_item(i) \end{verbatim} From this example you can also see that the builtin ``\class{slice}'' object is now the type object for the slice type, and is no longer a function. This is consistent with Python 2.2, where \class{int}, \class{str}, etc., underwent the same change. %====================================================================== \section{Other Language Changes} Here are all of the changes that Python 2.3 makes to the core Python language. \begin{itemize} \item The \keyword{yield} statement is now always a keyword, as described in section~\ref{section-generators} of this document. \item A new built-in function \function{enumerate()} was added, as described in section~\ref{section-enumerate} of this document. \item Two new constants, \constant{True} and \constant{False} were added along with the built-in \class{bool} type, as described in section~\ref{section-bool} of this document. \item Built-in types now support the extended slicing syntax, as described in section~\ref{section-slices} of this document. \item Dictionaries have a new method, \method{pop(\var{key})}, that returns the value corresponding to \var{key} and removes that key/value pair from the dictionary. \method{pop()} will raise a \exception{KeyError} if the requested key isn't present in the dictionary: \begin{verbatim} >>> d = {1:2} >>> d {1: 2} >>> d.pop(4) Traceback (most recent call last): File ``stdin'', line 1, in ? KeyError: 4 >>> d.pop(1) 2 >>> d.pop(1) Traceback (most recent call last): File ``stdin'', line 1, in ? KeyError: pop(): dictionary is empty >>> d {} >>> \end{verbatim} (Patch contributed by Raymond Hettinger.) \item The \keyword{assert} statement no longer checks the \code{__debug__} flag, so you can no longer disable assertions by assigning to \code{__debug__}. Running Python with the \programopt{-O} switch will still generate code that doesn't execute any assertions. \item 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 \module{new} module can be deprecated in a future Python version, because you can now use the type objects available in the \module{types} module.) % XXX should new.py use PendingDeprecationWarning? For example, you can create a new module object with the following code: \begin{verbatim} >>> import types >>> m = types.ModuleType('abc','docstring') >>> m >>> m.__doc__ 'docstring' \end{verbatim} \item A new warning, \exception{PendingDeprecationWarning} was added to indicate features which are in the process of being deprecated. The warning will \emph{not} be printed by default. To check for use of features that will be deprecated in the future, supply \programopt{-Walways::PendingDeprecationWarning::} on the command line or use \function{warnings.filterwarnings()}. \item Using \code{None} as a variable name will now result in a \exception{SyntaxWarning} warning. In a future version of Python, \code{None} may finally become a keyword. \item 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's easily fixed by setting the limit back to a lower number by calling \function{sys.setcheckinterval(\var{N})}. \item 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 \samp{.} in front of the type name. For example, in Python 2.2, if you created a socket and printed its \member{__class__}, you'd get this output: \begin{verbatim} >>> s = socket.socket() >>> s.__class__ \end{verbatim} In 2.3, you get this: \begin{verbatim} >>> s.__class__ \end{verbatim} \end{itemize} \subsection{String Changes} \begin{itemize} \item The \code{in} operator now works differently for strings. Previously, when evaluating \code{\var{X} in \var{Y}} where \var{X} and \var{Y} are strings, \var{X} could only be a single character. That's now changed; \var{X} can be a string of any length, and \code{\var{X} in \var{Y}} will return \constant{True} if \var{X} is a substring of \var{Y}. If \var{X} is the empty string, the result is always \constant{True}. \begin{verbatim} >>> 'ab' in 'abcd' True >>> 'ad' in 'abcd' False >>> '' in 'abcd' True \end{verbatim} Note that this doesn't tell you where the substring starts; the \method{find()} method is still necessary to figure that out. \item The \method{strip()}, \method{lstrip()}, and \method{rstrip()} string methods now have an optional argument for specifying the characters to strip. The default is still to remove all whitespace characters: \begin{verbatim} >>> ' abc '.strip() 'abc' >>> '><><><>'.strip('<>') 'abc' >>> '><><><>\n'.strip('<>') 'abc<><><>\n' >>> u'\u4000\u4001abc\u4000'.strip(u'\u4000') u'\u4001abc' >>> \end{verbatim} (Suggested by Simon Brunning, and implemented by Walter D\"orwald.) \item The \method{startswith()} and \method{endswith()} string methods now accept negative numbers for the start and end parameters. \item Another new string method is \method{zfill()}, originally a function in the \module{string} module. \method{zfill()} pads a numeric string with zeros on the left until it's the specified width. Note that the \code{\%} operator is still more flexible and powerful than \method{zfill()}. \begin{verbatim} >>> '45'.zfill(4) '0045' >>> '12345'.zfill(4) '12345' >>> 'goofy'.zfill(6) '0goofy' \end{verbatim} (Contributed by Walter D\"orwald.) \item A new type object, \class{basestring}, has been added. Both 8-bit strings and Unicode strings inherit from this type, so \code{isinstance(obj, basestring)} will return \constant{True} for either kind of string. It's a completely abstract type, so you can't create \class{basestring} instances. \item Interned strings are no longer immortal. Interned 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.) \end{itemize} \subsection{Optimizations} \begin{itemize} \item The \method{sort()} method of list objects has been extensively rewritten by Tim Peters, and the implementation is significantly faster. \item 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.) \item The \code{SET_LINENO} opcode is now gone. This may provide a small speed increase, subject to your compiler's idiosyncrasies. (Removed by Michael Hudson.) \item A number of small rearrangements have been made in various hotspots to improve performance, inlining a function here, removing some code there. (Implemented mostly by GvR, but lots of people have contributed to one change or another.) \end{itemize} %====================================================================== \section{New and Improved Modules} As usual, Python's standard modules had a number of enhancements and bug fixes. Here's a partial list of the most notable changes, sorted alphabetically by module name. Consult the \file{Misc/NEWS} file in the source tree for a more complete list of changes, or look through the CVS logs for all the details. \begin{itemize} \item The \module{array} module now supports arrays of Unicode characters using the \samp{u} format character. Arrays also now support using the \code{+=} assignment operator to add another array's contents, and the \code{*=} assignment operator to repeat an array. (Contributed by Jason Orendorff.) \item The Distutils \class{Extension} class now supports an extra constructor argument named \samp{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 \samp{sampmodule.c} includes the header file \file{sample.h}, you would create the \class{Extension} object like this: \begin{verbatim} ext = Extension("samp", sources=["sampmodule.c"], depends=["sample.h"]) \end{verbatim} Modifying \file{sample.h} would then cause the module to be recompiled. (Contributed by Jeremy Hylton.) \item Other minor changes to Distutils: it now checks for the \envvar{CC}, \envvar{CFLAGS}, \envvar{CPP}, \envvar{LDFLAGS}, and \envvar{CPPFLAGS} environment variables, using them to override the settings in Python's configuration (contributed by Robert Weber); the \function{get_distutils_option()} method lists recently-added extensions to Distutils. \item The \module{getopt} module gained a new function, \function{gnu_getopt()}, that supports the same arguments as the existing \function{getopt()} function but uses GNU-style scanning mode. The existing \function{getopt()} 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: \begin{verbatim} >>> getopt.getopt(['-f', 'filename', 'output', '-v'], 'f:v') ([('-f', 'filename')], ['output', '-v']) >>> getopt.gnu_getopt(['-f', 'filename', 'output', '-v'], 'f:v') ([('-f', 'filename'), ('-v', '')], ['output']) \end{verbatim} (Contributed by Peter \AA{strand}.) \item The \module{grp}, \module{pwd}, and \module{resource} modules now return enhanced tuples: \begin{verbatim} >>> import grp >>> g = grp.getgrnam('amk') >>> g.gr_name, g.gr_gid ('amk', 500) \end{verbatim} \item The new \module{heapq} module contains an implementation of a heap queue algorithm. A heap is an array-like data structure that keeps items in a sorted order such that, for every index k, heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2]. This makes it quick to remove the smallest item, and inserting a new item while maintaining the heap property is O(lg~n). (See \url{http://www.nist.gov/dads/HTML/priorityque.html} for more information about the priority queue data structure.) The Python \module{heapq} module provides \function{heappush()} and \function{heappop()} functions for adding and removing items while maintaining the heap property on top of some other mutable Python sequence type. For example: \begin{verbatim} >>> import heapq >>> heap = [] >>> for item in [3, 7, 5, 11, 1]: ... heapq.heappush(heap, item) ... >>> heap [1, 3, 5, 11, 7] >>> heapq.heappop(heap) 1 >>> heapq.heappop(heap) 3 >>> heap [5, 7, 11] >>> >>> heapq.heappush(heap, 5) >>> heap = [] >>> for item in [3, 7, 5, 11, 1]: ... heapq.heappush(heap, item) ... >>> heap [1, 3, 5, 11, 7] >>> heapq.heappop(heap) 1 >>> heapq.heappop(heap) 3 >>> heap [5, 7, 11] >>> \end{verbatim} (Contributed by Kevin O'Connor.) \item Two new functions in the \module{math} module, \function{degrees(\var{rads})} and \function{radians(\var{degs})}, convert between radians and degrees. Other functions in the \module{math} module such as \function{math.sin()} and \function{math.cos()} have always required input values measured in radians. (Contributed by Raymond Hettinger.) \item Seven new functions, \function{getpgid()}, \function{killpg()}, \function{lchown()}, \function{major()}, \function{makedev()}, \function{minor()}, and \function{mknod()}, were added to the \module{posix} module that underlies the \module{os} module. (Contributed by Gustavo Niemeyer and Geert Jansen.) \item The parser objects provided by the \module{pyexpat} module can now optionally buffer character data, resulting in fewer calls to your character data handler and therefore faster performance. Setting the parser object's \member{buffer_text} attribute to \constant{True} will enable buffering. \item The \module{readline} module also gained a number of new functions: \function{get_history_item()}, \function{get_current_history_length()}, and \function{redisplay()}. \item Support for more advanced POSIX signal handling was added to the \module{signal} module by adding the \function{sigpending}, \function{sigprocmask} and \function{sigsuspend} functions, where supported by the platform. These functions make it possible to avoid some previously unavoidable race conditions. \item The \module{socket} module now supports timeouts. You can call the \method{settimeout(\var{t})} method on a socket object to set a timeout of \var{t} seconds. Subsequent socket operations that take longer than \var{t} seconds to complete will abort and raise a \exception{socket.error} exception. The original timeout implementation was by Tim O'Malley. Michael Gilfix integrated it into the Python \module{socket} module, after the patch had undergone a lengthy review. After it was checked in, Guido van~Rossum rewrote parts of it. This is a good example of the free software development process in action. \item The value of the C \constant{PYTHON_API_VERSION} macro is now exposed at the Python level as \code{sys.api_version}. \item The new \module{textwrap} module contains functions for wrapping strings containing paragraphs of text. The \function{wrap(\var{text}, \var{width})} function takes a string and returns a list containing the text split into lines of no more than the chosen width. The \function{fill(\var{text}, \var{width})} function returns a single string, reformatted to fit into lines no longer than the chosen width. (As you can guess, \function{fill()} is built on top of \function{wrap()}. For example: \begin{verbatim} >>> import textwrap >>> paragraph = "Not a whit, we defy augury: ... more text ..." >>> textwrap.wrap(paragraph, 60) ["Not a whit, we defy augury: there's a special providence in", "the fall of a sparrow. If it be now, 'tis not to come; if it", ...] >>> print textwrap.fill(paragraph, 35) Not a whit, we defy augury: there's a special providence in the fall of a sparrow. If it be now, '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. >>> \end{verbatim} The module also contains a \class{TextWrapper} class that actually implements the text wrapping strategy. Both the \class{TextWrapper} class and the \function{wrap()} and \function{fill()} functions support a number of additional keyword arguments for fine-tuning the formatting; consult the module's documentation for details. % XXX add a link to the module docs? (Contributed by Greg Ward.) \item The \module{time} module's \function{strptime()} function has long been an annoyance because it uses the platform C library's \function{strptime()} implementation, and different platforms sometimes have odd bugs. Brett Cannon contributed a portable implementation that's written in pure Python, which should behave identically on all platforms. \item The DOM implementation in \module{xml.dom.minidom} can now generate XML output in a particular encoding, by specifying an optional encoding argument to the \method{toxml()} and \method{toprettyxml()} methods of DOM nodes. \item The \function{*stat()} family of functions can now report fractions of a second in a timestamp. Such time stamps are represented as floats, similar to \function{time.time()}. During testing, it was found that some applications will break if time stamps are floats. For compatibility, when using the tuple interface of the \class{stat_result}, time stamps are represented as integers. When using named fields (a feature first introduced in Python 2.2), time stamps are still represented as ints, unless \function{os.stat_float_times()} is invoked to enable float return values: \begin{verbatim} >>> os.stat("/tmp").st_mtime 1034791200 >>> os.stat_float_times(True) >>> os.stat("/tmp").st_mtime 1034791200.6335014 \end{verbatim} In Python 2.4, the default will change to always returning floats. Application developers should use 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. \end{itemize} %====================================================================== \section{Specialized Object Allocator (pymalloc)\label{section-pymalloc}} An experimental feature added to Python 2.1 was a specialized object allocator called pymalloc, written by Vladimir Marangozov. Pymalloc was intended to be faster than the system \cfunction{malloc()} and have less memory overhead for typical allocation patterns of Python programs. The allocator uses C's \cfunction{malloc()} 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't enabled by default; you had to explicitly turn it on by providing the \longprogramopt{with-pymalloc} option to the \program{configure} script. In 2.3, pymalloc has had further enhancements and is now enabled by default; you'll have to supply \longprogramopt{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 the object allocator enabled, because some incorrect code may cause core dumps at runtime. There are a bunch of memory allocation functions in Python's C API that have previously been just aliases for the C library's \cfunction{malloc()} and \cfunction{free()}, meaning that if you accidentally called mismatched functions, the error wouldn't be noticeable. When the object allocator is enabled, these functions aren't aliases of \cfunction{malloc()} and \cfunction{free()} any more, and calling the wrong function to free memory may get you a core dump. For example, if memory was allocated using \cfunction{PyObject_Malloc()}, it has to be freed using \cfunction{PyObject_Free()}, not \cfunction{free()}. 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 another family of functions specifically for allocating Python \emph{objects} (as opposed to memory). \begin{itemize} \item To allocate and free an undistinguished chunk of memory use the ``raw memory'' family: \cfunction{PyMem_Malloc()}, \cfunction{PyMem_Realloc()}, and \cfunction{PyMem_Free()}. \item The ``object memory'' family is the interface to the pymalloc facility described above and is biased towards a large number of ``small'' allocations: \cfunction{PyObject_Malloc}, \cfunction{PyObject_Realloc}, and \cfunction{PyObject_Free}. \item To allocate and free Python objects, use the ``object'' family \cfunction{PyObject_New()}, \cfunction{PyObject_NewVar()}, and \cfunction{PyObject_Del()}. \end{itemize} 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, turn on the Python interpreter's debugging code by running \program{configure} with \longprogramopt{with-pydebug}. To aid extension writers, a header file \file{Misc/pymemcompat.h} is distributed with the source to Python 2.3 that allows Python extensions to use the 2.3 interfaces to memory allocation and compile against any version of Python since 1.5.2. You would copy the file from Python's source distribution and bundle it with the source of your extension. \begin{seealso} \seeurl{http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/python/python/dist/src/Objects/obmalloc.c} {For the full details of the pymalloc implementation, see the comments at the top of the file \file{Objects/obmalloc.c} in the Python source code. The above link points to the file within the SourceForge CVS browser.} \end{seealso} % ====================================================================== \section{Build and C API Changes} Changes to Python's build process and to the C API include: \begin{itemize} \item The C-level interface to the garbage collector has been changed, to make it easier to write extension types that support garbage collection, and to make it easier to debug misuses of the functions. Various functions have slightly different semantics, so a bunch of functions had to be renamed. Extensions that use the old API will still compile but will \emph{not} participate in garbage collection, so updating them for 2.3 should be considered fairly high priority. To upgrade an extension module to the new API, perform the following steps: \begin{itemize} \item Rename \cfunction{Py_TPFLAGS_GC} to \cfunction{PyTPFLAGS_HAVE_GC}. \item Use \cfunction{PyObject_GC_New} or \cfunction{PyObject_GC_NewVar} to allocate objects, and \cfunction{PyObject_GC_Del} to deallocate them. \item Rename \cfunction{PyObject_GC_Init} to \cfunction{PyObject_GC_Track} and \cfunction{PyObject_GC_Fini} to \cfunction{PyObject_GC_UnTrack}. \item Remove \cfunction{PyGC_HEAD_SIZE} from object size calculations. \item Remove calls to \cfunction{PyObject_AS_GC} and \cfunction{PyObject_FROM_GC}. \end{itemize} \item Python can now optionally be built as a shared library (\file{libpython2.3.so}) by supplying \longprogramopt{enable-shared} when running Python's \file{configure} script. (Contributed by Ondrej Palkovsky.) \item The \csimplemacro{DL_EXPORT} and \csimplemacro{DL_IMPORT} macros are now deprecated. Initialization functions for Python extension modules should now be declared using the new macro \csimplemacro{PyMODINIT_FUNC}, while the Python core will generally use the \csimplemacro{PyAPI_FUNC} and \csimplemacro{PyAPI_DATA} macros. \item The interpreter can be compiled without any docstrings for the built-in functions and modules by supplying \longprogramopt{without-doc-strings} to the \file{configure} script. This makes the Python executable about 10\% smaller, but will also mean that you can't get help for Python's built-ins. (Contributed by Gustavo Niemeyer.) \item The cycle detection implementation used by the garbage collection has proven to be stable, so it's now being made mandatory; you can no longer compile Python without it, and the \longprogramopt{with-cycle-gc} switch to \file{configure} has been removed. \item The \cfunction{PyArg_NoArgs()} 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 \constant{METH_NOARGS} 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 \code{PyArg_ParseTuple(args, "")} instead, but this will be slower than using \constant{METH_NOARGS}. \item A new function, \cfunction{PyObject_DelItemString(\var{mapping}, char *\var{key})} was added as shorthand for \code{PyObject_DelItem(\var{mapping}, PyString_New(\var{key})}. \item File objects now manage their internal string buffer differently by increasing it exponentially when needed. This results in the benchmark tests in \file{Lib/test/test_bufio.py} speeding up from 57 seconds to 1.7 seconds, according to one measurement. \item It's now possible to define class and static methods for a C extension type by setting either the \constant{METH_CLASS} or \constant{METH_STATIC} flags in a method's \ctype{PyMethodDef} structure. \item Python now includes a copy of the Expat XML parser's source code, removing any dependence on a system version or local installation of Expat. \end{itemize} \subsection{Port-Specific Changes} Support for a port to IBM'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; \function{fork()} and \function{fcntl()} are restricted by the limitations of the underlying emulation layer. The standard OS/2 port, which uses IBM'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 curent OS version. Instead calling the missing routine will raise an exception. (Contributed by Jack Jansen.) The RPM spec files, found in the \file{Misc/RPM/} directory in the Python source distribution, were updated for 2.3. (Contributed by Sean Reifschneider.) Python now supports AtheOS (\url{http://www.atheos.cx}) and GNU/Hurd. %====================================================================== \section{Other Changes and Fixes} 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 289 patches applied and 323 bugs fixed between Python 2.2 and 2.3. Both figures are likely to be underestimates. Some of the more notable changes are: \begin{itemize} \item The tools used to build the documentation now work under Cygwin as well as \UNIX. \item The \code{SET_LINENO} 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., \module{pdb}). Since Python 1.5, the line numbers in tracebacks have been computed using a different mechanism that works with ``python -O''. For Python 2.3 Michael Hudson implemented a similar scheme to determine when to call the trace function, removing the need for \code{SET_LINENO} entirely. It would be difficult to detect any resulting difference from Python code, apart from a slight speed up when Python is run without \programopt{-O}. C extensions that access the \member{f_lineno} field of frame objects should instead call \code{PyCode_Addr2Line(f->f_code, f->f_lasti)}. This will have the added effect of making the code work as desired under ``python -O'' in earlier versions of Python. \end{itemize} %====================================================================== \section{Porting to Python 2.3} XXX write this %====================================================================== \section{Acknowledgements \label{acks}} The author would like to thank the following people for offering suggestions, corrections and assistance with various drafts of this article: Simon Brunning, Michael Chermside, Scott David Daniels, Fred~L. Drake, Jr., Michael Hudson, Detlef Lannert, Martin von L\"owis, Andrew MacIntyre, Lalo Martins, Gustavo Niemeyer, Neal Norwitz, Neil Schemenauer, Jason Tishler. \end{document}