From 913876d824d969f8c7431e8a9d4610a9a11a786e Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Sun, 28 Oct 2018 13:41:26 +0200 Subject: bpo-35054: Add yet more index entries for symbols. (GH-10121) --- Doc/library/argparse.rst | 6 +++ Doc/library/ast.rst | 3 ++ Doc/library/cmd.rst | 4 ++ Doc/library/codecs.rst | 8 ++++ Doc/library/configparser.rst | 4 +- Doc/library/curses.ascii.rst | 4 ++ Doc/library/datetime.rst | 2 +- Doc/library/doctest.rst | 8 ++-- Doc/library/fnmatch.rst | 7 ++++ Doc/library/gettext.rst | 2 +- Doc/library/glob.rst | 11 +++++ Doc/library/os.path.rst | 6 +-- Doc/library/os.rst | 13 +++--- Doc/library/re.rst | 35 +++++++--------- Doc/library/site.rst | 2 +- Doc/library/sqlite3.rst | 3 ++ Doc/library/stdtypes.rst | 60 +++++++++++++------------- Doc/library/string.rst | 32 +++++++------- Doc/library/struct.rst | 14 ++++--- Doc/library/time.rst | 4 +- Doc/library/tkinter.rst | 2 + Doc/library/traceback.rst | 2 +- Doc/library/winreg.rst | 2 +- Doc/reference/compound_stmts.rst | 38 ++++++++--------- Doc/reference/datamodel.rst | 2 +- Doc/reference/expressions.rst | 86 +++++++++++++++++--------------------- Doc/reference/lexical_analysis.rst | 23 +++++----- Doc/reference/simple_stmts.rst | 24 +++++------ Doc/tutorial/controlflow.rst | 4 +- Doc/tutorial/introduction.rst | 2 +- 30 files changed, 223 insertions(+), 190 deletions(-) diff --git a/Doc/library/argparse.rst b/Doc/library/argparse.rst index 1973afc..cef197f 100644 --- a/Doc/library/argparse.rst +++ b/Doc/library/argparse.rst @@ -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='' encoding='UTF-8'>, outfile=<_io.TextIOWrapper name='' 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:: diff --git a/Doc/library/ast.rst b/Doc/library/ast.rst index 97ce2f5..2883f3c 100644 --- a/Doc/library/ast.rst +++ b/Doc/library/ast.rst @@ -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 diff --git a/Doc/library/cmd.rst b/Doc/library/cmd.rst index 3b4a8ff..d57edb7 100644 --- a/Doc/library/cmd.rst +++ b/Doc/library/cmd.rst @@ -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 diff --git a/Doc/library/codecs.rst b/Doc/library/codecs.rst index b323ab5..65f41f6 100644 --- a/Doc/library/codecs.rst +++ b/Doc/library/codecs.rst @@ -312,6 +312,14 @@ defined and implemented by all standard Python codecs: The following error handlers are only applicable to :term:`text encodings `: +.. 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 | +=========================+===============================================+ diff --git a/Doc/library/configparser.rst b/Doc/library/configparser.rst index 1a5417f..efafd63 100644 --- a/Doc/library/configparser.rst +++ b/Doc/library/configparser.rst @@ -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() diff --git a/Doc/library/curses.ascii.rst b/Doc/library/curses.ascii.rst index 04b2a26..a69dbb2 100644 --- a/Doc/library/curses.ascii.rst +++ b/Doc/library/curses.ascii.rst @@ -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, diff --git a/Doc/library/datetime.rst b/Doc/library/datetime.rst index e7a0fdb..a1a60b0 100644 --- a/Doc/library/datetime.rst +++ b/Doc/library/datetime.rst @@ -2000,7 +2000,7 @@ Class attributes: .. index:: - single: %; datetime format + single: % (percent); datetime format .. _strftime-strptime-behavior: diff --git a/Doc/library/doctest.rst b/Doc/library/doctest.rst index 9988429..e7c0033 100644 --- a/Doc/library/doctest.rst +++ b/Doc/library/doctest.rst @@ -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 diff --git a/Doc/library/fnmatch.rst b/Doc/library/fnmatch.rst index abf9523..ecba4aa 100644 --- a/Doc/library/fnmatch.rst +++ b/Doc/library/fnmatch.rst @@ -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 | +============+====================================+ diff --git a/Doc/library/gettext.rst b/Doc/library/gettext.rst index 0a9456a..ef315e0 100644 --- a/Doc/library/gettext.rst +++ b/Doc/library/gettext.rst @@ -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 diff --git a/Doc/library/glob.rst b/Doc/library/glob.rst index 25bd4b7..0db10b5 100644 --- a/Doc/library/glob.rst +++ b/Doc/library/glob.rst @@ -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. diff --git a/Doc/library/os.path.rst b/Doc/library/os.path.rst index 03644e2..469b262 100644 --- a/Doc/library/os.path.rst +++ b/Doc/library/os.path.rst @@ -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) diff --git a/Doc/library/os.rst b/Doc/library/os.rst index b174b9d..6a9fe36 100644 --- a/Doc/library/os.rst +++ b/Doc/library/os.rst @@ -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 diff --git a/Doc/library/re.rst b/Doc/library/re.rst index 57d7402..31fb628 100644 --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -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 ``''``. .. 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 diff --git a/Doc/library/site.rst b/Doc/library/site.rst index e6a2980..7974e20 100644 --- a/Doc/library/site.rst +++ b/Doc/library/site.rst @@ -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` diff --git a/Doc/library/sqlite3.rst b/Doc/library/sqlite3.rst index 9e3c56b..37087ac 100644 --- a/Doc/library/sqlite3.rst +++ b/Doc/library/sqlite3.rst @@ -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. diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst index 381374c..4686cec 100644 --- a/Doc/library/stdtypes.rst +++ b/Doc/library/stdtypes.rst @@ -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 +---------+---------------------------------------------------------------------+ diff --git a/Doc/library/string.rst b/Doc/library/string.rst index 55913f8..7ed52ab 100644 --- a/Doc/library/string.rst +++ b/Doc/library/string.rst @@ -193,13 +193,11 @@ related to that of :ref:`formatted string literals `, 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 `_ package. -.. index:: single: $; in template strings +.. index:: single: $ (dollar); in template strings Template strings support ``$``-based substitutions, using the following rules: diff --git a/Doc/library/struct.rst b/Doc/library/struct.rst index 9ba4047..1a0fd73 100644 --- a/Doc/library/struct.rst +++ b/Doc/library/struct.rst @@ -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 diff --git a/Doc/library/time.rst b/Doc/library/time.rst index d76e089..c6a1f33 100644 --- a/Doc/library/time.rst +++ b/Doc/library/time.rst @@ -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]) diff --git a/Doc/library/tkinter.rst b/Doc/library/tkinter.rst index d9c1c35..4af4b73 100644 --- a/Doc/library/tkinter.rst +++ b/Doc/library/tkinter.rst @@ -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 diff --git a/Doc/library/traceback.rst b/Doc/library/traceback.rst index a21ef8e..462a6a5 100644 --- a/Doc/library/traceback.rst +++ b/Doc/library/traceback.rst @@ -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 diff --git a/Doc/library/winreg.rst b/Doc/library/winreg.rst index 99be47f..e9c0261 100644 --- a/Doc/library/winreg.rst +++ b/Doc/library/winreg.rst @@ -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) diff --git a/Doc/reference/compound_stmts.rst b/Doc/reference/compound_stmts.rst index fe745ee..0dc7ecf 100644 --- a/Doc/reference/compound_stmts.rst +++ b/Doc/reference/compound_stmts.rst @@ -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 ` 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 `. .. index:: - single: @; class definition + single: @ (at); class definition Classes can also be decorated: just like when decorating functions, :: diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst index efbc872..6067c72 100644 --- a/Doc/reference/datamodel.rst +++ b/Doc/reference/datamodel.rst @@ -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 diff --git a/Doc/reference/expressions.rst b/Doc/reference/expressions.rst index fdbbba1..fd7df4c 100644 --- a/Doc/reference/expressions.rst +++ b/Doc/reference/expressions.rst @@ -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, diff --git a/Doc/reference/lexical_analysis.rst b/Doc/reference/lexical_analysis.rst index b197f23..6ec2f8e 100644 --- a/Doc/reference/lexical_analysis.rst +++ b/Doc/reference/lexical_analysis.rst @@ -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 diff --git a/Doc/reference/simple_stmts.rst b/Doc/reference/simple_stmts.rst index 0ac7953..1fe1cde 100644 --- a/Doc/reference/simple_stmts.rst +++ b/Doc/reference/simple_stmts.rst @@ -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`)* diff --git a/Doc/tutorial/controlflow.rst b/Doc/tutorial/controlflow.rst index f87cd4d..c407ad4 100644 --- a/Doc/tutorial/controlflow.rst +++ b/Doc/tutorial/controlflow.rst @@ -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 ` are completely optional metadata information about the types used by user-defined functions (see :pep:`3107` and diff --git a/Doc/tutorial/introduction.rst b/Doc/tutorial/introduction.rst index f5a394a..3e0c995 100644 --- a/Doc/tutorial/introduction.rst +++ b/Doc/tutorial/introduction.rst @@ -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, -- cgit v0.12