What's New in Python 2.2b1?

Release date: 28-Sep-2100

===========================

Type/class unification and new-style classes

- New-style classes are now dynamic by default. Previous, they were

static (meaning class attributes could not be assigned to) and

dynamic classes had to be requested by adding __dynamic__ = 1 to the

body of the class or to the module. Static classes are faster than

dynamic classes, but dynamic classes are now at most 50% slower than

static classes; previously, they could be up to 10x slower. (This

was accomplished by making dynamic classes faster, not by making

static classes slower. :-) Note that according to one benchmark,

static classes are about the same speed as classic classes.

- C.__doc__ now works as expected for new-style classes (in 2.2a4 it

always returned None, even when there was a class docstring).

- doctest now finds and runs docstrings attached to new-style classes,

class methods, static methods, and properties.

Core

- binascii has now two quopri support functions, a2b_qp and b2a_qp.

- readline now supports setting the startup_hook and the pre_event_hook.

- posix supports chroot where available.

Library

- doctest now excludes functions and classes not defined by the module

being tested, thanks to Tim Hochberg.

- profile now produces correct output in situations where an exception

raised in Python is cleared by C code (e.g. hasattr()). This used

to cause wrong output, including spurious claims of recursive

functions and attribution of time spent to the wrong function.

- quopri's encode and decode methods take an optional header parameter,

which indicates whether output is intended for the header 'Q' encoding.

Tools/Demos

- Demo/dns was removed. It no longer serves any purpose; a package

derived from it is now maintained by Anthony Baxter, see

http://PyDNS.SourceForge.net.

Build

C API

- PyLong_AsLongLong() now accepts int (as well as long) arguments.

Consequently, PyArg_ParseTuple's 'L' code also accepts int (as well

as long) arguments.

New platforms

Tests

Windows

- The signal module now supports SIGBREAK on Windows, thanks to Steven

Scott. Note that SIGBREAK is unique to Windows. The default SIGBREAK

action remains to call Win32 ExitProcess(). This can be changed via

signal.signal(). For example:

# Make Ctrl+Break raise KeyboardInterrupt, like Python's default Ctrl+C

# (SIGINT) behavior.

import signal

signal.signal(signal.SIGBREAK,

signal.default_int_handler)

try:

while 1:

pass

except KeyboardInterrupt:

# We get here on Ctrl+C or Ctrl+Break now; if we had not changed

# SIGBREAK, only on Ctrl+C (and Ctrl+Break would terminate the

# program without the possibility for any Python-level cleanup).

print "Clean exit"

What's New in Python 2.2a4?

Release date: 28-Sep-2001

===========================

Type/class unification and new-style classes

- pydoc and inspect are now aware of new-style classes;

e.g. help(list) at the interactive prompt now shows proper

documentation for all operations on list objects.

- Applications using Jim Fulton's ExtensionClass module can now safely

be used with Python 2.2. In particular, Zope 2.4.1 now works with

Python 2.2 (as well as with Python 2.1.1). The Demo/metaclass

examples also work again. It is hoped that Gtk and Boost also work

with 2.2a4 and beyond. (If you can confirm this, please write

[email protected]; if there are still problems, please open a bug

report on SourceForge.)

- property() now takes 4 keyword arguments: fget, fset, fdel and doc.

These map to readonly attributes 'fget', 'fset', 'fdel', and '__doc__'

in the constructed property object. fget, fset and fdel weren't

discoverable from Python in 2.2a3. __doc__ is new, and allows to

associate a docstring with a property.

- Comparison overloading is now more completely implemented. For

example, a str subclass instance can properly be compared to a str

instance, and it can properly overload comparison. Ditto for most

other built-in object types.

- The repr() of new-style classes has changed; instead of <type

'M.Foo'> a new-style class is now rendered as <class 'M.Foo'>,

*except* for built-in types, which are still rendered as <type

'Foo'> (to avoid upsetting existing code that might parse or

otherwise rely on repr() of certain type objects).

- The repr() of new-style objects is now always <Foo object at XXX>;

previously, it was sometimes <Foo instance at XXX>.

- For new-style classes, what was previously called __getattr__ is now

called __getattribute__. This method, if defined, is called for

*every* attribute access. A new __getattr__ hook mor similar to the

one in classic classes is defined which is called only if regular

attribute access raises AttributeError; to catch *all* attribute

access, you can use __getattribute__ (for new-style classes). If

both are defined, __getattribute__ is called first, and if it raises

AttributeError, __getattr__ is called.

- The __class__ attribute of new-style objects can be assigned to.

The new class must have the same C-level object layout as the old

class.

- The builtin file type can be subclassed now. In the usual pattern,

"file" is the name of the builtin type, and file() is a new builtin

constructor, with the same signature as the builtin open() function.

file() is now the preferred way to open a file.

- Previously, __new__ would only see sequential arguments passed to

the type in a constructor call; __init__ would see both sequential

and keyword arguments. This made no sense whatsoever any more, so

now both __new__ and __init__ see all arguments.

- Previously, hash() applied to an instance of a subclass of str or

unicode always returned 0. This has been repaired.

- Previously, an operation on an instance of a subclass of an

immutable type (int, long, float, complex, tuple, str, unicode),

where the subtype didn't override the operation (and so the

operation was handled by the builtin type), could return that

instance instead a value of the base type. For example, if s was of

a str sublass type, s[:] returned s as-is. Now it returns a str

with the same value as s.

- Provisional support for pickling new-style objects has been added.

Core

- file.writelines() now accepts any iterable object producing strings.

- PyUnicode_FromEncodedObject() now works very much like

PyObject_Str(obj) in that it tries to use __str__/tp_str

on the object if the object is not a string or buffer. This

makes unicode() behave like str() when applied to non-string/buffer

objects.

- PyFile_WriteObject now passes Unicode object to the file's write

method. As a result, all file-like object which may be the target

of a print statement must support Unicode objects, i.e. they must

at least convert them into ASCII strings.

- Thread scheduling on Solaris should be improved; it is no longer

necessary to insert a small sleep at the start of a thread in order

to let other runnable threads be scheduled.

Library

- StringIO.StringIO instances and cStringIO.StringIO instances support

read character buffer compatible objects for their .write() methods.

These objects are converted to strings and then handled as such

by the instances.

- The "email" package has been added. This is basically a port of the

mimelib package <http://sf.net/projects/mimelib> with API changes

and some implementations updated to use iterators and generators.

- difflib.ndiff() and difflib.Differ.compare() are generators now. This

restores the ability of Tools/scripts/ndiff.py to start producing output

before the entire comparison is complete.

- StringIO.StringIO instances and cStringIO.StringIO instances support

iteration just like file objects (i.e. their .readline() method is

called for each iteration until it returns an empty string).

- The codecs module has grown four new helper APIs to access

builtin codecs: getencoder(), getdecoder(), getreader(),

getwriter().

- SimpleXMLRPCServer: a new module (based upon SimpleHTMLServer)

simplifies writing XML RPC servers.

- os.path.realpath(): a new function that returns the absolute pathname

after interpretation of symbolic links. On non-Unix systems, this

is an alias for os.path.abspath().

- operator.indexOf() (PySequence_Index() in the C API) now works with any

iterable object.

- smtplib now supports various authentication and security features of

the SMTP protocol through the new login() and starttls() methods.

- hmac: a new module implementing keyed hashing for message

authentication.

- mimetypes now recognizes more extensions and file types. At the

same time, some mappings not sanctioned by IANA were removed.

- The "compiler" package has been brought up to date to the state of

Python 2.2 bytecode generation. It has also been promoted from a

Tool to a standard library package. (Tools/compiler still exists as

a sample driver.)

Tools

Build

- Large file support (LFS) is now automatic when the platform supports

it; no more manual configuration tweaks are needed. On Linux, at

least, it's possible to have a system whose C library supports large

files but whose kernel doesn't; in this case, large file support is

still enabled but doesn't do you any good unless you upgrade your

kernel or share your Python executable with another system whose

kernel has large file support.

- The configure script now supplies plausible defaults in a

cross-compilation environment. This doesn't mean that the supplied

values are always correct, or that cross-compilation now works

flawlessly -- but it's a first step (and it shuts up most of

autoconf's warnings about AC_TRY_RUN).

- The Unix build is now a bit less chatty, courtesy of the parser

generator. The build is completely silent (except for errors) when

using "make -s", thanks to a -q option to setup.py.

C API

- The "structmember" API now supports some new flag bits to deny read

and/or write access to attributes in restricted execution mode.

New platforms

