Python2.6有什么新变化

PEP 366: 从主模块显式相对导入¶

Python's -m switch allows running a module as a script.

When you ran a module that was located inside a package, relative

imports didn't work correctly.

The fix for Python 2.6 adds a __package__ attribute to

modules. When this attribute is present, relative imports will be

relative to the value of this attribute instead of the

__name__ attribute.

PEP 302-style importers can then set __package__ as necessary.

The runpy module that implements the -m switch now

does this, so relative imports will now work correctly in scripts

running from inside a package.

PEP 370: 分用户的 site-packages 目录¶

When you run Python, the module search path sys.path usually

includes a directory whose path ends in "site-packages". This

directory is intended to hold locally-installed packages available to

all users using a machine or a particular site installation.

Python 2.6 introduces a convention for user-specific site directories.

The directory varies depending on the platform:

• Unix and Mac OS X: ~/.local/

• Windows: %APPDATA%/Python

Within this directory, there will be version-specific subdirectories,

such as lib/python2.6/site-packages on Unix/Mac OS and

Python26/site-packages on Windows.

If you don't like the default directory, it can be overridden by an

environment variable. PYTHONUSERBASE sets the root

directory used for all Python versions supporting this feature. On

Windows, the directory for application-specific data can be changed by

setting the APPDATA environment variable. You can also

modify the site.py file for your Python installation.

The feature can be disabled entirely by running Python with the

-s option or setting the PYTHONNOUSERSITE

environment variable.

PEP 371: 多任务处理包¶

The new multiprocessing package lets Python programs create new

processes that will perform a computation and return a result to the

parent. The parent and child processes can communicate using queues

and pipes, synchronize their operations using locks and semaphores,

and can share simple arrays of data.

The multiprocessing module started out as an exact emulation of

the threading module using processes instead of threads. That

goal was discarded along the path to Python 2.6, but the general

approach of the module is still similar. The fundamental class

is the Process, which is passed a callable object and

a collection of arguments. The start() method

sets the callable running in a subprocess, after which you can call

the is_alive() method to check whether the subprocess is still running

and the join() method to wait for the process to exit.

Here's a simple example where the subprocess will calculate a

factorial. The function doing the calculation is written strangely so

that it takes significantly longer when the input argument is a

multiple of 4.

importtime
frommultiprocessingimportProcess,Queue
deffactorial(queue,N):
"Compute a factorial."
# If N is a multiple of 4, this function will take much longer.
if(N%4)==0:
time.sleep(.05*N/4)
# Calculate the result
fact=1L
foriinrange(1,N+1):
fact=fact*i
# Put the result on the queue
queue.put(fact)
if__name__=='__main__':
queue=Queue()
N=5
p=Process(target=factorial,args=(queue,N))
p.start()
p.join()
result=queue.get()
print'Factorial',N,'=',result

A Queue is used to communicate the result of the factorial.

The Queue object is stored in a global variable.

The child process will use the value of the variable when the child

was created; because it's a Queue, parent and child can use

the object to communicate. (If the parent were to change the value of

the global variable, the child's value would be unaffected, and vice

versa.)

Two other classes, Pool and Manager, provide

higher-level interfaces. Pool will create a fixed number of

worker processes, and requests can then be distributed to the workers

by calling apply() or apply_async() to add a single request,

and map() or map_async() to add a number of

requests. The following code uses a Pool to spread requests

across 5 worker processes and retrieve a list of results:

frommultiprocessingimportPool
deffactorial(N,dictionary):
"Compute a factorial."
...
p=Pool(5)
result=p.map(factorial,range(1,1000,10))
forvinresult:
printv

This produces the following output:

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...

The other high-level interface, the Manager class, creates a

separate server process that can hold master copies of Python data

structures. Other processes can then access and modify these data

structures using proxy objects. The following example creates a

shared dictionary by calling the dict() method; the worker

processes then insert values into the dictionary. (Locking is not

done for you automatically, which doesn't matter in this example.

Manager's methods also include Lock(), RLock(),

and Semaphore() to create shared locks.)

importtime
frommultiprocessingimportPool,Manager
deffactorial(N,dictionary):
"Compute a factorial."
# Calculate the result
fact=1L
foriinrange(1,N+1):
fact=fact*i
# Store result in dictionary
dictionary[N]=fact
if__name__=='__main__':
p=Pool(5)
mgr=Manager()
d=mgr.dict()# Create shared dictionary
# Run tasks using the pool
forNinrange(1,1000,10):
p.apply_async(factorial,(N,d))
# Mark pool as closed -- no more tasks can be added.
p.close()
# Wait for tasks to exit
p.join()
# Output results
fork,vinsorted(d.items()):
printk,v

This will produce the output:

11
1139916800
2151090942171709440000
318222838654177922817725562880000000
4133452526613163807108170062053440751665152000000000
5115511187532873822802242430164693032110632597200169861120000...

PEP 3101: 高级字符串格式¶

In Python 3.0, the % operator is supplemented by a more powerful string

formatting method, format(). Support for the str.format() method

has been backported to Python 2.6.

In 2.6, both 8-bit and Unicode strings have a .format() method that

treats the string as a template and takes the arguments to be formatted.

The formatting template uses curly brackets ({, }) as special characters:

>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "User ID: {uid}   Last seen: {last_login}".format(
... uid="root",
... last_login="5 Mar 2008 07:20")
'User ID: root   Last seen: 5 Mar 2008 07:20'

Curly brackets can be escaped by doubling them:

>>> "Empty dict: {{}}".format()
"Empty dict: {}"

Field names can be integers indicating positional arguments, such as

{0}, {1}, etc. or names of keyword arguments. You can also

supply compound field names that read attributes or access dictionary keys:

>>> importsys
>>> print'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar  5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'
>>> importmimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'

Note that when using dictionary-style notation such as [.mp4], you

don't need to put any quotation marks around the string; it will look

up the value using .mp4 as the key. Strings beginning with a

number will be converted to an integer. You can't write more

complicated expressions inside a format string.

So far we've shown how to specify which field to substitute into the

resulting string. The precise formatting used is also controllable by

adding a colon followed by a format specifier. For example:

>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt='{0:15} ${1:>6}'
>>> fmt.format('Registration',35)
'Registration    $    35'
>>> fmt.format('Tutorial',50)
'Tutorial        $    50'
>>> fmt.format('Banquet',125)
'Banquet         $   125'

Format specifiers can reference other fields through nesting:

>>> fmt='{0:{1}}'
>>> width=15
>>> fmt.format('Invoice #1234',width)
'Invoice #1234  '
>>> width=35
>>> fmt.format('Invoice #1234',width)
'Invoice #1234                      '

可以指定所需宽度内的字段对齐方式：

Format specifiers can also include a presentation type, which

controls how the value is formatted. For example, floating-point numbers

can be formatted as a general number or in exponential notation:

>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'

A variety of presentation types are available. Consult the 2.6

documentation for a complete list; here's a sample:

Classes and types can define a __format__() method to control how they're

formatted. It receives a single argument, the format specifier:

def__format__(self,format_spec):
ifisinstance(format_spec,unicode):
returnunicode(str(self))
else:
returnstr(self)

There's also a format() builtin that will format a single

value. It calls the type's __format__() method with the

provided specifier:

>>> format(75.6564,'.2f')
'75.66'

PEP 3105: print 改为函数¶

The print statement becomes the print() function in Python 3.0.

Making print() a function makes it possible to replace the function

by doing defprint(...) or importing a new function from somewhere else.

Python 2.6 has a __future__ import that removes print as language

syntax, letting you use the functional form instead. For example:

>>> from__future__importprint_function
>>> print('# of entries',len(dictionary),file=sys.stderr)

