Index: whatsnew/2.6.rst =================================================================== --- whatsnew/2.6.rst (revision 66816) +++ whatsnew/2.6.rst (working copy) @@ -662,33 +662,33 @@ from multiprocessing import Pool, Manager def factorial(N, dictionary): - "Compute a factorial." - # Calculate the result - fact = 1L - for i in range(1, N+1): - fact = fact * i + "Compute a factorial." + # Calculate the result + fact = 1L + for i in range(1, N+1): + fact = fact * i # Store result in dictionary - dictionary[N] = fact + dictionary[N] = fact if __name__ == '__main__': - p = Pool(5) - mgr = Manager() - d = mgr.dict() # Create shared dictionary + p = Pool(5) + mgr = Manager() + d = mgr.dict() # Create shared dictionary - # Run tasks using the pool - for N in range(1, 1000, 10): - p.apply_async(factorial, (N, d)) + # Run tasks using the pool + for N in range(1, 1000, 10): + p.apply_async(factorial, (N, d)) - # Mark pool as closed -- no more tasks can be added. - p.close() + # Mark pool as closed -- no more tasks can be added. + p.close() - # Wait for tasks to exit - p.join() + # Wait for tasks to exit + p.join() - # Output results - for k, v in sorted(d.items()): - print k, v + # Output results + for k, v in sorted(d.items()): + print k, v This will produce the output:: @@ -723,32 +723,33 @@ treats the string as a template and takes the arguments to be formatted. The formatting template uses curly brackets (`{`, `}`) as special characters:: - # Substitute positional argument 0 into the string. - "User ID: {0}".format("root") -> "User ID: root" + >>> # Substitute positional argument 0 into the string. + >>> "User ID: {0}".format("root") + 'User ID: root' + >>> # Use the named keyword arguments + >>> "User ID: {uid} Last seen: {last_login}".format( + ... uid="root", + ... last_login = "5 Mar 2008 07:20") + 'User ID: root Last seen: 5 Mar 2008 07:20' - # Use the named keyword arguments - 'User ID: {uid} Last seen: {last_login}'.format( - uid='root', - last_login = '5 Mar 2008 07:20') -> - 'User ID: root Last seen: 5 Mar 2008 07:20' - Curly brackets can be escaped by doubling them:: - format("Empty dict: {{}}") -> "Empty dict: {}" + >>> format("Empty dict: {{}}") + "Empty dict: {}" Field names can be integers indicating positional arguments, such as ``{0}``, ``{1}``, etc. or names of keyword arguments. You can also supply compound field names that read attributes or access dictionary keys:: - import sys - 'Platform: {0.platform}\nPython version: {0.version}'.format(sys) -> - 'Platform: darwin\n - Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41) \n - [GCC 4.0.1 (Apple Computer, Inc. build 5367)]' + >>> import sys + >>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys) + Platform: darwin + Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41) + [GCC 4.0.1 (Apple Computer, Inc. build 5367)]' - import mimetypes - 'Content-type: {0[.mp4]}'.format(mimetypes.types_map) -> - 'Content-type: video/mp4' + >>> import mimetypes + >>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map) + 'Content-type: video/mp4' Note that when using dictionary-style notation such as ``[.mp4]``, you don't need to put any quotation marks around the string; it will look @@ -760,31 +761,26 @@ resulting string. The precise formatting used is also controllable by adding a colon followed by a format specifier. For example:: - # Field 0: left justify, pad to 15 characters - # Field 1: right justify, pad to 6 characters - fmt = '{0:15} ${1:>6}' + >>> # Field 0: left justify, pad to 15 characters + >>> # Field 1: right justify, pad to 6 characters + >>> fmt = '{0:15} ${1:>6}' + >>> fmt.format('Registration', 35) + 'Registration $ 35' + >>> fmt.format('Tutorial', 50) + 'Tutorial $ 50' + >>> fmt.format('Banquet', 125) + 'Banquet $ 125' - fmt.format('Registration', 35) -> - 'Registration $ 35' - - fmt.format('Tutorial', 50) -> - 'Tutorial $ 50' - - fmt.format('Banquet', 125) -> - 'Banquet $ 125' - Format specifiers can reference other fields through nesting:: - fmt = '{0:{1}}' + >>> fmt = '{0:{1}}' + >>> width = 15 + >>> fmt.format('Invoice #1234', width) + 'Invoice #1234 ' + >>> width = 35 + >>> fmt.format('Invoice #1234', width) + 'Invoice #1234 ' - width = 15 - fmt.format('Invoice #1234', width) -> - 'Invoice #1234 ' - - width = 35 - fmt.format('Invoice #1234', width) -> - 'Invoice #1234 ' - The alignment of a field within the desired width can be specified: ================ ============================================ @@ -798,7 +794,7 @@ Format specifiers can also include a presentation type, which controls how the value is formatted. For example, floating-point numbers -can be formatted as a general number or in exponential notation: +can be formatted as a general number or in exponential notation:: >>> '{0:g}'.format(3.75) '3.75' @@ -806,25 +802,27 @@ '3.750000e+00' A variety of presentation types are available. Consult the 2.6 -documentation for a :ref:`complete list `; here's a sample:: +documentation for a :ref:`complete list `; here's a sample: - 'b' - Binary. Outputs the number in base 2. - 'c' - Character. Converts the integer to the corresponding - Unicode character before printing. - 'd' - Decimal Integer. Outputs the number in base 10. - 'o' - Octal format. Outputs the number in base 8. - 'x' - Hex format. Outputs the number in base 16, using lower- - case letters for the digits above 9. - 'e' - Exponent notation. Prints the number in scientific - notation using the letter 'e' to indicate the exponent. - 'g' - General format. This prints the number as a fixed-point - number, unless the number is too large, in which case - it switches to 'e' exponent notation. - 'n' - Number. This is the same as 'g' (for floats) or 'd' (for - integers), except that it uses the current locale setting to - insert the appropriate number separator characters. - '%' - Percentage. Multiplies the number by 100 and displays - in fixed ('f') format, followed by a percent sign. +===== ======================================================================== +``b`` Binary. Outputs the number in base 2. +``c`` Character. Converts the integer to the corresponding Unicode character + before printing. +``d`` Decimal Integer. Outputs the number in base 10. +``o`` Octal format. Outputs the number in base 8. +``x`` Hex format. Outputs the number in base 16, using lower-case letters for + the digits above 9. +``e`` Exponent notation. Prints the number in scientific notation using the + letter 'e' to indicate the exponent. +``g`` General format. This prints the number as a fixed-point number, unless + the number is too large, in which case it switches to 'e' exponent + notation. +``n`` Number. This is the same as 'g' (for floats) or 'd' (for integers), + except that it uses the current locale setting to insert the appropriate + number separator characters. +``%`` Percentage. Multiplies the number by 100 and displays in fixed ('f') + format, followed by a percent sign. +===== ======================================================================== Classes and types can define a :meth:`__format__` method to control how they're formatted. It receives a single argument, the format specifier:: @@ -865,13 +863,14 @@ Python 2.6 has a ``__future__`` import that removes ``print`` as language syntax, letting you use the functional form instead. For example:: - from __future__ import print_function - print('# of entries', len(dictionary), file=sys.stderr) + >>> from __future__ import print_function + >>> print('# of entries', len(dictionary), file=sys.stderr) The signature of the new function is:: def print(*args, sep=' ', end='\n', file=None) + The parameters are: * *args*: positional arguments whose values will be printed out. @@ -988,6 +987,8 @@ and some of the methods of lists, such as :meth:`append`, :meth:`pop`, and :meth:`reverse`. +:: + >>> b = bytearray('ABC') >>> b.append('d') >>> b.append(ord('e')) @@ -1210,8 +1211,8 @@ now write:: def func(d): - if not isinstance(d, collections.MutableMapping): - raise ValueError("Mapping object expected, not %r" % d) + if not isinstance(d, collections.MutableMapping): + raise ValueError("Mapping object expected, not %r" % d) Don't feel that you must now begin writing lots of checks as in the above example. Python has a strong tradition of duck-typing, where @@ -1223,22 +1224,22 @@ You can write your own ABCs by using ``abc.ABCMeta`` as the metaclass in a class definition:: - from abc import ABCMeta, abstractmethod + from abc import ABCMeta, abstractmethod - class Drawable(): - __metaclass__ = ABCMeta + class Drawable(): + __metaclass__ = ABCMeta - @abstractmethod - def draw(self, x, y, scale=1.0): - pass + @abstractmethod + def draw(self, x, y, scale=1.0): + pass - def draw_doubled(self, x, y): - self.draw(x, y, scale=2.0) + def draw_doubled(self, x, y): + self.draw(x, y, scale=2.0) - class Square(Drawable): - def draw(self, x, y, scale): - ... + class Square(Drawable): + def draw(self, x, y, scale): + ... In the :class:`Drawable` ABC above, the :meth:`draw_doubled` method @@ -1258,7 +1259,7 @@ >>> class Circle(Drawable): ... pass ... - >>> c=Circle() + >>> c = Circle() Traceback (most recent call last): File "", line 1, in TypeError: Can't instantiate abstract class Circle with abstract methods draw @@ -1317,7 +1318,7 @@ The :func:`int` and :func:`long` built-ins will now accept the "0o" and "0b" prefixes when base-8 or base-2 are requested, or when the *base* argument is zero (signalling that the base used should be -determined from the string): +determined from the string):: >>> int ('0o52', 0) 42 @@ -1490,7 +1491,7 @@ (Contributed by Alexander Belopolsky; :issue:`1686487`.) It's also become legal to provide keyword arguments after a ``*args`` argument - to a function call. + to a function call. :: >>> def f(*args, **kw): ... print args, kw @@ -1531,17 +1532,17 @@ property. You would use them like this:: class C(object): - @property - def x(self): - return self._x + @property + def x(self): + return self._x - @x.setter - def x(self, value): - self._x = value + @x.setter + def x(self, value): + self._x = value - @x.deleter - def x(self): - del self._x + @x.deleter + def x(self): + del self._x class D(C): @C.x.getter @@ -1864,8 +1865,8 @@ >>> var_type = collections.namedtuple('variable', ... 'id name type size') - # Names are separated by spaces or commas. - # 'id, name, type, size' would also work. + >>> # Names are separated by spaces or commas. + >>> # 'id, name, type, size' would also work. >>> var_type._fields ('id', 'name', 'type', 'size') @@ -1915,11 +1916,13 @@ * A new window method in the :mod:`curses` module, :meth:`chgat`, changes the display attributes for a certain number of - characters on a single line. (Contributed by Fabian Kreutz.) :: + characters on a single line. (Contributed by Fabian Kreutz.) + + :: # Boldface text starting at y=0,x=21 # and affecting the rest of the line. - stdscr.chgat(0,21, curses.A_BOLD) + stdscr.chgat(0, 21, curses.A_BOLD) The :class:`Textbox` class in the :mod:`curses.textpad` module now supports editing in insert mode as well as overwrite mode. @@ -1985,8 +1988,8 @@ order, and returns a new generator that returns the contents of all the iterators, also in sorted order. For example:: - heapq.merge([1, 3, 5, 9], [2, 8, 16]) -> - [1, 2, 3, 5, 8, 9, 16] + >>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16])) + [1, 2, 3, 5, 8, 9, 16] Another new function, ``heappushpop(heap, item)``, pushes *item* onto *heap*, then pops off and returns the smallest item. @@ -2020,57 +2023,55 @@ each of the elements; if some of the iterables are shorter than others, the missing values are set to *fillvalue*. For example:: - itertools.izip_longest([1,2,3], [1,2,3,4,5]) -> - (1, 1), (2, 2), (3, 3), (None, 4), (None, 5) + >>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5])) + ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5)) ``product(iter1, iter2, ..., [repeat=N])`` returns the Cartesian product of the supplied iterables, a set of tuples containing every possible combination of the elements returned from each iterable. :: - itertools.product([1,2,3], [4,5,6]) -> - (1, 4), (1, 5), (1, 6), - (2, 4), (2, 5), (2, 6), - (3, 4), (3, 5), (3, 6) + >>> list(itertools.product([1,2,3], [4,5,6])) + [(1, 4), (1, 5), (1, 6), + (2, 4), (2, 5), (2, 6), + (3, 4), (3, 5), (3, 6)] The optional *repeat* keyword argument is used for taking the product of an iterable or a set of iterables with themselves, repeated *N* times. With a single iterable argument, *N*-tuples are returned:: - itertools.product([1,2], repeat=3) -> - (1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), - (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2) + >>> list(itertools.product([1,2], repeat=3)) + [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), + (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)] With two iterables, *2N*-tuples are returned. :: - itertools.product([1,2], [3,4], repeat=2) -> - (1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4), - (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4), - (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4), - (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4) + >>> list(itertools.product([1,2], [3,4], repeat=2)) + [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4), + (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4), + (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4), + (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)] ``combinations(iterable, r)`` returns sub-sequences of length *r* from the elements of *iterable*. :: - itertools.combinations('123', 2) -> - ('1', '2'), ('1', '3'), ('2', '3') + >>> list(itertools.combinations('123', 2)) + [('1', '2'), ('1', '3'), ('2', '3')] + >>> list(itertools.combinations('123', 3)) + [('1', '2', '3')] + >>> list(itertools.combinations('1234', 3)) + [('1', '2', '3'), ('1', '2', '4'), + ('1', '3', '4'), ('2', '3', '4')] - itertools.combinations('123', 3) -> - ('1', '2', '3') - - itertools.combinations('1234', 3) -> - ('1', '2', '3'), ('1', '2', '4'), ('1', '3', '4'), - ('2', '3', '4') - ``permutations(iter[, r])`` returns all the permutations of length *r* of the iterable's elements. If *r* is not specified, it will default to the number of elements produced by the iterable. :: - itertools.permutations([1,2,3,4], 2) -> - (1, 2), (1, 3), (1, 4), - (2, 1), (2, 3), (2, 4), - (3, 1), (3, 2), (3, 4), - (4, 1), (4, 2), (4, 3) + >>> list(itertools.permutations([1,2,3,4], 2)) + [(1, 2), (1, 3), (1, 4), + (2, 1), (2, 3), (2, 4), + (3, 1), (3, 2), (3, 4), + (4, 1), (4, 2), (4, 3)] ``itertools.chain(*iterables)`` is an existing function in :mod:`itertools` that gained a new constructor in Python 2.6. @@ -2079,8 +2080,8 @@ then return all the elements of the first iterable, then all the elements of the second, and so on. :: - chain.from_iterable([[1,2,3], [4,5,6]]) -> - 1, 2, 3, 4, 5, 6 + >>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]])) + [1, 2, 3, 4, 5, 6] (All contributed by Raymond Hettinger.) @@ -2251,16 +2252,15 @@ with an installed Python package. For example:: >>> import pkgutil - >>> pkgutil.get_data('test', 'exception_hierarchy.txt') - 'BaseException + >>> print pkgutil.get_data('test', 'exception_hierarchy.txt') + BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Exception +-- StopIteration +-- StandardError - ...' - >>> + ... (Contributed by Paul Moore; :issue:`2439`.) @@ -2534,9 +2534,9 @@ with test_support.check_warnings() as wrec: warnings.simplefilter("always") - ... code that triggers a warning ... + # ... code that triggers a warning ... assert str(wrec.message) == "function is outdated" - assert len(wrec.warnings) == 1, "Multiple warnings raised" + assert len(wrec.warnings) == 1, "Multiple warnings raised" (Contributed by Brett Cannon.) @@ -2710,7 +2710,7 @@ t = ast.parse(""" d = {} for i in 'abcdefghijklm': - d[i + i] = ord(i) - ord('a') + 1 + d[i + i] = ord(i) - ord('a') + 1 print d """) print ast.dump(t) @@ -2719,32 +2719,32 @@ Module(body=[ Assign(targets=[ - Name(id='d', ctx=Store()) + Name(id='d', ctx=Store()) ], value=Dict(keys=[], values=[])) For(target=Name(id='i', ctx=Store()), - iter=Str(s='abcdefghijklm'), body=[ - Assign(targets=[ - Subscript(value= - Name(id='d', ctx=Load()), - slice= - Index(value= - BinOp(left=Name(id='i', ctx=Load()), op=Add(), - right=Name(id='i', ctx=Load()))), ctx=Store()) - ], value= - BinOp(left= - BinOp(left= - Call(func= - Name(id='ord', ctx=Load()), args=[ - Name(id='i', ctx=Load()) - ], keywords=[], starargs=None, kwargs=None), - op=Sub(), right=Call(func= - Name(id='ord', ctx=Load()), args=[ - Str(s='a') - ], keywords=[], starargs=None, kwargs=None)), - op=Add(), right=Num(n=1))) - ], orelse=[]) - Print(dest=None, values=[ - Name(id='d', ctx=Load()) + iter=Str(s='abcdefghijklm'), body=[ + Assign(targets=[ + Subscript(value= + Name(id='d', ctx=Load()), + slice= + Index(value= + BinOp(left=Name(id='i', ctx=Load()), op=Add(), + right=Name(id='i', ctx=Load()))), ctx=Store()) + ], value= + BinOp(left= + BinOp(left= + Call(func= + Name(id='ord', ctx=Load()), args=[ + Name(id='i', ctx=Load()) + ], keywords=[], starargs=None, kwargs=None), + op=Sub(), right=Call(func= + Name(id='ord', ctx=Load()), args=[ + Str(s='a') + ], keywords=[], starargs=None, kwargs=None)), + op=Add(), right=Num(n=1))) + ], orelse=[]) + Print(dest=None, values=[ + Name(id='d', ctx=Load()) ], nl=True) ]) @@ -2848,8 +2848,8 @@ # Create data structure data_struct = dict(lastAccessed=datetime.datetime.now(), - version=1, - categories=('Personal','Shared','Private')) + version=1, + categories=('Personal','Shared','Private')) # Create string containing XML. plist_str = plistlib.writePlistToString(data_struct)