Python3.2有什么新变化

email¶

The usability of the email package in Python 3 has been mostly fixed by

the extensive efforts of R. David Murray. The problem was that emails are

typically read and stored in the form of bytes rather than str

text, and they may contain multiple encodings within a single email. So, the

email package had to be extended to parse and generate email messages in bytes

format.

• New functions message_from_bytes() and

  message_from_binary_file(), and new classes

  BytesFeedParser and BytesParser

  allow binary message data to be parsed into model objects.

• Given bytes input to the model, get_payload()

  will by default decode a message body that has a

  Content-Transfer-Encoding of 8bit using the charset

  specified in the MIME headers and return the resulting string.

• Given bytes input to the model, Generator will

  convert message bodies that have a Content-Transfer-Encoding of

  8bit to instead have a 7bitContent-Transfer-Encoding.

  Headers with unencoded non-ASCII bytes are deemed to be RFC 2047-encoded

  using the unknown-8bit character set.

• A new class BytesGenerator produces bytes as output,

  preserving any unchanged non-ASCII data that was present in the input used to

  build the model, including message bodies with a

  Content-Transfer-Encoding of 8bit.

• The smtplibSMTP class now accepts a byte string

  for the msg argument to the sendmail() method,

  and a new method, send_message() accepts a

  Message object and can optionally obtain the

  from_addr and to_addrs addresses directly from the object.

(Proposed and implemented by R. David Murray, bpo-4661 and bpo-10321.)

elementtree¶

The xml.etree.ElementTree package and its xml.etree.cElementTree

counterpart have been updated to version 1.3.

Several new and useful functions and methods have been added:

• xml.etree.ElementTree.fromstringlist() which builds an XML document

  from a sequence of fragments

• xml.etree.ElementTree.register_namespace() for registering a global

  namespace prefix

• xml.etree.ElementTree.tostringlist() for string representation

  including all sublists

• xml.etree.ElementTree.Element.extend() for appending a sequence of zero

  or more elements

• xml.etree.ElementTree.Element.iterfind() searches an element and

  subelements

• xml.etree.ElementTree.Element.itertext() creates a text iterator over

  an element and its subelements

• xml.etree.ElementTree.TreeBuilder.end() closes the current element

• xml.etree.ElementTree.TreeBuilder.doctype() handles a doctype

  declaration

两个方法被弃用：

• xml.etree.ElementTree.getchildren() 被 list(elem) 替代。

• xml.etree.ElementTree.getiterator() 被 Element.iter 替代。

For details of the update, see Introducing ElementTree on Fredrik Lundh's website.

（由 Florent Xicluna 和 Fredrik Lundh 在 bpo-1772833 中贡献。）

functools¶

• The functools module includes a new decorator for caching function

  calls. functools.lru_cache() can save repeated queries to an external

  resource whenever the results are expected to be the same.

  For example, adding a caching decorator to a database query function can save

  database accesses for popular searches:

  >>> importfunctools
  >>> @functools.lru_cache(maxsize=300)
  ... defget_phone_number(name):
  ... c=conn.cursor()
  ... c.execute('SELECT phonenumber FROM phonelist WHERE name=?',(name,))
  ... returnc.fetchone()[0]
  

  >>> fornameinuser_requests:
  ... get_phone_number(name)# cached lookup
  

  To help with choosing an effective cache size, the wrapped function is

  instrumented for tracking cache statistics:

  >>> get_phone_number.cache_info()
  CacheInfo(hits=4805, misses=980, maxsize=300, currsize=300)
  

  If the phonelist table gets updated, the outdated contents of the cache can be

  cleared with:

  >>> get_phone_number.cache_clear()
  

  (Contributed by Raymond Hettinger and incorporating design ideas from Jim

  Baker, Miki Tebeka, and Nick Coghlan; see recipe 498245, recipe 577479, bpo-10586, and

  bpo-10593.)

• The functools.wraps() decorator now adds a __wrapped__ attribute

  pointing to the original callable function. This allows wrapped functions to

  be introspected. It also copies __annotations__ if defined. And now

  it also gracefully skips over missing attributes such as __doc__ which

  might not be defined for the wrapped callable.

  In the above example, the cache can be removed by recovering the original

  function:

  >>> get_phone_number=get_phone_number.__wrapped__# uncached function
  

  (By Nick Coghlan and Terrence Cole; bpo-9567, bpo-3445, and

  bpo-8814.)