- Compaq's iPAQ handheld, running the "familiar" Linux distribution

(http://familiar.handhelds.org).

Tests

- The "classic" standard tests, which work by comparing stdout to

an expected-output file under Lib/test/output/, no longer stop at

the first mismatch. Instead the test is run to completion, and a

variant of ndiff-style comparison is used to report all differences.

This is much easier to understand than the previous style of reporting.

- The unittest-based standard tests now use regrtest's test_main()

convention, instead of running as a side-effect of merely being

imported. This allows these tests to be run in more natural and

flexible ways as unittests, outside the regrtest framework.

- regrtest.py is much better integrated with unittest and doctest now,

especially in regard to reporting errors.

Windows

- Large file support now also works for files > 4GB, on filesystems

that support it (NTFS under Windows 2000). See "What's New in

Python 2.2a3" for more detail.

What's New in Python 2.2a3?

Release Date: 07-Sep-2001

===========================

Core

- Conversion of long to float now raises OverflowError if the long is too

big to represent as a C double.

- The 3-argument builtin pow() no longer allows a third non-None argument

if either of the first two arguments is a float, or if both are of

integer types and the second argument is negative (in which latter case

the arguments are converted to float, so this is really the same

restriction).

- The builtin dir() now returns more information, and sometimes much

more, generally naming all attributes of an object, and all attributes

reachable from the object via its class, and from its class's base

classes, and so on from them too. Example: in 2.2a2, dir([]) returned

an empty list. In 2.2a3,

>>> dir([])

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',

'__eq__', '__ge__', '__getattr__', '__getitem__', '__getslice__',

'__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__le__',

'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__repr__',

'__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__',

'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove',

'reverse', 'sort']

dir(module) continues to return only the module's attributes, though.

- Overflowing operations on plain ints now return a long int rather

than raising OverflowError. This is a partial implementation of PEP

237. You can use -Wdefault::OverflowWarning to enable a warning for

this situation, and -Werror::OverflowWarning to revert to the old

OverflowError exception.

- A new command line option, -Q<arg>, is added to control run-time

warnings for the use of classic division. (See PEP 238.) Possible

values are -Qold, -Qwarn, -Qwarnall, and -Qnew. The default is

-Qold, meaning the / operator has its classic meaning and no

warnings are issued. Using -Qwarn issues a run-time warning about

all uses of classic division for int and long arguments; -Qwarnall

also warns about classic division for float and complex arguments

(for use with fixdiv.py). Using -Qnew is questionable; it turns on

new division by default, but only in the __main__ module. You can

usefully combine -Qwarn or -Qwarnall and -Qnew: this gives the

__main__ module new division, and warns about classic division

everywhere else.

- Many built-in types can now be subclassed. This applies to int,

long, float, str, unicode, and tuple. (The types complex, list and

dictionary can also be subclassed; this was introduced earlier.)

Note that restrictions apply when subclassing immutable built-in

types: you can only affect the value of the instance by overloading

__new__. You can add mutable attributes, and the subclass instances

will have a __dict__ attribute, but you cannot change the "value"

(as implemented by the base class) of an immutable subclass instance

once it is created.

- The dictionary constructor now takes an optional argument, a

mapping-like object, and initializes the dictionary from its

(key, value) pairs.

- A new built-in type, super, has been added. This facilitates making

"cooperative super calls" in a multiple inheritance setting. For an

explanation, see http://www.python.org/2.2/descrintro.html#cooperation

- A new built-in type, property, has been added. This enables the

creation of "properties". These are attributes implemented by

getter and setter functions (or only one of these for read-only or

write-only attributes), without the need to override __getattr__.

See http://www.python.org/2.2/descrintro.html#property

- The syntax of floating-point and imaginary literals has been

liberalized, to allow leading zeroes. Examples of literals now

legal that were SyntaxErrors before:

00.0 0e3 0100j 07.5 00000000000000000008.

- An old tokenizer bug allowed floating point literals with an incomplete

exponent, such as 1e and 3.1e-. Such literals now raise SyntaxError.

Library

- telnetlib includes symbolic names for the options, and support for

setting an option negotiation callback.

- The new C standard no longer requires that math libraries set errno to

ERANGE on overflow. For platform libraries that exploit this new

freedom, Python's overflow-checking was wholly broken. A new overflow-

checking scheme attempts to repair that, but may not be reliable on all