The signature of the new function is:

defprint(*args,sep=' ',end='\n',file=None)

The parameters are:

• args: positional arguments whose values will be printed out.

• sep: the separator, which will be printed between arguments.

• end: the ending text, which will be printed after all of the

  arguments have been output.

• file: the file object to which the output will be sent.

PEP 3110: 异常处理的变更¶

One error that Python programmers occasionally make

is writing the following code:

try:
...
exceptTypeError,ValueError:# Wrong!
...

The author is probably trying to catch both TypeError and

ValueError exceptions, but this code actually does something

different: it will catch TypeError and bind the resulting

exception object to the local name "ValueError". The

ValueError exception will not be caught at all. The correct

code specifies a tuple of exceptions:

try:
...
except(TypeError,ValueError):
...

This error happens because the use of the comma here is ambiguous:

does it indicate two different nodes in the parse tree, or a single

node that's a tuple?

Python 3.0 makes this unambiguous by replacing the comma with the word

"as". To catch an exception and store the exception object in the

variable exc, you must write:

try:
...
exceptTypeErrorasexc:
...

Python 3.0 will only support the use of "as", and therefore interprets

the first example as catching two different exceptions. Python 2.6

supports both the comma and "as", so existing code will continue to

work. We therefore suggest using "as" when writing new Python code

that will only be executed with 2.6.

PEP 3112: 字节字面值¶

Python 3.0 adopts Unicode as the language's fundamental string type and

denotes 8-bit literals differently, either as b'string'

or using a bytes constructor. For future compatibility,

Python 2.6 adds bytes as a synonym for the str type,

and it also supports the b'' notation.

The 2.6 str differs from 3.0's bytes type in various

ways; most notably, the constructor is completely different. In 3.0,

bytes([65,66,67]) is 3 elements long, containing the bytes

representing ABC; in 2.6, bytes([65,66,67]) returns the

12-byte string representing the str() of the list.

The primary use of bytes in 2.6 will be to write tests of

object type such as isinstance(x,bytes). This will help the 2to3

converter, which can't tell whether 2.x code intends strings to

contain either characters or 8-bit bytes; you can now

use either bytes or str to represent your intention

exactly, and the resulting code will also be correct in Python 3.0.

There's also a __future__ import that causes all string literals

to become Unicode strings. This means that \u escape sequences

can be used to include Unicode characters:

from__future__importunicode_literals
s=('\u751f\u3080\u304e\u3000\u751f\u3054'
'\u3081\u3000\u751f\u305f\u307e\u3054')
printlen(s)# 12 Unicode characters

At the C level, Python 3.0 will rename the existing 8-bit

string type, called PyStringObject in Python 2.x,

to PyBytesObject. Python 2.6 uses #define

to support using the names PyBytesObject(),

PyBytes_Check(), PyBytes_FromStringAndSize(),

and all the other functions and macros used with strings.

Instances of the bytes type are immutable just

as strings are. A new bytearray type stores a mutable

sequence of bytes:

>>> bytearray([65,66,67])
bytearray(b'ABC')
>>> b=bytearray(u'\u21ef\u3244','utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0]='\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b),'utf-8')
u'\u31ef \u3244'

Byte arrays support most of the methods of string types, such as

startswith()/endswith(), find()/rfind(),

and some of the methods of lists, such as append(),

pop(), and reverse().

>>> b=bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')

There's also a corresponding C API, with

PyByteArray_FromObject(),

PyByteArray_FromStringAndSize(),

and various other functions.

PEP 3116: 新 I/O 库¶

Python's built-in file objects support a number of methods, but

file-like objects don't necessarily support all of them. Objects that

imitate files usually support read() and write(), but they

may not support readline(), for example. Python 3.0 introduces

a layered I/O library in the io module that separates buffering

and text-handling features from the fundamental read and write

operations.

There are three levels of abstract base classes provided by

the io module:

• RawIOBase defines raw I/O operations: read(),

  readinto(),

  write(), seek(), tell(), truncate(),

  and close().

  Most of the methods of this class will often map to a single system call.

  There are also readable(), writable(), and seekable()

  methods for determining what operations a given object will allow.

  Python 3.0 has concrete implementations of this class for files and

  sockets, but Python 2.6 hasn't restructured its file and socket objects

  in this way.

• BufferedIOBase is an abstract base class that

  buffers data in memory to reduce the number of

  system calls used, making I/O processing more efficient.

  It supports all of the methods of RawIOBase,

  and adds a raw attribute holding the underlying raw object.

  There are five concrete classes implementing this ABC.

  BufferedWriter and BufferedReader are for objects

  that support write-only or read-only usage that have a seek()

  method for random access. BufferedRandom objects support

  read and write access upon the same underlying stream, and

  BufferedRWPair is for objects such as TTYs that have both

  read and write operations acting upon unconnected streams of data.

  The BytesIO class supports reading, writing, and seeking

  over an in-memory buffer.

• TextIOBase: Provides functions for reading and writing

  strings (remember, strings will be Unicode in Python 3.0),

  and supporting universal newlines. TextIOBase defines

  the readline() method and supports iteration upon

  objects.

  There are two concrete implementations. TextIOWrapper

  wraps a buffered I/O object, supporting all of the methods for

  text I/O and adding a buffer attribute for access

  to the underlying object. StringIO simply buffers

  everything in memory without ever writing anything to disk.

  (In Python 2.6, io.StringIO is implemented in

  pure Python, so it's pretty slow. You should therefore stick with the

  existing StringIO module or cStringIO for now. At some

  point Python 3.0's io module will be rewritten into C for speed,

  and perhaps the C implementation will be backported to the 2.x releases.)

In Python 2.6, the underlying implementations haven't been

restructured to build on top of the io module's classes. The

module is being provided to make it easier to write code that's

forward-compatible with 3.0, and to save developers the effort of writing

their own implementations of buffering and text I/O.

PEP 3118: 修改缓冲区协议¶

The buffer protocol is a C-level API that lets Python types

exchange pointers into their internal representations. A

memory-mapped file can be viewed as a buffer of characters, for

example, and this lets another module such as re

treat memory-mapped files as a string of characters to be searched.

The primary users of the buffer protocol are numeric-processing

packages such as NumPy, which expose the internal representation

of arrays so that callers can write data directly into an array instead

of going through a slower API. This PEP updates the buffer protocol in light of experience

from NumPy development, adding a number of new features

such as indicating the shape of an array or locking a memory region.

The most important new C API function is

PyObject_GetBuffer(PyObject*obj,Py_buffer*view,intflags), which

takes an object and a set of flags, and fills in the

Py_buffer structure with information

about the object's memory representation. Objects

can use this operation to lock memory in place

while an external caller could be modifying the contents,

so there's a corresponding PyBuffer_Release(Py_buffer*view) to

indicate that the external caller is done.

The flags argument to PyObject_GetBuffer() specifies

constraints upon the memory returned. Some examples are:

• PyBUF_WRITABLE indicates that the memory must be writable.

• PyBUF_LOCK requests a read-only or exclusive lock on the memory.

• PyBUF_C_CONTIGUOUS and PyBUF_F_CONTIGUOUS

  requests a C-contiguous (last dimension varies the fastest) or

  Fortran-contiguous (first dimension varies the fastest) array layout.

Two new argument codes for PyArg_ParseTuple(),

s* and z*, return locked buffer objects for a parameter.

PEP 3119: 抽象基类¶

Some object-oriented languages such as Java support interfaces,

declaring that a class has a given set of methods or supports a given

access protocol. Abstract Base Classes (or ABCs) are an equivalent

feature for Python. The ABC support consists of an abc module

containing a metaclass called ABCMeta, special handling of

