Navigation

This article explains the new features in Python 2.5. The final release of
Python 2.5 is scheduled for August 2006; PEP 356 describes the planned
release schedule.

The changes in Python 2.5 are an interesting mix of language and library
improvements. The library enhancements will be more important to Python’s user
community, I think, because several widely-useful packages were added. New
modules include ElementTree for XML processing (xml.etree),
the SQLite database module (sqlite), and the ctypes
module for calling C functions.

As well as the language and library additions, other improvements and bugfixes
were made throughout the source tree. A search through the SVN change logs
finds there were 353 patches applied and 458 bugs fixed between Python 2.4 and
2.5. (Both figures are likely to be underestimates.)

This article doesn’t try to be a complete specification of the new features;
instead changes are briefly introduced using helpful examples. For full
details, you should always refer to the documentation for Python 2.5 at
https://docs.python.org. If you want to understand the complete implementation
and design rationale, refer to the PEP for a particular new feature.

Comments, suggestions, and error reports for this document are welcome; please
e-mail them to the author or open a bug in the Python bug tracker.

For a long time, people have been requesting a way to write conditional
expressions, which are expressions that return value A or value B depending on
whether a Boolean value is true or false. A conditional expression lets you
write a single assignment statement that has the same effect as the following:

ifcondition:x=true_valueelse:x=false_value

There have been endless tedious discussions of syntax on both python-dev and
comp.lang.python. A vote was even held that found the majority of voters wanted
conditional expressions in some form, but there was no syntax that was preferred
by a clear majority. Candidates included C’s cond?true_v:false_v, ifcondthentrue_velsefalse_v, and 16 other variations.

Guido van Rossum a finalement choisi une syntaxe surprenante :

x=true_valueifconditionelsefalse_value

Evaluation is still lazy as in existing Boolean expressions, so the order of
evaluation jumps around a bit. The condition expression in the middle is
evaluated first, and the true_value expression is evaluated only if the
condition was true. Similarly, the false_value expression is only evaluated
when the condition is false.

This syntax may seem strange and backwards; why does the condition go in the
middle of the expression, and not in the front as in C’s c?x:y? The
decision was checked by applying the new syntax to the modules in the standard
library and seeing how the resulting code read. In many cases where a
conditional expression is used, one value seems to be the “common case” and one
value is an “exceptional case”, used only on rarer occasions when the condition
isn’t met. The conditional syntax makes this pattern a bit more obvious:

contents=((doc+'\n')ifdocelse'')

I read the above statement as meaning « here contents is usually assigned a
value of doc+'\n'; sometimes doc is empty, in which special case an empty
string is returned. » I doubt I will use conditional expressions very often
where there isn’t a clear common and uncommon case.

There was some discussion of whether the language should require surrounding
conditional expressions with parentheses. The decision was made to not
require parentheses in the Python language’s grammar, but as a matter of style I
think you should always use them. Consider these two statements:

# First version -- no parenslevel=1ifloggingelse0# Second version -- with parenslevel=(1ifloggingelse0)

In the first version, I think a reader’s eye might group the statement into
“level = 1”, “if logging”, “else 0”, and think that the condition decides
whether the assignment to level is performed. The second version reads
better, in my opinion, because it makes it clear that the assignment is always
performed and the choice is being made between two values.

Another reason for including the brackets: a few odd combinations of list
comprehensions and lambdas could look like incorrect conditional expressions.
See PEP 308 for some examples. If you put parentheses around your
conditional expressions, you won’t run into this case.

The functools module is intended to contain tools for functional-style
programming.

One useful tool in this module is the partial() function. For programs
written in a functional style, you’ll sometimes want to construct variants of
existing functions that have some of the parameters filled in. Consider a
Python function f(a,b,c); you could create a new function g(b,c) that
was equivalent to f(1,b,c). This is called « partial function
application ».

partial() takes the arguments (function,arg1,arg2,...kwarg1=value1,kwarg2=value2). The resulting object is callable, so you can just call it to
invoke function with the filled-in arguments.

Voici un exemple court mais réaliste :

importfunctoolsdeflog(message,subsystem):"Write the contents of 'message' to the specified subsystem."print'%s: %s'%(subsystem,message)...server_log=functools.partial(log,subsystem='server')server_log('Unable to open socket')

Here’s another example, from a program that uses PyGTK. Here a context-sensitive
pop-up menu is being constructed dynamically. The callback provided
for the menu option is a partially applied version of the open_item()
method, where the first argument has been provided.

Another function in the functools module is the
update_wrapper(wrapper,wrapped) function that helps you write
well-behaved decorators. update_wrapper() copies the name, module, and
docstring attribute to a wrapper function so that tracebacks inside the wrapped
function are easier to understand. For example, you might write:

Some simple dependency support was added to Distutils. The setup()
function now has requires, provides, and obsoletes keyword
parameters. When you build a source distribution using the sdist command,
the dependency information will be recorded in the PKG-INFO file.

Another new keyword parameter is download_url, which should be set to a URL
for the package’s source code. This means it’s now possible to look up an entry
in the package index, determine the dependencies for a package, and download the
required packages.

Another new enhancement to the Python package index at
https://pypi.python.org is storing source and binary archives for a
package. The new upload Distutils command will upload a package to
the repository.

Before a package can be uploaded, you must be able to build a distribution using
the sdist Distutils command. Once that works, you can run pythonsetup.pyupload to add your package to the PyPI archive. Optionally you can
GPG-sign the package by supplying the --sign and --identity
options.

The simpler part of PEP 328 was implemented in Python 2.4: parentheses could now
be used to enclose the names imported from a module using the from...import... statement, making it easier to import many different names.

The more complicated part has been implemented in Python 2.5: importing a module
can be specified to use absolute or package-relative imports. The plan is to
move toward making absolute imports the default in future versions of Python.

Let’s say you have a package directory like this:

pkg/pkg/__init__.pypkg/main.pypkg/string.py

This defines a package named pkg containing the pkg.main and
pkg.string submodules.

Consider the code in the main.py module. What happens if it executes
the statement importstring? In Python 2.4 and earlier, it will first look
in the package’s directory to perform a relative import, finds
pkg/string.py, imports the contents of that file as the
pkg.string module, and that module is bound to the name string in the
pkg.main module’s namespace.

That’s fine if pkg.string was what you wanted. But what if you wanted
Python’s standard string module? There’s no clean way to ignore
pkg.string and look for the standard module; generally you had to look at
the contents of sys.modules, which is slightly unclean. Holger Krekel’s
py.std package provides a tidier way to perform imports from the standard
library, importpy;py.std.string.join(), but that package isn’t available
on all Python installations.

Reading code which relies on relative imports is also less clear, because a
reader may be confused about which module, string or pkg.string,
is intended to be used. Python users soon learned not to duplicate the names of
standard library modules in the names of their packages” submodules, but you
can’t protect against having your submodule’s name being used for a new module
added in a future version of Python.

In Python 2.5, you can switch import’s behaviour to absolute imports
using a from__future__importabsolute_import directive. This absolute-import
behaviour will become the default in a future version (probably Python
2.7). Once absolute imports are the default, importstring will always
find the standard library’s version. It’s suggested that users should begin
using absolute imports as much as possible, so it’s preferable to begin writing
frompkgimportstring in your code.

Relative imports are still possible by adding a leading period to the module
name when using the from...import form:

This imports the string module relative to the current package, so in
pkg.main this will import name1 and name2 from pkg.string.
Additional leading periods perform the relative import starting from the parent
of the current package. For example, code in the A.B.C module can do:

The -m switch added in Python 2.4 to execute a module as a script
gained a few more abilities. Instead of being implemented in C code inside the
Python interpreter, the switch now uses an implementation in a new module,
runpy.

The runpy module implements a more sophisticated import mechanism so that
it’s now possible to run modules in a package such as pychecker.checker.
The module also supports alternative import mechanisms such as the
zipimport module. This means you can add a .zip archive’s path to
sys.path and then use the -m switch to execute code from the
archive.

Until Python 2.5, the try statement came in two flavours. You could
use a finally block to ensure that code is always executed, or one or
more except blocks to catch specific exceptions. You couldn’t
combine both except blocks and a finally block, because
generating the right bytecode for the combined version was complicated and it
wasn’t clear what the semantics of the combined statement should be.

Guido van Rossum spent some time working with Java, which does support the
equivalent of combining except blocks and a finally block,
and this clarified what the statement should mean. In Python 2.5, you can now
write:

The code in block-1 is executed. If the code raises an exception, the various
except blocks are tested: if the exception is of class
Exception1, handler-1 is executed; otherwise if it’s of class
Exception2, handler-2 is executed, and so forth. If no exception is
raised, the else-block is executed.

No matter what happened previously, the final-block is executed once the code
block is complete and any raised exceptions handled. Even if there’s an error in
an exception handler or the else-block and a new exception is raised, the code
in the final-block is still run.

Python 2.5 adds a simple way to pass values into a generator. As introduced in
Python 2.3, generators only produce output; once a generator’s code was invoked
to create an iterator, there was no way to pass any new information into the
function when its execution is resumed. Sometimes the ability to pass in some
information would be useful. Hackish solutions to this include making the
generator’s code look at a global variable and then changing the global
variable’s value, or passing in some mutable object that callers then modify.

To refresh your memory of basic generators, here’s a simple example:

defcounter(maximum):i=0whilei<maximum:yieldii+=1

When you call counter(10), the result is an iterator that returns the values
from 0 up to 9. On encountering the yield statement, the iterator
returns the provided value and suspends the function’s execution, preserving the
local variables. Execution resumes on the following call to the iterator’s
next() method, picking up after the yield statement.

In Python 2.3, yield was a statement; it didn’t return any value. In
2.5, yield is now an expression, returning a value that can be
assigned to a variable or otherwise operated on:

val=(yieldi)

I recommend that you always put parentheses around a yield expression
when you’re doing something with the returned value, as in the above example.
The parentheses aren’t always necessary, but it’s easier to always add them
instead of having to remember when they’re needed.

(PEP 342 explains the exact rules, which are that a yield-expression must always be parenthesized except when it occurs at the top-level
expression on the right-hand side of an assignment. This means you can write
val=yieldi but have to use parentheses when there’s an operation, as in
val=(yieldi)+12.)

Values are sent into a generator by calling its send(value) method. The
generator’s code is then resumed and the yield expression returns the
specified value. If the regular next() method is called, the
yield returns None.

Here’s the previous example, modified to allow changing the value of the
internal counter.

yield will usually return None, so you should always check
for this case. Don’t just use its value in expressions unless you’re sure that
the send() method will be the only method used to resume your generator
function.

In addition to send(), there are two other new methods on generators:

throw(type,value=None,traceback=None) is used to raise an exception
inside the generator; the exception is raised by the yield expression
where the generator’s execution is paused.

close() raises a new GeneratorExit exception inside the generator
to terminate the iteration. On receiving this exception, the generator’s code
must either raise GeneratorExit or StopIteration. Catching the
GeneratorExit exception and returning a value is illegal and will trigger
a RuntimeError; if the function raises some other exception, that
exception is propagated to the caller. close() will also be called by
Python’s garbage collector when the generator is garbage-collected.

If you need to run cleanup code when a GeneratorExit occurs, I suggest
using a try:...finally: suite instead of catching GeneratorExit.

The cumulative effect of these changes is to turn generators from one-way
producers of information into both producers and consumers.

Generators also become coroutines, a more generalized form of subroutines.
Subroutines are entered at one point and exited at another point (the top of the
function, and a return statement), but coroutines can be entered,
exited, and resumed at many different points (the yield statements).
We’ll have to figure out patterns for using coroutines effectively in Python.

The addition of the close() method has one side effect that isn’t obvious.
close() is called when a generator is garbage-collected, so this means the
generator’s code gets one last chance to run before the generator is destroyed.
This last chance means that try...finally statements in generators can now
be guaranteed to work; the finally clause will now always get a
chance to run. The syntactic restriction that you couldn’t mix yield
statements with a try...finally suite has therefore been removed. This
seems like a minor bit of language trivia, but using generators and
try...finally is actually necessary in order to implement the
with statement described by PEP 343. I’ll look at this new statement
in the following section.

Another even more esoteric effect of this change: previously, the
gi_frame attribute of a generator was always a frame object. It’s now
possible for gi_frame to be None once the generator has been
exhausted.

The “with” statement clarifies code that previously would use
try...finally blocks to ensure that clean-up code is executed. In this
section, I’ll discuss the statement as it will commonly be used. In the next
section, I’ll examine the implementation details and show how to write objects
for use with this statement.

The “with” statement is a new control-flow structure whose basic
structure is:

withexpression[asvariable]:with-block

The expression is evaluated, and it should result in an object that supports the
context management protocol (that is, has __enter__() and __exit__()
methods.

The object’s __enter__() is called before with-block is executed and
therefore can run set-up code. It also may return a value that is bound to the
name variable, if given. (Note carefully that variable is not assigned
the result of expression.)

After execution of the with-block is finished, the object’s __exit__()
method is called, even if the block raised an exception, and can therefore run
clean-up code.

To enable the statement in Python 2.5, you need to add the following directive
to your module:

from__future__importwith_statement

The statement will always be enabled in Python 2.6.

Some standard Python objects now support the context management protocol and can
be used with the “with” statement. File objects are one example:

After this statement has executed, the file object in f will have been
automatically closed, even if the for loop raised an exception
part-way through the block.

Note

In this case, f is the same object created by open(), because
file.__enter__() returns self.

The threading module’s locks and condition variables also support the
“with” statement:

lock=threading.Lock()withlock:# Critical section of code...

The lock is acquired before the block is executed and always released once the
block is complete.

The new localcontext() function in the decimal module makes it easy
to save and restore the current decimal context, which encapsulates the desired
precision and rounding characteristics for computations:

fromdecimalimportDecimal,Context,localcontext# Displays with default precision of 28 digitsv=Decimal('578')printv.sqrt()withlocalcontext(Context(prec=16)):# All code in this block uses a precision of 16 digits.# The original context is restored on exiting the block.printv.sqrt()

Under the hood, the “with” statement is fairly complicated. Most
people will only use “with” in company with existing objects and
don’t need to know these details, so you can skip the rest of this section if
you like. Authors of new objects will need to understand the details of the
underlying implementation and should keep reading.

A high-level explanation of the context management protocol is:

The expression is evaluated and should result in an object called a « context
manager ». The context manager must have __enter__() and __exit__()
methods.

The context manager’s __enter__() method is called. The value returned
is assigned to VAR. If no 'asVAR' clause is present, the value is simply
discarded.

Le code dans BLOCK est exécuté.

If BLOCK raises an exception, the __exit__(type,value,traceback)
is called with the exception details, the same values returned by
sys.exc_info(). The method’s return value controls whether the exception
is re-raised: any false value re-raises the exception, and True will result
in suppressing it. You’ll only rarely want to suppress the exception, because
if you do the author of the code containing the “with” statement will
never realize anything went wrong.

If BLOCK didn’t raise an exception, the __exit__() method is still
called, but type, value, and traceback are all None.

Let’s think through an example. I won’t present detailed code but will only
sketch the methods necessary for a database that supports transactions.

(For people unfamiliar with database terminology: a set of changes to the
database are grouped into a transaction. Transactions can be either committed,
meaning that all the changes are written into the database, or rolled back,
meaning that the changes are all discarded and the database is unchanged. See
any database textbook for more information.)

Let’s assume there’s an object representing a database connection. Our goal will
be to let the user write code like this:

db_connection=DatabaseConnection()withdb_connectionascursor:cursor.execute('insert into ...')cursor.execute('delete from ...')# ... more operations ...

The transaction should be committed if the code in the block runs flawlessly or
rolled back if there’s an exception. Here’s the basic interface for
DatabaseConnection that I’ll assume:

classDatabaseConnection:# Database interfacedefcursor(self):"Returns a cursor object and starts a new transaction"defcommit(self):"Commits current transaction"defrollback(self):"Rolls back current transaction"

The __enter__() method is pretty easy, having only to start a new
transaction. For this application the resulting cursor object would be a useful
result, so the method will return it. The user can then add ascursor to
their “with” statement to bind the cursor to a variable name.

classDatabaseConnection:...def__enter__(self):# Code to start a new transactioncursor=self.cursor()returncursor

The __exit__() method is the most complicated because it’s where most of
the work has to be done. The method has to check if an exception occurred. If
there was no exception, the transaction is committed. The transaction is rolled
back if there was an exception.

In the code below, execution will just fall off the end of the function,
returning the default value of None. None is false, so the exception
will be re-raised automatically. If you wished, you could be more explicit and
add a return statement at the marked location.

The new contextlib module provides some functions and a decorator that
are useful for writing objects for use with the “with” statement.

The decorator is called contextmanager(), and lets you write a single
generator function instead of defining a new class. The generator should yield
exactly one value. The code up to the yield will be executed as the
__enter__() method, and the value yielded will be the method’s return
value that will get bound to the variable in the “with” statement’s
as clause, if any. The code after the yield will be
executed in the __exit__() method. Any exception raised in the block will
be raised by the yield statement.

Our database example from the previous section could be written using this
decorator as:

The contextlib module also has a nested(mgr1,mgr2,...) function
that combines a number of context managers so you don’t need to write nested
“with” statements. In this example, the single “with”
statement both starts a database transaction and acquires a thread lock:

PEP written by Guido van Rossum and Nick Coghlan; implemented by Mike Bland,
Guido van Rossum, and Neal Norwitz. The PEP shows the code generated for a
“with” statement, which can be helpful in learning how the statement
works.

Exception classes can now be new-style classes, not just classic classes, and
the built-in Exception class and all the standard built-in exceptions
(NameError, ValueError, etc.) are now new-style classes.

The inheritance hierarchy for exceptions has been rearranged a bit. In 2.5, the
inheritance relationships are:

BaseException# New in Python 2.5|-KeyboardInterrupt|-SystemExit|-Exception|-(allothercurrentbuilt-inexceptions)

This rearrangement was done because people often want to catch all exceptions
that indicate program errors. KeyboardInterrupt and SystemExit
aren’t errors, though, and usually represent an explicit action such as the user
hitting Control-C or code calling sys.exit(). A bare except: will
catch all exceptions, so you commonly need to list KeyboardInterrupt and
SystemExit in order to re-raise them. The usual pattern is:

In Python 2.5, you can now write exceptException to achieve the same
result, catching all the exceptions that usually indicate errors but leaving
KeyboardInterrupt and SystemExit alone. As in previous versions,
a bare except: still catches all exceptions.

The goal for Python 3.0 is to require any class raised as an exception to derive
from BaseException or some descendant of BaseException, and future
releases in the Python 2.x series may begin to enforce this constraint.
Therefore, I suggest you begin making all your exception classes derive from
Exception now. It’s been suggested that the bare except: form should
be removed in Python 3.0, but Guido van Rossum hasn’t decided whether to do this
or not.

Raising of strings as exceptions, as in the statement raise"Erroroccurred", is deprecated in Python 2.5 and will trigger a warning. The aim is
to be able to remove the string-exception feature in a few releases.

A wide-ranging change to Python’s C API, using a new Py_ssize_t type
definition instead of int, will permit the interpreter to handle more
data on 64-bit platforms. This change doesn’t affect Python’s capacity on 32-bit
platforms.

Various pieces of the Python interpreter used C’s int type to store
sizes or counts; for example, the number of items in a list or tuple were stored
in an int. The C compilers for most 64-bit platforms still define
int as a 32-bit type, so that meant that lists could only hold up to
2**31-1 = 2147483647 items. (There are actually a few different
programming models that 64-bit C compilers can use – see
http://www.unix.org/version2/whatsnew/lp64_wp.html for a discussion – but the
most commonly available model leaves int as 32 bits.)

A limit of 2147483647 items doesn’t really matter on a 32-bit platform because
you’ll run out of memory before hitting the length limit. Each list item
requires space for a pointer, which is 4 bytes, plus space for a
PyObject representing the item. 2147483647*4 is already more bytes
than a 32-bit address space can contain.

It’s possible to address that much memory on a 64-bit platform, however. The
pointers for a list that size would only require 16 GiB of space, so it’s not
unreasonable that Python programmers might construct lists that large.
Therefore, the Python interpreter had to be changed to use some type other than
int, and this will be a 64-bit type on 64-bit platforms. The change
will cause incompatibilities on 64-bit machines, so it was deemed worth making
the transition now, while the number of 64-bit users is still relatively small.
(In 5 or 10 years, we may all be on 64-bit machines, and the transition would
be more painful then.)

This change most strongly affects authors of C extension modules. Python
strings and container types such as lists and tuples now use
Py_ssize_t to store their size. Functions such as
PyList_Size() now return Py_ssize_t. Code in extension modules
may therefore need to have some variables changed to Py_ssize_t.

The PyArg_ParseTuple() and Py_BuildValue() functions have a new
conversion code, n, for Py_ssize_t. PyArg_ParseTuple()”s
s# and t# still output int by default, but you can define the
macro PY_SSIZE_T_CLEAN before including Python.h to make
them return Py_ssize_t.

PEP 353 has a section on conversion guidelines that extension authors should
read to learn about supporting 64-bit platforms.

The NumPy developers had a problem that could only be solved by adding a new
special method, __index__(). When using slice notation, as in
[start:stop:step], the values of the start, stop, and step indexes
must all be either integers or long integers. NumPy defines a variety of
specialized integer types corresponding to unsigned and signed integers of 8,
16, 32, and 64 bits, but there was no way to signal that these types could be
used as slice indexes.

Slicing can’t just use the existing __int__() method because that method
is also used to implement coercion to integers. If slicing used
__int__(), floating-point numbers would also become legal slice indexes
and that’s clearly an undesirable behaviour.

Instead, a new special method called __index__() was added. It takes no
arguments and returns an integer giving the slice index to use. For example:

classC:def__index__(self):returnself.value

The return value must be either a Python integer or long integer. The
interpreter will check that the type returned is correct, and raises a
TypeError if this requirement isn’t met.

A corresponding nb_index slot was added to the C-level
PyNumberMethods structure to let C extensions implement this protocol.
PyNumber_Index(obj) can be used in extension code to call the
__index__() function and retrieve its result.

Here are all of the changes that Python 2.5 makes to the core Python language.

The dict type has a new hook for letting subclasses provide a default
value when a key isn’t contained in the dictionary. When a key isn’t found, the
dictionary’s __missing__(key) method will be called. This hook is used
to implement the new defaultdict class in the collections
module. The following example defines a dictionary that returns zero for any
missing key:

Both 8-bit and Unicode strings have new partition(sep) and
rpartition(sep) methods that simplify a common use case.

The find(S) method is often used to get an index which is then used to
slice the string and obtain the pieces that are before and after the separator.
partition(sep) condenses this pattern into a single method call that
returns a 3-tuple containing the substring before the separator, the separator
itself, and the substring after the separator. If the separator isn’t found,
the first element of the tuple is the entire string and the other two elements
are empty. rpartition(sep) also returns a 3-tuple but starts searching
from the end of the string; the r stands for “reverse”.

The min() and max() built-in functions gained a key keyword
parameter analogous to the key argument for sort(). This parameter
supplies a function that takes a single argument and is called for every value
in the list; min()/max() will return the element with the
smallest/largest return value from this function. For example, to find the
longest string in a list, you can do:

L=['medium','longest','short']# Prints 'longest'printmax(L,key=len)# Prints 'short', because lexicographically 'short' has the largest valueprintmax(L)

(Contributed by Steven Bethard and Raymond Hettinger.)

Two new built-in functions, any() and all(), evaluate whether an
iterator contains any true or false values. any() returns True
if any value returned by the iterator is true; otherwise it will return
False. all() returns True only if all of the values
returned by the iterator evaluate as true. (Suggested by Guido van Rossum, and
implemented by Raymond Hettinger.)

The result of a class’s __hash__() method can now be either a long
integer or a regular integer. If a long integer is returned, the hash of that
value is taken. In earlier versions the hash value was required to be a
regular integer, but in 2.5 the id() built-in was changed to always
return non-negative numbers, and users often seem to use id(self) in
__hash__() methods (though this is discouraged).

ASCII is now the default encoding for modules. It’s now a syntax error if a
module contains string literals with 8-bit characters but doesn’t have an
encoding declaration. In Python 2.4 this triggered a warning, not a syntax
error. See PEP 263 for how to declare a module’s encoding; for example, you
might add a line like this near the top of the source file:

# -*- coding: latin1 -*-

A new warning, UnicodeWarning, is triggered when you attempt to
compare a Unicode string and an 8-bit string that can’t be converted to Unicode
using the default ASCII encoding. The result of the comparison is false:

>>> chr(128)==unichr(128)# Can't convert chr(128) to Unicode__main__:1: UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequalFalse>>> chr(127)==unichr(127)# chr(127) can be convertedTrue

Previously this would raise a UnicodeDecodeError exception, but in 2.5
this could result in puzzling problems when accessing a dictionary. If you
looked up unichr(128) and chr(128) was being used as a key, you’d get a
UnicodeDecodeError exception. Other changes in 2.5 resulted in this
exception being raised instead of suppressed by the code in dictobject.c
that implements dictionaries.

Raising an exception for such a comparison is strictly correct, but the change
might have broken code, so instead UnicodeWarning was introduced.

(Implemented by Marc-André Lemburg.)

One error that Python programmers sometimes make is forgetting to include an
__init__.py module in a package directory. Debugging this mistake can be
confusing, and usually requires running Python with the -v switch to
log all the paths searched. In Python 2.5, a new ImportWarning warning is
triggered when an import would have picked up a directory as a package but no
__init__.py was found. This warning is silently ignored by default;
provide the -Wd option when running the Python executable to display
the warning message. (Implemented by Thomas Wouters.)

The list of base classes in a class definition can now be empty. As an
example, this is now legal:

In the interactive interpreter, quit and exit have long been strings so
that new users get a somewhat helpful message when they try to quit:

>>> quit'Use Ctrl-D (i.e. EOF) to exit.'

In Python 2.5, quit and exit are now objects that still produce string
representations of themselves, but are also callable. Newbies who try quit()
or exit() will now exit the interpreter as they expect. (Implemented by
Georg Brandl.)

The Python executable now accepts the standard long options --help
and --version; on Windows, it also accepts the /? option
for displaying a help message. (Implemented by Georg Brandl.)

Several of the optimizations were developed at the NeedForSpeed sprint, an event
held in Reykjavik, Iceland, from May 21–28 2006. The sprint focused on speed
enhancements to the CPython implementation and was funded by EWT LLC with local
support from CCP Games. Those optimizations added at this sprint are specially
marked in the following list.

When they were introduced in Python 2.4, the built-in set and
frozenset types were built on top of Python’s dictionary type. In 2.5
the internal data structure has been customized for implementing sets, and as a
result sets will use a third less memory and are somewhat faster. (Implemented
by Raymond Hettinger.)

The speed of some Unicode operations, such as finding substrings, string
splitting, and character map encoding and decoding, has been improved.
(Substring search and splitting improvements were added by Fredrik Lundh and
Andrew Dalke at the NeedForSpeed sprint. Character maps were improved by Walter
Dörwald and Martin von Löwis.)

The long(str,base) function is now faster on long digit strings
because fewer intermediate results are calculated. The peak is for strings of
around 800–1000 digits where the function is 6 times faster. (Contributed by
Alan McIntyre and committed at the NeedForSpeed sprint.)

It’s now illegal to mix iterating over a file with forlineinfile and
calling the file object’s read()/readline()/readlines()
methods. Iteration uses an internal buffer and the read*() methods
don’t use that buffer. Instead they would return the data following the
buffer, causing the data to appear out of order. Mixing iteration and these
methods will now trigger a ValueError from the read*() method.
(Implemented by Thomas Wouters.)

The struct module now compiles structure format strings into an
internal representation and caches this representation, yielding a 20% speedup.
(Contributed by Bob Ippolito at the NeedForSpeed sprint.)

The re module got a 1 or 2% speedup by switching to Python’s allocator
functions instead of the system’s malloc() and free().
(Contributed by Jack Diederich at the NeedForSpeed sprint.)

The code generator’s peephole optimizer now performs simple constant folding
in expressions. If you write something like a=2+3, the code generator
will do the arithmetic and produce code corresponding to a=5. (Proposed
and implemented by Raymond Hettinger.)

Function calls are now faster because code objects now keep the most recently
finished frame (a « zombie frame ») in an internal field of the code object,
reusing it the next time the code object is invoked. (Original patch by Michael
Hudson, modified by Armin Rigo and Richard Jones; committed at the NeedForSpeed
sprint.) Frame objects are also slightly smaller, which may improve cache
locality and reduce memory usage a bit. (Contributed by Neal Norwitz.)

Python’s built-in exceptions are now new-style classes, a change that speeds
up instantiation considerably. Exception handling in Python 2.5 is therefore
about 30% faster than in 2.4. (Contributed by Richard Jones, Georg Brandl and
Sean Reifschneider at the NeedForSpeed sprint.)

Importing now caches the paths tried, recording whether they exist or not so
that the interpreter makes fewer open() and stat() calls on
startup. (Contributed by Martin von Löwis and Georg Brandl.)

The standard library received many enhancements and bug fixes in Python 2.5.
Here’s a partial list of the most notable changes, sorted alphabetically by
module name. Consult the Misc/NEWS file in the source tree for a more
complete list of changes, or look through the SVN logs for all the details.

The audioop module now supports the a-LAW encoding, and the code for
u-LAW encoding has been improved. (Contributed by Lars Immisch.)

The codecs module gained support for incremental codecs. The
codec.lookup() function now returns a CodecInfo instance instead
of a tuple. CodecInfo instances behave like a 4-tuple to preserve
backward compatibility but also have the attributes encode,
decode, incrementalencoder, incrementaldecoder,
streamwriter, and streamreader. Incremental codecs can receive
input and produce output in multiple chunks; the output is the same as if the
entire input was fed to the non-incremental codec. See the codecs module
documentation for details. (Designed and implemented by Walter Dörwald.)

The collections module gained a new type, defaultdict, that
subclasses the standard dict type. The new type mostly behaves like a
dictionary but constructs a default value when a key isn’t present,
automatically adding it to the dictionary for the requested key value.

The first argument to defaultdict’s constructor is a factory function
that gets called whenever a key is requested but not found. This factory
function receives no arguments, so you can use built-in type constructors such
as list() or int(). For example, you can make an index of words
based on their initial letter like this:

The deque double-ended queue type supplied by the collections
module now has a remove(value) method that removes the first occurrence
of value in the queue, raising ValueError if the value isn’t found.
(Contributed by Raymond Hettinger.)

New module: The cProfile module is a C implementation of the existing
profile module that has much lower overhead. The module’s interface is
the same as profile: you run cProfile.run('main()') to profile a
function, can save profile data to a file, etc. It’s not yet known if the
Hotshot profiler, which is also written in C but doesn’t match the
profile module’s interface, will continue to be maintained in future
versions of Python. (Contributed by Armin Rigo.)

Also, the pstats module for analyzing the data measured by the profiler
now supports directing the output to any file object by supplying a stream
argument to the Stats constructor. (Contributed by Skip Montanaro.)

The csv module, which parses files in comma-separated value format,
received several enhancements and a number of bugfixes. You can now set the
maximum size in bytes of a field by calling the
csv.field_size_limit(new_limit) function; omitting the new_limit
argument will return the currently-set limit. The reader class now has
a line_num attribute that counts the number of physical lines read from
the source; records can span multiple physical lines, so line_num is not
the same as the number of records read.

The CSV parser is now stricter about multi-line quoted fields. Previously, if a
line ended within a quoted field without a terminating newline character, a
newline would be inserted into the returned field. This behavior caused problems
when reading files that contained carriage return characters within fields, so
the code was changed to return the field without inserting newlines. As a
consequence, if newlines embedded within fields are important, the input should
be split into lines in a manner that preserves the newline characters.

The SequenceMatcher.get_matching_blocks() method in the difflib
module now guarantees to return a minimal list of blocks describing matching
subsequences. Previously, the algorithm would occasionally break a block of
matching elements into two list entries. (Enhancement by Tim Peters.)

The doctest module gained a SKIP option that keeps an example from
being executed at all. This is intended for code snippets that are usage
examples intended for the reader and aren’t actually test cases.

An encoding parameter was added to the testfile() function and the
DocFileSuite class to specify the file’s encoding. This makes it
easier to use non-ASCII characters in tests contained within a docstring.
(Contributed by Bjorn Tillenius.)

The email package has been updated to version 4.0. (Contributed by
Barry Warsaw.)

The fileinput module was made more flexible. Unicode filenames are now
supported, and a mode parameter that defaults to "r" was added to the
input() function to allow opening files in binary or universal
newlines mode. Another new parameter, openhook, lets you use a function
other than open() to open the input files. Once you’re iterating over
the set of files, the FileInput object’s new fileno() returns
the file descriptor for the currently opened file. (Contributed by Georg
Brandl.)

In the gc module, the new get_count() function returns a 3-tuple
containing the current collection counts for the three GC generations. This is
accounting information for the garbage collector; when these counts reach a
specified threshold, a garbage collection sweep will be made. The existing
gc.collect() function now takes an optional generation argument of 0, 1,
or 2 to specify which generation to collect. (Contributed by Barry Warsaw.)

The nsmallest() and nlargest() functions in the heapq
module now support a key keyword parameter similar to the one provided by
the min()/max() functions and the sort() methods. For
example:

The format() function in the locale module has been modified and
two new functions were added, format_string() and currency().

The format() function’s val parameter could previously be a string as
long as no more than one %char specifier appeared; now the parameter must be
exactly one %char specifier with no surrounding text. An optional monetary
parameter was also added which, if True, will use the locale’s rules for
formatting currency in placing a separator between groups of three digits.

To format strings with multiple %char specifiers, use the new
format_string() function that works like format() but also supports
mixing %char specifiers with arbitrary text.

A new currency() function was also added that formats a number according
to the current locale’s settings.

(Contributed by Georg Brandl.)

The mailbox module underwent a massive rewrite to add the capability to
modify mailboxes in addition to reading them. A new set of classes that include
mbox, MH, and Maildir are used to read mailboxes, and
have an add(message) method to add messages, remove(key) to
remove messages, and lock()/unlock() to lock/unlock the mailbox.
The following example converts a maildir-format mailbox into an mbox-format
one:

New module: the msilib module allows creating Microsoft Installer
.msi files and CAB files. Some support for reading the .msi
database is also included. (Contributed by Martin von Löwis.)

The nis module now supports accessing domains other than the system
default domain by supplying a domain argument to the nis.match() and
nis.maps() functions. (Contributed by Ben Bell.)

The operator module’s itemgetter() and attrgetter()
functions now support multiple fields. A call such as
operator.attrgetter('a','b') will return a function that retrieves the
a and b attributes. Combining this new feature with the
sort() method’s key parameter lets you easily sort lists using
multiple fields. (Contributed by Raymond Hettinger.)

The optparse module was updated to version 1.5.1 of the Optik library.
The OptionParser class gained an epilog attribute, a string
that will be printed after the help message, and a destroy() method to
break reference cycles created by the object. (Contributed by Greg Ward.)

The os module underwent several changes. The stat_float_times
variable now defaults to true, meaning that os.stat() will now return time
values as floats. (This doesn’t necessarily mean that os.stat() will
return times that are precise to fractions of a second; not all systems support
such precision.)

Two new functions, wait3() and wait4(), were added. They’re similar
the waitpid() function which waits for a child process to exit and returns
a tuple of the process ID and its exit status, but wait3() and
wait4() return additional information. wait3() doesn’t take a
process ID as input, so it waits for any child process to exit and returns a
3-tuple of process-id, exit-status, resource-usage as returned from the
resource.getrusage() function. wait4(pid) does take a process ID.
(Contributed by Chad J. Schroeder.)

On FreeBSD, the os.stat() function now returns times with nanosecond
resolution, and the returned object now has st_gen and
st_birthtime. The st_flags attribute is also available, if the
platform supports it. (Contributed by Antti Louko and Diego Pettenò.)

The Python debugger provided by the pdb module can now store lists of
commands to execute when a breakpoint is reached and execution stops. Once
breakpoint #1 has been created, enter commands1 and enter a series of
commands to be executed, finishing the list with end. The command list can
include commands that resume execution, such as continue or next.
(Contributed by Grégoire Dooms.)

The pickle and cPickle modules no longer accept a return value
of None from the __reduce__() method; the method must return a tuple
of arguments instead. The ability to return None was deprecated in Python
2.4, so this completes the removal of the feature.

The pkgutil module, containing various utility functions for finding
packages, was enhanced to support PEP 302’s import hooks and now also works for
packages stored in ZIP-format archives. (Contributed by Phillip J. Eby.)

The pybench benchmark suite by Marc-André Lemburg is now included in the
Tools/pybench directory. The pybench suite is an improvement on the
commonly used pystone.py program because pybench provides a more
detailed measurement of the interpreter’s speed. It times particular operations
such as function calls, tuple slicing, method lookups, and numeric operations,
instead of performing many different operations and reducing the result to a
single number as pystone.py does.

The pyexpat module now uses version 2.0 of the Expat parser.
(Contributed by Trent Mick.)

The Queue class provided by the Queue module gained two new
methods. join() blocks until all items in the queue have been retrieved
and all processing work on the items have been completed. Worker threads call
the other new method, task_done(), to signal that processing for an item
has been completed. (Contributed by Raymond Hettinger.)

The old regex and regsub modules, which have been deprecated
ever since Python 2.0, have finally been deleted. Other deleted modules:
statcache, tzparse, whrandom.

Also deleted: the lib-old directory, which includes ancient modules
such as dircmp and ni, was removed. lib-old wasn’t on the
default sys.path, so unless your programs explicitly added the directory to
sys.path, this removal shouldn’t affect your code.

The rlcompleter module is no longer dependent on importing the
readline module and therefore now works on non-Unix platforms. (Patch
from Robert Kiendl.)

The SimpleXMLRPCServer and DocXMLRPCServer classes now have a
rpc_paths attribute that constrains XML-RPC operations to a limited set
of URL paths; the default is to allow only '/' and '/RPC2'. Setting
rpc_paths to None or an empty tuple disables this path checking.

The socket module now supports AF_NETLINK sockets on Linux,
thanks to a patch from Philippe Biondi. Netlink sockets are a Linux-specific
mechanism for communications between a user-space process and kernel code; an
introductory article about them is at https://www.linuxjournal.com/article/7356.
In Python code, netlink addresses are represented as a tuple of 2 integers,
(pid,group_mask).

Two new methods on socket objects, recv_into(buffer) and
recvfrom_into(buffer), store the received data in an object that
supports the buffer protocol instead of returning the data as a string. This
means you can put the data directly into an array or a memory-mapped file.

Socket objects also gained getfamily(), gettype(), and
getproto() accessor methods to retrieve the family, type, and protocol
values for the socket.

New module: the spwd module provides functions for accessing the shadow
password database on systems that support shadow passwords.

The struct is now faster because it compiles format strings into
Struct objects with pack() and unpack() methods. This is
similar to how the re module lets you create compiled regular expression
objects. You can still use the module-level pack() and unpack()
functions; they’ll create Struct objects and cache them. Or you can
use Struct instances directly:

You can also pack and unpack data to and from buffer objects directly using the
pack_into(buffer,offset,v1,v2,...) and unpack_from(buffer,offset) methods. This lets you store data directly into an array or a
memory-mapped file.

(Struct objects were implemented by Bob Ippolito at the NeedForSpeed
sprint. Support for buffer objects was added by Martin Blais, also at the
NeedForSpeed sprint.)

The Python developers switched from CVS to Subversion during the 2.5
development process. Information about the exact build version is available as
the sys.subversion variable, a 3-tuple of (interpreter-name,branch-name,revision-range). For example, at the time of writing my copy of 2.5 was
reporting ('CPython','trunk','45313:45315').

This information is also available to C extensions via the
Py_GetBuildInfo() function that returns a string of build information
like this: "trunk:45355:45356M,Apr132006,07:42:19". (Contributed by
Barry Warsaw.)

Another new function, sys._current_frames(), returns the current stack
frames for all running threads as a dictionary mapping thread identifiers to the
topmost stack frame currently active in that thread at the time the function is
called. (Contributed by Tim Peters.)

The TarFile class in the tarfile module now has an
extractall() method that extracts all members from the archive into the
current working directory. It’s also possible to set a different directory as
the extraction target, and to unpack only a subset of the archive’s members.

The compression used for a tarfile opened in stream mode can now be autodetected
using the mode 'r|*'. (Contributed by Lars Gustäbel.)

The threading module now lets you set the stack size used when new
threads are created. The stack_size([*size*]) function returns the
currently configured stack size, and supplying the optional size parameter
sets a new value. Not all platforms support changing the stack size, but
Windows, POSIX threading, and OS/2 all do. (Contributed by Andrew MacIntyre.)

The unicodedata module has been updated to use version 4.1.0 of the
Unicode character database. Version 3.2.0 is required by some specifications,
so it’s still available as unicodedata.ucd_3_2_0.

New module: the uuid module generates universally unique identifiers
(UUIDs) according to RFC 4122. The RFC defines several different UUID
versions that are generated from a starting string, from system properties, or
purely randomly. This module contains a UUID class and functions
named uuid1(), uuid3(), uuid4(), and uuid5() to
generate different versions of UUID. (Version 2 UUIDs are not specified in
RFC 4122 and are not supported by this module.)

>>> importuuid>>> # make a UUID based on the host ID and current time>>> uuid.uuid1()UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')>>> # make a UUID using an MD5 hash of a namespace UUID and a name>>> uuid.uuid3(uuid.NAMESPACE_DNS,'python.org')UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')>>> # make a random UUID>>> uuid.uuid4()UUID('16fd2706-8baf-433b-82eb-8c7fada847da')>>> # make a UUID using a SHA-1 hash of a namespace UUID and a name>>> uuid.uuid5(uuid.NAMESPACE_DNS,'python.org')UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')

(Contributed by Ka-Ping Yee.)

The weakref module’s WeakKeyDictionary and
WeakValueDictionary types gained new methods for iterating over the
weak references contained in the dictionary. iterkeyrefs() and
keyrefs() methods were added to WeakKeyDictionary, and
itervaluerefs() and valuerefs() were added to
WeakValueDictionary. (Contributed by Fred L. Drake, Jr.)

The webbrowser module received a number of enhancements. It’s now
usable as a script with python-mwebbrowser, taking a URL as the argument;
there are a number of switches to control the behaviour (-n for a new
browser window, -t for a new tab). New module-level functions,
open_new() and open_new_tab(), were added to support this. The
module’s open() function supports an additional feature, an autoraise
parameter that signals whether to raise the open window when possible. A number
of additional browsers were added to the supported list such as Firefox, Opera,
Konqueror, and elinks. (Contributed by Oleg Broytmann and Georg Brandl.)

The xmlrpclib module now supports returning datetime objects
for the XML-RPC date type. Supply use_datetime=True to the loads()
function or the Unmarshaller class to enable this feature. (Contributed
by Skip Montanaro.)

The zipfile module now supports the ZIP64 version of the format,
meaning that a .zip archive can now be larger than 4 GiB and can contain
individual files larger than 4 GiB. (Contributed by Ronald Oussoren.)

The zlib module’s Compress and Decompress objects now
support a copy() method that makes a copy of the object’s internal state
and returns a new Compress or Decompress object.
(Contributed by Chris AtLee.)

The ctypes package, written by Thomas Heller, has been added to the
standard library. ctypes lets you call arbitrary functions in shared
libraries or DLLs. Long-time users may remember the dl module, which
provides functions for loading shared libraries and calling functions in them.
The ctypes package is much fancier.

To load a shared library or DLL, you must create an instance of the
CDLL class and provide the name or path of the shared library or DLL.
Once that’s done, you can call arbitrary functions by accessing them as
attributes of the CDLL object.

importctypeslibc=ctypes.CDLL('libc.so.6')result=libc.printf("Line of output\n")

Type constructors for the various C types are provided: c_int(),
c_float(), c_double(), c_char_p() (equivalent to char*), and so forth. Unlike Python’s types, the C versions are all mutable; you
can assign to their value attribute to change the wrapped value. Python
integers and strings will be automatically converted to the corresponding C
types, but for other types you must call the correct type constructor. (And I
mean must; getting it wrong will often result in the interpreter crashing
with a segmentation fault.)

You shouldn’t use c_char_p() with a Python string when the C function will
be modifying the memory area, because Python strings are supposed to be
immutable; breaking this rule will cause puzzling bugs. When you need a
modifiable memory area, use create_string_buffer():

s="this is a string"buf=ctypes.create_string_buffer(s)libc.strfry(buf)

C functions are assumed to return integers, but you can set the restype
attribute of the function object to change this:

ctypes also provides a wrapper for Python’s C API as the
ctypes.pythonapi object. This object does not release the global
interpreter lock before calling a function, because the lock must be held when
calling into the interpreter’s code. There’s a py_object() type
constructor that will create a PyObject* pointer. A simple usage:

importctypesd={}ctypes.pythonapi.PyObject_SetItem(ctypes.py_object(d),ctypes.py_object("abc"),ctypes.py_object(1))# d is now {'abc', 1}.

Don’t forget to use py_object(); if it’s omitted you end up with a
segmentation fault.

ctypes has been around for a while, but people still write and
distribution hand-coded extension modules because you can’t rely on
ctypes being present. Perhaps developers will begin to write Python
wrappers atop a library accessed through ctypes instead of extension
modules, now that ctypes is included with core Python.

A subset of Fredrik Lundh’s ElementTree library for processing XML has been
added to the standard library as xml.etree. The available modules are
ElementTree, ElementPath, and ElementInclude from
ElementTree 1.2.6. The cElementTree accelerator module is also
included.

ElementTree represents an XML document as a tree of element nodes. The text
content of the document is stored as the text and tail
attributes of (This is one of the major differences between ElementTree and
the Document Object Model; in the DOM there are many different types of node,
including TextNode.)

The most commonly used parsing function is parse(), that takes either a
string (assumed to contain a filename) or a file-like object and returns an
ElementTree instance:

Once you have an ElementTree instance, you can call its getroot()
method to get the root Element node.

There’s also an XML() function that takes a string literal and returns an
Element node (not an ElementTree). This function provides a
tidy way to incorporate XML fragments, approaching the convenience of an XML
literal:

Each XML element supports some dictionary-like and some list-like access
methods. Dictionary-like operations are used to access attribute values, and
list-like operations are used to access child nodes.

Opération

Résultat

elem[n]

Returns n’th child element.

elem[m:n]

Returns list of m’th through n’th child
elements.

len(elem)

Returns number of child elements.

list(elem)

Returns list of child elements.

elem.append(elem2)

Adds elem2 as a child.

elem.insert(index,elem2)

Inserts elem2 at the specified location.

delelem[n]

Deletes n’th child element.

elem.keys()

Returns list of attribute names.

elem.get(name)

Returns value of attribute name.

elem.set(name,value)

Sets new value for attribute name.

elem.attrib

Retrieves the dictionary containing
attributes.

delelem.attrib[name]

Supprime l’attribut name.

Comments and processing instructions are also represented as Element
nodes. To check if a node is a comment or processing instructions:

ifelem.tagisET.Comment:...elifelem.tagisET.ProcessingInstruction:...

To generate XML output, you should call the ElementTree.write() method.
Like parse(), it can take either a string or a file-like object:

(Caution: the default encoding used for output is ASCII. For general XML work,
where an element’s name may contain arbitrary Unicode characters, ASCII isn’t a
very useful encoding because it will raise an exception if an element’s name
contains any characters with values greater than 127. Therefore, it’s best to
specify a different encoding such as UTF-8 that can handle any Unicode
character.)

This section is only a partial description of the ElementTree interfaces. Please
read the package’s official documentation for more details.

A new hashlib module, written by Gregory P. Smith, has been added to
replace the md5 and sha modules. hashlib adds support for
additional secure hashes (SHA-224, SHA-256, SHA-384, and SHA-512). When
available, the module uses OpenSSL for fast platform optimized implementations
of algorithms.

The old md5 and sha modules still exist as wrappers around hashlib
to preserve backwards compatibility. The new module’s interface is very close
to that of the old modules, but not identical. The most significant difference
is that the constructor functions for creating new hashing objects are named
differently.

# Old versionsh=md5.md5()h=md5.new()# New versionh=hashlib.md5()# Old versionsh=sha.sha()h=sha.new()# New versionh=hashlib.sha1()# Hash that weren't previously availableh=hashlib.sha224()h=hashlib.sha256()h=hashlib.sha384()h=hashlib.sha512()# Alternative formh=hashlib.new('md5')# Provide algorithm as a string

Once a hash object has been created, its methods are the same as before:
update(string) hashes the specified string into the current digest
state, digest() and hexdigest() return the digest value as a binary
string or a string of hex digits, and copy() returns a new hashing object
with the same digest state.

The pysqlite module (http://www.pysqlite.org), a wrapper for the SQLite embedded
database, has been added to the standard library under the package name
sqlite3.

SQLite is a C library that provides a lightweight disk-based database that
doesn’t require a separate server process and allows accessing the database
using a nonstandard variant of the SQL query language. Some applications can use
SQLite for internal data storage. It’s also possible to prototype an
application using SQLite and then port the code to a larger database such as
PostgreSQL or Oracle.

pysqlite was written by Gerhard Häring and provides a SQL interface compliant
with the DB-API 2.0 specification described by PEP 249.

If you’re compiling the Python source yourself, note that the source tree
doesn’t include the SQLite code, only the wrapper module. You’ll need to have
the SQLite libraries and headers installed before compiling Python, and the
build process will compile the module when the necessary headers are available.

To use the module, you must first create a Connection object that
represents the database. Here the data will be stored in the
/tmp/example file:

conn=sqlite3.connect('/tmp/example')

You can also supply the special name :memory: to create a database in RAM.

Once you have a Connection, you can create a Cursor object
and call its execute() method to perform SQL commands:

Usually your SQL operations will need to use values from Python variables. You
shouldn’t assemble your query using Python’s string operations because doing so
is insecure; it makes your program vulnerable to an SQL injection attack.

Instead, use the DB-API’s parameter substitution. Put ? as a placeholder
wherever you want to use a value, and then provide a tuple of values as the
second argument to the cursor’s execute() method. (Other database modules
may use a different placeholder, such as %s or :1.) For example:

# Never do this -- insecure!symbol='IBM'c.execute("... where symbol = '%s'"%symbol)# Do this insteadt=(symbol,)c.execute('select * from stocks where symbol=?',t)# Larger examplefortin(('2006-03-28','BUY','IBM',1000,45.00),('2006-04-05','BUY','MSOFT',1000,72.00),('2006-04-06','SELL','IBM',500,53.00),):c.execute('insert into stocks values (?,?,?,?,?)',t)

To retrieve data after executing a SELECT statement, you can either treat the
cursor as an iterator, call the cursor’s fetchone() method to retrieve a
single matching row, or call fetchall() to get a list of the matching
rows.

The Web Server Gateway Interface (WSGI) v1.0 defines a standard interface
between web servers and Python web applications and is described in PEP 333.
The wsgiref package is a reference implementation of the WSGI
specification.

The package includes a basic HTTP server that will run a WSGI application; this
server is useful for debugging but isn’t intended for production use. Setting
up a server takes only a few lines of code:

The Python source tree was converted from CVS to Subversion, in a complex
migration procedure that was supervised and flawlessly carried out by Martin von
Löwis. The procedure was developed as PEP 347.

Coverity, a company that markets a source code analysis tool called Prevent,
provided the results of their examination of the Python source code. The
analysis found about 60 bugs that were quickly fixed. Many of the bugs were
refcounting problems, often occurring in error-handling code. See
https://scan.coverity.com for the statistics.

The design of the bytecode compiler has changed a great deal, no longer
generating bytecode by traversing the parse tree. Instead the parse tree is
converted to an abstract syntax tree (or AST), and it is the abstract syntax
tree that’s traversed to produce the bytecode.

It’s possible for Python code to obtain AST objects by using the
compile() built-in and specifying _ast.PyCF_ONLY_AST as the value of
the flags parameter:

from_astimportPyCF_ONLY_ASTast=compile("""a=0for i in range(10): a += i""","<string>",'exec',PyCF_ONLY_AST)assignment=ast.body[0]for_loop=ast.body[1]

No official documentation has been written for the AST code yet, but PEP 339
discusses the design. To start learning about the code, read the definition of
the various AST nodes in Parser/Python.asdl. A Python script reads this
file and generates a set of C structure definitions in
Include/Python-ast.h. The PyParser_ASTFromString() and
PyParser_ASTFromFile(), defined in Include/pythonrun.h, take
Python source as input and return the root of an AST representing the contents.
This AST can then be turned into a code object by PyAST_Compile(). For
more information, read the source code, and then ask questions on python-dev.

The AST code was developed under Jeremy Hylton’s management, and implemented by
(in alphabetical order) Brett Cannon, Nick Coghlan, Grant Edwards, John
Ehresman, Kurt Kaiser, Neal Norwitz, Tim Peters, Armin Rigo, and Neil
Schemenauer, plus the participants in a number of AST sprints at conferences
such as PyCon.

Evan Jones’s patch to obmalloc, first described in a talk at PyCon DC 2005,
was applied. Python 2.4 allocated small objects in 256K-sized arenas, but never
freed arenas. With this patch, Python will free arenas when they’re empty. The
net effect is that on some platforms, when you allocate many objects, Python’s
memory usage may actually drop when you delete them and the memory may be
returned to the operating system. (Implemented by Evan Jones, and reworked by
Tim Peters.)

Previously these different families all reduced to the platform’s
malloc() and free() functions. This meant it didn’t matter if
you got things wrong and allocated memory with the PyMem() function but
freed it with the PyObject() function. With 2.5’s changes to obmalloc,
these families now do different things and mismatches will probably result in a
segfault. You should carefully test your C extension modules with Python 2.5.

C code can now obtain information about the exact revision of the Python
interpreter by calling the Py_GetBuildInfo() function that returns a
string of build information like this: "trunk:45355:45356M,Apr132006,07:42:19". (Contributed by Barry Warsaw.)

Two new macros can be used to indicate C functions that are local to the
current file so that a faster calling convention can be used.
Py_LOCAL(type) declares the function as returning a value of the
specified type and uses a fast-calling qualifier.
Py_LOCAL_INLINE(type) does the same thing and also requests the
function be inlined. If PY_LOCAL_AGGRESSIVE() is defined before
python.h is included, a set of more aggressive optimizations are enabled
for the module; you should benchmark the results to find out if these
optimizations actually make the code faster. (Contributed by Fredrik Lundh at
the NeedForSpeed sprint.)

PyErr_NewException(name,base,dict) can now accept a tuple of base
classes as its base argument. (Contributed by Georg Brandl.)

The PyErr_Warn() function for issuing warnings is now deprecated in
favour of PyErr_WarnEx(category,message,stacklevel) which lets you
specify the number of stack frames separating this function and the caller. A
stacklevel of 1 is the function calling PyErr_WarnEx(), 2 is the
function above that, and so forth. (Added by Neal Norwitz.)

The CPython interpreter is still written in C, but the code can now be
compiled with a C++ compiler without errors. (Implemented by Anthony Baxter,
Martin von Löwis, Skip Montanaro.)

The PyRange_New() function was removed. It was never documented, never
used in the core code, and had dangerously lax error checking. In the unlikely
case that your extensions were using it, you can replace it by something like
the following:

MacOS X: an --enable-universalsdk switch was added to the
configure script that compiles the interpreter as a universal binary
able to run on both PowerPC and Intel processors. (Contributed by Ronald
Oussoren; bpo-2573.)

Windows: .dll is no longer supported as a filename extension for
extension modules. .pyd is now the only filename extension that will be
searched for.

This section lists previously described changes that may require changes to your
code:

ASCII is now the default encoding for modules. It’s now a syntax error if a
module contains string literals with 8-bit characters but doesn’t have an
encoding declaration. In Python 2.4 this triggered a warning, not a syntax
error.

Previously, the gi_frame attribute of a generator was always a frame
object. Because of the PEP 342 changes described in section PEP 342: New Generator Features,
it’s now possible for gi_frame to be None.

A new warning, UnicodeWarning, is triggered when you attempt to
compare a Unicode string and an 8-bit string that can’t be converted to Unicode
using the default ASCII encoding. Previously such comparisons would raise a
UnicodeDecodeError exception.

Library: the csv module is now stricter about multi-line quoted fields.
If your files contain newlines embedded within fields, the input should be split
into lines in a manner which preserves the newline characters.

Library: the locale module’s format() function’s would
previously accept any string as long as no more than one %char specifier
appeared. In Python 2.5, the argument must be exactly one %char specifier with
no surrounding text.

Library: The pickle and cPickle modules no longer accept a
return value of None from the __reduce__() method; the method must
return a tuple of arguments instead. The modules also no longer accept the
deprecated bin keyword parameter.

Library: The SimpleXMLRPCServer and DocXMLRPCServer classes now
have a rpc_paths attribute that constrains XML-RPC operations to a
limited set of URL paths; the default is to allow only '/' and '/RPC2'.
Setting rpc_paths to None or an empty tuple disables this path
checking.

C API: Many functions now use Py_ssize_t instead of int to
allow processing more data on 64-bit machines. Extension code may need to make
the same change to avoid warnings and to support 64-bit machines. See the
earlier section PEP 353: Using ssize_t as the index type for a discussion of this change.

C API: The obmalloc changes mean that you must be careful to not mix usage
of the PyMem_*() and PyObject_*() families of functions. Memory
allocated with one family’s *_Malloc() must be freed with the
corresponding family’s *_Free() function.