Python2.5有什么新变化

PEP 352: 异常作为新型的类¶

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:

try:
...
except(KeyboardInterrupt,SystemExit):
raise
except:
# Log error...
# Continue running program...

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"Error

occurred", 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.

PEP 353: 使用ssize_t作为索引类型¶

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 spanly 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.

PEP 357: '__index__' 方法¶

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:

  classzerodict(dict):
  def__missing__(self,key):
  return0
  d=zerodict({1:1,2:2})
  printd[1],d[2]# Prints 1, 2
  printd[3],d[4]# Prints 0, 0
  

• 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'.

  几个例子:

  >>> ('http://www.python.org').partition('://')
  ('http', '://', 'www.python.org')
  >>> ('file:/usr/share/doc/index.html').partition('://')
  ('file:/usr/share/doc/index.html', '', '')
  >>> (u'Subject: a quick question').partition(':')
  (u'Subject', u':', u' a quick question')
  >>> 'www.python.org'.rpartition('.')
  ('www.python', '.', 'org')
  >>> 'www.python.org'.rpartition(':')
  ('', '', 'www.python.org')
  

  (Implemented by Fredrik Lundh following a suggestion by Raymond Hettinger.)

• The startswith() and endswith() methods of string types now accept

  tuples of strings to check for.

  defis_image_file(filename):
  returnfilename.endswith(('.gif','.jpg','.tiff'))
  

  (Implemented by Georg Brandl following a suggestion by Tom Lynn.)

• 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 value
  printmax(L)
  

  （由 Steven Bethard 和 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 unequal
  False
  >>> chr(127)==unichr(127)# chr(127) can be converted
  True
  

  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.

  （由 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:

  classC():
  pass
  

  （由 Brett Cannon 实现。）

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

新增，改进和删除的模块¶

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:

  words="""Nel mezzo del cammin di nostra vita
  mi ritrovai per una selva oscura
  che la diritta via era smarrita""".lower().split()
  index=defaultdict(list)
  forwinwords:
  init_letter=w[0]
  index[init_letter].append(w)
  

  打印 index 导致以下输出:

  defaultdict(<type'list'>,{'c':['cammin','che'],'e':['era'],
  'd':['del','di','diritta'],'m':['mezzo','mi'],
  'l':['la'],'o':['oscura'],'n':['nel','nostra'],
  'p':['per'],'s':['selva','smarrita'],
  'r':['ritrovai'],'u':['una'],'v':['vita','via']}
  

  （由 Guido van Rossum 贡献。）

• 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 contextlib module contains helper functions for use

  with the new 'with' statement. See section contextlib 模块

  for more about this module.

• 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.

  （由Skip Montanaro 和 Andrew McNamara 贡献。）

• The datetime class in the datetime module now has a

  strptime(string,format) method for parsing date strings, contributed

  by Josh Spoerri. It uses the same format characters as time.strptime() and

  time.strftime():

  fromdatetimeimportdatetime
  ts=datetime.strptime('10:13:15 2006-03-07',
  '%H:%M:%S %Y-%m-%d')
  

• 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.)

• email 包已经升级到 4.0 （由 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:

  >>> importheapq
  >>> L=["short",'medium','longest','longer still']
  >>> heapq.nsmallest(2,L)# Return two lowest elements, lexicographically
  ['longer still', 'longest']
  >>> heapq.nsmallest(2,L,key=len)# Return two shortest elements
  ['short', 'medium']
  

  （由 Raymond Hettinger 贡献。）

• The itertools.islice() function now accepts None for the start and

  step arguments. This makes it more compatible with the attributes of slice

  objects, so that you can now write the following:

  s=slice(5)# Create slice object
  itertools.islice(iterable,s.start,s.stop,s.step)
  

  （由 Raymond Hettinger 贡献。）

• 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.

  （由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:

  importmailbox
  # 'factory=None' uses email.Message.Message as the class representing
  # individual messages.
  src=mailbox.Maildir('maildir',factory=None)
  dest=mailbox.mbox('/tmp/mbox')
  formsginsrc:
  dest.add(msg)
  

  (Contributed by Gregory K. Johnson. Funding was provided by Google's 2005

  Summer of Code.)

• 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.)

  Constants named os.SEEK_SET, os.SEEK_CUR, and

  os.SEEK_END have been added; these are the parameters to the

  os.lseek() function. Two new constants for locking are

  os.O_SHLOCK and os.O_EXLOCK.

  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:

  s=struct.Struct('ih3s')
  data=s.pack(1972,187,'abc')
  year,number,name=s.unpack(data)
  

  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')
  

  （由 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.)

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

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

>>> libc.atof('2.71828')
-1783957616
>>> libc.atof.restype=ctypes.c_double
>>> libc.atof('2.71828')
2.71828

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

fromxml.etreeimportElementTreeasET
tree=ET.parse('ex-1.xml')
feed=urllib.urlopen(
'http://planet.python.org/rss10.xml')
tree=ET.parse(feed)

svg=ET.XML("""<svg width="10px" version="1.0">
             </svg>""")
svg.set('height','320px')
svg.append(elem1)

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

# Encoding is US-ASCII
tree.write('output.xml')
# Encoding is UTF-8
f=open('output.xml','w')
tree.write(f,encoding='utf-8')

# Old versions
h=md5.md5()
h=md5.new()
# New version
h=hashlib.md5()
# Old versions
h=sha.sha()
h=sha.new()
# New version
h=hashlib.sha1()
# Hash that weren't previously available
h=hashlib.sha224()
h=hashlib.sha256()
h=hashlib.sha384()
h=hashlib.sha512()
# Alternative form
h=hashlib.new('md5')# Provide algorithm as a string

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

c=conn.cursor()
# Create table
c.execute('''create table stocks
(date text, trans text, symbol text,
 qty real, price real)''')
# Insert a row of data
c.execute("""insert into stocks
          values ('2006-01-05','BUY','RHAT',100,35.14)""")

# Never do this -- insecure!
symbol='IBM'
c.execute("... where symbol = '%s'"%symbol)
# Do this instead
t=(symbol,)
c.execute('select * from stocks where symbol=?',t)
# Larger example
fortin(('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)

>>> c=conn.cursor()
>>> c.execute('select * from stocks order by price')
>>> forrowinc:
... printrow
...
(u'2006-01-05', u'BUY', u'RHAT', 100, 35.140000000000001)
(u'2006-03-28', u'BUY', u'IBM', 1000, 45.0)
(u'2006-04-06', u'SELL', u'IBM', 500, 53.0)
(u'2006-04-05', u'BUY', u'MSOFT', 1000, 72.0)
>>>

fromwsgirefimportsimple_server
wsgi_app=...
host=''
port=8000
httpd=simple_server.make_server(host,port,wsgi_app)
httpd.serve_forever()