platforms (C doesn't seem to provide anything both useful and portable

in this area anymore).

- Asynchronous timeout actions are available through the new class

threading.Timer.

- math.log and math.log10 now return sensible results for even huge

long arguments. For example, math.log10(10 ** 10000) ~= 10000.0.

- A new function, imp.lock_held(), returns 1 when the import lock is

currently held. See the docs for the imp module.

- pickle, cPickle and marshal on 32-bit platforms can now correctly read

dumps containing ints written on platforms where Python ints are 8 bytes.

When read on a box where Python ints are 4 bytes, such values are

converted to Python longs.

- In restricted execution mode (using the rexec module), unmarshalling

code objects is no longer allowed. This plugs a security hole.

- unittest.TestResult instances no longer store references to tracebacks

generated by test failures. This prevents unexpected dangling references

to objects that should be garbage collected between tests.

Tools

- Tools/scripts/fixdiv.py has been added which can be used to fix

division operators as per PEP 238.

Build

- If you are an adventurous person using Mac OS X you may want to look at

Mac/OSX. There is a Makefile there that will build Python as a real Mac

application, which can be used for experimenting with Carbon or Cocoa.

Discussion of this on pythonmac-sig, please.

C API

- New function PyObject_Dir(obj), like Python __builtin__.dir(obj).

- Note that PyLong_AsDouble can fail! This has always been true, but no

callers checked for it. It's more likely to fail now, because overflow

errors are properly detected now. The proper way to check:

double x = PyLong_AsDouble(some_long_object);

if (x == -1.0 && PyErr_Occurred()) {

/* The conversion failed. */

}

- The GC API has been changed. Extensions that use the old API will still

compile but will not participate in GC. To upgrade an extension

module:

- rename Py_TPFLAGS_GC to PyTPFLAGS_HAVE_GC

- use PyObject_GC_New or PyObject_GC_NewVar to allocate objects and

PyObject_GC_Del to deallocate them

- rename PyObject_GC_Init to PyObject_GC_Track and PyObject_GC_Fini

to PyObject_GC_UnTrack

- remove PyGC_HEAD_SIZE from object size calculations

- remove calls to PyObject_AS_GC and PyObject_FROM_GC

- Two new functions: PyString_FromFormat() and PyString_FromFormatV().

These can be used safely to construct string objects from a

sprintf-style format string (similar to the format string supported

by PyErr_Format()).

New platforms

- Stephen Hansen contributed patches sufficient to get a clean compile

under Borland C (Windows), but he reports problems running it and ran

out of time to complete the port. Volunteers? Expect a MemoryError

when importing the types module; this is probably shallow, and

causing later failures too.

Tests

Windows

- Large file support is now enabled on Win32 platforms as well as on

Win64. This means that, for example, you can use f.tell() and f.seek()

to manipulate files larger than 2 gigabytes (provided you have enough

disk space, and are using a Windows filesystem that supports large

partitions). Windows filesystem limits: FAT has a 2GB (gigabyte)

filesize limit, and large file support makes no difference there.

FAT32's limit is 4GB, and files >= 2GB are easier to use from Python now.

NTFS has no practical limit on file size, and files of any size can be

used from Python now.

- The w9xpopen hack is now used on Windows NT and 2000 too when COMPSPEC

points to command.com (patch from Brian Quinlan).

What's New in Python 2.2a2?

Release Date: 22-Aug-2001

===========================

Build

- Tim Peters developed a brand new Windows installer using Wise 8.1,

generously donated to us by Wise Solutions.

- configure supports a new option --enable-unicode, with the values

ucs2 and ucs4 (new in 2.2a1). With --disable-unicode, the Unicode

type and supporting code is completely removed from the interpreter.

- A new configure option --enable-framework builds a Mac OS X framework,

which "make frameworkinstall" will install. This provides a starting

point for more mac-like functionality, join [email protected]

if you are interested in helping.

- The NeXT platform is no longer supported.