this metaclass by the isinstance() and issubclass()

builtins, and a collection of basic ABCs that the Python developers

think will be widely useful. Future versions of Python will probably

add more ABCs.

Let's say you have a particular class and wish to know whether it supports

dictionary-style access. The phrase "dictionary-style" is vague, however.

It probably means that accessing items with obj[1] works.

Does it imply that setting items with obj[2]=value works?

Or that the object will have keys(), values(), and items()

methods? What about the iterative variants such as iterkeys()? copy()

and update()? Iterating over the object with iter()?

The Python 2.6 collections module includes a number of

different ABCs that represent these distinctions. Iterable

indicates that a class defines __iter__(), and

Container means the class defines a __contains__()

method and therefore supports xiny expressions. The basic

dictionary interface of getting items, setting items, and

keys(), values(), and items(), is defined by the

MutableMapping ABC.

You can derive your own classes from a particular ABC

to indicate they support that ABC's interface:

importcollections
classStorage(collections.MutableMapping):
...

Alternatively, you could write the class without deriving from

the desired ABC and instead register the class by

calling the ABC's register() method:

importcollections
classStorage:
...
collections.MutableMapping.register(Storage)

For classes that you write, deriving from the ABC is probably clearer.

The register() method is useful when you've written a new

ABC that can describe an existing type or class, or if you want

to declare that some third-party class implements an ABC.

For example, if you defined a PrintableType ABC,

it's legal to do:

# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)

Classes should obey the semantics specified by an ABC, but

Python can't check this; it's up to the class author to

understand the ABC's requirements and to implement the code accordingly.

To check whether an object supports a particular interface, you can

now write:

deffunc(d):
ifnotisinstance(d,collections.MutableMapping):
raiseValueError("Mapping object expected, not %r"%d)

Don't feel that you must now begin writing lots of checks as in the

above example. Python has a span tradition of duck-typing, where

explicit type-checking is never done and code simply calls methods on

an object, trusting that those methods will be there and raising an

exception if they aren't. Be judicious in checking for ABCs and only

do it where it's absolutely necessary.

You can write your own ABCs by using abc.ABCMeta as the

metaclass in a class definition:

fromabcimportABCMeta,abstractmethod
classDrawable():
__metaclass__=ABCMeta
@abstractmethod
defdraw(self,x,y,scale=1.0):
pass
defdraw_doubled(self,x,y):
self.draw(x,y,scale=2.0)
classSquare(Drawable):
defdraw(self,x,y,scale):
...

In the Drawable ABC above, the draw_doubled() method

renders the object at twice its size and can be implemented in terms

of other methods described in Drawable. Classes implementing

this ABC therefore don't need to provide their own implementation

of draw_doubled(), though they can do so. An implementation

of draw() is necessary, though; the ABC can't provide

a useful generic implementation.

You can apply the @abstractmethod decorator to methods such as

draw() that must be implemented; Python will then raise an

exception for classes that don't define the method.

Note that the exception is only raised when you actually

try to create an instance of a subclass lacking the method:

>>> classCircle(Drawable):
... pass
...
>>> c=Circle()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>

Abstract data attributes can be declared using the

@abstractproperty decorator:

fromabcimportabstractproperty
...
@abstractproperty
defreadonly(self):
returnself._x

Subclasses must then define a readonly() property.

PEP 3127: 整型文字支持和语法¶

Python 3.0 changes the syntax for octal (base-8) integer literals,

prefixing them with "0o" or "0O" instead of a leading zero, and adds

support for binary (base-2) integer literals, signalled by a "0b" or

"0B" prefix.

Python 2.6 doesn't drop support for a leading 0 signalling

an octal number, but it does add support for "0o" and "0b":

>>> 0o21,2*8+1
(17, 17)
>>> 0b101111
47

The oct() builtin still returns numbers

prefixed with a leading zero, and a new bin()

builtin returns the binary representation for a number:

>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'

The int() and long() builtins will now accept the "0o"

and "0b" prefixes when base-8 or base-2 are requested, or when the

base argument is zero (signalling that the base used should be

determined from the string):

>>> int('0o52',0)
42
>>> int('1101',2)
13
>>> int('0b1101',2)
13
>>> int('0b1101',0)
13

PEP 3129: 类装饰器¶

Decorators have been extended from functions to classes. It's now legal to

write:

@foo
@bar
classA:
pass

这相当于:

classA:
pass
A=foo(bar(A))

PEP 3141: A Type Hierarchy for Numbers¶

Python 3.0 adds several abstract base classes for numeric types

inspired by Scheme's numeric tower. These classes were backported to

2.6 as the numbers module.

The most general ABC is Number. It defines no operations at

all, and only exists to allow checking if an object is a number by

doing isinstance(obj,Number).

Complex is a subclass of Number. Complex numbers

can undergo the basic operations of addition, subtraction,

multiplication, division, and exponentiation, and you can retrieve the

real and imaginary parts and obtain a number's conjugate. Python's built-in

complex type is an implementation of Complex.

Real further derives from Complex, and adds

operations that only work on real numbers: floor(), trunc(),

rounding, taking the remainder mod N, floor division,

and comparisons.

Rational numbers derive from Real, have

numerator and denominator properties, and can be

converted to floats. Python 2.6 adds a simple rational-number class,

Fraction, in the fractions module. (It's called

Fraction instead of Rational to avoid

a name clash with numbers.Rational.)

Integral numbers derive from Rational, and

can be shifted left and right with << and >>,

combined using bitwise operations such as & and |,

and can be used as array indexes and slice boundaries.

In Python 3.0, the PEP slightly redefines the existing builtins

round(), math.floor(), math.ceil(), and adds a new

one, math.trunc(), that's been backported to Python 2.6.

math.trunc() rounds toward zero, returning the closest

Integral that's between the function's argument and zero.

>>> fromfractionsimportFraction
>>> a=Fraction(2,3)
>>> b=Fraction(2,5)
>>> float(a),float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)

>>> (2.5).as_integer_ratio()
(5, 2)
>>> (3.1415).as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3).as_integer_ratio()
(6004799503160661L, 18014398509481984L)

其他语言特性修改¶

对Python 语言核心进行的小改动：

• Directories and zip archives containing a __main__.py file

  can now be executed directly by passing their name to the

  interpreter. The directory or zip archive is automatically inserted

  as the first entry in sys.path. (Suggestion and initial patch by

  Andy Chu, subsequently revised by Phillip J. Eby and Nick Coghlan;

  bpo-1739468.)

• The hasattr() function was catching and ignoring all errors,

  under the assumption that they meant a __getattr__() method

  was failing somehow and the return value of hasattr() would

  therefore be False. This logic shouldn't be applied to

  KeyboardInterrupt and SystemExit, however; Python 2.6

  will no longer discard such exceptions when hasattr()

  encounters them. (Fixed by Benjamin Peterson; bpo-2196.)

• When calling a function using the ** syntax to provide keyword

  arguments, you are no longer required to use a Python dictionary;

  any mapping will now work:

  >>> deff(**kw):
  ... printsorted(kw)
  ...
  >>> ud=UserDict.UserDict()
  >>> ud['a']=1
  >>> ud['b']='string'
  >>> f(**ud)
  ['a', 'b']
  

  （由 Alexander Belopolsky 在 bpo-1686487 中贡献。）

  It's also become legal to provide keyword arguments after a *args argument

  to a function call.

  >>> deff(*args,**kw):
  ... printargs,kw
  ...
  >>> f(1,2,3,*(4,5,6),keyword=13)
  (1, 2, 3, 4, 5, 6) {'keyword': 13}
  

  Previously this would have been a syntax error.

  (Contributed by Amaury Forgeot d'Arc; bpo-3473.)

• A new builtin, next(iterator,[default]) returns the next item

  from the specified iterator. If the default argument is supplied,

  it will be returned if iterator has been exhausted; otherwise,

  the StopIteration exception will be raised. (Backported

  in bpo-2719.)

• Tuples now have index() and count() methods matching the

  list type's index() and count() methods:

  >>> t=(0,1,2,3,4,0,1,2)
  >>> t.index(3)
  3
  >>> t.count(0)
  2
  

  （由 Raymond Hettinger 贡献）

• The built-in types now have improved support for extended slicing syntax,

  accepting various combinations of (start,stop,step).

  Previously, the support was partial and certain corner cases wouldn't work.

  (Implemented by Thomas Wouters.)

• Properties now have three attributes, getter, setter

  and deleter, that are decorators providing useful shortcuts

  for adding a getter, setter or deleter function to an existing

  property. You would use them like this:

  classC(object):
  @property
  defx(self):
  returnself._x
  @x.setter
  defx(self,value):
  self._x=value
  @x.deleter
  defx(self):
  delself._x
  classD(C):
  @C.x.getter
  defx(self):
  returnself._x*2
  @x.setter
  defx(self,value):
  self._x=value/2
  

• Several methods of the built-in set types now accept multiple iterables:

  intersection(),

  intersection_update(),

  union(), update(),

  difference() and difference_update().

  >>> s=set('1234567890')
  >>> s.intersection('abc123','cdf246')# Intersection between all inputs
  set(['2'])
  >>> s.difference('246','789')
  set(['1', '0', '3', '5'])
  

  （由 Raymond Hettinger 贡献。）

• Many floating-point features were added. The float() function

  will now turn the string nan into an

  IEEE 754 Not A Number value, and +inf and -inf into

  positive or negative infinity. This works on any platform with

  IEEE 754 semantics. (Contributed by Christian Heimes; bpo-1635.)

  Other functions in the math module, isinf() and

  isnan(), return true if their floating-point argument is

  infinite or Not A Number. (bpo-1640)

  Conversion functions were added to convert floating-point numbers

  into hexadecimal strings (bpo-3008). These functions

  convert floats to and from a string representation without

  introducing rounding errors from the conversion between decimal and

  binary. Floats have a hex() method that returns a string

  representation, and the float.fromhex() method converts a string

  back into a number:

  >>> a=3.75
  >>> a.hex()
  '0x1.e000000000000p+1'
  >>> float.fromhex('0x1.e000000000000p+1')
  3.75
  >>> b=1./3
  >>> b.hex()
  '0x1.5555555555555p-2'
  

• A numerical nicety: when creating a complex number from two floats

  on systems that support signed zeros (-0 and +0), the

  complex() constructor will now preserve the sign

  of the zero. (Fixed by Mark T. Dickinson; bpo-1507.)

• Classes that inherit a __hash__() method from a parent class

  can set __hash__=None to indicate that the class isn't

  hashable. This will make hash(obj) raise a TypeError

  and the class will not be indicated as implementing the

  Hashable ABC.

  You should do this when you've defined a __cmp__() or

  __eq__() method that compares objects by their value rather

  than by identity. All objects have a default hash method that uses

  id(obj) as the hash value. There's no tidy way to remove the

  __hash__() method inherited from a parent class, so

  assigning None was implemented as an override. At the

  C level, extensions can set tp_hash to

  PyObject_HashNotImplemented().

  (Fixed by Nick Coghlan and Amaury Forgeot d'Arc; bpo-2235.)

• The GeneratorExit exception now subclasses

  BaseException instead of Exception. This means

  that an exception handler that does exceptException:

  will not inadvertently catch GeneratorExit.

  (Contributed by Chad Austin; bpo-1537.)

• Generator objects now have a gi_code attribute that refers to

  the original code object backing the generator.

  (Contributed by Collin Winter; bpo-1473257.)

• The compile() built-in function now accepts keyword arguments

  as well as positional parameters. (Contributed by Thomas Wouters;

  bpo-1444529.)

• The complex() constructor now accepts strings containing

  parenthesized complex numbers, meaning that complex(repr(cplx))

  will now round-trip values. For example, complex('(3+4j)')

  now returns the value (3+4j). (bpo-1491866)

• The string translate() method now accepts None as the

  translation table parameter, which is treated as the identity

  transformation. This makes it easier to carry out operations

  that only delete characters. (Contributed by Bengt Richter and

  implemented by Raymond Hettinger; bpo-1193128.)

• The built-in dir() function now checks for a __dir__()

  method on the objects it receives. This method must return a list

  of strings containing the names of valid attributes for the object,

  and lets the object control the value that dir() produces.

  Objects that have __getattr__() or __getattribute__()

  methods can use this to advertise pseudo-attributes they will honor.

  (bpo-1591665)

• Instance method objects have new attributes for the object and function

  comprising the method; the new synonym for im_self is

  __self__, and im_func is also available as __func__.

  The old names are still supported in Python 2.6, but are gone in 3.0.

• An obscure change: when you use the locals() function inside a

  class statement, the resulting dictionary no longer returns free

  variables. (Free variables, in this case, are variables referenced in the

  class statement that aren't attributes of the class.)

新增和改进的模块¶

As in every release, Python's standard library received a number of

enhancements and bug fixes. Here's a partial list of the most notable

changes, sorted alphabetically by module name. Consult the

Misc/NEWS file in the source tree for a more complete list of

changes, or look through the Subversion logs for all the details.

• The asyncore and asynchat modules are

  being actively maintained again, and a number of patches and bugfixes

  were applied. (Maintained by Josiah Carlson; see bpo-1736190 for

  one patch.)

• The bsddb module also has a new maintainer, Jesús Cea Avión, and the package

  is now available as a standalone package. The web page for the package is

  www.jcea.es/programacion/pybsddb.htm.

  The plan is to remove the package from the standard library

  in Python 3.0, because its pace of releases is much more frequent than

  Python's.

  The bsddb.dbshelve module now uses the highest pickling protocol

  available, instead of restricting itself to protocol 1.

  (Contributed by W. Barnes.)

• The cgi module will now read variables from the query string

  of an HTTP POST request. This makes it possible to use form actions

  with URLs that include query strings such as

  "/cgi-bin/add.py?category=1". (Contributed by Alexandre Fiori and

  Nubis; bpo-1817.)

  The parse_qs() and parse_qsl() functions have been

  relocated from the cgi module to the urlparse module.

  The versions still available in the cgi module will

  trigger PendingDeprecationWarning messages in 2.6

  (bpo-600362).

• The cmath module underwent extensive revision,

  contributed by Mark Dickinson and Christian Heimes.

  Five new functions were added:

  • polar() converts a complex number to polar form, returning

    the modulus and argument of the complex number.

  • rect() does the opposite, turning a modulus, argument pair

    back into the corresponding complex number.

  • phase() returns the argument (also called the angle) of a complex

    number.

  • isnan() returns True if either

    the real or imaginary part of its argument is a NaN.

  • isinf() returns True if either the real or imaginary part of

    its argument is infinite.

  The revisions also improved the numerical soundness of the

  cmath module. For all functions, the real and imaginary

  parts of the results are accurate to within a few units of least

  precision (ulps) whenever possible. See bpo-1381 for the

  details. The branch cuts for asinh(), atanh(): and

  atan() have also been corrected.

  The tests for the module have been greatly expanded; nearly 2000 new

  test cases exercise the algebraic functions.

  On IEEE 754 platforms, the cmath module now handles IEEE 754

  special values and floating-point exceptions in a manner consistent

  with Annex 'G' of the C99 standard.

• A new data type in the collections module: namedtuple(typename,

  fieldnames) is a factory function that creates subclasses of the standard tuple

  whose fields are accessible by name as well as index. For example:

  >>> var_type=collections.namedtuple('variable',
  ... 'id name type size')
  >>> # Names are separated by spaces or commas.
  >>> # 'id, name, type, size' would also work.
  >>> var_type._fields
  ('id', 'name', 'type', 'size')
  >>> var=var_type(1,'frequency','int',4)
  >>> printvar[0],var.id# Equivalent
  1 1
  >>> printvar[2],var.type# Equivalent
  int int
  >>> var._asdict()
  {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
  >>> v2=var._replace(name='amplitude')
  >>> v2
  variable(id=1, name='amplitude', type='int', size=4)
  

  Several places in the standard library that returned tuples have

  been modified to return namedtuple instances. For example,

  the Decimal.as_tuple() method now returns a named tuple with

  sign, digits, and exponent fields.

  （由 Raymond Hettinger 贡献。）

• Another change to the collections module is that the

  deque type now supports an optional maxlen parameter;

  if supplied, the deque's size will be restricted to no more

  than maxlen items. Adding more items to a full deque causes

  old items to be discarded.

  >>> fromcollectionsimportdeque
  >>> dq=deque(maxlen=3)
  >>> dq
  deque([], maxlen=3)
  >>> dq.append(1);dq.append(2);dq.append(3)
  >>> dq
  deque([1, 2, 3], maxlen=3)
  >>> dq.append(4)
  >>> dq
  deque([2, 3, 4], maxlen=3)
  

  （由 Raymond Hettinger 贡献。）

• The Cookie module's Morsel objects now support an

  httponly attribute. In some browsers. cookies with this attribute

  set cannot be accessed or manipulated by JavaScript code.

  (Contributed by Arvin Schnell; bpo-1638033.)

• A new window method in the curses module,

  chgat(), changes the display attributes for a certain number of

  characters on a single line. (Contributed by Fabian Kreutz.)

  # Boldface text starting at y=0,x=21
  # and affecting the rest of the line.
  stdscr.chgat(0,21,curses.A_BOLD)
  

  The Textbox class in the curses.textpad module

  now supports editing in insert mode as well as overwrite mode.

  Insert mode is enabled by supplying a true value for the insert_mode

  parameter when creating the Textbox instance.

• The datetime module's strftime() methods now support a

  %f format code that expands to the number of microseconds in the

  object, zero-padded on

  the left to six places. (Contributed by Skip Montanaro; bpo-1158.)

• The decimal module was updated to version 1.66 of

  the General Decimal Specification. New features

  include some methods for some basic mathematical functions such as

  exp() and log10():

  >>> Decimal(1).exp()
  Decimal("2.718281828459045235360287471")
  >>> Decimal("2.7182818").ln()
  Decimal("0.9999999895305022877376682436")
  >>> Decimal(1000).log10()
  Decimal("3")
  

  The as_tuple() method of Decimal objects now returns a

  named tuple with sign, digits, and exponent fields.

  (Implemented by Facundo Batista and Mark Dickinson. Named tuple

  support added by Raymond Hettinger.)

• The difflib module's SequenceMatcher class

  now returns named tuples representing matches,

  with a, b, and size attributes.

  (Contributed by Raymond Hettinger.)

• An optional timeout parameter, specifying a timeout measured in

  seconds, was added to the ftplib.FTP class constructor as

  well as the connect() method. (Added by Facundo Batista.)

  Also, the FTP class's storbinary() and

  storlines() now take an optional callback parameter that

  will be called with each block of data after the data has been sent.

  (Contributed by Phil Schwartz; bpo-1221598.)

• The reduce() built-in function is also available in the

  functools module. In Python 3.0, the builtin has been

  dropped and reduce() is only available from functools;

  currently there are no plans to drop the builtin in the 2.x series.

  (Patched by Christian Heimes; bpo-1739906.)

• When possible, the getpass module will now use

  /dev/tty to print a prompt message and read the password,

  falling back to standard error and standard input. If the

  password may be echoed to the terminal, a warning is printed before

  the prompt is displayed. (Contributed by Gregory P. Smith.)

• The glob.glob() function can now return Unicode filenames if

  a Unicode path was used and Unicode filenames are matched within the

  directory. (bpo-1001604)

• A new function in the heapq module, merge(iter1,iter2,...),

  takes any number of iterables returning data in sorted

  order, and returns a new generator that returns the contents of all

  the iterators, also in sorted order. For example:

  >>> list(heapq.merge([1,3,5,9],[2,8,16]))
  [1, 2, 3, 5, 8, 9, 16]
  

  Another new function, heappushpop(heap,item),

  pushes item onto heap, then pops off and returns the smallest item.

  This is more efficient than making a call to heappush() and then

  heappop().

  heapq is now implemented to only use less-than comparison,

  instead of the less-than-or-equal comparison it previously used.

  This makes heapq's usage of a type match the

  list.sort() method.

  (Contributed by Raymond Hettinger.)

• An optional timeout parameter, specifying a timeout measured in

  seconds, was added to the httplib.HTTPConnection and

  HTTPSConnection class constructors. (Added by Facundo

  Batista.)

• Most of the inspect module's functions, such as

  getmoduleinfo() and getargs(), now return named tuples.

  In addition to behaving like tuples, the elements of the return value

  can also be accessed as attributes.

  (Contributed by Raymond Hettinger.)

  Some new functions in the module include

  isgenerator(), isgeneratorfunction(),

  and isabstract().

• The itertools module gained several new functions.

  izip_longest(iter1,iter2,...[,fillvalue]) makes tuples from

  each of the elements; if some of the iterables are shorter than

  others, the missing values are set to fillvalue. For example:

  >>> tuple(itertools.izip_longest([1,2,3],[1,2,3,4,5]))
  ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
  

  product(iter1,iter2,...,[repeat=N]) returns the Cartesian product

  of the supplied iterables, a set of tuples containing

  every possible combination of the elements returned from each iterable.

  >>> list(itertools.product([1,2,3],[4,5,6]))
  [(1, 4), (1, 5), (1, 6),
   (2, 4), (2, 5), (2, 6),
   (3, 4), (3, 5), (3, 6)]
  

  The optional repeat keyword argument is used for taking the

  product of an iterable or a set of iterables with themselves,

  repeated N times. With a single iterable argument, N-tuples

  are returned:

  >>> list(itertools.product([1,2],repeat=3))
  [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
   (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
  

  With two iterables, 2N-tuples are returned.

  >>> list(itertools.product([1,2],[3,4],repeat=2))
  [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
   (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
   (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
   (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
  

  combinations(iterable,r) returns sub-sequences of length r from

  the elements of iterable.

  >>> list(itertools.combinations('123',2))
  [('1', '2'), ('1', '3'), ('2', '3')]
  >>> list(itertools.combinations('123',3))
  [('1', '2', '3')]
  >>> list(itertools.combinations('1234',3))
  [('1', '2', '3'), ('1', '2', '4'),
   ('1', '3', '4'), ('2', '3', '4')]
  

  permutations(iter[,r]) returns all the permutations of length r of

  the iterable's elements. If r is not specified, it will default to the

  number of elements produced by the iterable.

  >>> list(itertools.permutations([1,2,3,4],2))
  [(1, 2), (1, 3), (1, 4),
   (2, 1), (2, 3), (2, 4),
   (3, 1), (3, 2), (3, 4),
   (4, 1), (4, 2), (4, 3)]
  

  itertools.chain(*iterables) is an existing function in

  itertools that gained a new constructor in Python 2.6.

  itertools.chain.from_iterable(iterable) takes a single

  iterable that should return other iterables. chain() will

  then return all the elements of the first iterable, then

  all the elements of the second, and so on.

  >>> list(itertools.chain.from_iterable([[1,2,3],[4,5,6]]))
  [1, 2, 3, 4, 5, 6]
  

  (All contributed by Raymond Hettinger.)

• The logging module's FileHandler class

  and its subclasses WatchedFileHandler, RotatingFileHandler,

  and TimedRotatingFileHandler now

  have an optional delay parameter to their constructors. If delay

  is true, opening of the log file is deferred until the first

  emit() call is made. (Contributed by Vinay Sajip.)

  TimedRotatingFileHandler also has a utc constructor

  parameter. If the argument is true, UTC time will be used

  in determining when midnight occurs and in generating filenames;

  otherwise local time will be used.

• Several new functions were added to the math module:

  • isinf() and isnan() determine whether a given float

    is a (positive or negative) infinity or a NaN (Not a Number), respectively.

  • copysign() copies the sign bit of an IEEE 754 number,

    returning the absolute value of x combined with the sign bit of

    y. For example, math.copysign(1,-0.0) returns -1.0.

    (Contributed by Christian Heimes.)

  • factorial() computes the factorial of a number.

    (Contributed by Raymond Hettinger; bpo-2138.)

  • fsum() adds up the stream of numbers from an iterable,

    and is careful to avoid loss of precision through using partial sums.

    (Contributed by Jean Brouwers, Raymond Hettinger, and Mark Dickinson;

    bpo-2819.)

  • acosh(), asinh()

    and atanh() compute the inverse hyperbolic functions.

  • log1p() returns the natural logarithm of 1+x

    (base e).

  • trunc() rounds a number toward zero, returning the closest

    Integral that's between the function's argument and zero.

    Added as part of the backport of

    PEP 3141's type hierarchy for numbers.

• The math module has been improved to give more consistent

  behaviour across platforms, especially with respect to handling of

  floating-point exceptions and IEEE 754 special values.

  Whenever possible, the module follows the recommendations of the C99

  standard about 754's special values. For example, sqrt(-1.)

  should now give a ValueError across almost all platforms,

  while sqrt(float('NaN')) should return a NaN on all IEEE 754

  platforms. Where Annex 'F' of the C99 standard recommends signaling

  'divide-by-zero' or 'invalid', Python will raise ValueError.

  Where Annex 'F' of the C99 standard recommends signaling 'overflow',

  Python will raise OverflowError. (See bpo-711019 and

  bpo-1640.)

  （由 Christian Heimes 和 Mark Dickinson 贡献。）

• mmap objects now have a rfind() method that searches for a

  substring beginning at the end of the string and searching

  backwards. The find() method also gained an end parameter

  giving an index at which to stop searching.

  (Contributed by John Lenton.)

• The operator module gained a

  methodcaller() function that takes a name and an optional

  set of arguments, returning a callable that will call

  the named function on any arguments passed to it. For example:

  >>> # Equivalent to lambda s: s.replace('old', 'new')
  >>> replacer=operator.methodcaller('replace','old','new')
  >>> replacer('old wine in old bottles')
  'new wine in new bottles'
  

  （由 Gregory Petrosyan 提供建议，之后由 Georg Brandl 贡献。）

  The attrgetter() function now accepts dotted names and performs

  the corresponding attribute lookups:

  >>> inst_name=operator.attrgetter(
  ... '__class__.__name__')
  >>> inst_name('')
  'str'
  >>> inst_name(help)
  '_Helper'
  

  （由 Barry Warsaw 提供建议，之后由 Georg Brandl 贡献。）

• The os module now wraps several new system calls.

  fchmod(fd,mode) and fchown(fd,uid,gid) change the mode

  and ownership of an opened file, and lchmod(path,mode) changes

  the mode of a symlink. (Contributed by Georg Brandl and Christian

  Heimes.)

  chflags() and lchflags() are wrappers for the

  corresponding system calls (where they're available), changing the

  flags set on a file. Constants for the flag values are defined in

  the stat module; some possible values include

  UF_IMMUTABLE to signal the file may not be changed and

  UF_APPEND to indicate that data can only be appended to the

  file. (Contributed by M. Levinson.)

  os.closerange(low,high) efficiently closes all file descriptors

  from low to high, ignoring any errors and not including high itself.

  This function is now used by the subprocess module to make starting

  processes faster. (Contributed by Georg Brandl; bpo-1663329.)

• The os.environ object's clear() method will now unset the

  environment variables using os.unsetenv() in addition to clearing

  the object's keys. (Contributed by Martin Horcicka; bpo-1181.)

• The os.walk() function now has a followlinks parameter. If

  set to True, it will follow symlinks pointing to directories and

  visit the directory's contents. For backward compatibility, the

  parameter's default value is false. Note that the function can fall

  into an infinite recursion if there's a symlink that points to a

  parent directory. (bpo-1273829)

• In the os.path module, the splitext() function

  has been changed to not split on leading period characters.

  This produces better results when operating on Unix's dot-files.

  For example, os.path.splitext('.ipython')

  now returns ('.ipython','') instead of ('','.ipython').

  (bpo-1115886)

  A new function, os.path.relpath(path,start='.'), returns a relative path

  from the start path, if it's supplied, or from the current

  working directory to the destination path. (Contributed by

  Richard Barran; bpo-1339796.)

  On Windows, os.path.expandvars() will now expand environment variables

  given in the form "%var%", and "~user" will be expanded into the

  user's home directory path. (Contributed by Josiah Carlson;

  bpo-957650.)

• The Python debugger provided by the pdb module

  gained a new command: "run" restarts the Python program being debugged

  and can optionally take new command-line arguments for the program.

  (Contributed by Rocky Bernstein; bpo-1393667.)

• The pdb.post_mortem() function, used to begin debugging a

  traceback, will now use the traceback returned by sys.exc_info()

  if no traceback is supplied. (Contributed by Facundo Batista;

  bpo-1106316.)

• The pickletools module now has an optimize() function

  that takes a string containing a pickle and removes some unused

  opcodes, returning a shorter pickle that contains the same data structure.

  (Contributed by Raymond Hettinger.)

• A get_data() function was added to the pkgutil

  module that returns the contents of resource files included

  with an installed Python package. For example:

  >>> importpkgutil
  >>> printpkgutil.get_data('test','exception_hierarchy.txt')
  BaseException
   +-- SystemExit
   +-- KeyboardInterrupt
   +-- GeneratorExit
   +-- Exception
        +-- StopIteration
        +-- StandardError
   ...
  

  （由 Paul Moore 在 bpo-2439 中贡献。）

• The pyexpat module's Parser objects now allow setting

  their buffer_size attribute to change the size of the buffer

  used to hold character data.

  (Contributed by Achim Gaedke; bpo-1137.)

• The Queue module now provides queue variants that retrieve entries

  in different orders. The PriorityQueue class stores

  queued items in a heap and retrieves them in priority order,

  and LifoQueue retrieves the most recently added entries first,

  meaning that it behaves like a stack.

  (Contributed by Raymond Hettinger.)

• The random module's Random objects can

  now be pickled on a 32-bit system and unpickled on a 64-bit

  system, and vice versa. Unfortunately, this change also means

  that Python 2.6's Random objects can't be unpickled correctly

  on earlier versions of Python.

  (Contributed by Shawn Ligocki; bpo-1727780.)

  The new triangular(low,high,mode) function returns random

  numbers following a triangular distribution. The returned values

  are between low and high, not including high itself, and

  with mode as the most frequently occurring value

  in the distribution. (Contributed by Wladmir van der Laan and

  Raymond Hettinger; bpo-1681432.)

• Long regular expression searches carried out by the re

  module will check for signals being delivered, so

  time-consuming searches can now be interrupted.

  (Contributed by Josh Hoyt and Ralf Schmitt; bpo-846388.)

  The regular expression module is implemented by compiling bytecodes

  for a tiny regex-specific virtual machine. Untrusted code

  could create malicious strings of bytecode directly and cause crashes,

  so Python 2.6 includes a verifier for the regex bytecode.

  (Contributed by Guido van Rossum from work for Google App Engine;

  bpo-3487.)

• The rlcompleter module's Completer.complete() method

  will now ignore exceptions triggered while evaluating a name.

  (Fixed by Lorenz Quack; bpo-2250.)

• The sched module's scheduler instances now

  have a read-only queue attribute that returns the

  contents of the scheduler's queue, represented as a list of

  named tuples with the fields (time,priority,action,argument).

  (Contributed by Raymond Hettinger; bpo-1861.)

• The select module now has wrapper functions

  for the Linux epoll() and BSD kqueue() system calls.

  modify() method was added to the existing poll

  objects; pollobj.modify(fd,eventmask) takes a file descriptor

  or file object and an event mask, modifying the recorded event mask

  for that file.

  (Contributed by Christian Heimes; bpo-1657.)

• The shutil.copytree() function now has an optional ignore argument

  that takes a callable object. This callable will receive each directory path

  and a list of the directory's contents, and returns a list of names that

  will be ignored, not copied.

  The shutil module also provides an ignore_patterns()

  function for use with this new parameter. ignore_patterns()

  takes an arbitrary number of glob-style patterns and returns a

  callable that will ignore any files and directories that match any

  of these patterns. The following example copies a directory tree,

  but skips both .svn directories and Emacs backup files,

  which have names ending with '~':

  shutil.copytree('Doc/library','/tmp/library',
  ignore=shutil.ignore_patterns('*~','.svn'))
  

  （由 Tarek Ziadé 在 bpo-2663 中贡献。）

• Integrating signal handling with GUI handling event loops

  like those used by Tkinter or GTk+ has long been a problem; most

  software ends up polling, waking up every fraction of a second to check

  if any GUI events have occurred.

  The signal module can now make this more efficient.

  Calling signal.set_wakeup_fd(fd) sets a file descriptor

  to be used; when a signal is received, a byte is written to that

  file descriptor. There's also a C-level function,

  PySignal_SetWakeupFd(), for setting the descriptor.

  Event loops will use this by opening a pipe to create two descriptors,

  one for reading and one for writing. The writable descriptor

  will be passed to set_wakeup_fd(), and the readable descriptor

  will be added to the list of descriptors monitored by the event loop via

  select() or poll().

  On receiving a signal, a byte will be written and the main event loop

  will be woken up, avoiding the need to poll.

  （由 Adam Olsen 在 bpo-1583 中贡献。）

  The siginterrupt() function is now available from Python code,

  and allows changing whether signals can interrupt system calls or not.

  (Contributed by Ralf Schmitt.)

  The setitimer() and getitimer() functions have also been

  added (where they're available). setitimer()

  allows setting interval timers that will cause a signal to be

  delivered to the process after a specified time, measured in

  wall-clock time, consumed process time, or combined process+system

  time. (Contributed by Guilherme Polo; bpo-2240.)

• The smtplib module now supports SMTP over SSL thanks to the

  addition of the SMTP_SSL class. This class supports an

  interface identical to the existing SMTP class.

  (Contributed by Monty Taylor.) Both class constructors also have an

  optional timeout parameter that specifies a timeout for the

  initial connection attempt, measured in seconds. (Contributed by

  Facundo Batista.)

  An implementation of the LMTP protocol (RFC 2033) was also added

  to the module. LMTP is used in place of SMTP when transferring

  e-mail between agents that don't manage a mail queue. (LMTP

  implemented by Leif Hedstrom; bpo-957003.)

  SMTP.starttls() now complies with RFC 3207 and forgets any

  knowledge obtained from the server not obtained from the TLS

  negotiation itself. (Patch contributed by Bill Fenner;

  bpo-829951.)

• The socket module now supports TIPC (http://tipc.sourceforge.net/),

  a high-performance non-IP-based protocol designed for use in clustered

  environments. TIPC addresses are 4- or 5-tuples.

  (Contributed by Alberto Bertogli; bpo-1646.)

  A new function, create_connection(), takes an address and

  connects to it using an optional timeout value, returning the

  connected socket object. This function also looks up the address's

  type and connects to it using IPv4 or IPv6 as appropriate. Changing

  your code to use create_connection() instead of

  socket(socket.AF_INET,...) may be all that's required to make

  your code work with IPv6.

• The base classes in the SocketServer module now support

  calling a handle_timeout() method after a span of inactivity

  specified by the server's timeout attribute. (Contributed

  by Michael Pomraning.) The serve_forever() method

  now takes an optional poll interval measured in seconds,

  controlling how often the server will check for a shutdown request.

  (Contributed by Pedro Werneck and Jeffrey Yasskin;

  bpo-742598, bpo-1193577.)

• The sqlite3 module, maintained by Gerhard Häring,

  has been updated from version 2.3.2 in Python 2.5 to

  version 2.4.1.

• The struct module now supports the C99 _Bool type,

  using the format character '?'.

  (Contributed by David Remahl.)

• The Popen objects provided by the subprocess module

  now have terminate(), kill(), and send_signal() methods.

  On Windows, send_signal() only supports the SIGTERM

  signal, and all these methods are aliases for the Win32 API function

  TerminateProcess().

  (Contributed by Christian Heimes.)

• A new variable in the sys module, float_info, is an

  object containing information derived from the float.h file

  about the platform's floating-point support. Attributes of this

  object include mant_dig (number of digits in the mantissa),

  epsilon (smallest difference between 1.0 and the next

  largest value representable), and several others. (Contributed by

  Christian Heimes; bpo-1534.)

  Another new variable, dont_write_bytecode, controls whether Python

  writes any .pyc or .pyo files on importing a module.

  If this variable is true, the compiled files are not written. The

  variable is initially set on start-up by supplying the -B

  switch to the Python interpreter, or by setting the

  PYTHONDONTWRITEBYTECODE environment variable before

  running the interpreter. Python code can subsequently

  change the value of this variable to control whether bytecode files

  are written or not.

  (Contributed by Neal Norwitz and Georg Brandl.)

  Information about the command-line arguments supplied to the Python

  interpreter is available by reading attributes of a named

  tuple available as sys.flags. For example, the verbose

  attribute is true if Python

  was executed in verbose mode, debug is true in debugging mode, etc.

  These attributes are all read-only.

  (Contributed by Christian Heimes.)

  A new function, getsizeof(), takes a Python object and returns

  the amount of memory used by the object, measured in bytes. Built-in

  objects return correct results; third-party extensions may not,

  but can define a __sizeof__() method to return the

  object's size.

  (Contributed by Robert Schuppenies; bpo-2898.)

  It's now possible to determine the current profiler and tracer functions

  by calling sys.getprofile() and sys.gettrace().

  (Contributed by Georg Brandl; bpo-1648.)

• The tarfile module now supports POSIX.1-2001 (pax) tarfiles in

  addition to the POSIX.1-1988 (ustar) and GNU tar formats that were

  already supported. The default format is GNU tar; specify the

  format parameter to open a file using a different format:

  tar=tarfile.open("output.tar","w",
  format=tarfile.PAX_FORMAT)
  

  The new encoding and errors parameters specify an encoding and

  an error handling scheme for character conversions. 'strict',

  'ignore', and 'replace' are the three standard ways Python can

  handle errors,;

  'utf-8' is a special value that replaces bad characters with

  their UTF-8 representation. (Character conversions occur because the

  PAX format supports Unicode filenames, defaulting to UTF-8 encoding.)

  The TarFile.add() method now accepts an exclude argument that's

  a function that can be used to exclude certain filenames from

  an archive.

  The function must take a filename and return true if the file

  should be excluded or false if it should be archived.

  The function is applied to both the name initially passed to add()

  and to the names of files in recursively-added directories.

  (All changes contributed by Lars Gustäbel).

• An optional timeout parameter was added to the

  telnetlib.Telnet class constructor, specifying a timeout

  measured in seconds. (Added by Facundo Batista.)

• The tempfile.NamedTemporaryFile class usually deletes

  the temporary file it created when the file is closed. This

  behaviour can now be changed by passing delete=False to the

  constructor. (Contributed by Damien Miller; bpo-1537850.)

  A new class, SpooledTemporaryFile, behaves like

  a temporary file but stores its data in memory until a maximum size is

  exceeded. On reaching that limit, the contents will be written to

  an on-disk temporary file. (Contributed by Dustin J. Mitchell.)

  The NamedTemporaryFile and SpooledTemporaryFile classes

  both work as context managers, so you can write

  withtempfile.NamedTemporaryFile()astmp:....

  (Contributed by Alexander Belopolsky; bpo-2021.)

• The test.test_support module gained a number

  of context managers useful for writing tests.

  EnvironmentVarGuard() is a

  context manager that temporarily changes environment variables and

  automatically restores them to their old values.

  Another context manager, TransientResource, can surround calls

  to resources that may or may not be available; it will catch and

  ignore a specified list of exceptions. For example,

  a network test may ignore certain failures when connecting to an

  external web site:

  withtest_support.TransientResource(IOError,
  errno=errno.ETIMEDOUT):
  f=urllib.urlopen('https://sf.net')
  ...
  

  Finally, check_warnings() resets the warning module's

  warning filters and returns an object that will record all warning

  messages triggered (bpo-3781):

  withtest_support.check_warnings()aswrec:
  warnings.simplefilter("always")
  # ... code that triggers a warning ...
  assertstr(wrec.message)=="function is outdated"
  assertlen(wrec.warnings)==1,"Multiple warnings raised"
  

  （由 Brett Cannon 贡献。）

• The textwrap module can now preserve existing whitespace

  at the beginnings and ends of the newly-created lines

  by specifying drop_whitespace=False

  as an argument:

  >>> S="""This  sentence  has a bunch   of
  ...   extra   whitespace."""
  >>> printtextwrap.fill(S,width=15)
  This  sentence
  has a bunch
  of    extra
  whitespace.
  >>> printtextwrap.fill(S,drop_whitespace=False,width=15)
  This  sentence
    has a bunch
     of    extra
     whitespace.
  >>>
  

  （由 Dwayne Bailey 在 bpo-1581073 中贡献。）

• The threading module API is being changed to use properties

  such as daemon instead of setDaemon() and

  isDaemon() methods, and some methods have been renamed to use

  underscores instead of camel-case; for example, the

  activeCount() method is renamed to active_count(). Both

  the 2.6 and 3.0 versions of the module support the same properties

  and renamed methods, but don't remove the old methods. No date has been set

  for the deprecation of the old APIs in Python 3.x; the old APIs won't

  be removed in any 2.x version.

  (Carried out by several people, most notably Benjamin Peterson.)

  The threading module's Thread objects

  gained an ident property that returns the thread's

  identifier, a nonzero integer. (Contributed by Gregory P. Smith;

  bpo-2871.)

• The timeit module now accepts callables as well as strings

  for the statement being timed and for the setup code.

  Two convenience functions were added for creating

  Timer instances:

  repeat(stmt,setup,time,repeat,number) and

  timeit(stmt,setup,time,number) create an instance and call

  the corresponding method. (Contributed by Erik Demaine;

  bpo-1533909.)

• The Tkinter module now accepts lists and tuples for options,

  separating the elements by spaces before passing the resulting value to

  Tcl/Tk.

  (Contributed by Guilherme Polo; bpo-2906.)

• The turtle module for turtle graphics was greatly enhanced by

  Gregor Lingl. New features in the module include:

  • Better animation of turtle movement and rotation.

  • Control over turtle movement using the new delay(),

    tracer(), and speed() methods.

  • The ability to set new shapes for the turtle, and to

    define a new coordinate system.

  • Turtles now have an undo() method that can roll back actions.

  • Simple support for reacting to input events such as mouse and keyboard

    activity, making it possible to write simple games.

  • A turtle.cfg file can be used to customize the starting appearance

    of the turtle's screen.

  • The module's docstrings can be replaced by new docstrings that have been

    translated into another language.

  (bpo-1513695)

• An optional timeout parameter was added to the

  urllib.urlopen() function and the

  urllib.ftpwrapper class constructor, as well as the

  urllib2.urlopen() function. The parameter specifies a timeout

  measured in seconds. For example:

  >>> u=urllib2.urlopen("http://slow.example.com",
                          timeout=3)
  Traceback (most recent call last):
  ...
  urllib2.URLError: <urlopen error timed out>
  >>>
  

  (Added by Facundo Batista.)

• The Unicode database provided by the unicodedata module

  has been updated to version 5.1.0. (Updated by

  Martin von Löwis; bpo-3811.)

• The warnings module's formatwarning() and showwarning()

  gained an optional line argument that can be used to supply the

  line of source code. (Added as part of bpo-1631171, which re-implemented

  part of the warnings module in C code.)

  A new function, catch_warnings(), is a context manager

  intended for testing purposes that lets you temporarily modify the

  warning filters and then restore their original values (bpo-3781).

• The XML-RPC SimpleXMLRPCServer and DocXMLRPCServer

  classes can now be prevented from immediately opening and binding to

  their socket by passing False as the bind_and_activate

  constructor parameter. This can be used to modify the instance's

  allow_reuse_address attribute before calling the

  server_bind() and server_activate() methods to

  open the socket and begin listening for connections.

  (Contributed by Peter Parente; bpo-1599845.)

  SimpleXMLRPCServer also has a _send_traceback_header

  attribute; if true, the exception and formatted traceback are returned

  as HTTP headers "X-Exception" and "X-Traceback". This feature is

  for debugging purposes only and should not be used on production servers

  because the tracebacks might reveal passwords or other sensitive

  information. (Contributed by Alan McIntyre as part of his

  project for Google's Summer of Code 2007.)

• The xmlrpclib module no longer automatically converts

  datetime.date and datetime.time to the

  xmlrpclib.DateTime type; the conversion semantics were

  not necessarily correct for all applications. Code using

  xmlrpclib should convert date and time

  instances. (bpo-1330538) The code can also handle

  dates before 1900 (contributed by Ralf Schmitt; bpo-2014)

  and 64-bit integers represented by using <i8> in XML-RPC responses

  (contributed by Riku Lindblad; bpo-2985).

• The zipfile module's ZipFile class now has

  extract() and extractall() methods that will unpack

  a single file or all the files in the archive to the current directory, or

  to a specified directory:

  z=zipfile.ZipFile('python-251.zip')
  # Unpack a single file, writing it relative
  # to the /tmp directory.
  z.extract('Python/sysmodule.c','/tmp')
  # Unpack all the files in the archive.
  z.extractall()
  

  （由 Alan McIntyre 在 bpo-467924 中贡献。）

  The open(), read() and extract() methods can now

  take either a filename or a ZipInfo object. This is useful when an

  archive accidentally contains a duplicated filename.

  (Contributed by Graham Horler; bpo-1775025.)

  Finally, zipfile now supports using Unicode filenames

  for archived files. (Contributed by Alexey Borzenkov; bpo-1734346.)