• To help write classes with rich comparison methods, a new decorator

  functools.total_ordering() will use existing equality and inequality

  methods to fill in the remaining methods.

  For example, supplying __eq__ and __lt__ will enable

  total_ordering() to fill-in __le__, __gt__ and __ge__:

  @total_ordering
  classStudent:
  def__eq__(self,other):
  return((self.lastname.lower(),self.firstname.lower())==
  (other.lastname.lower(),other.firstname.lower()))
  def__lt__(self,other):
  return((self.lastname.lower(),self.firstname.lower())<
  (other.lastname.lower(),other.firstname.lower()))
  

  With the total_ordering decorator, the remaining comparison methods

  are filled in automatically.

  （由 Raymond Hettinger 贡献。）

• To aid in porting programs from Python 2, the functools.cmp_to_key()

  function converts an old-style comparison function to

  modern key function:

  >>> # locale-aware sort order
  >>> sorted(iterable,key=cmp_to_key(locale.strcoll))
  

  For sorting examples and a brief sorting tutorial, see the Sorting HowTo tutorial.

  （由 Raymond Hettinger 贡献。）

itertools¶

• The itertools module has a new accumulate() function

  modeled on APL's scan operator and Numpy's accumulate function:

  >>> fromitertoolsimportaccumulate
  >>> list(accumulate([8,2,50]))
  [8, 10, 60]
  

  >>> prob_dist=[0.1,0.4,0.2,0.3]
  >>> list(accumulate(prob_dist))# cumulative probability distribution
  [0.1, 0.5, 0.7, 1.0]
  

  For an example using accumulate(), see the examples for

  the random module.

  (Contributed by Raymond Hettinger and incorporating design suggestions

  from Mark Dickinson.)

collections¶

• The collections.Counter class now has two forms of in-place

  subtraction, the existing -= operator for saturating subtraction and the new

  subtract() method for regular subtraction. The

  former is suitable for multisets

  which only have positive counts, and the latter is more suitable for use cases

  that allow negative counts:

  >>> fromcollectionsimportCounter
  >>> tally=Counter(dogs=5,cats=3)
  >>> tally-=Counter(dogs=2,cats=8)# saturating subtraction
  >>> tally
  Counter({'dogs': 3})
  

  >>> tally=Counter(dogs=5,cats=3)
  >>> tally.subtract(dogs=2,cats=8)# regular subtraction
  >>> tally
  Counter({'dogs': 3, 'cats': -5})
  

  （由 Raymond Hettinger 贡献。）

• The collections.OrderedDict class has a new method

  move_to_end() which takes an existing key and

  moves it to either the first or last position in the ordered sequence.

  The default is to move an item to the last position. This is equivalent of

  renewing an entry with od[k]=od.pop(k).

  A fast move-to-end operation is useful for resequencing entries. For example,

  an ordered dictionary can be used to track order of access by aging entries

  from the oldest to the most recently accessed.

  >>> fromcollectionsimportOrderedDict
  >>> d=OrderedDict.fromkeys(['a','b','X','d','e'])
  >>> list(d)
  ['a', 'b', 'X', 'd', 'e']
  >>> d.move_to_end('X')
  >>> list(d)
  ['a', 'b', 'd', 'e', 'X']
  

  （由 Raymond Hettinger 贡献。）

• The collections.deque class grew two new methods

  count() and reverse() that

  make them more substitutable for list objects:

  >>> fromcollectionsimportdeque
  >>> d=deque('simsalabim')
  >>> d.count('s')
  2
  >>> d.reverse()
  >>> d
  deque(['m', 'i', 'b', 'a', 'l', 'a', 's', 'm', 'i', 's'])
  

  （由 Raymond Hettinger 贡献。）

threading¶

The threading module has a new Barrier

synchronization class for making multiple threads wait until all of them have

reached a common barrier point. Barriers are useful for making sure that a task

with multiple preconditions does not run until all of the predecessor tasks are

complete.

Barriers can work with an arbitrary number of threads. This is a generalization

of a Rendezvous which

is defined for only two threads.

Implemented as a two-phase cyclic barrier, Barrier objects

are suitable for use in loops. The separate filling and draining phases

assure that all threads get released (drained) before any one of them can loop

back and re-enter the barrier. The barrier fully resets after each cycle.

Example of using barriers:

fromthreadingimportBarrier,Thread
defget_votes(site):
ballots=conduct_election(site)
all_polls_closed.wait()# do not count until all polls are closed
totals=summarize(ballots)
publish(site,totals)
all_polls_closed=Barrier(len(sites))
forsiteinsites:
Thread(target=get_votes,args=(site,)).start()

In this example, the barrier enforces a rule that votes cannot be counted at any

polling site until all polls are closed. Notice how a solution with a barrier

is similar to one with threading.Thread.join(), but the threads stay alive

and continue to do work (summarizing ballots) after the barrier point is

crossed.

If any of the predecessor tasks can hang or be delayed, a barrier can be created

