bpo-35054: Add yet more index entries for symbols. (GH-10121)
This commit is contained in:
Serhiy Storchaka
GitHub
parent
95f68b10d5
commit
913876d824
|
|
@ -844,6 +844,8 @@ values are:
|
|||
Note that ``nargs=1`` produces a list of one item. This is different from
|
||||
the default, in which the item is produced by itself.
|
||||
|
||||
.. index:: single: ? (question mark); in argparse module
|
||||
|
||||
* ``'?'``. One argument will be consumed from the command line if possible, and
|
||||
produced as a single item. If no command-line argument is present, the value from
|
||||
default_ will be produced. Note that for optional arguments, there is an
|
||||
|
|
@ -876,6 +878,8 @@ values are:
|
|||
Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,
|
||||
outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)
|
||||
|
||||
.. index:: single: * (asterisk); in argparse module
|
||||
|
||||
* ``'*'``. All command-line arguments present are gathered into a list. Note that
|
||||
it generally doesn't make much sense to have more than one positional argument
|
||||
with ``nargs='*'``, but multiple optional arguments with ``nargs='*'`` is
|
||||
|
|
@ -888,6 +892,8 @@ values are:
|
|||
>>> parser.parse_args('a b --foo x y --bar 1 2'.split())
|
||||
Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
|
||||
|
||||
.. index:: single: + (plus); in argparse module
|
||||
|
||||
* ``'+'``. Just like ``'*'``, all command-line args present are gathered into a
|
||||
list. Additionally, an error message will be generated if there wasn't at
|
||||
least one command-line argument present. For example::
|
||||
|
|
|
|||
|
|
@ -41,6 +41,9 @@ Node classes
|
|||
with alternatives (aka "sums"), the left-hand side class is abstract: only
|
||||
instances of specific constructor nodes are ever created.
|
||||
|
||||
.. index:: single: ? (question mark); in AST grammar
|
||||
.. index:: single: * (asterisk); in AST grammar
|
||||
|
||||
.. attribute:: _fields
|
||||
|
||||
Each concrete class has an attribute :attr:`_fields` which gives the names
|
||||
|
|
|
|||
|
|
@ -61,6 +61,10 @@ A :class:`Cmd` instance has the following methods:
|
|||
|
||||
An end-of-file on input is passed back as the string ``'EOF'``.
|
||||
|
||||
.. index::
|
||||
single: ? (question mark); in a command interpreter
|
||||
single: ! (exclamation); in a command interpreter
|
||||
|
||||
An interpreter instance will recognize a command name ``foo`` if and only if it
|
||||
has a method :meth:`do_foo`. As a special case, a line beginning with the
|
||||
character ``'?'`` is dispatched to the method :meth:`do_help`. As another
|
||||
|
|
|
|||
|
|
@ -312,6 +312,14 @@ defined and implemented by all standard Python codecs:
|
|||
The following error handlers are only applicable to
|
||||
:term:`text encodings <text encoding>`:
|
||||
|
||||
.. index::
|
||||
single: ? (question mark); replacement character
|
||||
single: \ (backslash); escape sequence
|
||||
single: \x; escape sequence
|
||||
single: \u; escape sequence
|
||||
single: \U; escape sequence
|
||||
single: \N; escape sequence
|
||||
|
||||
+-------------------------+-----------------------------------------------+
|
||||
| Value | Meaning |
|
||||
+=========================+===============================================+
|
||||
|
|
|
|||
|
|
@ -295,7 +295,7 @@ On top of the core functionality, :class:`ConfigParser` supports
|
|||
interpolation. This means values can be preprocessed before returning them
|
||||
from ``get()`` calls.
|
||||
|
||||
.. index:: single: %; interpolation in configuration files
|
||||
.. index:: single: % (percent); interpolation in configuration files
|
||||
|
||||
.. class:: BasicInterpolation()
|
||||
|
||||
|
|
@ -325,7 +325,7 @@ from ``get()`` calls.
|
|||
``%(my_dir)s/Pictures`` as the value of ``my_pictures`` and
|
||||
``%(home_dir)s/lumberjack`` as the value of ``my_dir``.
|
||||
|
||||
.. index:: single: $; interpolation in configuration files
|
||||
.. index:: single: $ (dollar); interpolation in configuration files
|
||||
|
||||
.. class:: ExtendedInterpolation()
|
||||
|
||||
|
|
|
|||
|
|
@ -207,6 +207,10 @@ The following function takes either a single-character string or integer value;
|
|||
it returns a string.
|
||||
|
||||
|
||||
.. index::
|
||||
single: ^ (caret); in curses module
|
||||
single: ! (exclamation); in curses module
|
||||
|
||||
.. function:: unctrl(c)
|
||||
|
||||
Return a string representation of the ASCII character *c*. If *c* is printable,
|
||||
|
|
|
|||
|
|
@ -2000,7 +2000,7 @@ Class attributes:
|
|||
|
||||
|
||||
.. index::
|
||||
single: %; datetime format
|
||||
single: % (percent); datetime format
|
||||
|
||||
.. _strftime-strptime-behavior:
|
||||
|
||||
|
|
|
|||
|
|
@ -485,7 +485,7 @@ Some details you should read once, but won't need to remember:
|
|||
to test a :exc:`SyntaxError` that omits the traceback header, you will need to
|
||||
manually add the traceback header line to your test example.
|
||||
|
||||
.. index:: single: ^; caret
|
||||
.. index:: single: ^ (caret); marker
|
||||
|
||||
* For some :exc:`SyntaxError`\ s, Python displays the character position of the
|
||||
syntax error, using a ``^`` marker::
|
||||
|
|
@ -695,9 +695,9 @@ useful unless you intend to extend :mod:`doctest` internals via subclassing:
|
|||
|
||||
|
||||
.. index::
|
||||
single: #; in doctests
|
||||
single: +; in doctests
|
||||
single: -; in doctests
|
||||
single: # (hash); in doctests
|
||||
single: + (plus); in doctests
|
||||
single: - (minus); in doctests
|
||||
.. _doctest-directives:
|
||||
|
||||
Directives
|
||||
|
|
|
|||
|
|
@ -16,6 +16,13 @@ This module provides support for Unix shell-style wildcards, which are *not* the
|
|||
same as regular expressions (which are documented in the :mod:`re` module). The
|
||||
special characters used in shell-style wildcards are:
|
||||
|
||||
.. index::
|
||||
single: * (asterisk); in glob-style wildcards
|
||||
single: ? (question mark); in glob-style wildcards
|
||||
single: [] (square brackets); in glob-style wildcards
|
||||
single: ! (exclamation); in glob-style wildcards
|
||||
single: - (minus); in glob-style wildcards
|
||||
|
||||
+------------+------------------------------------+
|
||||
| Pattern | Meaning |
|
||||
+============+====================================+
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ class-based API instead.
|
|||
*domain*, which is returned.
|
||||
|
||||
|
||||
.. index:: single: _; gettext
|
||||
.. index:: single: _ (underscore); gettext
|
||||
.. function:: gettext(message)
|
||||
|
||||
Return the localized translation of *message*, based on the current global
|
||||
|
|
|
|||
|
|
@ -10,6 +10,14 @@
|
|||
|
||||
--------------
|
||||
|
||||
.. index::
|
||||
single: * (asterisk); in glob-style wildcards
|
||||
single: ? (question mark); in glob-style wildcards
|
||||
single: [] (square brackets); in glob-style wildcards
|
||||
single: ! (exclamation); in glob-style wildcards
|
||||
single: - (minus); in glob-style wildcards
|
||||
single: . (dot); in glob-style wildcards
|
||||
|
||||
The :mod:`glob` module finds all the pathnames matching a specified pattern
|
||||
according to the rules used by the Unix shell, although results are returned in
|
||||
arbitrary order. No tilde expansion is done, but ``*``, ``?``, and character
|
||||
|
|
@ -36,6 +44,9 @@ For example, ``'[?]'`` matches the character ``'?'``.
|
|||
:file:`../../Tools/\*/\*.gif`), and can contain shell-style wildcards. Broken
|
||||
symlinks are included in the results (as in the shell).
|
||||
|
||||
.. index::
|
||||
single: **; in glob-style wildcards
|
||||
|
||||
If *recursive* is true, the pattern "``**``" will match any files and zero or
|
||||
more directories and subdirectories. If the pattern is followed by an
|
||||
``os.sep``, only directories and subdirectories match.
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ the :mod:`glob` module.)
|
|||
Accepts a :term:`path-like object`.
|
||||
|
||||
|
||||
.. index:: single: ~; home directory expansion
|
||||
.. index:: single: ~ (tilde); home directory expansion
|
||||
|
||||
.. function:: expanduser(path)
|
||||
|
||||
|
|
@ -186,8 +186,8 @@ the :mod:`glob` module.)
|
|||
Accepts a :term:`path-like object`.
|
||||
|
||||
.. index::
|
||||
single: $; environment variables expansion
|
||||
single: %; environment variables expansion (Windows)
|
||||
single: $ (dollar); environment variables expansion
|
||||
single: % (percent); environment variables expansion (Windows)
|
||||
|
||||
.. function:: expandvars(path)
|
||||
|
||||
|
|
|
|||
|
|
@ -4086,7 +4086,7 @@ are defined for all platforms.
|
|||
Higher-level operations on pathnames are defined in the :mod:`os.path` module.
|
||||
|
||||
|
||||
.. index:: single: .; in pathnames
|
||||
.. index:: single: . (dot); in pathnames
|
||||
.. data:: curdir
|
||||
|
||||
The constant string used by the operating system to refer to the current
|
||||
|
|
@ -4102,8 +4102,8 @@ Higher-level operations on pathnames are defined in the :mod:`os.path` module.
|
|||
:mod:`os.path`.
|
||||
|
||||
|
||||
.. index:: single: /; in pathnames
|
||||
.. index:: single: \; in pathnames (Windows)
|
||||
.. index:: single: / (slash); in pathnames
|
||||
.. index:: single: \ (backslash); in pathnames (Windows)
|
||||
.. data:: sep
|
||||
|
||||
The character used by the operating system to separate pathname components.
|
||||
|
|
@ -4113,7 +4113,7 @@ Higher-level operations on pathnames are defined in the :mod:`os.path` module.
|
|||
useful. Also available via :mod:`os.path`.
|
||||
|
||||
|
||||
.. index:: single: /; in pathnames
|
||||
.. index:: single: / (slash); in pathnames
|
||||
.. data:: altsep
|
||||
|
||||
An alternative character used by the operating system to separate pathname
|
||||
|
|
@ -4122,14 +4122,15 @@ Higher-level operations on pathnames are defined in the :mod:`os.path` module.
|
|||
:mod:`os.path`.
|
||||
|
||||
|
||||
.. index:: single: .; in pathnames
|
||||
.. index:: single: . (dot); in pathnames
|
||||
.. data:: extsep
|
||||
|
||||
The character which separates the base filename from the extension; for example,
|
||||
the ``'.'`` in :file:`os.py`. Also available via :mod:`os.path`.
|
||||
|
||||
|
||||
.. index:: single: :; path separator (POSIX)
|
||||
.. index:: single: : (colon); path separator (POSIX)
|
||||
single: ; (semicolon)
|
||||
.. data:: pathsep
|
||||
|
||||
The character conventionally used by the operating system to separate search
|
||||
|
|
|
|||
|
|
@ -93,20 +93,20 @@ the expression ``(?:a{6})*`` matches any multiple of six ``'a'`` characters.
|
|||
|
||||
The special characters are:
|
||||
|
||||
.. index:: single: .; in regular expressions
|
||||
.. index:: single: . (dot); in regular expressions
|
||||
|
||||
``.``
|
||||
(Dot.) In the default mode, this matches any character except a newline. If
|
||||
the :const:`DOTALL` flag has been specified, this matches any character
|
||||
including a newline.
|
||||
|
||||
.. index:: single: ^; in regular expressions
|
||||
.. index:: single: ^ (caret); in regular expressions
|
||||
|
||||
``^``
|
||||
(Caret.) Matches the start of the string, and in :const:`MULTILINE` mode also
|
||||
matches immediately after each newline.
|
||||
|
||||
.. index:: single: $; in regular expressions
|
||||
.. index:: single: $ (dollar); in regular expressions
|
||||
|
||||
``$``
|
||||
Matches the end of the string or just before the newline at the end of the
|
||||
|
|
@ -117,21 +117,21 @@ The special characters are:
|
|||
a single ``$`` in ``'foo\n'`` will find two (empty) matches: one just before
|
||||
the newline, and one at the end of the string.
|
||||
|
||||
.. index:: single: *; in regular expressions
|
||||
.. index:: single: * (asterisk); in regular expressions
|
||||
|
||||
``*``
|
||||
Causes the resulting RE to match 0 or more repetitions of the preceding RE, as
|
||||
many repetitions as are possible. ``ab*`` will match 'a', 'ab', or 'a' followed
|
||||
by any number of 'b's.
|
||||
|
||||
.. index:: single: +; in regular expressions
|
||||
.. index:: single: + (plus); in regular expressions
|
||||
|
||||
``+``
|
||||
Causes the resulting RE to match 1 or more repetitions of the preceding RE.
|
||||
``ab+`` will match 'a' followed by any non-zero number of 'b's; it will not
|
||||
match just 'a'.
|
||||
|
||||
.. index:: single: ?; in regular expressions
|
||||
.. index:: single: ? (question mark); in regular expressions
|
||||
|
||||
``?``
|
||||
Causes the resulting RE to match 0 or 1 repetitions of the preceding RE.
|
||||
|
|
@ -152,8 +152,7 @@ The special characters are:
|
|||
only ``'<a>'``.
|
||||
|
||||
.. index::
|
||||
single: {; in regular expressions
|
||||
single: }; in regular expressions
|
||||
single: {} (curly brackets); in regular expressions
|
||||
|
||||
``{m}``
|
||||
Specifies that exactly *m* copies of the previous RE should be matched; fewer
|
||||
|
|
@ -176,7 +175,7 @@ The special characters are:
|
|||
6-character string ``'aaaaaa'``, ``a{3,5}`` will match 5 ``'a'`` characters,
|
||||
while ``a{3,5}?`` will only match 3 characters.
|
||||
|
||||
.. index:: single: \; in regular expressions
|
||||
.. index:: single: \ (backslash); in regular expressions
|
||||
|
||||
``\``
|
||||
Either escapes special characters (permitting you to match characters like
|
||||
|
|
@ -192,8 +191,7 @@ The special characters are:
|
|||
raw strings for all but the simplest expressions.
|
||||
|
||||
.. index::
|
||||
single: [; in regular expressions
|
||||
single: ]; in regular expressions
|
||||
single: [] (square brackets); in regular expressions
|
||||
|
||||
``[]``
|
||||
Used to indicate a set of characters. In a set:
|
||||
|
|
@ -201,7 +199,7 @@ The special characters are:
|
|||
* Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``,
|
||||
``'m'``, or ``'k'``.
|
||||
|
||||
.. index:: single: -; in regular expressions
|
||||
.. index:: single: - (minus); in regular expressions
|
||||
|
||||
* Ranges of characters can be indicated by giving two characters and separating
|
||||
them by a ``'-'``, for example ``[a-z]`` will match any lowercase ASCII letter,
|
||||
|
|
@ -214,13 +212,13 @@ The special characters are:
|
|||
``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``,
|
||||
``'*'``, or ``')'``.
|
||||
|
||||
.. index:: single: \; in regular expressions
|
||||
.. index:: single: \ (backslash); in regular expressions
|
||||
|
||||
* Character classes such as ``\w`` or ``\S`` (defined below) are also accepted
|
||||
inside a set, although the characters they match depends on whether
|
||||
:const:`ASCII` or :const:`LOCALE` mode is in force.
|
||||
|
||||
.. index:: single: ^; in regular expressions
|
||||
.. index:: single: ^ (caret); in regular expressions
|
||||
|
||||
* Characters that are not within a range can be matched by :dfn:`complementing`
|
||||
the set. If the first character of the set is ``'^'``, all the characters
|
||||
|
|
@ -252,7 +250,7 @@ The special characters are:
|
|||
:exc:`FutureWarning` is raised if a character set contains constructs
|
||||
that will change semantically in the future.
|
||||
|
||||
.. index:: single: |; in regular expressions
|
||||
.. index:: single: | (vertical bar); in regular expressions
|
||||
|
||||
``|``
|
||||
``A|B``, where *A* and *B* can be arbitrary REs, creates a regular expression that
|
||||
|
|
@ -266,8 +264,7 @@ The special characters are:
|
|||
character class, as in ``[|]``.
|
||||
|
||||
.. index::
|
||||
single: (; in regular expressions
|
||||
single: ); in regular expressions
|
||||
single: () (parentheses); in regular expressions
|
||||
|
||||
``(...)``
|
||||
Matches whatever regular expression is inside the parentheses, and indicates the
|
||||
|
|
@ -433,7 +430,7 @@ If the ordinary character is not an ASCII digit or an ASCII letter, then the
|
|||
resulting RE will match the second character. For example, ``\$`` matches the
|
||||
character ``'$'``.
|
||||
|
||||
.. index:: single: \; in regular expressions
|
||||
.. index:: single: \ (backslash); in regular expressions
|
||||
|
||||
``\number``
|
||||
Matches the contents of the group of the same number. Groups are numbered
|
||||
|
|
@ -719,7 +716,7 @@ form.
|
|||
.. data:: X
|
||||
VERBOSE
|
||||
|
||||
.. index:: single: #; in regular expressions
|
||||
.. index:: single: # (hash); in regular expressions
|
||||
|
||||
This flag allows you to write regular expressions that look nicer and are
|
||||
more readable by allowing you to visually separate logical sections of the
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ the key "include-system-site-packages" set to anything other than "false"
|
|||
searched for site-packages; otherwise they won't.
|
||||
|
||||
.. index::
|
||||
single: #; comment
|
||||
single: # (hash); comment
|
||||
statement: import
|
||||
|
||||
A path configuration file is a file whose name has the form :file:`{name}.pth`
|
||||
|
|
|
|||
|
|
@ -598,6 +598,9 @@ Cursor Objects
|
|||
|
||||
A :class:`Cursor` instance has the following attributes and methods.
|
||||
|
||||
.. index:: single: ? (question mark); in SQL statements
|
||||
.. index:: single: : (colon); in SQL statements
|
||||
|
||||
.. method:: execute(sql[, parameters])
|
||||
|
||||
Executes an SQL statement. The SQL statement may be parameterized (i. e.
|
||||
|
|
|
|||
|
|
@ -123,9 +123,9 @@ Comparisons
|
|||
pair: chaining; comparisons
|
||||
pair: operator; comparison
|
||||
operator: ==
|
||||
operator: <
|
||||
operator: < (less)
|
||||
operator: <=
|
||||
operator: >
|
||||
operator: > (greater)
|
||||
operator: >=
|
||||
operator: !=
|
||||
operator: is
|
||||
|
|
@ -246,16 +246,16 @@ and imaginary parts.
|
|||
builtin: int
|
||||
builtin: float
|
||||
builtin: complex
|
||||
single: operator; +
|
||||
single: +; unary operator
|
||||
single: +; binary operator
|
||||
single: operator; -
|
||||
single: -; unary operator
|
||||
single: -; binary operator
|
||||
operator: *
|
||||
operator: /
|
||||
single: operator; + (plus)
|
||||
single: + (plus); unary operator
|
||||
single: + (plus); binary operator
|
||||
single: operator; - (minus)
|
||||
single: - (minus); unary operator
|
||||
single: - (minus); binary operator
|
||||
operator: * (asterisk)
|
||||
operator: / (slash)
|
||||
operator: //
|
||||
operator: %
|
||||
operator: % (percent)
|
||||
operator: **
|
||||
|
||||
Python fully supports mixed arithmetic: when a binary arithmetic operator has
|
||||
|
|
@ -391,12 +391,12 @@ Bitwise Operations on Integer Types
|
|||
pair: bitwise; operations
|
||||
pair: shifting; operations
|
||||
pair: masking; operations
|
||||
operator: |
|
||||
operator: ^
|
||||
operator: &
|
||||
operator: | (vertical bar)
|
||||
operator: ^ (caret)
|
||||
operator: & (ampersand)
|
||||
operator: <<
|
||||
operator: >>
|
||||
operator: ~
|
||||
operator: ~ (tilde)
|
||||
|
||||
Bitwise operations only make sense for integers. The result of bitwise
|
||||
operations is calculated as though carried out in two's complement with an
|
||||
|
|
@ -2119,7 +2119,7 @@ expression support in the :mod:`re` module).
|
|||
single: string; interpolation, printf
|
||||
single: printf-style formatting
|
||||
single: sprintf-style formatting
|
||||
single: %; printf-style formatting
|
||||
single: % (percent); printf-style formatting
|
||||
|
||||
.. note::
|
||||
|
||||
|
|
@ -2148,8 +2148,7 @@ components, which must occur in this order:
|
|||
#. The ``'%'`` character, which marks the start of the specifier.
|
||||
|
||||
.. index::
|
||||
single: (; in printf-style formatting
|
||||
single: ); in printf-style formatting
|
||||
single: () (parentheses); in printf-style formatting
|
||||
|
||||
#. Mapping key (optional), consisting of a parenthesised sequence of characters
|
||||
(for example, ``(somename)``).
|
||||
|
|
@ -2157,13 +2156,13 @@ components, which must occur in this order:
|
|||
#. Conversion flags (optional), which affect the result of some conversion
|
||||
types.
|
||||
|
||||
.. index:: single: *; in printf-style formatting
|
||||
.. index:: single: * (asterisk); in printf-style formatting
|
||||
|
||||
#. Minimum field width (optional). If specified as an ``'*'`` (asterisk), the
|
||||
actual width is read from the next element of the tuple in *values*, and the
|
||||
object to convert comes after the minimum field width and optional precision.
|
||||
|
||||
.. index:: single: .; in printf-style formatting
|
||||
.. index:: single: . (dot); in printf-style formatting
|
||||
|
||||
#. Precision (optional), given as a ``'.'`` (dot) followed by the precision. If
|
||||
specified as ``'*'`` (an asterisk), the actual precision is read from the next
|
||||
|
|
@ -2189,9 +2188,9 @@ sequential parameter list).
|
|||
The conversion flag characters are:
|
||||
|
||||
.. index::
|
||||
single: #; in printf-style formatting
|
||||
single: -; in printf-style formatting
|
||||
single: +; in printf-style formatting
|
||||
single: # (hash); in printf-style formatting
|
||||
single: - (minus); in printf-style formatting
|
||||
single: + (plus); in printf-style formatting
|
||||
single: space; in printf-style formatting
|
||||
|
||||
+---------+---------------------------------------------------------------------+
|
||||
|
|
@ -3256,7 +3255,7 @@ place, and instead produce new objects.
|
|||
single: bytearray; interpolation
|
||||
single: printf-style formatting
|
||||
single: sprintf-style formatting
|
||||
single: %; printf-style formatting
|
||||
single: % (percent); printf-style formatting
|
||||
|
||||
.. note::
|
||||
|
||||
|
|
@ -3283,8 +3282,7 @@ components, which must occur in this order:
|
|||
#. The ``'%'`` character, which marks the start of the specifier.
|
||||
|
||||
.. index::
|
||||
single: (; in printf-style formatting
|
||||
single: ); in printf-style formatting
|
||||
single: () (parentheses); in printf-style formatting
|
||||
|
||||
#. Mapping key (optional), consisting of a parenthesised sequence of characters
|
||||
(for example, ``(somename)``).
|
||||
|
|
@ -3292,13 +3290,13 @@ components, which must occur in this order:
|
|||
#. Conversion flags (optional), which affect the result of some conversion
|
||||
types.
|
||||
|
||||
.. index:: single: *; in printf-style formatting
|
||||
.. index:: single: * (asterisk); in printf-style formatting
|
||||
|
||||
#. Minimum field width (optional). If specified as an ``'*'`` (asterisk), the
|
||||
actual width is read from the next element of the tuple in *values*, and the
|
||||
object to convert comes after the minimum field width and optional precision.
|
||||
|
||||
.. index:: single: .; in printf-style formatting
|
||||
.. index:: single: . (dot); in printf-style formatting
|
||||
|
||||
#. Precision (optional), given as a ``'.'`` (dot) followed by the precision. If
|
||||
specified as ``'*'`` (an asterisk), the actual precision is read from the next
|
||||
|
|
@ -3324,9 +3322,9 @@ sequential parameter list).
|
|||
The conversion flag characters are:
|
||||
|
||||
.. index::
|
||||
single: #; in printf-style formatting
|
||||
single: -; in printf-style formatting
|
||||
single: +; in printf-style formatting
|
||||
single: # (hash); in printf-style formatting
|
||||
single: - (minus); in printf-style formatting
|
||||
single: + (plus); in printf-style formatting
|
||||
single: space; in printf-style formatting
|
||||
|
||||
+---------+---------------------------------------------------------------------+
|
||||
|
|
|
|||
|
|
@ -193,13 +193,11 @@ related to that of :ref:`formatted string literals <f-strings>`, but
|
|||
there are differences.
|
||||
|
||||
.. index::
|
||||
single: {; in string formatting
|
||||
single: }; in string formatting
|
||||
single: .; in string formatting
|
||||
single: [; in string formatting
|
||||
single: ]; in string formatting
|
||||
single: !; in string formatting
|
||||
single: :; in string formatting
|
||||
single: {} (curly brackets); in string formatting
|
||||
single: . (dot); in string formatting
|
||||
single: [] (square brackets); in string formatting
|
||||
single: ! (exclamation); in string formatting
|
||||
single: : (colon); in string formatting
|
||||
|
||||
Format strings contain "replacement fields" surrounded by curly braces ``{}``.
|
||||
Anything that is not contained in braces is considered literal text, which is
|
||||
|
|
@ -333,10 +331,10 @@ affect the :func:`format` function.
|
|||
The meaning of the various alignment options is as follows:
|
||||
|
||||
.. index::
|
||||
single: <; in string formatting
|
||||
single: >; in string formatting
|
||||
single: =; in string formatting
|
||||
single: ^; in string formatting
|
||||
single: < (less); in string formatting
|
||||
single: > (greater); in string formatting
|
||||
single: = (equals); in string formatting
|
||||
single: ^ (caret); in string formatting
|
||||
|
||||
+---------+----------------------------------------------------------+
|
||||
| Option | Meaning |
|
||||
|
|
@ -365,8 +363,8 @@ The *sign* option is only valid for number types, and can be one of the
|
|||
following:
|
||||
|
||||
.. index::
|
||||
single: +; in string formatting
|
||||
single: -; in string formatting
|
||||
single: + (plus); in string formatting
|
||||
single: - (minus); in string formatting
|
||||
single: space; in string formatting
|
||||
|
||||
+---------+----------------------------------------------------------+
|
||||
|
|
@ -383,7 +381,7 @@ following:
|
|||
+---------+----------------------------------------------------------+
|
||||
|
||||
|
||||
.. index:: single: #; in string formatting
|
||||
.. index:: single: # (hash); in string formatting
|
||||
|
||||
The ``'#'`` option causes the "alternate form" to be used for the
|
||||
conversion. The alternate form is defined differently for different
|
||||
|
|
@ -397,7 +395,7 @@ decimal-point character appears in the result of these conversions
|
|||
only if a digit follows it. In addition, for ``'g'`` and ``'G'``
|
||||
conversions, trailing zeros are not removed from the result.
|
||||
|
||||
.. index:: single: ,; in string formatting
|
||||
.. index:: single: , (comma); in string formatting
|
||||
|
||||
The ``','`` option signals the use of a comma for a thousands separator.
|
||||
For a locale aware separator, use the ``'n'`` integer presentation type
|
||||
|
|
@ -406,7 +404,7 @@ instead.
|
|||
.. versionchanged:: 3.1
|
||||
Added the ``','`` option (see also :pep:`378`).
|
||||
|
||||
.. index:: single: _; in string formatting
|
||||
.. index:: single: _ (underscore); in string formatting
|
||||
|
||||
The ``'_'`` option signals the use of an underscore for a thousands
|
||||
separator for floating point presentation types and for integer
|
||||
|
|
@ -694,7 +692,7 @@ formatting facilities in Python. As an example of a library built on template
|
|||
strings for i18n, see the
|
||||
`flufl.i18n <http://flufli18n.readthedocs.io/en/latest/>`_ package.
|
||||
|
||||
.. index:: single: $; in template strings
|
||||
.. index:: single: $ (dollar); in template strings
|
||||
|
||||
Template strings support ``$``-based substitutions, using the following rules:
|
||||
|
||||
|
|
|
|||
|
|
@ -118,11 +118,11 @@ order, and properly aligned by skipping pad bytes if necessary (according to the
|
|||
rules used by the C compiler).
|
||||
|
||||
.. index::
|
||||
single: @; in struct format strings
|
||||
single: =; in struct format strings
|
||||
single: <; in struct format strings
|
||||
single: >; in struct format strings
|
||||
single: !; in struct format strings
|
||||
single: @ (at); in struct format strings
|
||||
single: = (equals); in struct format strings
|
||||
single: < (less); in struct format strings
|
||||
single: > (greater); in struct format strings
|
||||
single: ! (exclamation); in struct format strings
|
||||
|
||||
Alternatively, the first character of the format string can be used to indicate
|
||||
the byte order, size and alignment of the packed data, according to the
|
||||
|
|
@ -247,6 +247,8 @@ platform-dependent.
|
|||
Notes:
|
||||
|
||||
(1)
|
||||
.. index:: single: ? (question mark); in struct format strings
|
||||
|
||||
The ``'?'`` conversion code corresponds to the :c:type:`_Bool` type defined by
|
||||
C99. If this type is not available, it is simulated using a :c:type:`char`. In
|
||||
standard mode, it is always represented by one byte.
|
||||
|
|
@ -329,6 +331,8 @@ are used. Note that for :func:`unpack`, the ``'p'`` format character consumes
|
|||
``count`` bytes, but that the string returned can never contain more than 255
|
||||
bytes.
|
||||
|
||||
.. index:: single: ? (question mark); in struct format strings
|
||||
|
||||
For the ``'?'`` format character, the return value is either :const:`True` or
|
||||
:const:`False`. When packing, the truth value of the argument object is used.
|
||||
Either 0 or 1 in the native or standard bool representation will be packed, and
|
||||
|
|
|
|||
|
|
@ -370,7 +370,7 @@ Functions
|
|||
|
||||
|
||||
.. index::
|
||||
single: %; datetime format
|
||||
single: % (percent); datetime format
|
||||
|
||||
.. function:: strftime(format[, t])
|
||||
|
||||
|
|
@ -504,7 +504,7 @@ Functions
|
|||
|
||||
|
||||
.. index::
|
||||
single: %; datetime format
|
||||
single: % (percent); datetime format
|
||||
|
||||
.. function:: strptime(string[, format])
|
||||
|
||||
|
|
|
|||
|
|
@ -262,6 +262,8 @@ To make a widget in Tk, the command is always of the form::
|
|||
*classCommand*
|
||||
denotes which kind of widget to make (a button, a label, a menu...)
|
||||
|
||||
.. index:: single: . (dot); in Tkinter
|
||||
|
||||
*newPathname*
|
||||
is the new name for this widget. All names in Tk must be unique. To help
|
||||
enforce this, widgets in Tk are named with *pathnames*, just like files in a
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ The module defines the following functions:
|
|||
|
||||
* it prints the exception *etype* and *value* after the stack trace
|
||||
|
||||
.. index:: single: ^; caret
|
||||
.. index:: single: ^ (caret); marker
|
||||
|
||||
* if *type(value)* is :exc:`SyntaxError` and *value* has the appropriate
|
||||
format, it prints the line where the syntax error occurred with a caret
|
||||
|
|
|
|||
|
|
@ -225,7 +225,7 @@ This module offers the following functions:
|
|||
|
||||
|
||||
.. index::
|
||||
single: %; environment variables expansion (Windows)
|
||||
single: % (percent); environment variables expansion (Windows)
|
||||
|
||||
.. function:: ExpandEnvironmentStrings(str)
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ also syntactically compound statements.
|
|||
.. index::
|
||||
single: clause
|
||||
single: suite
|
||||
single: ;
|
||||
single: ; (semicolon)
|
||||
|
||||
A compound statement consists of one or more 'clauses.' A clause consists of a
|
||||
header and a 'suite.' The clause headers of a particular compound statement are
|
||||
|
|
@ -85,7 +85,7 @@ The :keyword:`if` statement
|
|||
statement: if
|
||||
keyword: elif
|
||||
keyword: else
|
||||
single: :; compound statement
|
||||
single: : (colon); compound statement
|
||||
|
||||
The :keyword:`if` statement is used for conditional execution:
|
||||
|
||||
|
|
@ -111,7 +111,7 @@ The :keyword:`while` statement
|
|||
keyword: else
|
||||
pair: loop; statement
|
||||
keyword: else
|
||||
single: :; compound statement
|
||||
single: : (colon); compound statement
|
||||
|
||||
The :keyword:`while` statement is used for repeated execution as long as an
|
||||
expression is true:
|
||||
|
|
@ -150,7 +150,7 @@ The :keyword:`for` statement
|
|||
keyword: else
|
||||
pair: target; list
|
||||
object: sequence
|
||||
single: :; compound statement
|
||||
single: : (colon); compound statement
|
||||
|
||||
The :keyword:`for` statement is used to iterate over the elements of a sequence
|
||||
(such as a string, tuple or list) or other iterable object:
|
||||
|
|
@ -233,7 +233,7 @@ The :keyword:`try` statement
|
|||
keyword: finally
|
||||
keyword: else
|
||||
keyword: as
|
||||
single: :; compound statement
|
||||
single: : (colon); compound statement
|
||||
|
||||
The :keyword:`try` statement specifies exception handlers and/or cleanup code
|
||||
for a group of statements:
|
||||
|
|
@ -384,8 +384,8 @@ The :keyword:`with` statement
|
|||
statement: with
|
||||
keyword: as
|
||||
single: as; with statement
|
||||
single: ,; with statement
|
||||
single: :; compound statement
|
||||
single: , (comma); with statement
|
||||
single: : (colon); compound statement
|
||||
|
||||
The :keyword:`with` statement is used to wrap the execution of a block with
|
||||
methods defined by a context manager (see section :ref:`context-managers`).
|
||||
|
|
@ -472,10 +472,9 @@ Function definitions
|
|||
object: function
|
||||
pair: function; name
|
||||
pair: name; binding
|
||||
single: (; function definition
|
||||
single: ); function definition
|
||||
single: ,; parameter list
|
||||
single: :; compound statement
|
||||
single: () (parentheses); function definition
|
||||
single: , (comma); parameter list
|
||||
single: : (colon); compound statement
|
||||
|
||||
A function definition defines a user-defined function object (see section
|
||||
:ref:`types`):
|
||||
|
|
@ -505,7 +504,7 @@ The function definition does not execute the function body; this gets executed
|
|||
only when the function is called. [#]_
|
||||
|
||||
.. index::
|
||||
single: @; function definition
|
||||
single: @ (at); function definition
|
||||
|
||||
A function definition may be wrapped by one or more :term:`decorator` expressions.
|
||||
Decorator expressions are evaluated when the function is defined, in the scope
|
||||
|
|
@ -528,7 +527,7 @@ except that the original function is not temporarily bound to the name ``func``.
|
|||
.. index::
|
||||
triple: default; parameter; value
|
||||
single: argument; function definition
|
||||
single: =; function definition
|
||||
single: = (equals); function definition
|
||||
|
||||
When one or more :term:`parameters <parameter>` have the form *parameter* ``=``
|
||||
*expression*, the function is said to have "default parameter values." For a
|
||||
|
|
@ -555,7 +554,7 @@ e.g.::
|
|||
return penguin
|
||||
|
||||
.. index::
|
||||
single: *; function definition
|
||||
single: * (asterisk); function definition
|
||||
single: **; function definition
|
||||
|
||||
Function call semantics are described in more detail in section :ref:`calls`. A
|
||||
|
|
@ -572,7 +571,7 @@ used keyword arguments.
|
|||
.. index::
|
||||
pair: function; annotations
|
||||
single: ->; function annotations
|
||||
single: :; function annotations
|
||||
single: : (colon); function annotations
|
||||
|
||||
Parameters may have annotations of the form "``: expression``" following the
|
||||
parameter name. Any parameter may have an annotation even those of the form
|
||||
|
|
@ -634,10 +633,9 @@ Class definitions
|
|||
pair: execution; frame
|
||||
single: inheritance
|
||||
single: docstring
|
||||
single: (; class definition
|
||||
single: ); class definition
|
||||
single: ,; expression list
|
||||
single: :; compound statement
|
||||
single: () (parentheses); class definition
|
||||
single: , (comma); expression list
|
||||
single: : (colon); compound statement
|
||||
|
||||
A class definition defines a class object (see section :ref:`types`):
|
||||
|
||||
|
|
@ -677,7 +675,7 @@ the definition syntax.
|
|||
Class creation can be customized heavily using :ref:`metaclasses <metaclasses>`.
|
||||
|
||||
.. index::
|
||||
single: @; class definition
|
||||
single: @ (at); class definition
|
||||
|
||||
Classes can also be decorated: just like when decorating functions, ::
|
||||
|
||||
|
|
|
|||
|
|
@ -1835,7 +1835,7 @@ Metaclasses
|
|||
.. index::
|
||||
single: metaclass
|
||||
builtin: type
|
||||
single: =; class definition
|
||||
single: = (equals); class definition
|
||||
|
||||
By default, classes are constructed using :func:`type`. The class body is
|
||||
executed in a new namespace and the class name is bound locally to the
|
||||
|
|
|
|||
|
|
@ -130,8 +130,7 @@ Parenthesized forms
|
|||
|
||||
.. index::
|
||||
single: parenthesized form
|
||||
single: (; tuple display
|
||||
single: ); tuple display
|
||||
single: () (parentheses); tuple display
|
||||
|
||||
A parenthesized form is an optional expression list enclosed in parentheses:
|
||||
|
||||
|
|
@ -151,7 +150,7 @@ tuple may or may not yield the same object).
|
|||
.. index::
|
||||
single: comma; tuple display
|
||||
pair: tuple; display
|
||||
single: ,; tuple display
|
||||
single: , (comma); tuple display
|
||||
|
||||
Note that tuples are not formed by the parentheses, but rather by use of the
|
||||
comma operator. The exception is the empty tuple, for which parentheses *are*
|
||||
|
|
@ -239,9 +238,8 @@ List displays
|
|||
pair: list; comprehensions
|
||||
pair: empty; list
|
||||
object: list
|
||||
single: [; list expression
|
||||
single: ]; list expression
|
||||
single: ,; expression list
|
||||
single: [] (square brackets); list expression
|
||||
single: , (comma); expression list
|
||||
|
||||
A list display is a possibly empty series of expressions enclosed in square
|
||||
brackets:
|
||||
|
|
@ -264,9 +262,8 @@ Set displays
|
|||
.. index::
|
||||
pair: set; display
|
||||
object: set
|
||||
single: {; set expression
|
||||
single: }; set expression
|
||||
single: ,; expression list
|
||||
single: {} (curly brackets); set expression
|
||||
single: , (comma); expression list
|
||||
|
||||
A set display is denoted by curly braces and distinguishable from dictionary
|
||||
displays by the lack of colons separating keys and values:
|
||||
|
|
@ -293,10 +290,9 @@ Dictionary displays
|
|||
pair: dictionary; display
|
||||
key, datum, key/datum pair
|
||||
object: dictionary
|
||||
single: {; dictionary expression
|
||||
single: }; dictionary expression
|
||||
single: :; in dictionary expressions
|
||||
single: ,; in dictionary displays
|
||||
single: {} (curly brackets); dictionary expression
|
||||
single: : (colon); in dictionary expressions
|
||||
single: , (comma); in dictionary displays
|
||||
|
||||
A dictionary display is a possibly empty series of key/datum pairs enclosed in
|
||||
curly braces:
|
||||
|
|
@ -350,8 +346,7 @@ Generator expressions
|
|||
.. index::
|
||||
pair: generator; expression
|
||||
object: generator
|
||||
single: (; generator expression
|
||||
single: ); generator expression
|
||||
single: () (parentheses); generator expression
|
||||
|
||||
A generator expression is a compact generator notation in parentheses:
|
||||
|
||||
|
|
@ -753,7 +748,7 @@ Attribute references
|
|||
|
||||
.. index::
|
||||
pair: attribute; reference
|
||||
single: .; attribute reference
|
||||
single: . (dot); attribute reference
|
||||
|
||||
An attribute reference is a primary followed by a period and a name:
|
||||
|
||||
|
|
@ -781,8 +776,7 @@ Subscriptions
|
|||
|
||||
.. index::
|
||||
single: subscription
|
||||
single: [; subscription
|
||||
single: ]; subscription
|
||||
single: [] (square brackets); subscription
|
||||
|
||||
.. index::
|
||||
object: sequence
|
||||
|
|
@ -839,8 +833,8 @@ Slicings
|
|||
.. index::
|
||||
single: slicing
|
||||
single: slice
|
||||
single: :; slicing
|
||||
single: ,; slicing
|
||||
single: : (colon); slicing
|
||||
single: , (comma); slicing
|
||||
|
||||
.. index::
|
||||
object: sequence
|
||||
|
|
@ -890,10 +884,9 @@ substituting ``None`` for missing expressions.
|
|||
object: callable
|
||||
single: call
|
||||
single: argument; call semantics
|
||||
single: (; call
|
||||
single: ); call
|
||||
single: ,; argument list
|
||||
single: =; in function calls
|
||||
single: () (parentheses); call
|
||||
single: , (comma); argument list
|
||||
single: = (equals); in function calls
|
||||
|
||||
.. _calls:
|
||||
|
||||
|
|
@ -970,7 +963,7 @@ and the argument values as corresponding values), or a (new) empty dictionary if
|
|||
there were no excess keyword arguments.
|
||||
|
||||
.. index::
|
||||
single: *; in function calls
|
||||
single: * (asterisk); in function calls
|
||||
single: unpacking; in function calls
|
||||
|
||||
If the syntax ``*expression`` appears in the function call, ``expression`` must
|
||||
|
|
@ -1142,21 +1135,21 @@ All unary arithmetic and bitwise operations have the same priority:
|
|||
.. index::
|
||||
single: negation
|
||||
single: minus
|
||||
single: operator; -
|
||||
single: -; unary operator
|
||||
single: operator; - (minus)
|
||||
single: - (minus); unary operator
|
||||
|
||||
The unary ``-`` (minus) operator yields the negation of its numeric argument.
|
||||
|
||||
.. index::
|
||||
single: plus
|
||||
single: operator; +
|
||||
single: +; unary operator
|
||||
single: operator; + (plus)
|
||||
single: + (plus); unary operator
|
||||
|
||||
The unary ``+`` (plus) operator yields its numeric argument unchanged.
|
||||
|
||||
.. index::
|
||||
single: inversion
|
||||
operator: ~
|
||||
operator: ~ (tilde)
|
||||
|
||||
The unary ``~`` (invert) operator yields the bitwise inversion of its integer
|
||||
argument. The bitwise inversion of ``x`` is defined as ``-(x+1)``. It only
|
||||
|
|
@ -1188,7 +1181,7 @@ operators and one for additive operators:
|
|||
|
||||
.. index::
|
||||
single: multiplication
|
||||
operator: *
|
||||
operator: * (asterisk)
|
||||
|
||||
The ``*`` (multiplication) operator yields the product of its arguments. The
|
||||
arguments must either both be numbers, or one argument must be an integer and
|
||||
|
|
@ -1198,7 +1191,7 @@ repetition is performed; a negative repetition factor yields an empty sequence.
|
|||
|
||||
.. index::
|
||||
single: matrix multiplication
|
||||
operator: @
|
||||
operator: @ (at)
|
||||
|
||||
The ``@`` (at) operator is intended to be used for matrix multiplication. No
|
||||
builtin Python types implement this operator.
|
||||
|
|
@ -1208,7 +1201,7 @@ builtin Python types implement this operator.
|
|||
.. index::
|
||||
exception: ZeroDivisionError
|
||||
single: division
|
||||
operator: /
|
||||
operator: / (slash)
|
||||
operator: //
|
||||
|
||||
The ``/`` (division) and ``//`` (floor division) operators yield the quotient of
|
||||
|
|
@ -1220,7 +1213,7 @@ exception.
|
|||
|
||||
.. index::
|
||||
single: modulo
|
||||
operator: %
|
||||
operator: % (percent)
|
||||
|
||||
The ``%`` (modulo) operator yields the remainder from the division of the first
|
||||
argument by the second. The numeric arguments are first converted to a common
|
||||
|
|
@ -1247,8 +1240,8 @@ point number using the :func:`abs` function if appropriate.
|
|||
|
||||
.. index::
|
||||
single: addition
|
||||
single: operator; +
|
||||
single: +; binary operator
|
||||
single: operator; + (plus)
|
||||
single: + (plus); binary operator
|
||||
|
||||
The ``+`` (addition) operator yields the sum of its arguments. The arguments
|
||||
must either both be numbers or both be sequences of the same type. In the
|
||||
|
|
@ -1257,8 +1250,8 @@ In the latter case, the sequences are concatenated.
|
|||
|
||||
.. index::
|
||||
single: subtraction
|
||||
single: operator; -
|
||||
single: -; binary operator
|
||||
single: operator; - (minus)
|
||||
single: - (minus); binary operator
|
||||
|
||||
The ``-`` (subtraction) operator yields the difference of its arguments. The
|
||||
numeric arguments are first converted to a common type.
|
||||
|
|
@ -1304,7 +1297,7 @@ Each of the three bitwise operations has a different priority level:
|
|||
|
||||
.. index::
|
||||
pair: bitwise; and
|
||||
operator: &
|
||||
operator: & (ampersand)
|
||||
|
||||
The ``&`` operator yields the bitwise AND of its arguments, which must be
|
||||
integers.
|
||||
|
|
@ -1312,7 +1305,7 @@ integers.
|
|||
.. index::
|
||||
pair: bitwise; xor
|
||||
pair: exclusive; or
|
||||
operator: ^
|
||||
operator: ^ (caret)
|
||||
|
||||
The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, which
|
||||
must be integers.
|
||||
|
|
@ -1320,7 +1313,7 @@ must be integers.
|
|||
.. index::
|
||||
pair: bitwise; or
|
||||
pair: inclusive; or
|
||||
operator: |
|
||||
operator: | (vertical bar)
|
||||
|
||||
The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which
|
||||
must be integers.
|
||||
|
|
@ -1334,8 +1327,8 @@ Comparisons
|
|||
.. index::
|
||||
single: comparison
|
||||
pair: C; language
|
||||
operator: <
|
||||
operator: >
|
||||
operator: < (less)
|
||||
operator: > (greater)
|
||||
operator: <=
|
||||
operator: >=
|
||||
operator: ==
|
||||
|
|
@ -1685,7 +1678,7 @@ Lambdas
|
|||
pair: lambda; expression
|
||||
pair: lambda; form
|
||||
pair: anonymous; function
|
||||
single: :; lambda expression
|
||||
single: : (colon); lambda expression
|
||||
|
||||
.. productionlist::
|
||||
lambda_expr: "lambda" [`parameter_list`] ":" `expression`
|
||||
|
|
@ -1712,8 +1705,7 @@ Expression lists
|
|||
|
||||
.. index::
|
||||
pair: expression; list
|
||||
single: comma; expression list
|
||||
single: ,; expression list
|
||||
single: , (comma); expression list
|
||||
|
||||
.. productionlist::
|
||||
expression_list: `expression` ("," `expression`)* [","]
|
||||
|
|
@ -1730,7 +1722,7 @@ evaluated from left to right.
|
|||
|
||||
.. index::
|
||||
pair: iterable; unpacking
|
||||
single: *; in expression lists
|
||||
single: * (asterisk); in expression lists
|
||||
|
||||
An asterisk ``*`` denotes :dfn:`iterable unpacking`. Its operand must be
|
||||
an :term:`iterable`. The iterable is expanded into a sequence of items,
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ Comments
|
|||
--------
|
||||
|
||||
.. index:: comment, hash character
|
||||
single: #; comment
|
||||
single: # (hash); comment
|
||||
|
||||
A comment starts with a hash character (``#``) that is not part of a string
|
||||
literal, and ends at the end of the physical line. A comment signifies the end
|
||||
|
|
@ -79,7 +79,7 @@ Encoding declarations
|
|||
---------------------
|
||||
|
||||
.. index:: source character set, encoding declarations (source file)
|
||||
single: #; source encoding declaration
|
||||
single: # (hash); source encoding declaration
|
||||
|
||||
If a comment in the first or second line of the Python script matches the
|
||||
regular expression ``coding[=:]\s*([-\w.]+)``, this comment is processed as an
|
||||
|
|
@ -401,8 +401,8 @@ Literals are notations for constant values of some built-in types.
|
|||
|
||||
|
||||
.. index:: string literal, bytes literal, ASCII
|
||||
single: '; string literal
|
||||
single: "; string literal
|
||||
single: ' (single quote); string literal
|
||||
single: " (double quote); string literal
|
||||
single: u'; string literal
|
||||
single: u"; string literal
|
||||
.. _strings:
|
||||
|
|
@ -495,7 +495,7 @@ retained), except that three unescaped quotes in a row terminate the literal. (
|
|||
"quote" is the character used to open the literal, i.e. either ``'`` or ``"``.)
|
||||
|
||||
.. index:: physical line, escape sequence, Standard C, C
|
||||
single: \; escape sequence
|
||||
single: \ (backslash); escape sequence
|
||||
single: \\; escape sequence
|
||||
single: \a; escape sequence
|
||||
single: \b; escape sequence
|
||||
|
|
@ -639,10 +639,9 @@ and formatted string literals may be concatenated with plain string literals.
|
|||
single: string; formatted literal
|
||||
single: string; interpolated literal
|
||||
single: f-string
|
||||
single: {; in formatted string literal
|
||||
single: }; in formatted string literal
|
||||
single: !; in formatted string literal
|
||||
single: :; in formatted string literal
|
||||
single: {} (curly brackets); in formatted string literal
|
||||
single: ! (exclamation); in formatted string literal
|
||||
single: : (colon); in formatted string literal
|
||||
.. _f-strings:
|
||||
|
||||
Formatted string literals
|
||||
|
|
@ -781,7 +780,7 @@ actually an expression composed of the unary operator '``-``' and the literal
|
|||
single: 0b; integer literal
|
||||
single: 0o; integer literal
|
||||
single: 0x; integer literal
|
||||
single: _; in numeric literal
|
||||
single: _ (underscore); in numeric literal
|
||||
|
||||
.. _integers:
|
||||
|
||||
|
|
@ -824,9 +823,9 @@ Some examples of integer literals::
|
|||
|
||||
|
||||
.. index::
|
||||
single: .; in numeric literal
|
||||
single: . (dot); in numeric literal
|
||||
single: e; in numeric literal
|
||||
single: _; in numeric literal
|
||||
single: _ (underscore); in numeric literal
|
||||
.. _floating:
|
||||
|
||||
Floating point literals
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ Assignment statements
|
|||
=====================
|
||||
|
||||
.. index::
|
||||
single: =; assignment statement
|
||||
single: = (equals); assignment statement
|
||||
pair: assignment; statement
|
||||
pair: binding; name
|
||||
pair: rebinding; name
|
||||
|
|
@ -112,12 +112,10 @@ unacceptable. The rules observed by various types and the exceptions raised are
|
|||
given with the definition of the object types (see section :ref:`types`).
|
||||
|
||||
.. index:: triple: target; list; assignment
|
||||
single: ,; in target list
|
||||
single: *; in assignment target list
|
||||
single: [; in assignment target list
|
||||
single: ]; in assignment target list
|
||||
single: (; in assignment target list
|
||||
single: ); in assignment target list
|
||||
single: , (comma); in target list
|
||||
single: * (asterisk); in assignment target list
|
||||
single: [] (square brackets); in assignment target list
|
||||
single: () (parentheses); in assignment target list
|
||||
|
||||
Assignment of an object to a target list, optionally enclosed in parentheses or
|
||||
square brackets, is recursively defined as follows.
|
||||
|
|
@ -327,7 +325,7 @@ Annotated assignment statements
|
|||
.. index::
|
||||
pair: annotated; assignment
|
||||
single: statement; assignment, annotated
|
||||
single: :; annotated variable
|
||||
single: : (colon); annotated variable
|
||||
|
||||
Annotation assignment is the combination, in a single statement,
|
||||
of a variable or attribute annotation and an optional assignment statement:
|
||||
|
|
@ -379,7 +377,7 @@ The :keyword:`assert` statement
|
|||
.. index::
|
||||
statement: assert
|
||||
pair: debugging; assertions
|
||||
single: ,; expression list
|
||||
single: , (comma); expression list
|
||||
|
||||
Assert statements are a convenient way to insert debugging assertions into a
|
||||
program:
|
||||
|
|
@ -722,7 +720,7 @@ The :keyword:`import` statement
|
|||
keyword: from
|
||||
keyword: as
|
||||
exception: ImportError
|
||||
single: ,; import statement
|
||||
single: , (comma); import statement
|
||||
|
||||
.. productionlist::
|
||||
import_stmt: "import" `module` ["as" `identifier`] ("," `module` ["as" `identifier`])*
|
||||
|
|
@ -796,7 +794,7 @@ Examples::
|
|||
from foo.bar import baz # foo.bar.baz imported and bound as baz
|
||||
from foo import attr # foo imported and foo.attr bound as attr
|
||||
|
||||
.. index:: single: *; import statement
|
||||
.. index:: single: * (asterisk); import statement
|
||||
|
||||
If the list of identifiers is replaced by a star (``'*'``), all public
|
||||
names defined in the module are bound in the local namespace for the scope
|
||||
|
|
@ -932,7 +930,7 @@ The :keyword:`global` statement
|
|||
.. index::
|
||||
statement: global
|
||||
triple: global; name; binding
|
||||
single: ,; identifier list
|
||||
single: , (comma); identifier list
|
||||
|
||||
.. productionlist::
|
||||
global_stmt: "global" `identifier` ("," `identifier`)*
|
||||
|
|
@ -977,7 +975,7 @@ The :keyword:`nonlocal` statement
|
|||
=================================
|
||||
|
||||
.. index:: statement: nonlocal
|
||||
single: ,; identifier list
|
||||
single: , (comma); identifier list
|
||||
|
||||
.. productionlist::
|
||||
nonlocal_stmt: "nonlocal" `identifier` ("," `identifier`)*
|
||||
|
|
|
|||
|
|
@ -526,7 +526,7 @@ Arbitrary Argument Lists
|
|||
------------------------
|
||||
|
||||
.. index::
|
||||
single: *; in function calls
|
||||
single: * (asterisk); in function calls
|
||||
|
||||
Finally, the least frequently used option is to specify that a function can be
|
||||
called with an arbitrary number of arguments. These arguments will be wrapped
|
||||
|
|
@ -676,7 +676,7 @@ Function Annotations
|
|||
.. index::
|
||||
pair: function; annotations
|
||||
single: ->; function annotations
|
||||
single: :; function annotations
|
||||
single: : (colon); function annotations
|
||||
|
||||
:ref:`Function annotations <function>` are completely optional metadata
|
||||
information about the types used by user-defined functions (see :pep:`3107` and
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ with a prompt are output from the interpreter. Note that a secondary prompt on a
|
|||
line by itself in an example means you must type a blank line; this is used to
|
||||
end a multi-line command.
|
||||
|
||||
.. index:: single: #; comment
|
||||
.. index:: single: # (hash); comment
|
||||
|
||||
Many of the examples in this manual, even those entered at the interactive
|
||||
prompt, include comments. Comments in Python start with the hash character,
|
||||
|
|
|
|||
Loading…
Reference in New Issue