Python2.4有什么新变化

PEP 328: 多行导入¶

One language change is a small syntactic tweak aimed at making it easier to

import many names from a module. In a frommoduleimportnames statement,

names is a sequence of names separated by commas. If the sequence is very

long, you can either write multiple imports from the same module, or you can use

backslashes to escape the line endings like this:

fromSimpleXMLRPCServerimportSimpleXMLRPCServer,\
SimpleXMLRPCRequestHandler,\
CGIXMLRPCRequestHandler,\
resolve_dotted_attribute

The syntactic change in Python 2.4 simply allows putting the names within

parentheses. Python ignores newlines within a parenthesized expression, so the

backslashes are no longer needed:

fromSimpleXMLRPCServerimport(SimpleXMLRPCServer,
SimpleXMLRPCRequestHandler,
CGIXMLRPCRequestHandler,
resolve_dotted_attribute)

The PEP also proposes that all import statements be absolute imports,

with a leading . character to indicate a relative import. This part of the

PEP was not implemented for Python 2.4, but was completed for Python 2.5.

PEP 331: Locale-Independent Float/String Conversions¶

The locale modules lets Python software select various conversions and

display conventions that are localized to a particular country or language.

However, the module was careful to not change the numeric locale because various

functions in Python's implementation required that the numeric locale remain set

to the 'C' locale. Often this was because the code was using the C

library's atof() function.

Not setting the numeric locale caused trouble for extensions that used third-party

C libraries, however, because they wouldn't have the correct locale set.

The motivating example was GTK+, whose user interface widgets weren't displaying

numbers in the current locale.

The solution described in the PEP is to add three new functions to the Python

API that perform ASCII-only conversions, ignoring the locale setting:

• PyOS_ascii_strtod(str,ptr) and PyOS_ascii_atof(str,ptr)

  both convert a string to a C double.

• PyOS_ascii_formatd(buffer,buf_len,format,d) converts a

  double to an ASCII string.

The code for these functions came from the GLib library

