689 lines
25 KiB
TeX
689 lines
25 KiB
TeX
\documentclass{howto}
|
|
\usepackage{distutils}
|
|
% $Id$
|
|
|
|
\title{What's New in Python 2.4}
|
|
\release{0.0}
|
|
\author{A.M.\ Kuchling}
|
|
\authoraddress{
|
|
\strong{Python Software Foundation}\\
|
|
Email: \email{amk@amk.ca}
|
|
}
|
|
|
|
\begin{document}
|
|
\maketitle
|
|
\tableofcontents
|
|
|
|
This article explains the new features in Python 2.4. The release
|
|
date is expected to be around September 2004.
|
|
|
|
While Python 2.3 was primarily a library development release, Python
|
|
2.4 may extend the core language and interpreter in
|
|
as-yet-undetermined ways.
|
|
|
|
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.4,
|
|
such as the \citetitle[../lib/lib.html]{Python Library Reference} and
|
|
the \citetitle[../ref/ref.html]{Python Reference Manual}.
|
|
If you want to understand the complete implementation and design
|
|
rationale, refer to the PEP for a particular new feature.
|
|
|
|
|
|
%======================================================================
|
|
\section{PEP 218: Built-In Set Objects}
|
|
|
|
Two new built-in types, \function{set(\var{iterable})} and
|
|
\function{frozenset(\var{iterable})} provide high speed data types for
|
|
membership testing, for eliminating duplicates from sequences, and
|
|
for mathematical operations like unions, intersections, differences,
|
|
and symmetric differences.
|
|
|
|
\begin{verbatim}
|
|
>>> a = set('abracadabra') # form a set from a string
|
|
>>> 'z' in a # fast membership testing
|
|
False
|
|
>>> a # unique letters in a
|
|
set(['a', 'r', 'b', 'c', 'd'])
|
|
>>> ''.join(a) # convert back into a string
|
|
'arbcd'
|
|
|
|
>>> b = set('alacazam') # form a second set
|
|
>>> a - b # letters in a but not in b
|
|
set(['r', 'd', 'b'])
|
|
>>> a | b # letters in either a or b
|
|
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
|
|
>>> a & b # letters in both a and b
|
|
set(['a', 'c'])
|
|
>>> a ^ b # letters in a or b but not both
|
|
set(['r', 'd', 'b', 'm', 'z', 'l'])
|
|
|
|
>>> a.add('z') # add a new element
|
|
>>> a.update('wxy') # add multiple new elements
|
|
>>> a
|
|
set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'x', 'z'])
|
|
>>> a.remove('x') # take one element out
|
|
>>> a
|
|
set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'z'])
|
|
\end{verbatim}
|
|
|
|
The type \function{frozenset()} is an immutable version of \function{set()}.
|
|
Since it is immutable and hashable, it may be used as a dictionary key or
|
|
as a member of another set. Accordingly, it does not have methods
|
|
like \method{add()} and \method{remove()} which could alter its contents.
|
|
|
|
% XXX what happens to the sets module?
|
|
% The current thinking is that the sets module will be left alone.
|
|
% That way, existing code will continue to run without alteration.
|
|
% Also, the module provides an autoconversion feature not supported by set()
|
|
% and frozenset().
|
|
|
|
\begin{seealso}
|
|
\seepep{218}{Adding a Built-In Set Object Type}{Originally proposed by
|
|
Greg Wilson and ultimately implemented by Raymond Hettinger.}
|
|
\end{seealso}
|
|
|
|
%======================================================================
|
|
\section{PEP 237: Unifying Long Integers and Integers}
|
|
|
|
XXX write this.
|
|
|
|
%======================================================================
|
|
\section{PEP 229: Generator Expressions}
|
|
|
|
Now, simple generators can be coded succinctly as expressions using a syntax
|
|
like list comprehensions but with parentheses instead of brackets. These
|
|
expressions are designed for situations where the generator is used right
|
|
away by an enclosing function. Generator expressions are more compact but
|
|
less versatile than full generator definitions and they tend to be more memory
|
|
friendly than equivalent list comprehensions.
|
|
|
|
\begin{verbatim}
|
|
g = (tgtexp for var1 in exp1 for var2 in exp2 if exp3)
|
|
\end{verbatim}
|
|
|
|
is equivalent to:
|
|
|
|
\begin{verbatim}
|
|
def __gen(exp):
|
|
for var1 in exp:
|
|
for var2 in exp2:
|
|
if exp3:
|
|
yield tgtexp
|
|
g = __gen(iter(exp1))
|
|
del __gen
|
|
\end{verbatim}
|
|
|
|
The advantage over full generator definitions is in economy of
|
|
expression. Their advantage over list comprehensions is in saving
|
|
memory by creating data only when it is needed rather than forming
|
|
a whole list is memory all at once. Applications using memory
|
|
friendly generator expressions may scale-up to high volumes of data
|
|
more readily than with list comprehensions.
|
|
|
|
Generator expressions are best used in functions that consume their
|
|
data all at once and would not benefit from having a full list instead
|
|
of a generator as an input:
|
|
|
|
\begin{verbatim}
|
|
>>> sum(i*i for i in range(10))
|
|
285
|
|
|
|
>>> sorted(set(i*i for i in xrange(-20, 20) if i%2==1)) # odd squares
|
|
[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]
|
|
|
|
>>> from itertools import izip
|
|
>>> xvec = [10, 20, 30]
|
|
>>> yvec = [7, 5, 3]
|
|
>>> sum(x*y for x,y in izip(xvec, yvec)) # dot product
|
|
260
|
|
|
|
>>> from math import pi, sin
|
|
>>> sine_table = dict((x, sin(x*pi/180)) for x in xrange(0, 91))
|
|
|
|
>>> unique_words = set(word for line in page for word in line.split())
|
|
|
|
>>> valedictorian = max((student.gpa, student.name) for student in graduates)
|
|
|
|
\end{verbatim}
|
|
|
|
For more complex uses of generators, it is strongly recommended that
|
|
the traditional full generator definitions be used instead. In a
|
|
generator expression, the first for-loop expression is evaluated
|
|
as soon as the expression is defined while the other expressions do
|
|
not get evaluated until the generator is run. This nuance is never
|
|
an issue when the generator is used immediately; however, if it is not
|
|
used right away, a full generator definition would be much more clear
|
|
about when the sub-expressions are evaluated and would be more obvious
|
|
about the visibility and lifetime of the variables.
|
|
|
|
\begin{seealso}
|
|
\seepep{289}{Generator Expressions}{Proposed by Raymond Hettinger and
|
|
implemented by Jiwon Seo with early efforts steered by Hye-Shik Chang.}
|
|
\end{seealso}
|
|
|
|
%======================================================================
|
|
\section{PEP 322: Reverse Iteration}
|
|
|
|
A new built-in function, \function{reversed(\var{seq})}, takes a sequence
|
|
and returns an iterator that returns the elements of the sequence
|
|
in reverse order.
|
|
|
|
\begin{verbatim}
|
|
>>> for i in reversed(xrange(1,4)):
|
|
... print i
|
|
...
|
|
3
|
|
2
|
|
1
|
|
\end{verbatim}
|
|
|
|
Compared to extended slicing, \code{range(1,4)[::-1]}, \function{reversed()}
|
|
is easier to read, runs faster, and uses substantially less memory.
|
|
|
|
Note that \function{reversed()} only accepts sequences, not arbitrary
|
|
iterators. If you want to reverse an iterator, first convert it to
|
|
a list with \function{list()}.
|
|
|
|
\begin{verbatim}
|
|
>>> input= open('/etc/passwd', 'r')
|
|
>>> for line in reversed(list(input)):
|
|
... print line
|
|
...
|
|
root:*:0:0:System Administrator:/var/root:/bin/tcsh
|
|
...
|
|
\end{verbatim}
|
|
|
|
\begin{seealso}
|
|
\seepep{322}{Reverse Iteration}{Written and implemented by Raymond Hettinger.}
|
|
|
|
\end{seealso}
|
|
|
|
|
|
%======================================================================
|
|
\section{Other Language Changes}
|
|
|
|
Here are all of the changes that Python 2.4 makes to the core Python
|
|
language.
|
|
|
|
\begin{itemize}
|
|
|
|
\item The \method{dict.update()} method now accepts the same
|
|
argument forms as the \class{dict} constructor. This includes any
|
|
mapping, any iterable of key/value pairs, and/or keyword arguments.
|
|
|
|
\item The string methods, \method{ljust()}, \method{rjust()}, and
|
|
\method{center()} now take an optional argument for specifying a
|
|
fill character other than a space.
|
|
|
|
\item Strings also gained an \method{rsplit()} method that
|
|
works like the \method{split()} method but splits from the end of
|
|
the string.
|
|
|
|
\begin{verbatim}
|
|
>>> 'www.python.org'.split('.', 1)
|
|
['www', 'python.org']
|
|
'www.python.org'.rsplit('.', 1)
|
|
['www.python', 'org']
|
|
\end{verbatim}
|
|
|
|
\item The \method{sort()} method of lists gained three keyword
|
|
arguments, \var{cmp}, \var{key}, and \var{reverse}. These arguments
|
|
make some common usages of \method{sort()} simpler. All are optional.
|
|
|
|
\var{cmp} is the same as the previous single argument to
|
|
\method{sort()}; if provided, the value should be a comparison
|
|
function that takes two arguments and returns -1, 0, or +1 depending
|
|
on how the arguments compare.
|
|
|
|
\var{key} should be a single-argument function that takes a list
|
|
element and returns a comparison key for the element. The list is
|
|
then sorted using the comparison keys. The following example sorts a
|
|
list case-insensitively:
|
|
|
|
\begin{verbatim}
|
|
>>> L = ['A', 'b', 'c', 'D']
|
|
>>> L.sort() # Case-sensitive sort
|
|
>>> L
|
|
['A', 'D', 'b', 'c']
|
|
>>> L.sort(key=lambda x: x.lower())
|
|
>>> L
|
|
['A', 'b', 'c', 'D']
|
|
>>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))
|
|
>>> L
|
|
['A', 'b', 'c', 'D']
|
|
\end{verbatim}
|
|
|
|
The last example, which uses the \var{cmp} parameter, is the old way
|
|
to perform a case-insensitive sort. It works but is slower than
|
|
using a \var{key} parameter. Using \var{key} results in calling the
|
|
\method{lower()} method once for each element in the list while using
|
|
\var{cmp} will call the method twice for each comparison.
|
|
|
|
For simple key functions and comparison functions, it is often
|
|
possible to avoid a \keyword{lambda} expression by using an unbound
|
|
method instead. For example, the above case-insensitive sort is best
|
|
coded as:
|
|
|
|
\begin{verbatim}
|
|
>>> L.sort(key=str.lower)
|
|
>>> L
|
|
['A', 'b', 'c', 'D']
|
|
\end{verbatim}
|
|
|
|
The \var{reverse} parameter should have a Boolean value. If the value is
|
|
\constant{True}, the list will be sorted into reverse order. Instead
|
|
of \code{L.sort(lambda x,y: cmp(y.score, x.score))}, you can now write:
|
|
\code{L.sort(key = lambda x: x.score, reverse=True)}.
|
|
|
|
The results of sorting are now guaranteed to be stable. This means
|
|
that two entries with equal keys will be returned in the same order as
|
|
they were input. For example, you can sort a list of people by name,
|
|
and then sort the list by age, resulting in a list sorted by age where
|
|
people with the same age are in name-sorted order.
|
|
|
|
\item There is a new built-in function
|
|
\function{sorted(\var{iterable})} that works like the in-place
|
|
\method{list.sort()} method but has been made suitable for use in
|
|
expressions. The differences are:
|
|
\begin{itemize}
|
|
\item the input may be any iterable;
|
|
\item a newly formed copy is sorted, leaving the original intact; and
|
|
\item the expression returns the new sorted copy
|
|
\end{itemize}
|
|
|
|
\begin{verbatim}
|
|
>>> L = [9,7,8,3,2,4,1,6,5]
|
|
>>> [10+i for i in sorted(L)] # usable in a list comprehension
|
|
[11, 12, 13, 14, 15, 16, 17, 18, 19]
|
|
>>> L = [9,7,8,3,2,4,1,6,5] # original is left unchanged
|
|
[9,7,8,3,2,4,1,6,5]
|
|
|
|
>>> sorted('Monte Python') # any iterable may be an input
|
|
[' ', 'M', 'P', 'e', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y']
|
|
|
|
>>> # List the contents of a dict sorted by key values
|
|
>>> colormap = dict(red=1, blue=2, green=3, black=4, yellow=5)
|
|
>>> for k, v in sorted(colormap.iteritems()):
|
|
... print k, v
|
|
...
|
|
black 4
|
|
blue 2
|
|
green 3
|
|
red 1
|
|
yellow 5
|
|
|
|
\end{verbatim}
|
|
|
|
\item The \function{zip()} built-in function and \function{itertools.izip()}
|
|
now return an empty list instead of raising a \exception{TypeError}
|
|
exception if called with no arguments. This makes them more
|
|
suitable for use with variable length argument lists:
|
|
|
|
\begin{verbatim}
|
|
>>> def transpose(array):
|
|
... return zip(*array)
|
|
...
|
|
>>> transpose([(1,2,3), (4,5,6)])
|
|
[(1, 4), (2, 5), (3, 6)]
|
|
>>> transpose([])
|
|
[]
|
|
\end{verbatim}
|
|
|
|
\end{itemize}
|
|
|
|
|
|
%======================================================================
|
|
\subsection{Optimizations}
|
|
|
|
\begin{itemize}
|
|
|
|
\item The inner loops for \class{list} and \class{tuple} slicing
|
|
were optimized and now run about one-third faster. The inner
|
|
loops were also optimized for \class{dict} with performance
|
|
boosts to \method{keys()}, \method{values()}, \method{items()},
|
|
\method{iterkeys()}, \method{itervalues()}, and \method{iteritems()}.
|
|
|
|
\item The machinery for growing and shrinking lists was optimized
|
|
for speed and for space efficiency. Small lists (under eight elements)
|
|
never over-allocate by more than three elements. Large lists do not
|
|
over-allocate by more than 1/8th. Appending and popping from lists
|
|
now runs faster due to more efficient code paths and less frequent
|
|
use of the underlying system realloc(). List comprehensions also
|
|
benefit. The amount of improvement varies between systems and shows
|
|
the greatest improvement on systems with poor realloc() implementations.
|
|
\method{list.extend()} was also optimized and no longer converts its
|
|
argument into a temporary list prior to extending the base list.
|
|
|
|
\item \function{list()}, \function{tuple()}, \function{map()},
|
|
\function{filter()}, and \function{zip()} now run several times
|
|
faster with non-sequence arguments that supply a \method{__len__()}
|
|
method. Previously, the pre-sizing optimization only applied to
|
|
sequence arguments.
|
|
|
|
\item The methods \method{list.__getitem__()},
|
|
\method{dict.__getitem__()}, and \method{dict.__contains__()} are
|
|
are now implemented as \class{method_descriptor} objects rather
|
|
than \class{wrapper_descriptor} objects. This form of optimized
|
|
access doubles their performance and makes them more suitable for
|
|
use as arguments to functionals:
|
|
\samp{map(mydict.__getitem__, keylist)}.
|
|
|
|
\item Added a new opcode, \code{LIST_APPEND}, that simplifies
|
|
the generated bytecode for list comprehensions and speeds them up
|
|
by about a third.
|
|
|
|
\end{itemize}
|
|
|
|
The net result of the 2.4 optimizations is that Python 2.4 runs the
|
|
pystone benchmark around XX\% faster than Python 2.3 and YY\% faster
|
|
than Python 2.2.
|
|
|
|
|
|
%======================================================================
|
|
\section{New, Improved, and Deprecated Modules}
|
|
|
|
As usual, Python's standard library received a number of enhancements and
|
|
bug fixes. Here's a partial list of the most notable changes, sorted
|
|
alphabetically by module name. Consult the
|
|
\file{Misc/NEWS} file in the source tree for a more
|
|
complete list of changes, or look through the CVS logs for all the
|
|
details.
|
|
|
|
\begin{itemize}
|
|
|
|
\item The \module{curses} modules now supports the ncurses extension
|
|
\function{use_default_colors()}. On platforms where the terminal
|
|
supports transparency, this makes it possible to use a transparent
|
|
background. (Contributed by J\"org Lehmann.)
|
|
|
|
\item The \module{bisect} module now has an underlying C implementation
|
|
for improved performance.
|
|
(Contributed by Dmitry Vasiliev.)
|
|
|
|
\item The CJKCodecs collections of East Asian codecs, maintained
|
|
by Hye-Shik Chang, was integrated into 2.4.
|
|
The new encodings are:
|
|
|
|
\begin{itemize}
|
|
\item Chinese (PRC): gb2312, gbk, gb18030, hz
|
|
\item Chinese (ROC): big5, cp950
|
|
\item Japanese: cp932, shift-jis, shift-jisx0213, euc-jp,
|
|
euc-jisx0213, iso-2022-jp, iso-2022-jp-1, iso-2022-jp-2,
|
|
iso-2022-jp-3, iso-2022-jp-ext
|
|
\item Korean: cp949, euc-kr, johab, iso-2022-kr
|
|
\end{itemize}
|
|
|
|
\item There is a new \module{collections} module for
|
|
various specialized collection datatypes.
|
|
Currently it contains just one type, \class{deque},
|
|
a double-ended queue that supports efficiently adding and removing
|
|
elements from either end.
|
|
|
|
\begin{verbatim}
|
|
>>> from collections import deque
|
|
>>> d = deque('ghi') # make a new deque with three items
|
|
>>> d.append('j') # add a new entry to the right side
|
|
>>> d.appendleft('f') # add a new entry to the left side
|
|
>>> d # show the representation of the deque
|
|
deque(['f', 'g', 'h', 'i', 'j'])
|
|
>>> d.pop() # return and remove the rightmost item
|
|
'j'
|
|
>>> d.popleft() # return and remove the leftmost item
|
|
'f'
|
|
>>> list(d) # list the contents of the deque
|
|
['g', 'h', 'i']
|
|
>>> 'h' in d # search the deque
|
|
True
|
|
\end{verbatim}
|
|
|
|
Several modules now take advantage of \class{collections.deque} for
|
|
improved performance: \module{Queue}, \module{mutex}, \module{shlex}
|
|
\module{threading}, and \module{pydoc}.
|
|
|
|
\item The \module{ConfigParser} classes have been enhanced slightly.
|
|
The \method{read()} method now returns a list of the files that
|
|
were successfully parsed, and the \method{set()} method raises
|
|
\exception{TypeError} if passed a \var{value} argument that isn't a
|
|
string.
|
|
|
|
\item The \module{heapq} module has been converted to C. The resulting
|
|
tenfold improvement in speed makes the module suitable for handling
|
|
high volumes of data. In addition, the module has two new functions
|
|
\function{nlargest()} and \function{nsmallest()} that use heaps to
|
|
find the largest or smallest n values in a dataset without the
|
|
expense of a full sort.
|
|
|
|
\item The \module{imaplib} module now supports IMAP's THREAD command.
|
|
(Contributed by Yves Dionne.)
|
|
|
|
\item The \module{itertools} module gained a
|
|
\function{groupby(\var{iterable}\optional{, \var{func}})} function,
|
|
inspired by the GROUP BY clause from SQL.
|
|
\var{iterable} returns a succession of elements, and the optional
|
|
\var{func} is a function that takes an element and returns a key
|
|
value; if omitted, the key is simply the element itself.
|
|
\function{groupby()} then groups the elements into subsequences
|
|
which have matching values of the key, and returns a series of 2-tuples
|
|
containing the key value and an iterator over the subsequence.
|
|
|
|
Here's an example. The \var{key} function simply returns whether a
|
|
number is even or odd, so the result of \function{groupby()} is to
|
|
return consecutive runs of odd or even numbers.
|
|
|
|
\begin{verbatim}
|
|
>>> import itertools
|
|
>>> L = [2,4,6, 7,8,9,11, 12, 14]
|
|
>>> for key_val, it in itertools.groupby(L, lambda x: x % 2):
|
|
... print key_val, list(it)
|
|
...
|
|
0 [2, 4, 6]
|
|
1 [7]
|
|
0 [8]
|
|
1 [9, 11]
|
|
0 [12, 14]
|
|
>>>
|
|
\end{verbatim}
|
|
|
|
Like its SQL counterpart, \function{groupby()} is typically used with
|
|
sorted input. The logic for \function{groupby()} is similar to the
|
|
\UNIX{} \code{uniq} filter which makes it handy for eliminating,
|
|
counting, or identifying duplicate elements:
|
|
|
|
\begin{verbatim}
|
|
>>> word = 'abracadabra'
|
|
>>> letters = sorted(word) # Turn string into a sorted list of letters
|
|
>>> letters
|
|
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']
|
|
>>> [k for k, g in groupby(letters)] # List unique letters
|
|
['a', 'b', 'c', 'd', 'r']
|
|
>>> [(k, len(list(g))) for k, g in groupby(letters)] # Count letter occurences
|
|
[('a', 5), ('b', 2), ('c', 1), ('d', 1), ('r', 2)]
|
|
>>> [k for k, g in groupby(letters) if len(list(g)) > 1] # List duplicated letters
|
|
['a', 'b', 'r']
|
|
\end{verbatim}
|
|
|
|
\item \module{itertools} also gained a function named
|
|
\function{tee(\var{iterator}, \var{N})} that returns \var{N} independent
|
|
iterators that replicate \var{iterator}. If \var{N} is omitted, the
|
|
default is 2.
|
|
|
|
\begin{verbatim}
|
|
>>> L = [1,2,3]
|
|
>>> i1, i2 = itertools.tee(L)
|
|
>>> i1,i2
|
|
(<itertools.tee object at 0x402c2080>, <itertools.tee object at 0x402c2090>)
|
|
>>> list(i1) # Run the first iterator to exhaustion
|
|
[1, 2, 3]
|
|
>>> list(i2) # Run the second iterator to exhaustion
|
|
[1, 2, 3]
|
|
>\end{verbatim}
|
|
|
|
Note that \function{tee()} has to keep copies of the values returned
|
|
by the iterator; in the worst case, it may need to keep all of them.
|
|
This should therefore be used carefully if the leading iterator
|
|
can run far ahead of the trailing iterator in a long stream of inputs.
|
|
If the separation is large, then it becomes preferable to use
|
|
\function{list()} instead. When the iterators track closely with one
|
|
another, \function{tee()} is ideal. Possible applications include
|
|
bookmarking, windowing, or lookahead iterators.
|
|
|
|
\item A new \function{getsid()} function was added to the
|
|
\module{posix} module that underlies the \module{os} module.
|
|
(Contributed by J. Raynor.)
|
|
|
|
\item The \module{operator} module gained two new functions,
|
|
\function{attrgetter(\var{attr})} and \function{itemgetter(\var{index})}.
|
|
Both functions return callables that take a single argument and return
|
|
the corresponding attribute or item; these callables make excellent
|
|
data extractors when used with \function{map()} or \function{sorted()}.
|
|
For example:
|
|
|
|
\begin{verbatim}
|
|
>>> L = [('c', 2), ('d', 1), ('a', 4), ('b', 3)]
|
|
>>> map(operator.itemgetter(0), L)
|
|
['c', 'd', 'a', 'b']
|
|
>>> map(operator.itemgetter(1), L)
|
|
[2, 1, 4, 3]
|
|
>>> sorted(L, key=operator.itemgetter(1)) # Sort list by second tuple item
|
|
[('d', 1), ('c', 2), ('b', 3), ('a', 4)]
|
|
\end{verbatim}
|
|
|
|
\item The \module{random} module has a new method called \method{getrandbits(N)}
|
|
which returns an N-bit long integer. This method supports the existing
|
|
\method{randrange()} method, making it possible to efficiently generate
|
|
arbitrarily large random numbers.
|
|
|
|
\item The regular expression language accepted by the \module{re} module
|
|
was extended with simple conditional expressions, written as
|
|
\code{(?(\var{group})\var{A}|\var{B})}. \var{group} is either a
|
|
numeric group ID or a group name defined with \code{(?P<group>...)}
|
|
earlier in the expression. If the specified group matched, the
|
|
regular expression pattern \var{A} will be tested against the string; if
|
|
the group didn't match, the pattern \var{B} will be used instead.
|
|
|
|
\item The \module{weakref} module now supports a wider variety of objects
|
|
including Python functions, class instances, sets, frozensets, deques,
|
|
arrays, files, sockets, and regular expression pattern objects.
|
|
|
|
\end{itemize}
|
|
|
|
|
|
%======================================================================
|
|
% whole new modules get described in \subsections here
|
|
|
|
\subsection{cookielib}
|
|
|
|
The \module{cookielib} library supports client-side handling for HTTP
|
|
cookies, just as the \module{Cookie} provides server-side cookie
|
|
support in CGI scripts. This library manages cookies in a way similar
|
|
to web browsers. Cookies are stored in cookie jars; the library
|
|
transparently stores cookies offered by the web server in the cookie
|
|
jar, and fetches the cookie from the jar when connecting to the
|
|
server. Similar to web browsers, policy objects control whether
|
|
cookies are accepted or not.
|
|
|
|
In order to store cookies across sessions, two implementations of
|
|
cookie jars are provided: one that stores cookies in the Netscape
|
|
format, so applications can use the Mozilla or Lynx cookie jars, and
|
|
one that stores cookies in the same format as the Perl libwww libary.
|
|
|
|
\module{urllib2} has been changed to interact with \module{cookielib}:
|
|
\class{HTTPCookieProcessor} manages a cookie jar that is used when
|
|
accessing URLs.
|
|
|
|
% ======================================================================
|
|
\section{Build and C API Changes}
|
|
|
|
Changes to Python's build process and to the C API include:
|
|
|
|
\begin{itemize}
|
|
|
|
\item Three new convenience macros were added for common return
|
|
values from extension functions: \csimplemacro{Py_RETURN_NONE},
|
|
\csimplemacro{Py_RETURN_TRUE}, and \csimplemacro{Py_RETURN_FALSE}.
|
|
|
|
\item A new function, \cfunction{PyTuple_Pack(\var{N}, \var{obj1},
|
|
\var{obj2}, ..., \var{objN})}, constructs tuples from a variable
|
|
length argument list of Python objects.
|
|
|
|
\item A new function, \cfunction{PyDict_Contains(\var{d}, \var{k})},
|
|
implements fast dictionary lookups without masking exceptions raised
|
|
during the look-up process.
|
|
|
|
\item A new method flag, \constant{METH_COEXISTS}, allows a function
|
|
defined in slots to co-exist with a PyCFunction having the same name.
|
|
This can halve the access to time to a method such as
|
|
\method{set.__contains__()}
|
|
|
|
\end{itemize}
|
|
|
|
|
|
%======================================================================
|
|
\subsection{Port-Specific Changes}
|
|
|
|
\begin{itemize}
|
|
|
|
\item The Windows port now builds under MSVC++ 7.1 as well as version 6.
|
|
|
|
\end{itemize}
|
|
|
|
|
|
%======================================================================
|
|
\section{Other Changes and Fixes \label{section-other}}
|
|
|
|
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 XXX patches applied and YYY bugs fixed between
|
|
Python 2.3 and 2.4. Both figures are likely to be underestimates.
|
|
|
|
Some of the more notable changes are:
|
|
|
|
\begin{itemize}
|
|
|
|
\item The \module{timeit} module now automatically disables periodic
|
|
garbarge collection during the timing loop. This change makes
|
|
consecutive timings more comparable.
|
|
|
|
\item The \module{base64} module now has more complete RFC 3548 support
|
|
for Base64, Base32, and Base16 encoding and decoding, including
|
|
optional case folding and optional alternative alphabets.
|
|
(Contributed by Barry Warsaw.)
|
|
|
|
\end{itemize}
|
|
|
|
|
|
%======================================================================
|
|
\section{Porting to Python 2.4}
|
|
|
|
This section lists previously described changes that may require
|
|
changes to your code:
|
|
|
|
\begin{itemize}
|
|
|
|
\item The \function{zip()} built-in function and \function{itertools.izip()}
|
|
now return an empty list instead of raising a \exception{TypeError}
|
|
exception if called with no arguments.
|
|
|
|
\item \function{dircache.listdir()} now passes exceptions to the caller
|
|
instead of returning empty lists.
|
|
|
|
\item \function{LexicalHandler.startDTD()} used to receive public and
|
|
system ID in the wrong order. This has been corrected; applications
|
|
relying on the wrong order need to be fixed.
|
|
|
|
\item \function{fcntl.ioctl} now warns if the mutate arg is omitted
|
|
and relevant.
|
|
|
|
\end{itemize}
|
|
|
|
|
|
%======================================================================
|
|
\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: Raymond Hettinger.
|
|
|
|
\end{document}
|