mirror of
https://github.com/python/cpython.git
synced 2025-09-26 10:19:53 +00:00
#4058: fix some whatsnew markup.
This commit is contained in:
Georg Brandl
parent
26497d91ca
commit
06a1386902
1 changed files with 172 additions and 172 deletions
|
|
@ -723,31 +723,32 @@ In 2.6, both 8-bit and Unicode strings have a `.format()` method that
|
|||
treats the string as a template and takes the arguments to be formatted.
|
||||
The formatting template uses curly brackets (`{`, `}`) as special characters::
|
||||
|
||||
# Substitute positional argument 0 into the string.
|
||||
"User ID: {0}".format("root") -> "User ID: root"
|
||||
|
||||
# Use the named keyword arguments
|
||||
'User ID: {uid} Last seen: {last_login}'.format(
|
||||
uid='root',
|
||||
last_login = '5 Mar 2008 07:20') ->
|
||||
>>> # Substitute positional argument 0 into the string.
|
||||
>>> "User ID: {0}".format("root")
|
||||
'User ID: root'
|
||||
>>> # Use the named keyword arguments
|
||||
>>> "User ID: {uid} Last seen: {last_login}".format(
|
||||
... uid="root",
|
||||
... last_login = "5 Mar 2008 07:20")
|
||||
'User ID: root Last seen: 5 Mar 2008 07:20'
|
||||
|
||||
Curly brackets can be escaped by doubling them::
|
||||
|
||||
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
|
||||
>>> 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) ->
|
||||
>>> 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
|
||||
|
|
@ -760,29 +761,24 @@ So far we've shown how to specify which field to substitute into the
|
|||
resulting string. The precise formatting used is also controllable by
|
||||
adding a colon followed by a format specifier. For example::
|
||||
|
||||
# Field 0: left justify, pad to 15 characters
|
||||
# Field 1: right justify, pad to 6 characters
|
||||
fmt = '{0:15} ${1:>6}'
|
||||
|
||||
fmt.format('Registration', 35) ->
|
||||
>>> # 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) ->
|
||||
>>> fmt.format('Tutorial', 50)
|
||||
'Tutorial $ 50'
|
||||
|
||||
fmt.format('Banquet', 125) ->
|
||||
>>> fmt.format('Banquet', 125)
|
||||
'Banquet $ 125'
|
||||
|
||||
Format specifiers can reference other fields through nesting::
|
||||
|
||||
fmt = '{0:{1}}'
|
||||
|
||||
width = 15
|
||||
fmt.format('Invoice #1234', width) ->
|
||||
>>> fmt = '{0:{1}}'
|
||||
>>> width = 15
|
||||
>>> fmt.format('Invoice #1234', width)
|
||||
'Invoice #1234 '
|
||||
|
||||
width = 35
|
||||
fmt.format('Invoice #1234', width) ->
|
||||
>>> 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 @@ Character Effect
|
|||
|
||||
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 @@ can be formatted as a general number or in exponential notation:
|
|||
'3.750000e+00'
|
||||
|
||||
A variety of presentation types are available. Consult the 2.6
|
||||
documentation for a :ref:`complete list <formatstrings>`; here's a sample::
|
||||
documentation for a :ref:`complete list <formatstrings>`; 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 @@ by doing ``def print(...)`` or importing a new function from somewhere else.
|
|||
Python 2.6 has a ``__future__`` import that removes ``print`` as language
|
||||
syntax, letting you use the functional form instead. For example::
|
||||
|
||||
from __future__ 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.
|
||||
|
|
@ -1002,6 +1001,8 @@ Byte arrays support most of the methods of string types, such as
|
|||
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'))
|
||||
|
|
@ -1331,7 +1332,7 @@ built-in returns the binary representation for a number::
|
|||
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
|
||||
|
|
@ -1504,7 +1505,7 @@ Some smaller changes made to the core Python language are:
|
|||
(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
|
||||
|
|
@ -1878,8 +1879,8 @@ changes, or look through the Subversion logs for all the details.
|
|||
|
||||
>>> 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')
|
||||
|
||||
|
|
@ -1929,7 +1930,9 @@ changes, or look through the Subversion logs for all the details.
|
|||
|
||||
* 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.
|
||||
|
|
@ -1999,7 +2002,7 @@ changes, or look through the Subversion logs for all the details.
|
|||
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]) ->
|
||||
>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
|
||||
[1, 2, 3, 5, 8, 9, 16]
|
||||
|
||||
Another new function, ``heappushpop(heap, item)``,
|
||||
|
|
@ -2034,57 +2037,55 @@ changes, or look through the Subversion logs for all the details.
|
|||
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),
|
||||
>>> 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)
|
||||
(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),
|
||||
>>> 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)
|
||||
(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')
|
||||
|
||||
itertools.combinations('123', 3) ->
|
||||
('1', '2', '3')
|
||||
|
||||
itertools.combinations('1234', 3) ->
|
||||
('1', '2', '3'), ('1', '2', '4'), ('1', '3', '4'),
|
||||
('2', '3', '4')
|
||||
>>> list(itertools.combinations('123', 2))
|
||||
[('1', '2'), ('1', '3'), ('2', '3')]
|
||||
>>> list(itertools.combinations('123', 3))
|
||||
[('1', '2', '3')]
|
||||
>>> list(itertools.combinations('1234', 3))
|
||||
[('1', '2', '3'), ('1', '2', '4'),
|
||||
('1', '3', '4'), ('2', '3', '4')]
|
||||
|
||||
``permutations(iter[, r])`` returns all the permutations of length *r* of
|
||||
the iterable's elements. If *r* is not specified, it will default to the
|
||||
number of elements produced by the iterable. ::
|
||||
|
||||
itertools.permutations([1,2,3,4], 2) ->
|
||||
(1, 2), (1, 3), (1, 4),
|
||||
>>> 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)
|
||||
(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.
|
||||
|
|
@ -2093,8 +2094,8 @@ changes, or look through the Subversion logs for all the details.
|
|||
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.)
|
||||
|
||||
|
|
@ -2265,16 +2266,15 @@ changes, or look through the Subversion logs for all the details.
|
|||
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`.)
|
||||
|
||||
|
|
@ -2548,7 +2548,7 @@ changes, or look through the Subversion logs for all the details.
|
|||
|
||||
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"
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue