mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-04 00:48:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

bpo-35054: Add yet more index entries for symbols. (GH-10121)

Browse source
This commit is contained in:
Serhiy Storchaka 2018-10-28 13:41:26 +02:00 • committed by GitHub
parent 95f68b10d5
commit 913876d824
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
30 changed files with 223 additions and 190 deletions
Download patch file Download diff file Expand all files Collapse all files

38
Doc/reference/compound_stmts.rst
View file

@ -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, ::

2
Doc/reference/datamodel.rst
View file

@ -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

86
Doc/reference/expressions.rst
View file

@ -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,

23
Doc/reference/lexical_analysis.rst
View file

@ -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

24
Doc/reference/simple_stmts.rst
View file

@ -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`)*