- The `new' module is now statically linked.

Tools

- The new Tools/scripts/cleanfuture.py can be used to automatically

edit out obsolete future statements from Python source code. See

the module docstring for details.

Tests

- regrtest.py now knows which tests are expected to be skipped on some

platforms, allowing to give clearer test result output. regrtest

also has optional --use/-u switch to run normally disabled tests

which require network access or consume significant disk resources.

- Several new tests in the standard test suite, with special thanks to

Nick Mathewson.

Core

- The floor division operator // has been added as outlined in PEP

238. The / operator still provides classic division (and will until

Python 3.0) unless "from __future__ import division" is included, in

which case the / operator will provide true division. The operator

module provides truediv() and floordiv() functions. Augmented

assignment variants are included, as are the equivalent overloadable

methods and C API methods. See the PEP for a full discussion:

<http://python.sf.net/peps/pep-0238.html>

- Future statements are now effective in simulated interactive shells

(like IDLE). This should "just work" by magic, but read Michael

Hudson's "Future statements in simulated shells" PEP 264 for full

details: <http://python.sf.net/peps/pep-0264.html>.

- The type/class unification (PEP 252-253) was integrated into the

trunk and is not so tentative any more (the exact specification of

some features is still tentative). A lot of work has done on fixing

bugs and adding robustness and features (performance still has to

come a long way).

- Warnings about a mismatch in the Python API during extension import

now use the Python warning framework (which makes it possible to

write filters for these warnings).

- A function's __dict__ (aka func_dict) will now always be a

dictionary. It used to be possible to delete it or set it to None,

but now both actions raise TypeErrors. It is still legal to set it

to a dictionary object. Getting func.__dict__ before any attributes

have been assigned now returns an empty dictionary instead of None.

- A new command line option, -E, was added which disables the use of

all environment variables, or at least those that are specifically

significant to Python. Usually those have a name starting with

"PYTHON". This was used to fix a problem where the tests fail if

the user happens to have PYTHONHOME or PYTHONPATH pointing to an

older distribution.

Library

- New class Differ and new functions ndiff() and restore() in difflib.py.

These package the algorithms used by the popular Tools/scripts/ndiff.py,

for programmatic reuse.

- New function xml.sax.saxutils.quoteattr(): Quote an XML attribute

value using the minimal quoting required for the value; more

reliable than using xml.sax.saxutils.escape() for attribute values.

- Readline completion support for cmd.Cmd was added.

- Calling os.tempnam() or os.tmpnam() generate RuntimeWarnings.

- Added function threading.BoundedSemaphore()

- Added Ka-Ping Yee's cgitb.py module.

- The `new' module now exposes the CO_xxx flags.

New platforms

C API

- Two new APIs PyOS_snprintf() and PyOS_vsnprintf() were added

which provide a cross-platform implementations for the

relatively new snprintf()/vsnprintf() C lib APIs. In contrast to

the standard sprintf() and vsprintf() C lib APIs, these versions

apply bounds checking on the used buffer which enhances protection

against buffer overruns.

- Unicode APIs now use name mangling to assure that mixing interpreters

and extensions using different Unicode widths is rendered next to

impossible. Trying to import an incompatible Unicode-aware extension

will result in an ImportError. Unicode extensions writers must make

sure to check the Unicode width compatibility in their extensions by

using at least one of the mangled Unicode APIs in the extension.

- Two new flags METH_NOARGS and METH_O are available in method definition

tables to simplify implementation of methods with no arguments and a

single untyped argument. Calling such methods is more efficient than

calling corresponding METH_VARARGS methods. METH_OLDARGS is now

deprecated.

Windows

- "import module" now compiles module.pyw if it exists and nothing else

relevant is found.

What's New in Python 2.2a1?

===========================

Core

- TENTATIVELY, a large amount of code implementing much of what's

described in PEP 252 (Making Types Look More Like Classes) and PEP

253 (Subtyping Built-in Types) was added. This will be released

with Python 2.2a1. Documentation will be provided separately

through http://www.python.org/2.2/. The purpose of releasing this

with Python 2.2a1 is to test backwards compatibility. It is

possible, though not likely, that a decision is made not to release

this code as part of 2.2 final, if any serious backwards

incompapatibilities are found during alpha testing that cannot be

repaired.

- Generators were added; this is a new way to create an iterator (see

below) using what looks like a simple function containing one or

more 'yield' statements. See PEP 255. Since this adds a new

keyword to the language, this feature must be enabled by including a

future statement: "from __future__ import generators" (see PEP 236).

Generators will become a standard feature in a future release

(probably 2.3). Without this future statement, 'yield' remains an

ordinary identifier, but a warning is issued each time it is used.

(These warnings currently don't conform to the warnings framework of

PEP 230; we intend to fix this in 2.2a2.)

- The UTF-16 codec was modified to be more RFC compliant. It will now

only remove BOM characters at the start of the string and then

only if running in native mode (UTF-16-LE and -BE won't remove a

leading BMO character).

- Strings now have a new method .decode() to complement the already

existing .encode() method. These two methods provide direct access

to the corresponding decoders and encoders of the registered codecs.

To enhance the usability of the .encode() method, the special

casing of Unicode object return values was dropped (Unicode objects

were auto-magically converted to string using the default encoding).

Both methods will now return whatever the codec in charge of the

requested encoding returns as object, e.g. Unicode codecs will

return Unicode objects when decoding is requested ("äöü".decode("latin-1")

will return u"äöü"). This enables codec writer to create codecs

for various simple to use conversions.

New codecs were added to demonstrate these new features (the .encode()

and .decode() columns indicate the type of the returned objects):

Name | .encode() | .decode() | Description

----------------------------------------------------------------------

uu | string | string | UU codec (e.g. for email)

base64 | string | string | base64 codec

quopri | string | string | quoted-printable codec

zlib | string | string | zlib compression

hex | string | string | 2-byte hex codec

rot-13 | string | Unicode | ROT-13 Unicode charmap codec

- Some operating systems now support the concept of a default Unicode

encoding for file system operations. Notably, Windows supports 'mbcs'

as the default. The Macintosh will also adopt this concept in the medium

term, although the default encoding for that platform will be other than

'mbcs'.

On operating system that support non-ASCII filenames, it is common for

functions that return filenames (such as os.listdir()) to return Python

string objects pre-encoded using the default file system encoding for

the platform. As this encoding is likely to be different from Python's

default encoding, converting this name to a Unicode object before passing

it back to the Operating System would result in a Unicode error, as Python

would attempt to use its default encoding (generally ASCII) rather than

the default encoding for the file system.

In general, this change simply removes surprises when working with

Unicode and the file system, making these operations work as you expect,

increasing the transparency of Unicode objects in this context.

See [????] for more details, including examples.

- Float (and complex) literals in source code were evaluated to full

precision only when running from a .py file; the same code loaded from a

.pyc (or .pyo) file could suffer numeric differences starting at about the

12th significant decimal digit. For example, on a machine with IEEE-754

floating arithmetic,

x = 9007199254740992.0

print long(x)

printed 9007199254740992 if run directly from .py, but 9007199254740000

if from a compiled (.pyc or .pyo) file. This was due to marshal using

str(float) instead of repr(float) when building code objects. marshal

now uses repr(float) instead, which should reproduce floats to full

machine precision (assuming the platform C float<->string I/O conversion

functions are of good quality).

This may cause floating-point results to change in some cases, and

usually for the better, but may also cause numerically unstable

algorithms to break.

- The implementation of dicts suffers fewer collisions, which has speed

benefits. However, the order in which dict entries appear in dict.keys(),

dict.values() and dict.items() may differ from previous releases for a

given dict. Nothing is defined about this order, so no program should

rely on it. Nevertheless, it's easy to write test cases that rely on the

order by accident, typically because of printing the str() or repr() of a

dict to an "expected results" file. See Lib/test/test_support.py's new

sortdict(dict) function for a simple way to display a dict in sorted

order.

- Many other small changes to dicts were made, resulting in faster

operation along the most common code paths.

- Dictionary objects now support the "in" operator: "x in dict" means

the same as dict.has_key(x).

- The update() method of dictionaries now accepts generic mapping

objects. Specifically the argument object must support the .keys()

and __getitem__() methods. This allows you to say, for example,

{}.update(UserDict())

- Iterators were added; this is a generalized way of providing values

to a for loop. See PEP 234. There's a new built-in function iter()

to return an iterator. There's a new protocol to get the next value

from an iterator using the next() method (in Python) or the

tp_iternext slot (in C). There's a new protocol to get iterators

using the __iter__() method (in Python) or the tp_iter slot (in C).

Iterating (i.e. a for loop) over a dictionary generates its keys.

Iterating over a file generates its lines.

- The following functions were generalized to work nicely with iterator

arguments:

map(), filter(), reduce(), zip()

list(), tuple() (PySequence_Tuple() and PySequence_Fast() in C API)

max(), min()

join() method of strings

extend() method of lists

'x in y' and 'x not in y' (PySequence_Contains() in C API)

operator.countOf() (PySequence_Count() in C API)

right-hand side of assignment statements with multiple targets, such as

x, y, z = some_iterable_object_returning_exactly_3_values

- Accessing module attributes is significantly faster (for example,

random.random or os.path or yourPythonModule.yourAttribute).

- Comparing dictionary objects via == and != is faster, and now works even

if the keys and values don't support comparisons other than ==.

- Comparing dictionaries in ways other than == and != is slower: there were

insecurities in the dict comparison implementation that could cause Python

to crash if the element comparison routines for the dict keys and/or

values mutated the dicts. Making the code bulletproof slowed it down.

- Collisions in dicts are resolved via a new approach, which can help

dramatically in bad cases. For example, looking up every key in a dict

d with d.keys() == [i << 16 for i in range(20000)] is approximately 500x

faster now. Thanks to Christian Tismer for pointing out the cause and

the nature of an effective cure (last December! better late than never).

- repr() is much faster for large containers (dict, list, tuple).

Library

- The constants ascii_letters, ascii_lowercase. and ascii_uppercase

were added to the string module. These a locale-indenpendent

constants, unlike letters, lowercase, and uppercase. These are now

use in appropriate locations in the standard library.

- The flags used in dlopen calls can now be configured using

sys.setdlopenflags and queried using sys.getdlopenflags.

- Fredrik Lundh's xmlrpclib is now a standard library module. This

provides full client-side XML-RPC support. In addition,

Demo/xmlrpc/ contains two server frameworks (one SocketServer-based,

one asyncore-based). Thanks to Eric Raymond for the documentation.

- The xrange() object is simplified: it no longer supports slicing,

repetition, comparisons, efficient 'in' checking, the tolist()

method, or the start, stop and step attributes. See PEP 260.

- A new function fnmatch.filter to filter lists of file names was added.

- calendar.py uses month and day names based on the current locale.

- strop is now *really* obsolete (this was announced before with 1.6),

and issues DeprecationWarning when used (except for the four items

that are still imported into string.py).

- Cookie.py now sorts key+value pairs by key in output strings.

- pprint.isrecursive(object) didn't correctly identify recursive objects.

Now it does.

- pprint functions now much faster for large containers (tuple, list, dict).

- New 'q' and 'Q' format codes in the struct module, corresponding to C

types "long long" and "unsigned long long" (on Windows, __int64). In

native mode, these can be used only when the platform C compiler supports

these types (when HAVE_LONG_LONG is #define'd by the Python config

process), and then they inherit the sizes and alignments of the C types.

In standard mode, 'q' and 'Q' are supported on all platforms, and are

8-byte integral types.

- The site module installs a new built-in function 'help' that invokes

pydoc.help. It must be invoked as 'help()'; when invoked as 'help',

it displays a message reminding the user to use 'help()' or

'help(object)'.

Tests

- New test_mutants.py runs dict comparisons where the key and value

comparison operators mutute the dicts randomly during comparison. This

rapidly causes Python to crash under earlier releases (not for the faint

of heart: it can also cause Win9x to freeze or reboot!).

- New test_pprint.py verfies that pprint.isrecursive() and

pprint.isreadable() return sensible results. Also verifies that simple

cases produce correct output.

C API

- Removed the unused last_is_sticky argument from the internal

_PyTuple_Resize(). If this affects you, you were cheating.

======================================================================

What's New in Python 2.1 (final)?

=================================

We only changed a few things since the last release candidate, all in

Python library code:

- A bug in the locale module was fixed that affected locales which

define no grouping for numeric formatting.

- A few bugs in the weakref module's implementations of weak

dictionaries (WeakValueDictionary and WeakKeyDictionary) were fixed,

and the test suite was updated to check for these bugs.

- An old bug in the os.path.walk() function (introduced in Python

2.0!) was fixed: a non-existent file would cause an exception

instead of being ignored.

- Fixed a few bugs in the new symtable module found by Neil Norwitz's

PyChecker.

What's New in Python 2.1c2?

===========================

A flurry of small changes, and one showstopper fixed in the nick of

time made it necessary to release another release candidate. The list

here is the *complete* list of patches (except version updates):

Core

- Tim discovered a nasty bug in the dictionary code, caused by

PyDict_Next() calling dict_resize(), and the GC code's use of

PyDict_Next() violating an assumption in dict_items(). This was

fixed with considerable amounts of band-aid, but the net effect is a

saner and more robust implementation.

- Made a bunch of symbols static that were accidentally global.

Build and Ports

- The setup.py script didn't check for a new enough version of zlib

(1.1.3 is needed). Now it does.

- Changed "make clean" target to also remove shared libraries.

- Added a more general warning about the SGI Irix optimizer to README.

Library

- Fix a bug in urllib.basejoin("http://host", "../file.html") which

omitted the slash between host and file.html.

- The mailbox module's _Mailbox class contained a completely broken

and undocumented seek() method. Ripped it out.

- Fixed a bunch of typos in various library modules (urllib2, smtpd,

sgmllib, netrc, chunk) found by Neil Norwitz's PyChecker.

- Fixed a few last-minute bugs in unittest.

Extensions

- Reverted the patch to the OpenSSL code in socketmodule.c to support

RAND_status() and the EGD, and the subsequent patch that tried to

fix it for pre-0.9.5 versions; the problem with the patch is that on

some systems it issues a warning whenever socket is imported, and

that's unacceptable.

Tests

- Fixed the pickle tests to work with "import test.test_pickle".

- Tweaked test_locale.py to actually run the test Windows.

- In distutils/archive_util.py, call zipfile.ZipFile() with mode "w",

not "wb" (which is not a valid mode at all).

- Fix pstats browser crashes. Import readline if it exists to make

the user interface nicer.

- Add "import thread" to the top of test modules that import the

threading module (test_asynchat and test_threadedtempfile). This

prevents test failures caused by a broken threading module resulting

from a previously caught failed import.

- Changed test_asynchat.py to set the SO_REUSEADDR option; this was

needed on some platforms (e.g. Solaris 8) when the tests are run

twice in succession.

- Skip rather than fail test_sunaudiodev if no audio device is found.

What's New in Python 2.1c1?

===========================

This list was significantly updated when 2.1c2 was released; the 2.1c1

release didn't mention most changes that were actually part of 2.1c1:

Legal

- Copyright was assigned to the Python Software Foundation (PSF) and a

PSF license (very similar to the CNRI license) was added.

- The CNRI copyright notice was updated to include 2001.

Core

- After a public outcry, assignment to __debug__ is no longer illegal;

instead, a warning is issued. It will become illegal in 2.2.

- Fixed a core dump with "%#x" % 0, and changed the semantics so that

"%#x" now always prepends "0x", even if the value is zero.

- Fixed some nits in the bytecode compiler.

- Fixed core dumps when calling certain kinds of non-functions.

- Fixed various core dumps caused by reference count bugs.

Build and Ports

- Use INSTALL_SCRIPT to install script files.

- New port: SCO Unixware 7, by Billy G. Allie.

- Updated RISCOS port.

- Updated BeOS port and notes.

- Various other porting problems resolved.

Library

- The TERMIOS and SOCKET modules are now truly obsolete and

unnecessary. Their symbols are incorporated in the termios and

socket modules.

- Fixed some 64-bit bugs in pickle, cPickle, and struct, and added

better tests for pickling.

- threading: make Condition.wait() robust against KeyboardInterrupt.

- zipfile: add support to zipfile to support opening an archive

represented by an open file rather than a file name. Fix bug where

the archive was not properly closed. Fixed a bug in this bugfix

where flush() was called for a read-only file.

- imputil: added an uninstall() method to the ImportManager.

- Canvas: fixed bugs in lower() and tkraise() methods.

- SocketServer: API change (added overridable close_request() method)

so that the TCP server can explicitly close the request.

- pstats: Eric Raymond added a simple interactive statistics browser,

invoked when the module is run as a script.

- locale: fixed a problem in format().

- webbrowser: made it work when the BROWSER environment variable has a

value like "/usr/bin/netscape". Made it auto-detect Konqueror for

KDE 2. Fixed some other nits.

- unittest: changes to allow using a different exception than

AssertionError, and added a few more function aliases. Some other

small changes.

- urllib, urllib2: fixed redirect problems and a coupleof other nits.

- asynchat: fixed a critical bug in asynchat that slipped through the

2.1b2 release. Fixed another rare bug.

- Fix some unqualified except: clauses (always a bad code example).

XML

- pyexpat: new API get_version_string().