with an optional timeout parameter. Then if the timeout period elapses before

all the predecessor tasks reach the barrier point, all waiting threads are

released and a BrokenBarrierError exception is raised:

defget_votes(site):
ballots=conduct_election(site)
try:
all_polls_closed.wait(timeout=midnight-time.now())
exceptBrokenBarrierError:
lockbox=seal_ballots(ballots)
queue.put(lockbox)
else:
totals=summarize(ballots)
publish(site,totals)

In this example, the barrier enforces a more robust rule. If some election

sites do not finish before midnight, the barrier times-out and the ballots are

sealed and deposited in a queue for later handling.

See Barrier Synchronization Patterns

for more examples of how barriers can be used in parallel computing. Also, there is

a simple but thorough explanation of barriers in The Little Book of Semaphores, section 3.6.

(Contributed by Kristján Valur Jónsson with an API review by Jeffrey Yasskin in

bpo-8777.)

datetime 和 time¶

• The datetime module has a new type timezone that

  implements the tzinfo interface by returning a fixed UTC

  offset and timezone name. This makes it easier to create timezone-aware

  datetime objects:

  >>> fromdatetimeimportdatetime,timezone
  >>> datetime.now(timezone.utc)
  datetime.datetime(2010, 12, 8, 21, 4, 2, 923754, tzinfo=datetime.timezone.utc)
  >>> datetime.strptime("01/01/2000 12:00 +0000","%m/%d/%Y %H:%M %z")
  datetime.datetime(2000, 1, 1, 12, 0, tzinfo=datetime.timezone.utc)
  

• Also, timedelta objects can now be multiplied by

  float and divided by float and int objects.

  And timedelta objects can now divide one another.

• The datetime.date.strftime() method is no longer restricted to years

  after 1900. The new supported year range is from 1000 to 9999 inclusive.

• Whenever a two-digit year is used in a time tuple, the interpretation has been

  governed by time.accept2dyear. The default is True which means that

  for a two-digit year, the century is guessed according to the POSIX rules

  governing the %y strptime format.

  Starting with Py3.2, use of the century guessing heuristic will emit a

  DeprecationWarning. Instead, it is recommended that

  time.accept2dyear be set to False so that large date ranges

  can be used without guesswork:

  >>> importtime,warnings
  >>> warnings.resetwarnings()# remove the default warning filters
  >>> time.accept2dyear=True# guess whether 11 means 11 or 2011
  >>> time.asctime((11,1,1,12,34,56,4,1,0))
  Warning (from warnings module):
    ...
  DeprecationWarning: Century info guessed for a 2-digit year.
  'Fri Jan  1 12:34:56 2011'
  >>> time.accept2dyear=False# use the full range of allowable dates
  >>> time.asctime((11,1,1,12,34,56,4,1,0))
  'Fri Jan  1 12:34:56 11'
  

  Several functions now have significantly expanded date ranges. When

  time.accept2dyear is false, the time.asctime() function will

  accept any year that fits in a C int, while the time.mktime() and

  time.strftime() functions will accept the full range supported by the

  corresponding operating system functions.

(Contributed by Alexander Belopolsky and Victor Stinner in bpo-1289118,

bpo-5094, bpo-6641, bpo-2706, bpo-1777412, bpo-8013,

and bpo-10827.)

math¶

The math module has been updated with six new functions inspired by the

C99 standard.

The isfinite() function provides a reliable and fast way to detect

special values. It returns True for regular numbers and False for Nan or

Infinity:

>>> frommathimportisfinite
>>> [isfinite(x)forxin(123,4.56,float('Nan'),float('Inf'))]
[True, True, False, False]

The expm1() function computes e**x-1 for small values of x

without incurring the loss of precision that usually accompanies the subtraction

of nearly equal quantities:

>>> frommathimportexpm1
>>> expm1(0.013671875)# more accurate way to compute e**x-1 for a small x
0.013765762467652909

The erf() function computes a probability integral or Gaussian

error function. The

complementary error function, erfc(), is 1-erf(x):

>>> frommathimporterf,erfc,sqrt
>>> erf(1.0/sqrt(2.0))# portion of normal distribution within 1 standard deviation
0.682689492137086
>>> erfc(1.0/sqrt(2.0))# portion of normal distribution outside 1 standard deviation
0.31731050786291404
>>> erf(1.0/sqrt(2.0))+erfc(1.0/sqrt(2.0))
1.0

The gamma() function is a continuous extension of the factorial

function. See https://en.wikipedia.org/wiki/Gamma_function for details. Because

the function is related to factorials, it grows large even for small values of

x, so there is also a lgamma() function for computing the natural

logarithm of the gamma function:

>>> frommathimportgamma,lgamma
>>> gamma(7.0)# six factorial
720.0
>>> lgamma(801.0)# log(800 factorial)
4551.950730698041

（由 Mark Dickinson 贡献）

abc¶

The abc module now supports abstractclassmethod() and

abstractstaticmethod().

These tools make it possible to define an abstract base class that

requires a particular classmethod() or staticmethod() to be

implemented:

classTemperature(metaclass=abc.ABCMeta):
@abc.abstractclassmethod
deffrom_fahrenheit(cls,t):
...
@abc.abstractclassmethod
deffrom_celsius(cls,t):
...

(Patch submitted by Daniel Urban; bpo-5867.)

io¶

The io.BytesIO has a new method, getbuffer(), which

provides functionality similar to memoryview(). It creates an editable

view of the data without making a copy. The buffer's random access and support

for slice notation are well-suited to in-place editing:

>>> REC_LEN,LOC_START,LOC_LEN=34,7,11
>>> defchange_location(buffer,record_number,location):
... start=record_number*REC_LEN+LOC_START
... buffer[start:start+LOC_LEN]=location
>>> importio
>>> byte_stream=io.BytesIO(
... b'G3805  storeroom  Main chassis    '
... b'X7899  shipping   Reserve cog     '
... b'L6988  receiving  Primary sprocket'
... )
>>> buffer=byte_stream.getbuffer()
>>> change_location(buffer,1,b'warehouse  ')
>>> change_location(buffer,0,b'showroom   ')
>>> print(byte_stream.getvalue())
b'G3805  showroom   Main chassis    '
b'X7899  warehouse  Reserve cog     '
b'L6988  receiving  Primary sprocket'

（由 Antoine Pitrou 在 bpo-5506 中贡献。）

reprlib¶

When writing a __repr__() method for a custom container, it is easy to

forget to handle the case where a member refers back to the container itself.

Python's builtin objects such as list and set handle

self-reference by displaying "..." in the recursive part of the representation

string.

To help write such __repr__() methods, the reprlib module has a new

decorator, recursive_repr(), for detecting recursive calls to

__repr__() and substituting a placeholder string instead:

>>> classMyList(list):
... @recursive_repr()
... def__repr__(self):
... return'<'+'|'.join(map(repr,self))+'>'
...
>>> m=MyList('abc')
>>> m.append(m)
>>> m.append('x')
>>> print(m)
<'a'|'b'|'c'|...|'x'>

（由 Raymond Hettinger 在 bpo-9826 和 bpo-9826 中贡献。）

logging¶

In addition to dictionary-based configuration described above, the

logging package has many other improvements.

The logging documentation has been augmented by a basic tutorial, an advanced tutorial, and a cookbook of

logging recipes. These documents are the fastest way to learn about logging.

The logging.basicConfig() set-up function gained a style argument to

support three different types of string formatting. It defaults to "%" for

traditional %-formatting, can be set to "{" for the new str.format() style, or

can be set to "$" for the shell-style formatting provided by

string.Template. The following three configurations are equivalent:

>>> fromloggingimportbasicConfig
>>> basicConfig(style='%',format="%(name)s -> %(levelname)s: %(message)s")
>>> basicConfig(style='{',format="{name} -> {levelname}{message}")
>>> basicConfig(style='$',format="$name -> $levelname: $message")

If no configuration is set-up before a logging event occurs, there is now a

default configuration using a StreamHandler directed to

sys.stderr for events of WARNING level or higher. Formerly, an

event occurring before a configuration was set-up would either raise an

exception or silently drop the event depending on the value of

logging.raiseExceptions. The new default handler is stored in

logging.lastResort.

The use of filters has been simplified. Instead of creating a

Filter object, the predicate can be any Python callable that

returns True or False.

There were a number of other improvements that add flexibility and simplify

configuration. See the module documentation for a full listing of changes in

Python 3.2.

csv¶

The csv module now supports a new dialect, unix_dialect,

which applies quoting for all fields and a traditional Unix style with '\n' as

the line terminator. The registered dialect name is unix.

The csv.DictWriter has a new method,

writeheader() for writing-out an initial row to document

the field names:

>>> importcsv,sys
>>> w=csv.DictWriter(sys.stdout,['name','dept'],dialect='unix')
>>> w.writeheader()
"name","dept"
>>> w.writerows([
... {'name':'tom','dept':'accounting'},
... {'name':'susan','dept':'Salesl'}])
"tom","accounting"
"susan","sales"

(New dialect suggested by Jay Talbot in bpo-5975, and the new method

suggested by Ed Abraham in bpo-1537721.)

contextlib¶

There is a new and slightly mind-blowing tool

ContextDecorator that is helpful for creating a

context manager that does double duty as a function decorator.

As a convenience, this new functionality is used by

contextmanager() so that no extra effort is needed to support

both roles.

The basic idea is that both context managers and function decorators can be used

for pre-action and post-action wrappers. Context managers wrap a group of

statements using a with statement, and function decorators wrap a

group of statements enclosed in a function. So, occasionally there is a need to

write a pre-action or post-action wrapper that can be used in either role.

For example, it is sometimes useful to wrap functions or groups of statements

with a logger that can track the time of entry and time of exit. Rather than

writing both a function decorator and a context manager for the task, the

contextmanager() provides both capabilities in a single

definition:

fromcontextlibimportcontextmanager
importlogging
logging.basicConfig(level=logging.INFO)
@contextmanager
deftrack_entry_and_exit(name):
logging.info('Entering: %s',name)
yield
logging.info('Exiting: %s',name)

Formerly, this would have only been usable as a context manager:

withtrack_entry_and_exit('widget loader'):
print('Some time consuming activity goes here')
load_widget()

Now, it can be used as a decorator as well:

@track_entry_and_exit('widget loader')
defactivity():
print('Some time consuming activity goes here')
load_widget()

Trying to fulfill two roles at once places some limitations on the technique.

Context managers normally have the flexibility to return an argument usable by

a with statement, but there is no parallel for function decorators.

In the above example, there is not a clean way for the track_entry_and_exit

context manager to return a logging instance for use in the body of enclosed

statements.

（由 Michael Foord 在 bpo-9110 中贡献。）

decimal and fractions¶

Mark Dickinson crafted an elegant and efficient scheme for assuring that

different numeric datatypes will have the same hash value whenever their actual

values are equal (bpo-8188):

asserthash(Fraction(3,2))==hash(1.5)== \
hash(Decimal("1.5"))==hash(complex(1.5,0))

Some of the hashing details are exposed through a new attribute,

sys.hash_info, which describes the bit width of the hash value, the

prime modulus, the hash values for infinity and nan, and the multiplier

used for the imaginary part of a number:

>>> sys.hash_info
sys.hash_info(width=64, modulus=2305843009213693951, inf=314159, nan=0, imag=1000003)

An early decision to limit the inter-operability of various numeric types has

been relaxed. It is still unsupported (and ill-advised) to have implicit

mixing in arithmetic expressions such as Decimal('1.1')+float('1.1')

because the latter loses information in the process of constructing the binary

float. However, since existing floating point value can be converted losslessly

to either a decimal or rational representation, it makes sense to add them to

the constructor and to support mixed-type comparisons.

• The decimal.Decimal constructor now accepts float objects

  directly so there in no longer a need to use the from_float()

  method (bpo-8257).

• Mixed type comparisons are now fully supported so that

  Decimal objects can be directly compared with float

  and fractions.Fraction (bpo-2531 and bpo-8188).

Similar changes were made to fractions.Fraction so that the

from_float() and from_decimal()

methods are no longer needed (bpo-8294):

>>> fromdecimalimportDecimal
>>> fromfractionsimportFraction
>>> Decimal(1.1)
Decimal('1.100000000000000088817841970012523233890533447265625')
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248)

Another useful change for the decimal module is that the

Context.clamp attribute is now public. This is useful in creating

contexts that correspond to the decimal interchange formats specified in IEEE

754 (see bpo-8540).

（由 Mark Dickinson 和 Raymond Hettinger贡献。）

ftp¶

The ftplib.FTP class now supports the context management protocol to

unconditionally consume socket.error exceptions and to close the FTP

connection when done:

>>> fromftplibimportFTP
>>> withFTP("ftp1.at.proftpd.org")asftp:
        ftp.login()
        ftp.dir()
'230 Anonymous login ok, restrictions apply.'
dr-xr-xr-x   9 ftp      ftp           154 May  6 10:43 .
dr-xr-xr-x   9 ftp      ftp           154 May  6 10:43 ..
dr-xr-xr-x   5 ftp      ftp          4096 May  6 10:43 CentOS
dr-xr-xr-x   3 ftp      ftp            18 Jul 10  2008 Fedora

Other file-like objects such as mmap.mmap and fileinput.input()

also grew auto-closing context managers:

withfileinput.input(files=('log1.txt','log2.txt'))asf:
forlineinf:
process(line)

（由 Tarek Ziadé 和 Giampaolo Rodolà 在 bpo-4972`贡献，由 Georg Brandl 在 :issue:`8046 和 bpo-1286 贡献。）

The FTP_TLS class now accepts a context parameter, which is a

ssl.SSLContext object allowing bundling SSL configuration options,

certificates and private keys into a single (potentially long-lived) structure.

（由 Giampaolo Rodolà 在 bpo-8806 中贡献。）

popen¶

The os.popen() and subprocess.Popen() functions now support

with statements for auto-closing of the file descriptors.

（由 Antoine Pitrou 和 Brian Curtin 在 bpo-7461 和 bpo-10554 中贡献。）

select¶

The select module now exposes a new, constant attribute,

PIPE_BUF, which gives the minimum number of bytes which are

guaranteed not to block when select.select() says a pipe is ready

for writing.

>>> importselect
>>> select.PIPE_BUF
512

(Available on Unix systems. Patch by Sébastien Sablé in bpo-9862)

gzip 和 zipfile¶

gzip.GzipFile now implements the io.BufferedIOBase

abstract base class (except for truncate()). It also has a

peek() method and supports unseekable as well as

zero-padded file objects.

The gzip module also gains the compress() and

decompress() functions for easier in-memory compression and

decompression. Keep in mind that text needs to be encoded as bytes

before compressing and decompressing:

>>> importgzip
>>> s='Three shall be the number thou shalt count, '
>>> s+='and the number of the counting shall be three'
>>> b=s.encode()# convert to utf-8
>>> len(b)
89
>>> c=gzip.compress(b)
>>> len(c)
77
>>> gzip.decompress(c).decode()[:42]# decompress and convert to text
'Three shall be the number thou shalt count'

（由 Anand B. Pillai 在 bpo-3488 中贡献，由Antoine Pitrou, Nir Aides 和 Brian Curtin 在 bpo-9962，bpo-1675951 ，bpo-7471 和 bpo-2846 中贡献。）

Also, the zipfile.ZipExtFile class was reworked internally to represent

files stored inside an archive. The new implementation is significantly faster

and can be wrapped in an io.BufferedReader object for more speedups. It

also solves an issue where interleaved calls to read and readline gave the

wrong results.

(Patch submitted by Nir Aides in bpo-7610.)

tarfile¶

The TarFile class can now be used as a context manager. In

addition, its add() method has a new option, filter,

that controls which files are added to the archive and allows the file metadata

to be edited.

The new filter option replaces the older, less flexible exclude parameter

which is now deprecated. If specified, the optional filter parameter needs to

be a keyword argument. The user-supplied filter function accepts a

TarInfo object and returns an updated

TarInfo object, or if it wants the file to be excluded, the

function can return None:

>>> importtarfile,glob
>>> defmyfilter(tarinfo):
... iftarinfo.isfile():# only save real files
... tarinfo.uname='monty'# redact the user name
... returntarinfo
>>> withtarfile.open(name='myarchive.tar.gz',mode='w:gz')astf:
... forfilenameinglob.glob('*.txt'):
... tf.add(filename,filter=myfilter)
... tf.list()
-rw-r--r-- monty/501        902 2011-01-26 17:59:11 annotations.txt
-rw-r--r-- monty/501        123 2011-01-26 17:59:11 general_questions.txt
-rw-r--r-- monty/501       3514 2011-01-26 17:59:11 prion.txt
-rw-r--r-- monty/501        124 2011-01-26 17:59:11 py_todo.txt
-rw-r--r-- monty/501       1399 2011-01-26 17:59:11 semaphore_notes.txt

(Proposed by Tarek Ziadé and implemented by Lars Gustäbel in bpo-6856.)

hashlib¶

The hashlib module has two new constant attributes listing the hashing

algorithms guaranteed to be present in all implementations and those available

on the current implementation:

>>> importhashlib
>>> hashlib.algorithms_guaranteed
{'sha1', 'sha224', 'sha384', 'sha256', 'sha512', 'md5'}
>>> hashlib.algorithms_available
{'md2', 'SHA256', 'SHA512', 'dsaWithSHA', 'mdc2', 'SHA224', 'MD4', 'sha256',
'sha512', 'ripemd160', 'SHA1', 'MDC2', 'SHA', 'SHA384', 'MD2',
'ecdsa-with-SHA1','md4', 'md5', 'sha1', 'DSA-SHA', 'sha224',
'dsaEncryption', 'DSA', 'RIPEMD160', 'sha', 'MD5', 'sha384'}

（由 Carl Chenet 在 bpo-7418 中建议。）

ast¶

The ast module has a wonderful a general-purpose tool for safely

evaluating expression strings using the Python literal

syntax. The ast.literal_eval() function serves as a secure alternative to

the builtin eval() function which is easily abused. Python 3.2 adds

bytes and set literals to the list of supported types:

strings, bytes, numbers, tuples, lists, dicts, sets, booleans, and None.

>>> fromastimportliteral_eval
>>> request="{'req': 3, 'func': 'pow', 'args': (2, 0.5)}"
>>> literal_eval(request)
{'args': (2, 0.5), 'req': 3, 'func': 'pow'}
>>> request="os.system('do something harmful')"
>>> literal_eval(request)
Traceback (most recent call last):
...
ValueError: malformed node or string: <_ast.Call object at 0x101739a10>

（由Benjamin Peterson 和 Georg Brandl 实现。）

os¶

Different operating systems use various encodings for filenames and environment

variables. The os module provides two new functions,

fsencode() and fsdecode(), for encoding and decoding

filenames:

>>> importos
>>> filename='Sehenswürdigkeiten'
>>> os.fsencode(filename)
b'Sehensw\xc3\xbcrdigkeiten'

Some operating systems allow direct access to encoded bytes in the

environment. If so, the os.supports_bytes_environ constant will be

true.

For direct access to encoded environment variables (if available),

use the new os.getenvb() function or use os.environb

which is a bytes version of os.environ.

（由 Victor Stinner 贡献。）

shutil¶

The shutil.copytree() function has two new options:

• ignore_dangling_symlinks: when symlinks=False so that the function

  copies a file pointed to by a symlink, not the symlink itself. This option

  will silence the error raised if the file doesn't exist.

• copy_function: is a callable that will be used to copy files.

  shutil.copy2() is used by default.

（由 Tarek Ziadé 贡献。）

In addition, the shutil module now supports archiving operations for zipfiles, uncompressed tarfiles, gzipped tarfiles,

and bzipped tarfiles. And there are functions for registering additional

archiving file formats (such as xz compressed tarfiles or custom formats).

The principal functions are make_archive() and

unpack_archive(). By default, both operate on the current

directory (which can be set by os.chdir()) and on any sub-directories.

The archive filename needs to be specified with a full pathname. The archiving

step is non-destructive (the original files are left unchanged).

>>> importshutil,pprint
>>> os.chdir('mydata')# change to the source directory
>>> f=shutil.make_archive('/var/backup/mydata',
... 'zip')# archive the current directory
>>> f# show the name of archive
'/var/backup/mydata.zip'
>>> os.chdir('tmp')# change to an unpacking
>>> shutil.unpack_archive('/var/backup/mydata.zip')# recover the data
>>> pprint.pprint(shutil.get_archive_formats())# display known formats
[('bztar', "bzip2'ed tar-file"),
 ('gztar', "gzip'ed tar-file"),
 ('tar', 'uncompressed tar file'),
 ('zip', 'ZIP file')]
>>> shutil.register_archive_format(# register a new archive format
... name='xz',
... function=xz.compress,# callable archiving function
... extra_args=[('level',8)],# arguments to the function
... description='xz compression'
... )

（由 Tarek Ziadé 贡献。）

sqlite3¶

The sqlite3 module was updated to pysqlite version 2.6.0. It has two new capabilities.

• The sqlite3.Connection.in_transit attribute is true if there is an

  active transaction for uncommitted changes.

• The sqlite3.Connection.enable_load_extension() and

  sqlite3.Connection.load_extension() methods allows you to load SQLite

  extensions from ".so" files. One well-known extension is the fulltext-search

  extension distributed with SQLite.

（由 R. David Murray 和 Shashwat Anand 在 bpo-4739 中贡献。）

html¶

A new html module was introduced with only a single function,

escape(), which is used for escaping reserved characters from HTML

markup:

>>> importhtml
>>> html.escape('x > 2 && x < 7')
'x &gt; 2 &amp;&amp; x &lt; 7'

withtempfile.TemporaryDirectory()astmpdirname:
print('created temporary dir:',tmpdirname)

$ pydoc3.2 -b

>>> importdis,random
>>> dis.show_code(random.choice)
Name:              choice
Filename:          /Library/Frameworks/Python.framework/Versions/3.2/lib/python3.2/random.py
Argument count:    2
Kw-only arguments: 0
Number of locals:  3
Stack size:        11
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: 'Choose a random element from a non-empty sequence.'
   1: 'Cannot choose from an empty sequence'
Names:
   0: _randbelow
   1: len
   2: ValueError
   3: IndexError
Variable names:
   0: self
   1: seq
   2: i

>>> dis('3*x+1 if x%2==1 else x//2')
  1           0 LOAD_NAME                0 (x)
              3 LOAD_CONST               0 (2)
              6 BINARY_MODULO
              7 LOAD_CONST               1 (1)
             10 COMPARE_OP               2 (==)
             13 POP_JUMP_IF_FALSE       28
             16 LOAD_CONST               2 (3)
             19 LOAD_NAME                0 (x)
             22 BINARY_MULTIPLY
             23 LOAD_CONST               1 (1)
             26 BINARY_ADD
             27 RETURN_VALUE
        >>   28 LOAD_NAME                0 (x)
             31 LOAD_CONST               0 (2)
             34 BINARY_FLOOR_DIVIDE
             35 RETURN_VALUE

>>> importsite
>>> site.getsitepackages()
['/Library/Frameworks/Python.framework/Versions/3.2/lib/python3.2/site-packages',
 '/Library/Frameworks/Python.framework/Versions/3.2/lib/site-python',
 '/Library/Python/3.2/site-packages']
>>> site.getuserbase()
'/Users/raymondhettinger/Library/Python/3.2'
>>> site.getusersitepackages()
'/Users/raymondhettinger/Library/Python/3.2/lib/python/site-packages'

$ python -m site --user-base
/Users/raymondhettinger/.local
$ python -m site --user-site
/Users/raymondhettinger/.local/lib/python3.2/site-packages

C:\Python32>python -m sysconfig
Platform: "win32"
Python version: "3.2"
Current installation scheme: "nt"
Paths:
        data = "C:\Python32"
        include = "C:\Python32\Include"
        platinclude = "C:\Python32\Include"
        platlib = "C:\Python32\Lib\site-packages"
        platstdlib = "C:\Python32\Lib"
        purelib = "C:\Python32\Lib\site-packages"
        scripts = "C:\Python32\Scripts"
        stdlib = "C:\Python32\Lib"
Variables:
        BINDIR = "C:\Python32"
        BINLIBDEST = "C:\Python32\Lib"
        EXE = ".exe"
        INCLUDEPY = "C:\Python32\Include"
        LIBDEST = "C:\Python32\Lib"
        SO = ".pyd"
        VERSION = "32"
        abiflags = ""
        base = "C:\Python32"
        exec_prefix = "C:\Python32"
        platbase = "C:\Python32"
        prefix = "C:\Python32"
        projectbase = "C:\Python32"
        py_version = "3.2"
        py_version_nodot = "32"
        py_version_short = "3.2"
        srcdir = "C:\Python32"
        userbase = "C:\Documents and Settings\Raymond\Application Data\Python"

>>> parser=ConfigParser()
>>> parser.read_string("""
... [DEFAULT]
... location = upper left
... visible = yes
... editable = no
... color = blue
...
... [main]
... title = Main Menu
... color = green
...
... [options]
... title = Options
... """)
>>> parser['main']['color']
'green'
>>> parser['main']['editable']
'no'
>>> section=parser['options']
>>> section['title']
'Options'
>>> section['title']='Options (editable: %(editable)s)'
>>> section['title']
'Options (editable: no)'

>>> parser=ConfigParser(interpolation=ExtendedInterpolation())
>>> parser.read_dict({'buildout':{'directory':'/home/ambv/zope9'},
... 'custom':{'prefix':'/usr/local'}})
>>> parser.read_string("""
... [buildout]
... parts =
...   zope9
...   instance
... find-links =
...   ${buildout:directory}/downloads/dist
...
... [zope9]
... recipe = plone.recipe.zope9install
... location = /opt/zope
...
... [instance]
... recipe = plone.recipe.zope9instance
... zope9-location = ${zope9:location}
... zope-conf = ${custom:prefix}/etc/zope.conf
... """)
>>> parser['buildout']['find-links']
'\n/home/ambv/zope9/downloads/dist'
>>> parser['instance']['zope-conf']
'/usr/local/etc/zope.conf'
>>> instance=parser['instance']
>>> instance['zope-conf']
'/usr/local/etc/zope.conf'
>>> instance['zope9-location']
'/opt/zope'

>>> importurllib.parse
>>> urllib.parse.urlparse('http://[dead:beef:cafe:5417:affe:8FA3:deaf:feed]/foo/')
ParseResult(scheme='http',
            netloc='[dead:beef:cafe:5417:affe:8FA3:deaf:feed]',
            path='/foo/',
            params='',
            query='',
            fragment='')

>>> r=urllib.parse.urldefrag('http://python.org/about/#target')
>>> r
DefragResult(url='http://python.org/about/', fragment='target')
>>> r[0]
'http://python.org/about/'
>>> r.fragment
'target'

>>> urllib.parse.urlencode([
... ('type','telenovela'),
... ('name','¿Dónde Está Elisa?')],
... encoding='latin-1')
'type=telenovela&name=%BFD%F3nde+Est%E1+Elisa%3F'

>>> urllib.parse.urlparse(b'http://www.python.org:80/about/')
ParseResultBytes(scheme=b'http', netloc=b'www.python.org:80',
                 path=b'/about/', params=b'', query=b'', fragment=b'')

$ python -m turtledemo