mirror of
https://github.com/python/cpython.git
synced 2025-08-07 18:38:38 +00:00
Python 3.12.5
This commit is contained in:
Thomas Wouters
parent
b895f1804f
commit
ff3bc82f7c
77 changed files with 935 additions and 287 deletions
|
|
@ -1,5 +1,5 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Autogenerated by Sphinx on Thu Jun 6 20:20:21 2024
|
||||
# Autogenerated by Sphinx on Tue Aug 6 21:02:50 2024
|
||||
# as part of the release process.
|
||||
topics = {'assert': 'The "assert" statement\n'
|
||||
'**********************\n'
|
||||
|
|
@ -308,10 +308,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'target.\n'
|
||||
'The target is only evaluated once.\n'
|
||||
'\n'
|
||||
'An augmented assignment expression like "x += 1" can be '
|
||||
'rewritten as\n'
|
||||
'"x = x + 1" to achieve a similar, but not exactly equal '
|
||||
'effect. In the\n'
|
||||
'An augmented assignment statement like "x += 1" can be '
|
||||
'rewritten as "x\n'
|
||||
'= x + 1" to achieve a similar, but not exactly equal effect. '
|
||||
'In the\n'
|
||||
'augmented version, "x" is only evaluated once. Also, when '
|
||||
'possible,\n'
|
||||
'the actual operation is performed *in-place*, meaning that '
|
||||
|
|
@ -362,21 +362,26 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'a single\n'
|
||||
'target is allowed.\n'
|
||||
'\n'
|
||||
'For simple names as assignment targets, if in class or module '
|
||||
'scope,\n'
|
||||
'the annotations are evaluated and stored in a special class or '
|
||||
'module\n'
|
||||
'attribute "__annotations__" that is a dictionary mapping from '
|
||||
'variable\n'
|
||||
'names (mangled if private) to evaluated annotations. This '
|
||||
'attribute is\n'
|
||||
'writable and is automatically created at the start of class or '
|
||||
'module\n'
|
||||
'body execution, if annotations are found statically.\n'
|
||||
'\n'
|
||||
'For expressions as assignment targets, the annotations are '
|
||||
'The assignment target is considered “simple” if it consists of '
|
||||
'a\n'
|
||||
'single name that is not enclosed in parentheses. For simple '
|
||||
'assignment\n'
|
||||
'targets, if in class or module scope, the annotations are '
|
||||
'evaluated\n'
|
||||
'if in class or module scope, but not stored.\n'
|
||||
'and stored in a special class or module attribute '
|
||||
'"__annotations__"\n'
|
||||
'that is a dictionary mapping from variable names (mangled if '
|
||||
'private)\n'
|
||||
'to evaluated annotations. This attribute is writable and is\n'
|
||||
'automatically created at the start of class or module body '
|
||||
'execution,\n'
|
||||
'if annotations are found statically.\n'
|
||||
'\n'
|
||||
'If the assignment target is not simple (an attribute, '
|
||||
'subscript node,\n'
|
||||
'or parenthesized name), the annotation is evaluated if in '
|
||||
'class or\n'
|
||||
'module scope, but not stored.\n'
|
||||
'\n'
|
||||
'If a name is annotated in a function scope, then this name is '
|
||||
'local\n'
|
||||
|
|
@ -555,31 +560,67 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'evaluate it\n'
|
||||
'raises a "NameError" exception.\n'
|
||||
'\n'
|
||||
'**Private name mangling:** When an identifier that '
|
||||
'textually occurs in\n'
|
||||
'a class definition begins with two or more underscore '
|
||||
'characters and\n'
|
||||
'does not end in two or more underscores, it is '
|
||||
'considered a *private\n'
|
||||
'name* of that class. Private names are transformed to a '
|
||||
'longer form\n'
|
||||
'before code is generated for them. The transformation '
|
||||
'inserts the\n'
|
||||
'class name, with leading underscores removed and a '
|
||||
'single underscore\n'
|
||||
'inserted, in front of the name. For example, the '
|
||||
'identifier "__spam"\n'
|
||||
'occurring in a class named "Ham" will be transformed to '
|
||||
'"_Ham__spam".\n'
|
||||
'This transformation is independent of the syntactical '
|
||||
'\n'
|
||||
'Private name mangling\n'
|
||||
'=====================\n'
|
||||
'\n'
|
||||
'When an identifier that textually occurs in a class '
|
||||
'definition begins\n'
|
||||
'with two or more underscore characters and does not end '
|
||||
'in two or more\n'
|
||||
'underscores, it is considered a *private name* of that '
|
||||
'class.\n'
|
||||
'\n'
|
||||
'See also: The class specifications.\n'
|
||||
'\n'
|
||||
'More precisely, private names are transformed to a '
|
||||
'longer form before\n'
|
||||
'code is generated for them. If the transformed name is '
|
||||
'longer than\n'
|
||||
'255 characters, implementation-defined truncation may '
|
||||
'happen.\n'
|
||||
'\n'
|
||||
'The transformation is independent of the syntactical '
|
||||
'context in which\n'
|
||||
'the identifier is used. If the transformed name is '
|
||||
'extremely long\n'
|
||||
'(longer than 255 characters), implementation defined '
|
||||
'truncation may\n'
|
||||
'happen. If the class name consists only of underscores, '
|
||||
'no\n'
|
||||
'transformation is done.\n',
|
||||
'the identifier is used but only the following private '
|
||||
'identifiers are\n'
|
||||
'mangled:\n'
|
||||
'\n'
|
||||
'* Any name used as the name of a variable that is '
|
||||
'assigned or read or\n'
|
||||
' any name of an attribute being accessed.\n'
|
||||
'\n'
|
||||
' The "__name__" attribute of nested functions, classes, '
|
||||
'and type\n'
|
||||
' aliases is however not mangled.\n'
|
||||
'\n'
|
||||
'* The name of imported modules, e.g., "__spam" in '
|
||||
'"import __spam". If\n'
|
||||
' the module is part of a package (i.e., its name '
|
||||
'contains a dot), the\n'
|
||||
' name is *not* mangled, e.g., the "__foo" in "import '
|
||||
'__foo.bar" is\n'
|
||||
' not mangled.\n'
|
||||
'\n'
|
||||
'* The name of an imported member, e.g., "__f" in "from '
|
||||
'spam import\n'
|
||||
' __f".\n'
|
||||
'\n'
|
||||
'The transformation rule is defined as follows:\n'
|
||||
'\n'
|
||||
'* The class name, with leading underscores removed and a '
|
||||
'single\n'
|
||||
' leading underscore inserted, is inserted in front of '
|
||||
'the identifier,\n'
|
||||
' e.g., the identifier "__spam" occurring in a class '
|
||||
'named "Foo",\n'
|
||||
' "_Foo" or "__Foo" is transformed to "_Foo__spam".\n'
|
||||
'\n'
|
||||
'* If the class name consists only of underscores, the '
|
||||
'transformation\n'
|
||||
' is the identity, e.g., the identifier "__spam" '
|
||||
'occurring in a class\n'
|
||||
' named "_" or "__" is left as is.\n',
|
||||
'atom-literals': 'Literals\n'
|
||||
'********\n'
|
||||
'\n'
|
||||
|
|
@ -592,10 +633,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'Evaluation of a literal yields an object of the given type '
|
||||
'(string,\n'
|
||||
'bytes, integer, floating point number, complex number) with '
|
||||
'bytes, integer, floating-point number, complex number) with '
|
||||
'the given\n'
|
||||
'value. The value may be approximated in the case of '
|
||||
'floating point\n'
|
||||
'floating-point\n'
|
||||
'and imaginary (complex) literals. See section Literals for '
|
||||
'details.\n'
|
||||
'\n'
|
||||
|
|
@ -1163,10 +1204,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'target.\n'
|
||||
'The target is only evaluated once.\n'
|
||||
'\n'
|
||||
'An augmented assignment expression like "x += 1" can be '
|
||||
'rewritten as\n'
|
||||
'"x = x + 1" to achieve a similar, but not exactly equal effect. '
|
||||
'In the\n'
|
||||
'An augmented assignment statement like "x += 1" can be '
|
||||
'rewritten as "x\n'
|
||||
'= x + 1" to achieve a similar, but not exactly equal effect. In '
|
||||
'the\n'
|
||||
'augmented version, "x" is only evaluated once. Also, when '
|
||||
'possible,\n'
|
||||
'the actual operation is performed *in-place*, meaning that '
|
||||
|
|
@ -1239,6 +1280,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'The "@" (at) operator is intended to be used for matrix\n'
|
||||
'multiplication. No builtin Python types implement this operator.\n'
|
||||
'\n'
|
||||
'This operation can be customized using the special "__matmul__()" '
|
||||
'and\n'
|
||||
'"__rmatmul__()" methods.\n'
|
||||
'\n'
|
||||
'Added in version 3.5.\n'
|
||||
'\n'
|
||||
'The "/" (division) and "//" (floor division) operators yield the\n'
|
||||
|
|
@ -1251,17 +1296,19 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'result. Division by zero raises the "ZeroDivisionError" '
|
||||
'exception.\n'
|
||||
'\n'
|
||||
'This operation can be customized using the special "__truediv__()" '
|
||||
'The division operation can be customized using the special\n'
|
||||
'"__truediv__()" and "__rtruediv__()" methods. The floor division\n'
|
||||
'operation can be customized using the special "__floordiv__()" '
|
||||
'and\n'
|
||||
'"__floordiv__()" methods.\n'
|
||||
'"__rfloordiv__()" methods.\n'
|
||||
'\n'
|
||||
'The "%" (modulo) operator yields the remainder from the division '
|
||||
'of\n'
|
||||
'the first argument by the second. The numeric arguments are '
|
||||
'first\n'
|
||||
'converted to a common type. A zero right argument raises the\n'
|
||||
'"ZeroDivisionError" exception. The arguments may be floating '
|
||||
'point\n'
|
||||
'"ZeroDivisionError" exception. The arguments may be '
|
||||
'floating-point\n'
|
||||
'numbers, e.g., "3.14%0.7" equals "0.34" (since "3.14" equals '
|
||||
'"4*0.7 +\n'
|
||||
'0.34".) The modulo operator always yields a result with the same '
|
||||
|
|
@ -1288,13 +1335,13 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'The *modulo* operation can be customized using the special '
|
||||
'"__mod__()"\n'
|
||||
'method.\n'
|
||||
'and "__rmod__()" methods.\n'
|
||||
'\n'
|
||||
'The floor division operator, the modulo operator, and the '
|
||||
'"divmod()"\n'
|
||||
'function are not defined for complex numbers. Instead, convert to '
|
||||
'a\n'
|
||||
'floating point number using the "abs()" function if appropriate.\n'
|
||||
'floating-point number using the "abs()" function if appropriate.\n'
|
||||
'\n'
|
||||
'The "+" (addition) operator yields the sum of its arguments. The\n'
|
||||
'arguments must either both be numbers or both be sequences of the '
|
||||
|
|
@ -1313,7 +1360,8 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'The numeric arguments are first converted to a common type.\n'
|
||||
'\n'
|
||||
'This operation can be customized using the special "__sub__()" '
|
||||
'method.\n',
|
||||
'and\n'
|
||||
'"__rsub__()" methods.\n',
|
||||
'bitwise': 'Binary bitwise operations\n'
|
||||
'*************************\n'
|
||||
'\n'
|
||||
|
|
@ -2388,18 +2436,16 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'An\n'
|
||||
'expression-less "except" clause, if present, must be last; it '
|
||||
'matches\n'
|
||||
'any exception. For an "except" clause with an expression, that\n'
|
||||
'expression is evaluated, and the clause matches the exception if '
|
||||
'the\n'
|
||||
'resulting object is “compatible” with the exception. An object '
|
||||
'is\n'
|
||||
'compatible with an exception if the object is the class or a '
|
||||
'*non-\n'
|
||||
'virtual base class* of the exception object, or a tuple '
|
||||
'containing an\n'
|
||||
'item that is the class or a non-virtual base class of the '
|
||||
'exception\n'
|
||||
'object.\n'
|
||||
'any exception.\n'
|
||||
'\n'
|
||||
'For an "except" clause with an expression, the expression must\n'
|
||||
'evaluate to an exception type or a tuple of exception types. '
|
||||
'The\n'
|
||||
'raised exception matches an "except" clause whose expression '
|
||||
'evaluates\n'
|
||||
'to the class or a *non-virtual base class* of the exception '
|
||||
'object, or\n'
|
||||
'to a tuple that contains such a class.\n'
|
||||
'\n'
|
||||
'If no "except" clause matches the exception, the search for an\n'
|
||||
'exception handler continues in the surrounding code and on the\n'
|
||||
|
|
@ -2548,13 +2594,16 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
' ...\n'
|
||||
" ExceptionGroup('', (BlockingIOError()))\n"
|
||||
'\n'
|
||||
'An "except*" clause must have a matching type, and this type '
|
||||
'cannot be\n'
|
||||
'a subclass of "BaseExceptionGroup". It is not possible to mix '
|
||||
'"except"\n'
|
||||
'and "except*" in the same "try". "break", "continue" and '
|
||||
'"return"\n'
|
||||
'cannot appear in an "except*" clause.\n'
|
||||
'An "except*" clause must have a matching expression; it cannot '
|
||||
'be\n'
|
||||
'"except*:". Furthermore, this expression cannot contain '
|
||||
'exception\n'
|
||||
'group types, because that would have ambiguous semantics.\n'
|
||||
'\n'
|
||||
'It is not possible to mix "except" and "except*" in the same '
|
||||
'"try".\n'
|
||||
'"break", "continue" and "return" cannot appear in an "except*" '
|
||||
'clause.\n'
|
||||
'\n'
|
||||
'\n'
|
||||
'"else" clause\n'
|
||||
|
|
@ -4400,7 +4449,7 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'converted to\n'
|
||||
' complex;\n'
|
||||
'\n'
|
||||
'* otherwise, if either argument is a floating point number, '
|
||||
'* otherwise, if either argument is a floating-point number, '
|
||||
'the other\n'
|
||||
' is converted to floating point;\n'
|
||||
'\n'
|
||||
|
|
@ -4511,6 +4560,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
' It is not guaranteed that "__del__()" methods are called '
|
||||
'for\n'
|
||||
' objects that still exist when the interpreter exits.\n'
|
||||
' "weakref.finalize" provides a straightforward way to '
|
||||
'register a\n'
|
||||
' cleanup function to be called when an object is garbage '
|
||||
'collected.\n'
|
||||
'\n'
|
||||
' Note:\n'
|
||||
'\n'
|
||||
|
|
@ -6413,10 +6466,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'that expression. (To create an empty tuple, use an empty pair '
|
||||
'of\n'
|
||||
'parentheses: "()".)\n',
|
||||
'floating': 'Floating point literals\n'
|
||||
'floating': 'Floating-point literals\n'
|
||||
'***********************\n'
|
||||
'\n'
|
||||
'Floating point literals are described by the following lexical\n'
|
||||
'Floating-point literals are described by the following lexical\n'
|
||||
'definitions:\n'
|
||||
'\n'
|
||||
' floatnumber ::= pointfloat | exponentfloat\n'
|
||||
|
|
@ -6430,12 +6483,12 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'using\n'
|
||||
'radix 10. For example, "077e010" is legal, and denotes the same '
|
||||
'number\n'
|
||||
'as "77e10". The allowed range of floating point literals is\n'
|
||||
'as "77e10". The allowed range of floating-point literals is\n'
|
||||
'implementation-dependent. As in integer literals, underscores '
|
||||
'are\n'
|
||||
'supported for digit grouping.\n'
|
||||
'\n'
|
||||
'Some examples of floating point literals:\n'
|
||||
'Some examples of floating-point literals:\n'
|
||||
'\n'
|
||||
' 3.14 10. .001 1e100 3.14e-10 0e0 '
|
||||
'3.14_15_93\n'
|
||||
|
|
@ -6818,7 +6871,7 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'The "\'_\'" option signals the use of an underscore for a '
|
||||
'thousands\n'
|
||||
'separator for floating point presentation types and for '
|
||||
'separator for floating-point presentation types and for '
|
||||
'integer\n'
|
||||
'presentation type "\'d\'". For integer presentation types '
|
||||
'"\'b\'", "\'o\'",\n'
|
||||
|
|
@ -6945,11 +6998,11 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'In addition to the above presentation types, integers can '
|
||||
'be formatted\n'
|
||||
'with the floating point presentation types listed below '
|
||||
'with the floating-point presentation types listed below '
|
||||
'(except "\'n\'"\n'
|
||||
'and "None"). When doing so, "float()" is used to convert '
|
||||
'the integer\n'
|
||||
'to a floating point number before formatting.\n'
|
||||
'to a floating-point number before formatting.\n'
|
||||
'\n'
|
||||
'The available presentation types for "float" and "Decimal" '
|
||||
'values are:\n'
|
||||
|
|
@ -7807,11 +7860,11 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'An imaginary literal yields a complex number with a real part '
|
||||
'of 0.0.\n'
|
||||
'Complex numbers are represented as a pair of floating point '
|
||||
'Complex numbers are represented as a pair of floating-point '
|
||||
'numbers\n'
|
||||
'and have the same restrictions on their range. To create a '
|
||||
'complex\n'
|
||||
'number with a nonzero real part, add a floating point number to '
|
||||
'number with a nonzero real part, add a floating-point number to '
|
||||
'it,\n'
|
||||
'e.g., "(3+4j)". Some examples of imaginary literals:\n'
|
||||
'\n'
|
||||
|
|
@ -8605,8 +8658,8 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'numbers': 'Numeric literals\n'
|
||||
'****************\n'
|
||||
'\n'
|
||||
'There are three types of numeric literals: integers, floating '
|
||||
'point\n'
|
||||
'There are three types of numeric literals: integers, '
|
||||
'floating-point\n'
|
||||
'numbers, and imaginary numbers. There are no complex literals\n'
|
||||
'(complex numbers can be formed by adding a real number and an\n'
|
||||
'imaginary number).\n'
|
||||
|
|
@ -9176,8 +9229,8 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'"complex"\n'
|
||||
'number. (In earlier versions it raised a "ValueError".)\n'
|
||||
'\n'
|
||||
'This operation can be customized using the special "__pow__()" '
|
||||
'method.\n',
|
||||
'This operation can be customized using the special "__pow__()" and\n'
|
||||
'"__rpow__()" methods.\n',
|
||||
'raise': 'The "raise" statement\n'
|
||||
'*********************\n'
|
||||
'\n'
|
||||
|
|
@ -9591,9 +9644,12 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'the\n'
|
||||
'second argument.\n'
|
||||
'\n'
|
||||
'This operation can be customized using the special '
|
||||
'"__lshift__()" and\n'
|
||||
'"__rshift__()" methods.\n'
|
||||
'The left shift operation can be customized using the special\n'
|
||||
'"__lshift__()" and "__rlshift__()" methods. The right shift '
|
||||
'operation\n'
|
||||
'can be customized using the special "__rshift__()" and '
|
||||
'"__rrshift__()"\n'
|
||||
'methods.\n'
|
||||
'\n'
|
||||
'A right shift by *n* bits is defined as floor division by '
|
||||
'"pow(2,n)".\n'
|
||||
|
|
@ -9863,6 +9919,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
' It is not guaranteed that "__del__()" methods are called '
|
||||
'for\n'
|
||||
' objects that still exist when the interpreter exits.\n'
|
||||
' "weakref.finalize" provides a straightforward way to '
|
||||
'register a\n'
|
||||
' cleanup function to be called when an object is garbage '
|
||||
'collected.\n'
|
||||
'\n'
|
||||
' Note:\n'
|
||||
'\n'
|
||||
|
|
@ -12657,11 +12717,11 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
' and are deemed to delimit empty strings (for example,\n'
|
||||
' "\'1,,2\'.split(\',\')" returns "[\'1\', \'\', '
|
||||
'\'2\']"). The *sep* argument\n'
|
||||
' may consist of multiple characters (for example,\n'
|
||||
' "\'1<>2<>3\'.split(\'<>\')" returns "[\'1\', \'2\', '
|
||||
'\'3\']"). Splitting an\n'
|
||||
' empty string with a specified separator returns '
|
||||
'"[\'\']".\n'
|
||||
' may consist of multiple characters as a single '
|
||||
'delimiter (to split\n'
|
||||
' with multiple delimiters, use "re.split()"). Splitting '
|
||||
'an empty\n'
|
||||
' string with a specified separator returns "[\'\']".\n'
|
||||
'\n'
|
||||
' For example:\n'
|
||||
'\n'
|
||||
|
|
@ -12671,6 +12731,8 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
" ['1', '2,3']\n"
|
||||
" >>> '1,2,,3,'.split(',')\n"
|
||||
" ['1', '2', '', '3', '']\n"
|
||||
" >>> '1<>2<>3<4'.split('<>')\n"
|
||||
" ['1', '2', '3<4']\n"
|
||||
'\n'
|
||||
' If *sep* is not specified or is "None", a different '
|
||||
'splitting\n'
|
||||
|
|
@ -13351,14 +13413,15 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'clauses in turn until one is found that matches the exception. An\n'
|
||||
'expression-less "except" clause, if present, must be last; it '
|
||||
'matches\n'
|
||||
'any exception. For an "except" clause with an expression, that\n'
|
||||
'expression is evaluated, and the clause matches the exception if the\n'
|
||||
'resulting object is “compatible” with the exception. An object is\n'
|
||||
'compatible with an exception if the object is the class or a *non-\n'
|
||||
'virtual base class* of the exception object, or a tuple containing '
|
||||
'an\n'
|
||||
'item that is the class or a non-virtual base class of the exception\n'
|
||||
'object.\n'
|
||||
'any exception.\n'
|
||||
'\n'
|
||||
'For an "except" clause with an expression, the expression must\n'
|
||||
'evaluate to an exception type or a tuple of exception types. The\n'
|
||||
'raised exception matches an "except" clause whose expression '
|
||||
'evaluates\n'
|
||||
'to the class or a *non-virtual base class* of the exception object, '
|
||||
'or\n'
|
||||
'to a tuple that contains such a class.\n'
|
||||
'\n'
|
||||
'If no "except" clause matches the exception, the search for an\n'
|
||||
'exception handler continues in the surrounding code and on the\n'
|
||||
|
|
@ -13487,12 +13550,13 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
' ...\n'
|
||||
" ExceptionGroup('', (BlockingIOError()))\n"
|
||||
'\n'
|
||||
'An "except*" clause must have a matching type, and this type cannot '
|
||||
'be\n'
|
||||
'a subclass of "BaseExceptionGroup". It is not possible to mix '
|
||||
'"except"\n'
|
||||
'and "except*" in the same "try". "break", "continue" and "return"\n'
|
||||
'cannot appear in an "except*" clause.\n'
|
||||
'An "except*" clause must have a matching expression; it cannot be\n'
|
||||
'"except*:". Furthermore, this expression cannot contain exception\n'
|
||||
'group types, because that would have ambiguous semantics.\n'
|
||||
'\n'
|
||||
'It is not possible to mix "except" and "except*" in the same "try".\n'
|
||||
'"break", "continue" and "return" cannot appear in an "except*" '
|
||||
'clause.\n'
|
||||
'\n'
|
||||
'\n'
|
||||
'"else" clause\n'
|
||||
|
|
@ -13653,7 +13717,7 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'* A sign is shown only when the number is negative.\n'
|
||||
'\n'
|
||||
'Python distinguishes between integers, floating point numbers, and\n'
|
||||
'Python distinguishes between integers, floating-point numbers, and\n'
|
||||
'complex numbers:\n'
|
||||
'\n'
|
||||
'\n'
|
||||
|
|
@ -13698,28 +13762,28 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'"numbers.Real" ("float")\n'
|
||||
'------------------------\n'
|
||||
'\n'
|
||||
'These represent machine-level double precision floating point '
|
||||
'These represent machine-level double precision floating-point '
|
||||
'numbers.\n'
|
||||
'You are at the mercy of the underlying machine architecture (and C '
|
||||
'or\n'
|
||||
'Java implementation) for the accepted range and handling of '
|
||||
'overflow.\n'
|
||||
'Python does not support single-precision floating point numbers; '
|
||||
'Python does not support single-precision floating-point numbers; '
|
||||
'the\n'
|
||||
'savings in processor and memory usage that are usually the reason '
|
||||
'for\n'
|
||||
'using these are dwarfed by the overhead of using objects in Python, '
|
||||
'so\n'
|
||||
'there is no reason to complicate the language with two kinds of\n'
|
||||
'floating point numbers.\n'
|
||||
'floating-point numbers.\n'
|
||||
'\n'
|
||||
'\n'
|
||||
'"numbers.Complex" ("complex")\n'
|
||||
'-----------------------------\n'
|
||||
'\n'
|
||||
'These represent complex numbers as a pair of machine-level double\n'
|
||||
'precision floating point numbers. The same caveats apply as for\n'
|
||||
'floating point numbers. The real and imaginary parts of a complex\n'
|
||||
'precision floating-point numbers. The same caveats apply as for\n'
|
||||
'floating-point numbers. The real and imaginary parts of a complex\n'
|
||||
'number "z" can be retrieved through the read-only attributes '
|
||||
'"z.real"\n'
|
||||
'and "z.imag".\n'
|
||||
|
|
@ -14134,21 +14198,10 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'to\n'
|
||||
'calling "f(C,1)" where "f" is the underlying function.\n'
|
||||
'\n'
|
||||
'Note that the transformation from function object to instance '
|
||||
'method\n'
|
||||
'object happens each time the attribute is retrieved from the '
|
||||
'instance.\n'
|
||||
'In some cases, a fruitful optimization is to assign the attribute '
|
||||
'to a\n'
|
||||
'local variable and call that local variable. Also notice that this\n'
|
||||
'transformation only happens for user-defined functions; other '
|
||||
'callable\n'
|
||||
'objects (and all non-callable objects) are retrieved without\n'
|
||||
'transformation. It is also important to note that user-defined\n'
|
||||
'functions which are attributes of a class instance are not '
|
||||
'converted\n'
|
||||
'to bound methods; this *only* happens when the function is an\n'
|
||||
'attribute of the class.\n'
|
||||
'It is important to note that user-defined functions which are\n'
|
||||
'attributes of a class instance are not converted to bound methods;\n'
|
||||
'this *only* happens when the function is an attribute of the '
|
||||
'class.\n'
|
||||
'\n'
|
||||
'\n'
|
||||
'Generator functions\n'
|
||||
|
|
@ -15155,7 +15208,7 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
' Return a shallow copy of the dictionary.\n'
|
||||
'\n'
|
||||
' classmethod fromkeys(iterable, value=None)\n'
|
||||
' classmethod fromkeys(iterable, value=None, /)\n'
|
||||
'\n'
|
||||
' Create a new dictionary with keys from *iterable* and '
|
||||
'values set\n'
|
||||
|
|
@ -15923,7 +15976,9 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'Notes:\n'
|
||||
'\n'
|
||||
'1. *t* must have the same length as the slice it is replacing.\n'
|
||||
'1. If *k* is not equal to "1", *t* must have the same length as '
|
||||
'the\n'
|
||||
' slice it is replacing.\n'
|
||||
'\n'
|
||||
'2. The optional argument *i* defaults to "-1", so that by '
|
||||
'default the\n'
|
||||
|
|
@ -16280,7 +16335,7 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
' * The linspace recipe shows how to implement a lazy version of '
|
||||
'range\n'
|
||||
' suitable for floating point applications.\n',
|
||||
' suitable for floating-point applications.\n',
|
||||
'typesseq-mutable': 'Mutable Sequence Types\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
|
|
@ -16387,8 +16442,9 @@ topics = {'assert': 'The "assert" statement\n'
|
|||
'\n'
|
||||
'Notes:\n'
|
||||
'\n'
|
||||
'1. *t* must have the same length as the slice it is '
|
||||
'replacing.\n'
|
||||
'1. If *k* is not equal to "1", *t* must have the same '
|
||||
'length as the\n'
|
||||
' slice it is replacing.\n'
|
||||
'\n'
|
||||
'2. The optional argument *i* defaults to "-1", so that '
|
||||
'by default the\n'
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue