bpo-35054: Add more index entries for symbols. (GH-10064)
diff --git a/Doc/reference/expressions.rst b/Doc/reference/expressions.rst
index f4b1618..fdbbba1 100644
--- a/Doc/reference/expressions.rst
+++ b/Doc/reference/expressions.rst
@@ -128,7 +128,10 @@
Parenthesized forms
-------------------
-.. index:: single: parenthesized form
+.. index::
+ single: parenthesized form
+ single: (; tuple display
+ single: ); tuple display
A parenthesized form is an optional expression list enclosed in parentheses:
@@ -146,8 +149,9 @@
tuple may or may not yield the same object).
.. index::
- single: comma
+ single: comma; tuple display
pair: tuple; display
+ single: ,; 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*
@@ -168,6 +172,11 @@
* they are computed via a set of looping and filtering instructions, called a
:dfn:`comprehension`.
+.. index::
+ single: for; in comprehensions
+ single: if; in comprehensions
+ single: async for; in comprehensions
+
Common syntax elements for comprehensions are:
.. productionlist::
@@ -198,6 +207,9 @@
type, ``yield`` and ``yield from`` expressions are prohibited in the implicitly
nested scope.
+.. index::
+ single: await; in comprehensions
+
Since Python 3.6, in an :keyword:`async def` function, an :keyword:`async for`
clause may be used to iterate over a :term:`asynchronous iterator`.
A comprehension in an :keyword:`async def` function may consist of either a
@@ -227,6 +239,9 @@
pair: list; comprehensions
pair: empty; list
object: list
+ single: [; list expression
+ single: ]; list expression
+ single: ,; expression list
A list display is a possibly empty series of expressions enclosed in square
brackets:
@@ -246,8 +261,12 @@
Set displays
------------
-.. index:: pair: set; display
- object: set
+.. index::
+ pair: set; display
+ object: set
+ single: {; set expression
+ single: }; set expression
+ single: ,; expression list
A set display is denoted by curly braces and distinguishable from dictionary
displays by the lack of colons separating keys and values:
@@ -270,9 +289,14 @@
Dictionary displays
-------------------
-.. index:: pair: dictionary; display
- key, datum, key/datum pair
- object: dictionary
+.. index::
+ pair: dictionary; display
+ key, datum, key/datum pair
+ object: dictionary
+ single: {; dictionary expression
+ single: }; dictionary expression
+ single: :; in dictionary expressions
+ single: ,; in dictionary displays
A dictionary display is a possibly empty series of key/datum pairs enclosed in
curly braces:
@@ -291,7 +315,9 @@
that you can specify the same key multiple times in the key/datum list, and the
final dictionary's value for that key will be the last one given.
-.. index:: unpacking; dictionary, **; in dictionary displays
+.. index::
+ unpacking; dictionary
+ single: **; in dictionary displays
A double asterisk ``**`` denotes :dfn:`dictionary unpacking`.
Its operand must be a :term:`mapping`. Each mapping item is added
@@ -321,8 +347,11 @@
Generator expressions
---------------------
-.. index:: pair: generator; expression
- object: generator
+.. index::
+ pair: generator; expression
+ object: generator
+ single: (; generator expression
+ single: ); generator expression
A generator expression is a compact generator notation in parentheses:
@@ -376,6 +405,7 @@
.. index::
keyword: yield
+ keyword: from
pair: yield; expression
pair: generator; function
@@ -439,6 +469,9 @@
the generator-iterator's :meth:`~generator.close` method will be called,
allowing any pending :keyword:`finally` clauses to execute.
+.. index::
+ single: from; yield from expression
+
When ``yield from <expr>`` is used, it treats the supplied expression as
a subiterator. All values produced by that subiterator are passed directly
to the caller of the current generator's methods. Any values passed in with
@@ -718,7 +751,9 @@
Attribute references
--------------------
-.. index:: pair: attribute; reference
+.. index::
+ pair: attribute; reference
+ single: .; attribute reference
An attribute reference is a primary followed by a period and a name:
@@ -744,7 +779,10 @@
Subscriptions
-------------
-.. index:: single: subscription
+.. index::
+ single: subscription
+ single: [; subscription
+ single: ]; subscription
.. index::
object: sequence
@@ -801,6 +839,8 @@
.. index::
single: slicing
single: slice
+ single: :; slicing
+ single: ,; slicing
.. index::
object: sequence
@@ -850,6 +890,10 @@
object: callable
single: call
single: argument; call semantics
+ single: (; call
+ single: ); call
+ single: ,; argument list
+ single: =; in function calls
.. _calls:
@@ -1032,6 +1076,7 @@
if that method was called.
+.. index:: keyword: await
.. _await:
Await expression
@@ -1051,6 +1096,10 @@
The power operator
==================
+.. index::
+ pair: power; operation
+ operator: **
+
The power operator binds more tightly than unary operators on its left; it binds
less tightly than unary operators on its right. The syntax is:
@@ -1093,15 +1142,21 @@
.. index::
single: negation
single: minus
+ single: operator; -
+ single: -; unary operator
The unary ``-`` (minus) operator yields the negation of its numeric argument.
-.. index:: single: plus
+.. index::
+ single: plus
+ single: operator; +
+ single: +; unary operator
The unary ``+`` (plus) operator yields its numeric argument unchanged.
-.. index:: single: inversion
-
+.. index::
+ single: inversion
+ operator: ~
The unary ``~`` (invert) operator yields the bitwise inversion of its integer
argument. The bitwise inversion of ``x`` is defined as ``-(x+1)``. It only
@@ -1131,7 +1186,9 @@
: `m_expr` "%" `u_expr`
a_expr: `m_expr` | `a_expr` "+" `m_expr` | `a_expr` "-" `m_expr`
-.. index:: single: multiplication
+.. index::
+ single: multiplication
+ operator: *
The ``*`` (multiplication) operator yields the product of its arguments. The
arguments must either both be numbers, or one argument must be an integer and
@@ -1151,6 +1208,8 @@
.. index::
exception: ZeroDivisionError
single: division
+ operator: /
+ operator: //
The ``/`` (division) and ``//`` (floor division) operators yield the quotient of
their arguments. The numeric arguments are first converted to a common type.
@@ -1159,7 +1218,9 @@
applied to the result. Division by zero raises the :exc:`ZeroDivisionError`
exception.
-.. index:: single: modulo
+.. index::
+ single: modulo
+ operator: %
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
@@ -1184,14 +1245,20 @@
function are not defined for complex numbers. Instead, convert to a floating
point number using the :func:`abs` function if appropriate.
-.. index:: single: addition
+.. index::
+ single: addition
+ single: operator; +
+ single: +; 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
former case, the numbers are converted to a common type and then added together.
In the latter case, the sequences are concatenated.
-.. index:: single: subtraction
+.. index::
+ single: subtraction
+ single: operator; -
+ single: -; binary operator
The ``-`` (subtraction) operator yields the difference of its arguments. The
numeric arguments are first converted to a common type.
@@ -1202,7 +1269,10 @@
Shifting operations
===================
-.. index:: pair: shifting; operation
+.. index::
+ pair: shifting; operation
+ operator: <<
+ operator: >>
The shifting operations have lower priority than the arithmetic operations:
@@ -1232,7 +1302,9 @@
xor_expr: `and_expr` | `xor_expr` "^" `and_expr`
or_expr: `xor_expr` | `or_expr` "|" `xor_expr`
-.. index:: pair: bitwise; and
+.. index::
+ pair: bitwise; and
+ operator: &
The ``&`` operator yields the bitwise AND of its arguments, which must be
integers.
@@ -1240,6 +1312,7 @@
.. index::
pair: bitwise; xor
pair: exclusive; or
+ operator: ^
The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, which
must be integers.
@@ -1247,6 +1320,7 @@
.. index::
pair: bitwise; or
pair: inclusive; or
+ operator: |
The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which
must be integers.
@@ -1257,9 +1331,15 @@
Comparisons
===========
-.. index:: single: comparison
-
-.. index:: pair: C; language
+.. index::
+ single: comparison
+ pair: C; language
+ operator: <
+ operator: >
+ operator: <=
+ operator: >=
+ operator: ==
+ operator: !=
Unlike C, all comparison operations in Python have the same priority, which is
lower than that of any arithmetic, shifting or bitwise operation. Also unlike
@@ -1577,6 +1657,8 @@
.. index::
pair: conditional; expression
pair: ternary; operator
+ single: if; conditional expression
+ single: else; conditional expression
.. productionlist::
conditional_expression: `or_test` ["if" `or_test` "else" `expression`]
@@ -1603,10 +1685,11 @@
pair: lambda; expression
pair: lambda; form
pair: anonymous; function
+ single: :; lambda expression
.. productionlist::
- lambda_expr: "lambda" [`parameter_list`]: `expression`
- lambda_expr_nocond: "lambda" [`parameter_list`]: `expression_nocond`
+ lambda_expr: "lambda" [`parameter_list`] ":" `expression`
+ lambda_expr_nocond: "lambda" [`parameter_list`] ":" `expression_nocond`
Lambda expressions (sometimes called lambda forms) are used to create anonymous
functions. The expression ``lambda parameters: expression`` yields a function
@@ -1627,7 +1710,10 @@
Expression lists
================
-.. index:: pair: expression; list
+.. index::
+ pair: expression; list
+ single: comma; expression list
+ single: ,; expression list
.. productionlist::
expression_list: `expression` ("," `expression`)* [","]
@@ -1689,7 +1775,8 @@
Operator precedence
===================
-.. index:: pair: operator; precedence
+.. index::
+ pair: operator; precedence
The following table summarizes the operator precedence in Python, from lowest
precedence (least binding) to highest precedence (most binding). Operators in
@@ -1737,7 +1824,7 @@
+-----------------------------------------------+-------------------------------------+
| ``**`` | Exponentiation [#]_ |
+-----------------------------------------------+-------------------------------------+
-| ``await`` ``x`` | Await expression |
+| :keyword:`await` ``x`` | Await expression |
+-----------------------------------------------+-------------------------------------+
| ``x[index]``, ``x[index:index]``, | Subscription, slicing, |
| ``x(arguments...)``, ``x.attribute`` | call, attribute reference |