(https://developer.gnome.org/glib/stable/), whose developers kindly

relicensed the relevant functions and donated them to the Python Software

Foundation. The locale module can now change the numeric locale,

letting extensions such as GTK+ produce the correct results.

其他语言特性修改¶

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

• Decorators for functions and methods were added (PEP 318).

• Built-in set() and frozenset() types were added (PEP 218).

  Other new built-ins include the reversed(seq) function (PEP 322).

• Generator expressions were added (PEP 289).

• Certain numeric expressions no longer return values restricted to 32 or 64

  bits (PEP 237).

• You can now put parentheses around the list of names in a frommoduleimport

  names statement (PEP 328).

• The dict.update() method now accepts the same argument forms as the

  dict constructor. This includes any mapping, any iterable of key/value

  pairs, and keyword arguments. (Contributed by Raymond Hettinger.)

• The string methods ljust(), rjust(), and center() now take

  an optional argument for specifying a fill character other than a space.

  (Contributed by Raymond Hettinger.)

• Strings also gained an rsplit() method that works like the split()

  method but splits from the end of the string. (Contributed by Sean

  Reifschneider.)

  >>> 'www.python.org'.split('.',1)
  ['www', 'python.org']
  'www.python.org'.rsplit('.', 1)
  ['www.python', 'org']
  

• Three keyword parameters, cmp, key, and reverse, were added to the

  sort() method of lists. These parameters make some common usages of

  sort() simpler. All of these parameters are optional.

  For the cmp parameter, the value should be a comparison function that takes

  two parameters and returns -1, 0, or +1 depending on how the parameters compare.

  This function will then be used to sort the list. Previously this was the only

  parameter that could be provided to sort().

  key should be a single-parameter function that takes a list element and

  returns a comparison key for the element. The list is then sorted using the

  comparison keys. The following example sorts a list case-insensitively:

  >>> L=['A','b','c','D']
  >>> L.sort()# Case-sensitive sort
  >>> L
  ['A', 'D', 'b', 'c']
  >>> # Using 'key' parameter to sort list
  >>> L.sort(key=lambdax:x.lower())
  >>> L
  ['A', 'b', 'c', 'D']
  >>> # Old-fashioned way
  >>> L.sort(cmp=lambdax,y:cmp(x.lower(),y.lower()))
  >>> L
  ['A', 'b', 'c', 'D']
  

  The last example, which uses the cmp parameter, is the old way to perform a

  case-insensitive sort. It works but is slower than using a key parameter.

  Using key calls lower() method once for each element in the list while

  using cmp will call it twice for each comparison, so using key saves on

  invocations of the lower() method.

  For simple key functions and comparison functions, it is often possible to avoid

  a lambda expression by using an unbound method instead. For example,

  the above case-insensitive sort is best written as:

  >>> L.sort(key=str.lower)
  >>> L
  ['A', 'b', 'c', 'D']
  

  Finally, the reverse parameter takes a Boolean value. If the value is true,

  the list will be sorted into reverse order. Instead of L.sort();

  L.reverse(), you can now write L.sort(reverse=True).

  The results of sorting are now guaranteed to be stable. This means that two

  entries with equal keys will be returned in the same order as they were input.

  For example, you can sort a list of people by name, and then sort the list by

  age, resulting in a list sorted by age where people with the same age are in

  name-sorted order.

  (All changes to sort() contributed by Raymond Hettinger.)

• There is a new built-in function sorted(iterable) that works like the

  in-place list.sort() method but can be used in expressions. The

  differences are:

• the input may be any iterable;

• a newly formed copy is sorted, leaving the original intact; and

• the expression returns the new sorted copy

  >>> L=[9,7,8,3,2,4,1,6,5]
  >>> [10+iforiinsorted(L)]# usable in a list comprehension
  [11, 12, 13, 14, 15, 16, 17, 18, 19]
  >>> L# original is left unchanged
  [9,7,8,3,2,4,1,6,5]
  >>> sorted('Monty Python')# any iterable may be an input
  [' ', 'M', 'P', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y', 'y']
  >>> # List the contents of a dict sorted by key values
  >>> colormap=dict(red=1,blue=2,green=3,black=4,yellow=5)
  >>> fork,vinsorted(colormap.iteritems()):
  ... printk,v
  ...
  black 4
  blue 2
  green 3
  red 1
  yellow 5
  

  （由 Raymond Hettinger 贡献。）

• Integer operations will no longer trigger an OverflowWarning. The

  OverflowWarning warning will disappear in Python 2.5.

• The interpreter gained a new switch, -m, that takes a name, searches

  for the corresponding module on sys.path, and runs the module as a script.

  For example, you can now run the Python profiler with python-mprofile.

  (Contributed by Nick Coghlan.)

• The eval(expr,globals,locals) and execfile(filename,globals,

  locals) functions and the exec statement now accept any mapping type

  for the locals parameter. Previously this had to be a regular Python

  dictionary. (Contributed by Raymond Hettinger.)

• The zip() built-in function and itertools.izip() now return an

  empty list if called with no arguments. Previously they raised a

  TypeError exception. This makes them more suitable for use with variable

  length argument lists:

  >>> deftranspose(array):
  ... returnzip(*array)
  ...
  >>> transpose([(1,2,3),(4,5,6)])
  [(1, 4), (2, 5), (3, 6)]
  >>> transpose([])
  []
  

  （由 Raymond Hettinger 贡献。）

• Encountering a failure while importing a module no longer leaves a partially-initialized

  module object in sys.modules. The incomplete module object left

  behind would fool further imports of the same module into succeeding, leading to

  confusing errors. (Fixed by Tim Peters.)

• None is now a constant; code that binds a new value to the name

  None is now a syntax error. (Contributed by Raymond Hettinger.)

新增，改进和弃用的模块¶

As usual, Python's standard library received a number of enhancements and bug

fixes. Here's a partial list of the most notable changes, sorted alphabetically

by module name. Consult the Misc/NEWS file in the source tree for a more

complete list of changes, or look through the CVS logs for all the details.

• The asyncore module's loop() function now has a count parameter

  that lets you perform a limited number of passes through the polling loop. The

  default is still to loop forever.

• The base64 module now has more complete RFC 3548 support for Base64,

  Base32, and Base16 encoding and decoding, including optional case folding and

  optional alternative alphabets. (Contributed by Barry Warsaw.)

• The bisect module now has an underlying C implementation for improved

  performance. (Contributed by Dmitry Vasiliev.)

• 由 Hye-Shik Chang 维护的东亚编解码器的 CJKCodecs 集合已集成到 2.4 中。新的编码为：

• 汉语（台湾）:: gb2312, gbk, gb18030, big5hkscs, hz

• 汉语（大陆）: big5, cp950

• 日语: cp932, euc-jis-2004, euc-jp, euc-jisx0213, iso-2022-jp,

  iso-2022-jp-1, iso-2022-jp-2, iso-2022-jp-3, iso-2022-jp-ext, iso-2022-jp-2004,

  shift-jis, shift-jisx0213, shift-jis-2004

• 韩语: cp949, euc-kr, johab, iso-2022-kr

• 添加了其他一些新的编码：HP Roman8, ISO_8859-11, ISO_8859-16, PCTP-154 和 TIS-620

• The UTF-8 and UTF-16 codecs now cope better with receiving partial input.

  Previously the StreamReader class would try to read more data, making

  it impossible to resume decoding from the stream. The read() method will

  now return as much data as it can and future calls will resume decoding where

  previous ones left off. (Implemented by Walter Dörwald.)

• There is a new collections module for various specialized collection

  datatypes. Currently it contains just one type, deque, a double-ended

  queue that supports efficiently adding and removing elements from either

  end:

  >>> fromcollectionsimportdeque
  >>> d=deque('ghi')# make a new deque with three items
  >>> d.append('j')# add a new entry to the right side
  >>> d.appendleft('f')# add a new entry to the left side
  >>> d# show the representation of the deque
  deque(['f', 'g', 'h', 'i', 'j'])
  >>> d.pop()# return and remove the rightmost item
  'j'
  >>> d.popleft()# return and remove the leftmost item
  'f'
  >>> list(d)# list the contents of the deque
  ['g', 'h', 'i']
  >>> 'h'ind# search the deque
  True
  

  Several modules, such as the Queue and threading modules, now take

  advantage of collections.deque for improved performance. (Contributed

  by Raymond Hettinger.)

• The ConfigParser classes have been enhanced slightly. The read()

  method now returns a list of the files that were successfully parsed, and the

  set() method raises TypeError if passed a value argument that

  isn't a string. (Contributed by John Belmonte and David Goodger.)

• The curses module now supports the ncurses extension

  use_default_colors(). On platforms where the terminal supports

  transparency, this makes it possible to use a transparent background.

  (Contributed by Jörg Lehmann.)

• The difflib module now includes an HtmlDiff class that creates

  an HTML table showing a side by side comparison of two versions of a text.

  (Contributed by Dan Gass.)

• The email package was updated to version 3.0, which dropped various

  deprecated APIs and removes support for Python versions earlier than 2.3. The

  3.0 version of the package uses a new incremental parser for MIME messages,

  available in the email.FeedParser module. The new parser doesn't require

  reading the entire message into memory, and doesn't raise exceptions if a

  message is malformed; instead it records any problems in the defect

  attribute of the message. (Developed by Anthony Baxter, Barry Warsaw, Thomas

  Wouters, and others.)

• The heapq module has been converted to C. The resulting tenfold

  improvement in speed makes the module suitable for handling high volumes of

  data. In addition, the module has two new functions nlargest() and

  nsmallest() that use heaps to find the N largest or smallest values in a

  dataset without the expense of a full sort. (Contributed by Raymond Hettinger.)

• The httplib module now contains constants for HTTP status codes defined

  in various HTTP-related RFC documents. Constants have names such as

  OK, CREATED, CONTINUE, and

  MOVED_PERMANENTLY; use pydoc to get a full list. (Contributed by

  Andrew Eland.)

• The imaplib module now supports IMAP's THREAD command (contributed by

  Yves Dionne) and new deleteacl() and myrights() methods (contributed

  by Arnaud Mazin).

• The itertools module gained a groupby(iterable[,*func*])

  function. iterable is something that can be iterated over to return a stream

  of elements, and the optional func parameter is a function that takes an

  element and returns a key value; if omitted, the key is simply the element

  itself. groupby() then groups the elements into subsequences which have

  matching values of the key, and returns a series of 2-tuples containing the key

  value and an iterator over the subsequence.

  Here's an example to make this clearer. The key function simply returns

  whether a number is even or odd, so the result of groupby() is to return

  consecutive runs of odd or even numbers.

  >>> importitertools
  >>> L=[2,4,6,7,8,9,11,12,14]
  >>> forkey_val,itinitertools.groupby(L,lambdax:x%2):
  ... printkey_val,list(it)
  ...
  0 [2, 4, 6]
  1 [7]
  0 [8]
  1 [9, 11]
  0 [12, 14]
  >>>
  

  groupby() is typically used with sorted input. The logic for

  groupby() is similar to the Unix uniq filter which makes it handy for

  eliminating, counting, or identifying duplicate elements:

  >>> word='abracadabra'
  >>> letters=sorted(word)# Turn string into a sorted list of letters
  >>> letters
  ['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']
  >>> fork,ginitertools.groupby(letters):
  ... printk,list(g)
  ...
  a ['a', 'a', 'a', 'a', 'a']
  b ['b', 'b']
  c ['c']
  d ['d']
  r ['r', 'r']
  >>> # List unique letters
  >>> [kfork,gingroupby(letters)]
  ['a', 'b', 'c', 'd', 'r']
  >>> # Count letter occurrences
  >>> [(k,len(list(g)))fork,gingroupby(letters)]
  [('a', 5), ('b', 2), ('c', 1), ('d', 1), ('r', 2)]
  

  （由 Hye-Shik Chang 贡献。）

• itertools also gained a function named tee(iterator,N) that

  returns N independent iterators that replicate iterator. If N is omitted,

  the default is 2.

  >>> L=[1,2,3]
  >>> i1,i2=itertools.tee(L)
  >>> i1,i2
  (<itertools.tee object at 0x402c2080>, <itertools.tee object at 0x402c2090>)
  >>> list(i1)# Run the first iterator to exhaustion
  [1, 2, 3]
  >>> list(i2)# Run the second iterator to exhaustion
  [1, 2, 3]
  

  Note that tee() has to keep copies of the values returned by the

  iterator; in the worst case, it may need to keep all of them. This should

  therefore be used carefully if the leading iterator can run far ahead of the

  trailing iterator in a long stream of inputs. If the separation is large, then

  you might as well use list() instead. When the iterators track closely

  with one another, tee() is ideal. Possible applications include

  bookmarking, windowing, or lookahead iterators. (Contributed by Raymond

  Hettinger.)

• A number of functions were added to the locale module, such as

  bind_textdomain_codeset() to specify a particular encoding and a family of

  l*gettext() functions that return messages in the chosen encoding.

  (Contributed by Gustavo Niemeyer.)

• Some keyword arguments were added to the logging package's

  basicConfig() function to simplify log configuration. The default

  behavior is to log messages to standard error, but various keyword arguments can

  be specified to log to a particular file, change the logging format, or set the

  logging level. For example:

  importlogging
  logging.basicConfig(filename='/var/log/application.log',
  level=0,# Log all messages
  format='%(levelname):%(process):%(thread):%(message)')
  

  Other additions to the logging package include a log(level,msg)

  convenience method, as well as a TimedRotatingFileHandler class that

  rotates its log files at a timed interval. The module already had

  RotatingFileHandler, which rotated logs once the file exceeded a

  certain size. Both classes derive from a new BaseRotatingHandler class

  that can be used to implement other rotating handlers.

  （更改由 Vinay Sajip 实现。）

• The marshal module now shares interned strings on unpacking a data

  structure. This may shrink the size of certain pickle strings, but the primary

  effect is to make .pyc files significantly smaller. (Contributed by

  Martin von Löwis.)

• The nntplib module's NNTP class gained description() and

  descriptions() methods to retrieve newsgroup descriptions for a single

  group or for a range of groups. (Contributed by Jürgen A. Erhard.)

• Two new functions were added to the operator module,

  attrgetter(attr) and itemgetter(index). Both functions return

  callables that take a single argument and return the corresponding attribute or

  item; these callables make excellent data extractors when used with map()

  or sorted(). For example:

  >>> L=[('c',2),('d',1),('a',4),('b',3)]
  >>> map(operator.itemgetter(0),L)
  ['c', 'd', 'a', 'b']
  >>> map(operator.itemgetter(1),L)
  [2, 1, 4, 3]
  >>> sorted(L,key=operator.itemgetter(1))# Sort list by second tuple item
  [('d', 1), ('c', 2), ('b', 3), ('a', 4)]
  

  （由 Raymond Hettinger 贡献。）

• The optparse module was updated in various ways. The module now passes

  its messages through gettext.gettext(), making it possible to

  internationalize Optik's help and error messages. Help messages for options can

  now include the string '%default', which will be replaced by the option's

  default value. (Contributed by Greg Ward.)

• The long-term plan is to deprecate the rfc822 module in some future

  Python release in favor of the email package. To this end, the

  email.Utils.formatdate() function has been changed to make it usable as a

  replacement for rfc822.formatdate(). You may want to write new e-mail

  processing code with this in mind. (Change implemented by Anthony Baxter.)

• A new urandom(n) function was added to the os module, returning

  a string containing n bytes of random data. This function provides access to

  platform-specific sources of randomness such as /dev/urandom on Linux or

  the Windows CryptoAPI. (Contributed by Trevor Perrin.)

• Another new function: os.path.lexists(path) returns true if the file

  specified by path exists, whether or not it's a symbolic link. This differs

  from the existing os.path.exists(path) function, which returns false if

  path is a symlink that points to a destination that doesn't exist.

  (Contributed by Beni Cherniavsky.)

• A new getsid() function was added to the posix module that

  underlies the os module. (Contributed by J. Raynor.)

• The poplib module now supports POP over SSL. (Contributed by Hector

  Urtubia.)

• The profile module can now profile C extension functions. (Contributed

  by Nick Bastin.)

• The random module has a new method called getrandbits(N) that

  returns a long integer N bits in length. The existing randrange()

  method now uses getrandbits() where appropriate, making generation of

  arbitrarily large random numbers more efficient. (Contributed by Raymond

  Hettinger.)

• The regular expression language accepted by the re module was extended

  with simple conditional expressions, written as (?(group)A|B). group is

  either a numeric group ID or a group name defined with (?P<group>...)

  earlier in the expression. If the specified group matched, the regular

  expression pattern A will be tested against the string; if the group didn't

  match, the pattern B will be used instead. (Contributed by Gustavo Niemeyer.)

• The re module is also no longer recursive, thanks to a massive amount

  of work by Gustavo Niemeyer. In a recursive regular expression engine, certain

  patterns result in a large amount of C stack space being consumed, and it was

  possible to overflow the stack. For example, if you matched a 30000-byte string

  of a characters against the expression (a|b)+, one stack frame was

  consumed per character. Python 2.3 tried to check for stack overflow and raise

  a RuntimeError exception, but certain patterns could sidestep the

  checking and if you were unlucky Python could segfault. Python 2.4's regular

  expression engine can match this pattern without problems.

• The signal module now performs tighter error-checking on the parameters

  to the signal.signal() function. For example, you can't set a handler on

  the SIGKILL signal; previous versions of Python would quietly accept

  this, but 2.4 will raise a RuntimeError exception.

• Two new functions were added to the socket module. socketpair()

  returns a pair of connected sockets and getservbyport(port) looks up the

  service name for a given port number. (Contributed by Dave Cole and Barry

  Warsaw.)

• The sys.exitfunc() function has been deprecated. Code should be using

  the existing atexit module, which correctly handles calling multiple exit

  functions. Eventually sys.exitfunc() will become a purely internal

  interface, accessed only by atexit.

• The tarfile module now generates GNU-format tar files by default.

  (Contributed by Lars Gustäbel.)

• The threading module now has an elegantly simple way to support

  thread-local data. The module contains a local class whose attribute

  values are local to different threads.

  importthreading
  data=threading.local()
  data.number=42
  data.url=('www.python.org',80)
  

  Other threads can assign and retrieve their own values for the number

  and url attributes. You can subclass local to initialize

  attributes or to add methods. (Contributed by Jim Fulton.)

• The timeit module now automatically disables periodic garbage

  collection during the timing loop. This change makes consecutive timings more

  comparable. (Contributed by Raymond Hettinger.)

• The weakref module now supports a wider variety of objects including

  Python functions, class instances, sets, frozensets, deques, arrays, files,

  sockets, and regular expression pattern objects. (Contributed by Raymond

  Hettinger.)

• The xmlrpclib module now supports a multi-call extension for

  transmitting multiple XML-RPC calls in a single HTTP operation. (Contributed by

  Brian Quinlan.)

• mpz, rotor 和 xreadlines 模块已被移除。

deff(x,y):
""">>> f(2,2)
4
>>> f(3,2)
6
    """
returnx*y
finder=doctest.DocTestFinder()
# Get list of DocTest instances
tests=finder.find(f)

runner=doctest.DocTestRunner()
fortintests:
tried,failed=runner.run(t)
runner.summarize(verbose=1)

1itemspassedalltests:
2testsinf
2testsin1items.
2passedand0failed.
Testpassed.

defo(n):
""">>> o(1)
<__main__.C instance at 0x...>
>>>
"""

defp(n):
""">>> p(1)
<BLANKLINE>
>>>
"""

defg(n):
""">>> g(4)
here
is
a
lengthy
>>>"""
L='here is a rather lengthy list of words'.split()
forwordinL[:n]:
printword

**********************************************************************
File "t.py", line 15, in g
Failed example:
    g(4)
Differences (unified diff with -expected +actual):
    @@ -2,3 +2,3 @@
     is
     a
    -lengthy
    +rather
**********************************************************************