Update pydoc topics for 3.6.0rc1
This commit is contained in:
Ned Deily
parent
5976b9a88b
commit
cefca3d7b5
|
|
@ -1,7 +1,6 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Autogenerated by Sphinx on Tue Dec 6 18:51:51 2016
|
||||
topics = {'assert': '\n'
|
||||
'The "assert" statement\n'
|
||||
# Autogenerated by Sphinx on Sat Mar 4 12:14:44 2017
|
||||
topics = {'assert': 'The "assert" statement\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
'Assert statements are a convenient way to insert debugging '
|
||||
|
|
@ -39,8 +38,7 @@ topics = {'assert': '\n'
|
|||
'Assignments to "__debug__" are illegal. The value for the '
|
||||
'built-in\n'
|
||||
'variable is determined when the interpreter starts.\n',
|
||||
'assignment': '\n'
|
||||
'Assignment statements\n'
|
||||
'assignment': 'Assignment statements\n'
|
||||
'*********************\n'
|
||||
'\n'
|
||||
'Assignment statements are used to (re)bind names to values and '
|
||||
|
|
@ -405,8 +403,7 @@ topics = {'assert': '\n'
|
|||
'See also: **PEP 526** - Variable and attribute annotation '
|
||||
'syntax\n'
|
||||
' **PEP 484** - Type hints\n',
|
||||
'atom-identifiers': '\n'
|
||||
'Identifiers (Names)\n'
|
||||
'atom-identifiers': 'Identifiers (Names)\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'An identifier occurring as an atom is a name. See '
|
||||
|
|
@ -446,8 +443,7 @@ topics = {'assert': '\n'
|
|||
'happen. If the class name consists only of underscores, '
|
||||
'no\n'
|
||||
'transformation is done.\n',
|
||||
'atom-literals': '\n'
|
||||
'Literals\n'
|
||||
'atom-literals': 'Literals\n'
|
||||
'********\n'
|
||||
'\n'
|
||||
'Python supports string and bytes literals and various '
|
||||
|
|
@ -476,8 +472,7 @@ topics = {'assert': '\n'
|
|||
'may obtain\n'
|
||||
'the same object or a different object with the same '
|
||||
'value.\n',
|
||||
'attribute-access': '\n'
|
||||
'Customizing attribute access\n'
|
||||
'attribute-access': 'Customizing attribute access\n'
|
||||
'****************************\n'
|
||||
'\n'
|
||||
'The following methods can be defined to customize the '
|
||||
|
|
@ -851,8 +846,7 @@ topics = {'assert': '\n'
|
|||
'* *__class__* assignment works only if both classes have '
|
||||
'the same\n'
|
||||
' *__slots__*.\n',
|
||||
'attribute-references': '\n'
|
||||
'Attribute references\n'
|
||||
'attribute-references': 'Attribute references\n'
|
||||
'********************\n'
|
||||
'\n'
|
||||
'An attribute reference is a primary followed by a '
|
||||
|
|
@ -875,8 +869,7 @@ topics = {'assert': '\n'
|
|||
'determined by the object. Multiple evaluations of '
|
||||
'the same attribute\n'
|
||||
'reference may yield different objects.\n',
|
||||
'augassign': '\n'
|
||||
'Augmented assignment statements\n'
|
||||
'augassign': 'Augmented assignment statements\n'
|
||||
'*******************************\n'
|
||||
'\n'
|
||||
'Augmented assignment is the combination, in a single statement, '
|
||||
|
|
@ -940,8 +933,7 @@ topics = {'assert': '\n'
|
|||
'about\n'
|
||||
'class and instance attributes applies as for regular '
|
||||
'assignments.\n',
|
||||
'binary': '\n'
|
||||
'Binary arithmetic operations\n'
|
||||
'binary': 'Binary arithmetic operations\n'
|
||||
'****************************\n'
|
||||
'\n'
|
||||
'The binary arithmetic operations have the conventional priority\n'
|
||||
|
|
@ -1029,8 +1021,7 @@ topics = {'assert': '\n'
|
|||
'The "-" (subtraction) operator yields the difference of its '
|
||||
'arguments.\n'
|
||||
'The numeric arguments are first converted to a common type.\n',
|
||||
'bitwise': '\n'
|
||||
'Binary bitwise operations\n'
|
||||
'bitwise': 'Binary bitwise operations\n'
|
||||
'*************************\n'
|
||||
'\n'
|
||||
'Each of the three bitwise operations has a different priority '
|
||||
|
|
@ -1050,8 +1041,7 @@ topics = {'assert': '\n'
|
|||
'The "|" operator yields the bitwise (inclusive) OR of its '
|
||||
'arguments,\n'
|
||||
'which must be integers.\n',
|
||||
'bltin-code-objects': '\n'
|
||||
'Code Objects\n'
|
||||
'bltin-code-objects': 'Code Objects\n'
|
||||
'************\n'
|
||||
'\n'
|
||||
'Code objects are used by the implementation to '
|
||||
|
|
@ -1074,8 +1064,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
'See The standard type hierarchy for more '
|
||||
'information.\n',
|
||||
'bltin-ellipsis-object': '\n'
|
||||
'The Ellipsis Object\n'
|
||||
'bltin-ellipsis-object': 'The Ellipsis Object\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'This object is commonly used by slicing (see '
|
||||
|
|
@ -1087,8 +1076,7 @@ topics = {'assert': '\n'
|
|||
'"Ellipsis" singleton.\n'
|
||||
'\n'
|
||||
'It is written as "Ellipsis" or "...".\n',
|
||||
'bltin-null-object': '\n'
|
||||
'The Null Object\n'
|
||||
'bltin-null-object': 'The Null Object\n'
|
||||
'***************\n'
|
||||
'\n'
|
||||
"This object is returned by functions that don't "
|
||||
|
|
@ -1100,8 +1088,7 @@ topics = {'assert': '\n'
|
|||
'same singleton.\n'
|
||||
'\n'
|
||||
'It is written as "None".\n',
|
||||
'bltin-type-objects': '\n'
|
||||
'Type Objects\n'
|
||||
'bltin-type-objects': 'Type Objects\n'
|
||||
'************\n'
|
||||
'\n'
|
||||
'Type objects represent the various object types. An '
|
||||
|
|
@ -1113,8 +1100,7 @@ topics = {'assert': '\n'
|
|||
'all standard built-in types.\n'
|
||||
'\n'
|
||||
'Types are written like this: "<class \'int\'>".\n',
|
||||
'booleans': '\n'
|
||||
'Boolean operations\n'
|
||||
'booleans': 'Boolean operations\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
' or_test ::= and_test | or_test "or" and_test\n'
|
||||
|
|
@ -1163,8 +1149,7 @@ topics = {'assert': '\n'
|
|||
'its\n'
|
||||
'argument (for example, "not \'foo\'" produces "False" rather '
|
||||
'than "\'\'".)\n',
|
||||
'break': '\n'
|
||||
'The "break" statement\n'
|
||||
'break': 'The "break" statement\n'
|
||||
'*********************\n'
|
||||
'\n'
|
||||
' break_stmt ::= "break"\n'
|
||||
|
|
@ -1185,8 +1170,7 @@ topics = {'assert': '\n'
|
|||
'clause, that "finally" clause is executed before really leaving '
|
||||
'the\n'
|
||||
'loop.\n',
|
||||
'callable-types': '\n'
|
||||
'Emulating callable objects\n'
|
||||
'callable-types': 'Emulating callable objects\n'
|
||||
'**************************\n'
|
||||
'\n'
|
||||
'object.__call__(self[, args...])\n'
|
||||
|
|
@ -1195,8 +1179,7 @@ topics = {'assert': '\n'
|
|||
'this method\n'
|
||||
' is defined, "x(arg1, arg2, ...)" is a shorthand for\n'
|
||||
' "x.__call__(arg1, arg2, ...)".\n',
|
||||
'calls': '\n'
|
||||
'Calls\n'
|
||||
'calls': 'Calls\n'
|
||||
'*****\n'
|
||||
'\n'
|
||||
'A call calls a callable object (e.g., a *function*) with a '
|
||||
|
|
@ -1217,7 +1200,8 @@ topics = {'assert': '\n'
|
|||
' ("," "*" expression | "," '
|
||||
'keyword_item)*\n'
|
||||
' keywords_arguments ::= (keyword_item | "**" expression)\n'
|
||||
' ("," keyword_item | "**" expression)*\n'
|
||||
' ("," keyword_item | "," "**" '
|
||||
'expression)*\n'
|
||||
' keyword_item ::= identifier "=" expression\n'
|
||||
'\n'
|
||||
'An optional trailing comma may be present after the positional and\n'
|
||||
|
|
@ -1382,8 +1366,7 @@ topics = {'assert': '\n'
|
|||
' The class must define a "__call__()" method; the effect is then '
|
||||
'the\n'
|
||||
' same as if that method was called.\n',
|
||||
'class': '\n'
|
||||
'Class definitions\n'
|
||||
'class': 'Class definitions\n'
|
||||
'*****************\n'
|
||||
'\n'
|
||||
'A class definition defines a class object (see section The '
|
||||
|
|
@ -1469,8 +1452,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
'See also: **PEP 3115** - Metaclasses in Python 3 **PEP 3129** -\n'
|
||||
' Class Decorators\n',
|
||||
'comparisons': '\n'
|
||||
'Comparisons\n'
|
||||
'comparisons': 'Comparisons\n'
|
||||
'***********\n'
|
||||
'\n'
|
||||
'Unlike C, all comparison operations in Python have the same '
|
||||
|
|
@ -1623,7 +1605,7 @@ topics = {'assert': '\n'
|
|||
'restriction that\n'
|
||||
' ranges do not support order comparison. Equality '
|
||||
'comparison across\n'
|
||||
' these types results in unequality, and ordering comparison '
|
||||
' these types results in inequality, and ordering comparison '
|
||||
'across\n'
|
||||
' these types raises "TypeError".\n'
|
||||
'\n'
|
||||
|
|
@ -1762,6 +1744,12 @@ topics = {'assert': '\n'
|
|||
' to sequences, but not to sets or mappings). See also the\n'
|
||||
' "total_ordering()" decorator.\n'
|
||||
'\n'
|
||||
'* The "hash()" result should be consistent with equality. '
|
||||
'Objects\n'
|
||||
' that are equal should either have the same hash value, or '
|
||||
'be marked\n'
|
||||
' as unhashable.\n'
|
||||
'\n'
|
||||
'Python does not enforce these consistency rules. In fact, '
|
||||
'the\n'
|
||||
'not-a-number values are an example for not following these '
|
||||
|
|
@ -1833,8 +1821,7 @@ topics = {'assert': '\n'
|
|||
'is determined using the "id()" function. "x is not y" yields '
|
||||
'the\n'
|
||||
'inverse truth value. [4]\n',
|
||||
'compound': '\n'
|
||||
'Compound statements\n'
|
||||
'compound': 'Compound statements\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'Compound statements contain (groups of) other statements; they '
|
||||
|
|
@ -2613,7 +2600,8 @@ topics = {'assert': '\n'
|
|||
'functions, even if they do not contain "await" or "async" '
|
||||
'keywords.\n'
|
||||
'\n'
|
||||
'It is a "SyntaxError" to use "yield" expressions in "async def"\n'
|
||||
'It is a "SyntaxError" to use "yield from" expressions in "async '
|
||||
'def"\n'
|
||||
'coroutines.\n'
|
||||
'\n'
|
||||
'An example of a coroutine function:\n'
|
||||
|
|
@ -2724,8 +2712,7 @@ topics = {'assert': '\n'
|
|||
' body is transformed into the namespace\'s "__doc__" item '
|
||||
'and\n'
|
||||
" therefore the class's *docstring*.\n",
|
||||
'context-managers': '\n'
|
||||
'With Statement Context Managers\n'
|
||||
'context-managers': 'With Statement Context Managers\n'
|
||||
'*******************************\n'
|
||||
'\n'
|
||||
'A *context manager* is an object that defines the '
|
||||
|
|
@ -2787,8 +2774,7 @@ topics = {'assert': '\n'
|
|||
' The specification, background, and examples for the '
|
||||
'Python "with"\n'
|
||||
' statement.\n',
|
||||
'continue': '\n'
|
||||
'The "continue" statement\n'
|
||||
'continue': 'The "continue" statement\n'
|
||||
'************************\n'
|
||||
'\n'
|
||||
' continue_stmt ::= "continue"\n'
|
||||
|
|
@ -2805,8 +2791,7 @@ topics = {'assert': '\n'
|
|||
'"finally" clause, that "finally" clause is executed before '
|
||||
'really\n'
|
||||
'starting the next loop cycle.\n',
|
||||
'conversions': '\n'
|
||||
'Arithmetic conversions\n'
|
||||
'conversions': 'Arithmetic conversions\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
'When a description of an arithmetic operator below uses the '
|
||||
|
|
@ -2832,8 +2817,7 @@ topics = {'assert': '\n'
|
|||
"left argument to the '%' operator). Extensions must define "
|
||||
'their own\n'
|
||||
'conversion behavior.\n',
|
||||
'customization': '\n'
|
||||
'Basic customization\n'
|
||||
'customization': 'Basic customization\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'object.__new__(cls[, ...])\n'
|
||||
|
|
@ -3152,15 +3136,18 @@ topics = {'assert': '\n'
|
|||
'on members\n'
|
||||
' of hashed collections including "set", "frozenset", and '
|
||||
'"dict".\n'
|
||||
' "__hash__()" should return an integer. The only '
|
||||
'required property\n'
|
||||
' "__hash__()" should return an integer. The only required '
|
||||
'property\n'
|
||||
' is that objects which compare equal have the same hash '
|
||||
'value; it is\n'
|
||||
' advised to somehow mix together (e.g. using exclusive '
|
||||
'or) the hash\n'
|
||||
' values for the components of the object that also play a '
|
||||
'part in\n'
|
||||
' comparison of objects.\n'
|
||||
' advised to mix together the hash values of the '
|
||||
'components of the\n'
|
||||
' object that also play a part in comparison of objects by '
|
||||
'packing\n'
|
||||
' them into a tuple and hashing the tuple. Example:\n'
|
||||
'\n'
|
||||
' def __hash__(self):\n'
|
||||
' return hash((self.name, self.nick, self.color))\n'
|
||||
'\n'
|
||||
' Note: "hash()" truncates the value returned from an '
|
||||
"object's\n"
|
||||
|
|
@ -3272,8 +3259,7 @@ topics = {'assert': '\n'
|
|||
' neither "__len__()" nor "__bool__()", all its instances '
|
||||
'are\n'
|
||||
' considered true.\n',
|
||||
'debugger': '\n'
|
||||
'"pdb" --- The Python Debugger\n'
|
||||
'debugger': '"pdb" --- The Python Debugger\n'
|
||||
'*****************************\n'
|
||||
'\n'
|
||||
'**Source code:** Lib/pdb.py\n'
|
||||
|
|
@ -3938,8 +3924,7 @@ topics = {'assert': '\n'
|
|||
'[1] Whether a frame is considered to originate in a certain '
|
||||
'module\n'
|
||||
' is determined by the "__name__" in the frame globals.\n',
|
||||
'del': '\n'
|
||||
'The "del" statement\n'
|
||||
'del': 'The "del" statement\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
' del_stmt ::= "del" target_list\n'
|
||||
|
|
@ -3968,8 +3953,7 @@ topics = {'assert': '\n'
|
|||
'Changed in version 3.2: Previously it was illegal to delete a name\n'
|
||||
'from the local namespace if it occurs as a free variable in a nested\n'
|
||||
'block.\n',
|
||||
'dict': '\n'
|
||||
'Dictionary displays\n'
|
||||
'dict': 'Dictionary displays\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'A dictionary display is a possibly empty series of key/datum pairs\n'
|
||||
|
|
@ -4013,8 +3997,7 @@ topics = {'assert': '\n'
|
|||
'should be *hashable*, which excludes all mutable objects.) Clashes\n'
|
||||
'between duplicate keys are not detected; the last datum (textually\n'
|
||||
'rightmost in the display) stored for a given key value prevails.\n',
|
||||
'dynamic-features': '\n'
|
||||
'Interaction with dynamic features\n'
|
||||
'dynamic-features': 'Interaction with dynamic features\n'
|
||||
'*********************************\n'
|
||||
'\n'
|
||||
'Name resolution of free variables occurs at runtime, not '
|
||||
|
|
@ -4050,8 +4033,7 @@ topics = {'assert': '\n'
|
|||
'override the global and local namespace. If only one '
|
||||
'namespace is\n'
|
||||
'specified, it is used for both.\n',
|
||||
'else': '\n'
|
||||
'The "if" statement\n'
|
||||
'else': 'The "if" statement\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
'The "if" statement is used for conditional execution:\n'
|
||||
|
|
@ -4068,8 +4050,7 @@ topics = {'assert': '\n'
|
|||
'(and no other part of the "if" statement is executed or evaluated).\n'
|
||||
'If all expressions are false, the suite of the "else" clause, if\n'
|
||||
'present, is executed.\n',
|
||||
'exceptions': '\n'
|
||||
'Exceptions\n'
|
||||
'exceptions': 'Exceptions\n'
|
||||
'**********\n'
|
||||
'\n'
|
||||
'Exceptions are a means of breaking out of the normal flow of '
|
||||
|
|
@ -4145,8 +4126,7 @@ topics = {'assert': '\n'
|
|||
' these operations is not available at the time the module '
|
||||
'is\n'
|
||||
' compiled.\n',
|
||||
'execmodel': '\n'
|
||||
'Execution model\n'
|
||||
'execmodel': 'Execution model\n'
|
||||
'***************\n'
|
||||
'\n'
|
||||
'\n'
|
||||
|
|
@ -4477,8 +4457,7 @@ topics = {'assert': '\n'
|
|||
' these operations is not available at the time the module '
|
||||
'is\n'
|
||||
' compiled.\n',
|
||||
'exprlists': '\n'
|
||||
'Expression lists\n'
|
||||
'exprlists': 'Expression lists\n'
|
||||
'****************\n'
|
||||
'\n'
|
||||
' expression_list ::= expression ( "," expression )* [","]\n'
|
||||
|
|
@ -4515,8 +4494,7 @@ topics = {'assert': '\n'
|
|||
'value of that expression. (To create an empty tuple, use an '
|
||||
'empty pair\n'
|
||||
'of parentheses: "()".)\n',
|
||||
'floating': '\n'
|
||||
'Floating point literals\n'
|
||||
'floating': 'Floating point literals\n'
|
||||
'***********************\n'
|
||||
'\n'
|
||||
'Floating point literals are described by the following lexical\n'
|
||||
|
|
@ -4552,8 +4530,7 @@ topics = {'assert': '\n'
|
|||
'Changed in version 3.6: Underscores are now allowed for '
|
||||
'grouping\n'
|
||||
'purposes in literals.\n',
|
||||
'for': '\n'
|
||||
'The "for" statement\n'
|
||||
'for': 'The "for" statement\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'The "for" statement is used to iterate over the elements of a '
|
||||
|
|
@ -4625,8 +4602,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
' for x in a[:]:\n'
|
||||
' if x < 0: a.remove(x)\n',
|
||||
'formatstrings': '\n'
|
||||
'Format String Syntax\n'
|
||||
'formatstrings': 'Format String Syntax\n'
|
||||
'********************\n'
|
||||
'\n'
|
||||
'The "str.format()" method and the "Formatter" class share '
|
||||
|
|
@ -5345,8 +5321,7 @@ topics = {'assert': '\n'
|
|||
' 9 9 11 1001\n'
|
||||
' 10 A 12 1010\n'
|
||||
' 11 B 13 1011\n',
|
||||
'function': '\n'
|
||||
'Function definitions\n'
|
||||
'function': 'Function definitions\n'
|
||||
'********************\n'
|
||||
'\n'
|
||||
'A function definition defines a user-defined function object '
|
||||
|
|
@ -5515,8 +5490,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
' **PEP 3107** - Function Annotations\n'
|
||||
' The original specification for function annotations.\n',
|
||||
'global': '\n'
|
||||
'The "global" statement\n'
|
||||
'global': 'The "global" statement\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
' global_stmt ::= "global" identifier ("," identifier)*\n'
|
||||
|
|
@ -5560,8 +5534,7 @@ topics = {'assert': '\n'
|
|||
'code containing the function call. The same applies to the '
|
||||
'"eval()"\n'
|
||||
'and "compile()" functions.\n',
|
||||
'id-classes': '\n'
|
||||
'Reserved classes of identifiers\n'
|
||||
'id-classes': 'Reserved classes of identifiers\n'
|
||||
'*******************************\n'
|
||||
'\n'
|
||||
'Certain classes of identifiers (besides keywords) have '
|
||||
|
|
@ -5609,8 +5582,7 @@ topics = {'assert': '\n'
|
|||
' to help avoid name clashes between "private" attributes of '
|
||||
'base and\n'
|
||||
' derived classes. See section Identifiers (Names).\n',
|
||||
'identifiers': '\n'
|
||||
'Identifiers and keywords\n'
|
||||
'identifiers': 'Identifiers and keywords\n'
|
||||
'************************\n'
|
||||
'\n'
|
||||
'Identifiers (also referred to as *names*) are described by '
|
||||
|
|
@ -5758,8 +5730,7 @@ topics = {'assert': '\n'
|
|||
' to help avoid name clashes between "private" attributes of '
|
||||
'base and\n'
|
||||
' derived classes. See section Identifiers (Names).\n',
|
||||
'if': '\n'
|
||||
'The "if" statement\n'
|
||||
'if': 'The "if" statement\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
'The "if" statement is used for conditional execution:\n'
|
||||
|
|
@ -5775,8 +5746,7 @@ topics = {'assert': '\n'
|
|||
'(and no other part of the "if" statement is executed or evaluated).\n'
|
||||
'If all expressions are false, the suite of the "else" clause, if\n'
|
||||
'present, is executed.\n',
|
||||
'imaginary': '\n'
|
||||
'Imaginary literals\n'
|
||||
'imaginary': 'Imaginary literals\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
'Imaginary literals are described by the following lexical '
|
||||
|
|
@ -5796,8 +5766,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
' 3.14j 10.j 10j .001j 1e100j 3.14e-10j '
|
||||
'3.14_15_93j\n',
|
||||
'import': '\n'
|
||||
'The "import" statement\n'
|
||||
'import': 'The "import" statement\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
' import_stmt ::= "import" module ["as" name] ( "," module '
|
||||
|
|
@ -6058,8 +6027,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
' **PEP 236** - Back to the __future__\n'
|
||||
' The original proposal for the __future__ mechanism.\n',
|
||||
'in': '\n'
|
||||
'Membership test operations\n'
|
||||
'in': 'Membership test operations\n'
|
||||
'**************************\n'
|
||||
'\n'
|
||||
'The operators "in" and "not in" test for membership. "x in s"\n'
|
||||
|
|
@ -6094,8 +6062,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
'The operator "not in" is defined to have the inverse true value of\n'
|
||||
'"in".\n',
|
||||
'integers': '\n'
|
||||
'Integer literals\n'
|
||||
'integers': 'Integer literals\n'
|
||||
'****************\n'
|
||||
'\n'
|
||||
'Integer literals are described by the following lexical '
|
||||
|
|
@ -6141,8 +6108,7 @@ topics = {'assert': '\n'
|
|||
'Changed in version 3.6: Underscores are now allowed for '
|
||||
'grouping\n'
|
||||
'purposes in literals.\n',
|
||||
'lambda': '\n'
|
||||
'Lambdas\n'
|
||||
'lambda': 'Lambdas\n'
|
||||
'*******\n'
|
||||
'\n'
|
||||
' lambda_expr ::= "lambda" [parameter_list]: expression\n'
|
||||
|
|
@ -6165,8 +6131,7 @@ topics = {'assert': '\n'
|
|||
'Note that functions created with lambda expressions cannot '
|
||||
'contain\n'
|
||||
'statements or annotations.\n',
|
||||
'lists': '\n'
|
||||
'List displays\n'
|
||||
'lists': 'List displays\n'
|
||||
'*************\n'
|
||||
'\n'
|
||||
'A list display is a possibly empty series of expressions enclosed '
|
||||
|
|
@ -6183,8 +6148,7 @@ topics = {'assert': '\n'
|
|||
'from left to right and placed into the list object in that order.\n'
|
||||
'When a comprehension is supplied, the list is constructed from the\n'
|
||||
'elements resulting from the comprehension.\n',
|
||||
'naming': '\n'
|
||||
'Naming and binding\n'
|
||||
'naming': 'Naming and binding\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
'\n'
|
||||
|
|
@ -6397,8 +6361,7 @@ topics = {'assert': '\n'
|
|||
'override the global and local namespace. If only one namespace '
|
||||
'is\n'
|
||||
'specified, it is used for both.\n',
|
||||
'nonlocal': '\n'
|
||||
'The "nonlocal" statement\n'
|
||||
'nonlocal': 'The "nonlocal" statement\n'
|
||||
'************************\n'
|
||||
'\n'
|
||||
' nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*\n'
|
||||
|
|
@ -6429,8 +6392,7 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
' **PEP 3104** - Access to Names in Outer Scopes\n'
|
||||
' The specification for the "nonlocal" statement.\n',
|
||||
'numbers': '\n'
|
||||
'Numeric literals\n'
|
||||
'numbers': 'Numeric literals\n'
|
||||
'****************\n'
|
||||
'\n'
|
||||
'There are three types of numeric literals: integers, floating '
|
||||
|
|
@ -6444,8 +6406,7 @@ topics = {'assert': '\n'
|
|||
'is actually an expression composed of the unary operator \'"-"\' '
|
||||
'and the\n'
|
||||
'literal "1".\n',
|
||||
'numeric-types': '\n'
|
||||
'Emulating numeric types\n'
|
||||
'numeric-types': 'Emulating numeric types\n'
|
||||
'***********************\n'
|
||||
'\n'
|
||||
'The following methods can be defined to emulate numeric '
|
||||
|
|
@ -6621,8 +6582,7 @@ topics = {'assert': '\n'
|
|||
' "__index__()" is defined "__int__()" should also be '
|
||||
'defined, and\n'
|
||||
' both should return the same value.\n',
|
||||
'objects': '\n'
|
||||
'Objects, values and types\n'
|
||||
'objects': 'Objects, values and types\n'
|
||||
'*************************\n'
|
||||
'\n'
|
||||
"*Objects* are Python's abstraction for data. All data in a "
|
||||
|
|
@ -6750,8 +6710,7 @@ topics = {'assert': '\n'
|
|||
'created empty lists. (Note that "c = d = []" assigns the same '
|
||||
'object\n'
|
||||
'to both "c" and "d".)\n',
|
||||
'operator-summary': '\n'
|
||||
'Operator precedence\n'
|
||||
'operator-summary': 'Operator precedence\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'The following table summarizes the operator precedence '
|
||||
|
|
@ -6924,8 +6883,7 @@ topics = {'assert': '\n'
|
|||
'arithmetic\n'
|
||||
' or bitwise unary operator on its right, that is, '
|
||||
'"2**-1" is "0.5".\n',
|
||||
'pass': '\n'
|
||||
'The "pass" statement\n'
|
||||
'pass': 'The "pass" statement\n'
|
||||
'********************\n'
|
||||
'\n'
|
||||
' pass_stmt ::= "pass"\n'
|
||||
|
|
@ -6938,8 +6896,7 @@ topics = {'assert': '\n'
|
|||
' def f(arg): pass # a function that does nothing (yet)\n'
|
||||
'\n'
|
||||
' class C: pass # a class with no methods (yet)\n',
|
||||
'power': '\n'
|
||||
'The power operator\n'
|
||||
'power': 'The power operator\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
'The power operator binds more tightly than unary operators on its\n'
|
||||
|
|
@ -6973,8 +6930,7 @@ topics = {'assert': '\n'
|
|||
'Raising a negative number to a fractional power results in a '
|
||||
'"complex"\n'
|
||||
'number. (In earlier versions it raised a "ValueError".)\n',
|
||||
'raise': '\n'
|
||||
'The "raise" statement\n'
|
||||
'raise': 'The "raise" statement\n'
|
||||
'*********************\n'
|
||||
'\n'
|
||||
' raise_stmt ::= "raise" [expression ["from" expression]]\n'
|
||||
|
|
@ -7059,8 +7015,7 @@ topics = {'assert': '\n'
|
|||
'Exceptions, and information about handling exceptions is in '
|
||||
'section\n'
|
||||
'The try statement.\n',
|
||||
'return': '\n'
|
||||
'The "return" statement\n'
|
||||
'return': 'The "return" statement\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
' return_stmt ::= "return" [expression_list]\n'
|
||||
|
|
@ -7087,9 +7042,15 @@ topics = {'assert': '\n'
|
|||
'generator is done and will cause "StopIteration" to be raised. '
|
||||
'The\n'
|
||||
'returned value (if any) is used as an argument to construct\n'
|
||||
'"StopIteration" and becomes the "StopIteration.value" attribute.\n',
|
||||
'sequence-types': '\n'
|
||||
'Emulating container types\n'
|
||||
'"StopIteration" and becomes the "StopIteration.value" attribute.\n'
|
||||
'\n'
|
||||
'In an asynchronous generator function, an empty "return" '
|
||||
'statement\n'
|
||||
'indicates that the asynchronous generator is done and will cause\n'
|
||||
'"StopAsyncIteration" to be raised. A non-empty "return" statement '
|
||||
'is\n'
|
||||
'a syntax error in an asynchronous generator function.\n',
|
||||
'sequence-types': 'Emulating container types\n'
|
||||
'*************************\n'
|
||||
'\n'
|
||||
'The following methods can be defined to implement '
|
||||
|
|
@ -7310,8 +7271,7 @@ topics = {'assert': '\n'
|
|||
' iteration protocol via "__getitem__()", see this '
|
||||
'section in the\n'
|
||||
' language reference.\n',
|
||||
'shifting': '\n'
|
||||
'Shifting operations\n'
|
||||
'shifting': 'Shifting operations\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'The shifting operations have lower priority than the arithmetic\n'
|
||||
|
|
@ -7335,8 +7295,7 @@ topics = {'assert': '\n'
|
|||
'operand is\n'
|
||||
' larger than "sys.maxsize" an "OverflowError" exception is '
|
||||
'raised.\n',
|
||||
'slicings': '\n'
|
||||
'Slicings\n'
|
||||
'slicings': 'Slicings\n'
|
||||
'********\n'
|
||||
'\n'
|
||||
'A slicing selects a range of items in a sequence object (e.g., '
|
||||
|
|
@ -7387,8 +7346,7 @@ topics = {'assert': '\n'
|
|||
'as lower bound, upper bound and stride, respectively, '
|
||||
'substituting\n'
|
||||
'"None" for missing expressions.\n',
|
||||
'specialattrs': '\n'
|
||||
'Special Attributes\n'
|
||||
'specialattrs': 'Special Attributes\n'
|
||||
'******************\n'
|
||||
'\n'
|
||||
'The implementation adds a few special read-only attributes '
|
||||
|
|
@ -7473,8 +7431,7 @@ topics = {'assert': '\n'
|
|||
'[5] To format only a tuple you should therefore provide a\n'
|
||||
' singleton tuple whose only element is the tuple to be '
|
||||
'formatted.\n',
|
||||
'specialnames': '\n'
|
||||
'Special method names\n'
|
||||
'specialnames': 'Special method names\n'
|
||||
'********************\n'
|
||||
'\n'
|
||||
'A class can implement certain operations that are invoked by '
|
||||
|
|
@ -7835,15 +7792,18 @@ topics = {'assert': '\n'
|
|||
'on members\n'
|
||||
' of hashed collections including "set", "frozenset", and '
|
||||
'"dict".\n'
|
||||
' "__hash__()" should return an integer. The only required '
|
||||
' "__hash__()" should return an integer. The only required '
|
||||
'property\n'
|
||||
' is that objects which compare equal have the same hash '
|
||||
'value; it is\n'
|
||||
' advised to somehow mix together (e.g. using exclusive or) '
|
||||
'the hash\n'
|
||||
' values for the components of the object that also play a '
|
||||
'part in\n'
|
||||
' comparison of objects.\n'
|
||||
' advised to mix together the hash values of the components '
|
||||
'of the\n'
|
||||
' object that also play a part in comparison of objects by '
|
||||
'packing\n'
|
||||
' them into a tuple and hashing the tuple. Example:\n'
|
||||
'\n'
|
||||
' def __hash__(self):\n'
|
||||
' return hash((self.name, self.nick, self.color))\n'
|
||||
'\n'
|
||||
' Note: "hash()" truncates the value returned from an '
|
||||
"object's\n"
|
||||
|
|
@ -9262,8 +9222,7 @@ topics = {'assert': '\n'
|
|||
'special method *must* be set on the class object itself in '
|
||||
'order to be\n'
|
||||
'consistently invoked by the interpreter).\n',
|
||||
'string-methods': '\n'
|
||||
'String Methods\n'
|
||||
'string-methods': 'String Methods\n'
|
||||
'**************\n'
|
||||
'\n'
|
||||
'Strings implement all of the common sequence operations, '
|
||||
|
|
@ -9500,12 +9459,11 @@ topics = {'assert': '\n'
|
|||
'characters\n'
|
||||
' and there is at least one character, false otherwise. '
|
||||
'Decimal\n'
|
||||
' characters are those from general category "Nd". This '
|
||||
'category\n'
|
||||
' includes digit characters, and all characters that can '
|
||||
'be used to\n'
|
||||
' form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC '
|
||||
'DIGIT ZERO.\n'
|
||||
' characters are those that can be used to form numbers '
|
||||
'in base 10,\n'
|
||||
' e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Formally a '
|
||||
'decimal character\n'
|
||||
' is a character in the Unicode General Category "Nd".\n'
|
||||
'\n'
|
||||
'str.isdigit()\n'
|
||||
'\n'
|
||||
|
|
@ -9515,10 +9473,13 @@ topics = {'assert': '\n'
|
|||
'include decimal\n'
|
||||
' characters and digits that need special handling, such '
|
||||
'as the\n'
|
||||
' compatibility superscript digits. Formally, a digit is '
|
||||
'a character\n'
|
||||
' that has the property value Numeric_Type=Digit or\n'
|
||||
' Numeric_Type=Decimal.\n'
|
||||
' compatibility superscript digits. This covers digits '
|
||||
'which cannot\n'
|
||||
' be used to form numbers in base 10, like the Kharosthi '
|
||||
'numbers.\n'
|
||||
' Formally, a digit is a character that has the property '
|
||||
'value\n'
|
||||
' Numeric_Type=Digit or Numeric_Type=Decimal.\n'
|
||||
'\n'
|
||||
'str.isidentifier()\n'
|
||||
'\n'
|
||||
|
|
@ -10064,8 +10025,7 @@ topics = {'assert': '\n'
|
|||
" '00042'\n"
|
||||
' >>> "-42".zfill(5)\n'
|
||||
" '-0042'\n",
|
||||
'strings': '\n'
|
||||
'String and Bytes literals\n'
|
||||
'strings': 'String and Bytes literals\n'
|
||||
'*************************\n'
|
||||
'\n'
|
||||
'String literals are described by the following lexical '
|
||||
|
|
@ -10299,8 +10259,7 @@ topics = {'assert': '\n'
|
|||
'followed by a newline is interpreted as those two characters as '
|
||||
'part\n'
|
||||
'of the literal, *not* as a line continuation.\n',
|
||||
'subscriptions': '\n'
|
||||
'Subscriptions\n'
|
||||
'subscriptions': 'Subscriptions\n'
|
||||
'*************\n'
|
||||
'\n'
|
||||
'A subscription selects an item of a sequence (string, tuple '
|
||||
|
|
@ -10357,8 +10316,7 @@ topics = {'assert': '\n'
|
|||
"A string's items are characters. A character is not a "
|
||||
'separate data\n'
|
||||
'type but a string of exactly one character.\n',
|
||||
'truth': '\n'
|
||||
'Truth Value Testing\n'
|
||||
'truth': 'Truth Value Testing\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'Any object can be tested for truth value, for use in an "if" or\n'
|
||||
|
|
@ -10390,8 +10348,7 @@ topics = {'assert': '\n'
|
|||
'otherwise stated. (Important exception: the Boolean operations '
|
||||
'"or"\n'
|
||||
'and "and" always return one of their operands.)\n',
|
||||
'try': '\n'
|
||||
'The "try" statement\n'
|
||||
'try': 'The "try" statement\n'
|
||||
'*******************\n'
|
||||
'\n'
|
||||
'The "try" statement specifies exception handlers and/or cleanup code\n'
|
||||
|
|
@ -10538,8 +10495,7 @@ topics = {'assert': '\n'
|
|||
'Exceptions, and information on using the "raise" statement to '
|
||||
'generate\n'
|
||||
'exceptions may be found in section The raise statement.\n',
|
||||
'types': '\n'
|
||||
'The standard type hierarchy\n'
|
||||
'types': 'The standard type hierarchy\n'
|
||||
'***************************\n'
|
||||
'\n'
|
||||
'Below is a list of the types that are built into Python. '
|
||||
|
|
@ -11097,6 +11053,27 @@ topics = {'assert': '\n'
|
|||
'statements.\n'
|
||||
' See also the Coroutine Objects section.\n'
|
||||
'\n'
|
||||
' Asynchronous generator functions\n'
|
||||
' A function or method which is defined using "async def" and\n'
|
||||
' which uses the "yield" statement is called a *asynchronous\n'
|
||||
' generator function*. Such a function, when called, returns '
|
||||
'an\n'
|
||||
' asynchronous iterator object which can be used in an "async '
|
||||
'for"\n'
|
||||
' statement to execute the body of the function.\n'
|
||||
'\n'
|
||||
' Calling the asynchronous iterator\'s "aiterator.__anext__()"\n'
|
||||
' method will return an *awaitable* which when awaited will\n'
|
||||
' execute until it provides a value using the "yield" '
|
||||
'expression.\n'
|
||||
' When the function executes an empty "return" statement or '
|
||||
'falls\n'
|
||||
' off the end, a "StopAsyncIteration" exception is raised and '
|
||||
'the\n'
|
||||
' asynchronous iterator will have reached the end of the set '
|
||||
'of\n'
|
||||
' values to be yielded.\n'
|
||||
'\n'
|
||||
' Built-in functions\n'
|
||||
' A built-in function object is a wrapper around a C function.\n'
|
||||
' Examples of built-in functions are "len()" and "math.sin()"\n'
|
||||
|
|
@ -11233,14 +11210,14 @@ topics = {'assert': '\n'
|
|||
'the\n'
|
||||
' dictionary containing the class\'s namespace; "__bases__" is a '
|
||||
'tuple\n'
|
||||
' (possibly empty or a singleton) containing the base classes, in '
|
||||
'the\n'
|
||||
' order of their occurrence in the base class list; "__doc__" is '
|
||||
'the\n'
|
||||
' class\'s documentation string, or "None" if undefined;\n'
|
||||
' "__annotations__" (optional) is a dictionary containing '
|
||||
'*variable\n'
|
||||
' annotations* collected during class body execution.\n'
|
||||
' containing the base classes, in the order of their occurrence '
|
||||
'in\n'
|
||||
' the base class list; "__doc__" is the class\'s documentation '
|
||||
'string,\n'
|
||||
' or "None" if undefined; "__annotations__" (optional) is a\n'
|
||||
' dictionary containing *variable annotations* collected during '
|
||||
'class\n'
|
||||
' body execution.\n'
|
||||
'\n'
|
||||
'Class instances\n'
|
||||
' A class instance is created by calling a class object (see '
|
||||
|
|
@ -11520,8 +11497,7 @@ topics = {'assert': '\n'
|
|||
' under "User-defined methods". Class method objects are '
|
||||
'created\n'
|
||||
' by the built-in "classmethod()" constructor.\n',
|
||||
'typesfunctions': '\n'
|
||||
'Functions\n'
|
||||
'typesfunctions': 'Functions\n'
|
||||
'*********\n'
|
||||
'\n'
|
||||
'Function objects are created by function definitions. The '
|
||||
|
|
@ -11538,8 +11514,7 @@ topics = {'assert': '\n'
|
|||
'different object types.\n'
|
||||
'\n'
|
||||
'See Function definitions for more information.\n',
|
||||
'typesmapping': '\n'
|
||||
'Mapping Types --- "dict"\n'
|
||||
'typesmapping': 'Mapping Types --- "dict"\n'
|
||||
'************************\n'
|
||||
'\n'
|
||||
'A *mapping* object maps *hashable* values to arbitrary '
|
||||
|
|
@ -11896,8 +11871,7 @@ topics = {'assert': '\n'
|
|||
" {'bacon'}\n"
|
||||
" >>> keys ^ {'sausage', 'juice'}\n"
|
||||
" {'juice', 'sausage', 'bacon', 'spam'}\n",
|
||||
'typesmethods': '\n'
|
||||
'Methods\n'
|
||||
'typesmethods': 'Methods\n'
|
||||
'*******\n'
|
||||
'\n'
|
||||
'Methods are functions that are called using the attribute '
|
||||
|
|
@ -11954,8 +11928,7 @@ topics = {'assert': '\n'
|
|||
" 'my name is method'\n"
|
||||
'\n'
|
||||
'See The standard type hierarchy for more information.\n',
|
||||
'typesmodules': '\n'
|
||||
'Modules\n'
|
||||
'typesmodules': 'Modules\n'
|
||||
'*******\n'
|
||||
'\n'
|
||||
'The only special operation on a module is attribute access: '
|
||||
|
|
@ -11992,8 +11965,7 @@ topics = {'assert': '\n'
|
|||
'written as\n'
|
||||
'"<module \'os\' from '
|
||||
'\'/usr/local/lib/pythonX.Y/os.pyc\'>".\n',
|
||||
'typesseq': '\n'
|
||||
'Sequence Types --- "list", "tuple", "range"\n'
|
||||
'typesseq': 'Sequence Types --- "list", "tuple", "range"\n'
|
||||
'*******************************************\n'
|
||||
'\n'
|
||||
'There are three basic sequence types: lists, tuples, and range\n'
|
||||
|
|
@ -12141,9 +12113,9 @@ topics = {'assert': '\n'
|
|||
'\n'
|
||||
'3. If *i* or *j* is negative, the index is relative to the end '
|
||||
'of\n'
|
||||
' the string: "len(s) + i" or "len(s) + j" is substituted. But '
|
||||
'note\n'
|
||||
' that "-0" is still "0".\n'
|
||||
' sequence *s*: "len(s) + i" or "len(s) + j" is substituted. '
|
||||
'But\n'
|
||||
' note that "-0" is still "0".\n'
|
||||
'\n'
|
||||
'4. The slice of *s* from *i* to *j* is defined as the sequence '
|
||||
'of\n'
|
||||
|
|
@ -12162,12 +12134,17 @@ topics = {'assert': '\n'
|
|||
' (j-i)/k". In other words, the indices are "i", "i+k", '
|
||||
'"i+2*k",\n'
|
||||
' "i+3*k" and so on, stopping when *j* is reached (but never\n'
|
||||
' including *j*). If *i* or *j* is greater than "len(s)", use\n'
|
||||
' "len(s)". If *i* or *j* are omitted or "None", they become '
|
||||
'"end"\n'
|
||||
' values (which end depends on the sign of *k*). Note, *k* '
|
||||
'cannot be\n'
|
||||
' zero. If *k* is "None", it is treated like "1".\n'
|
||||
' including *j*). When *k* is positive, *i* and *j* are '
|
||||
'reduced to\n'
|
||||
' "len(s)" if they are greater. When *k* is negative, *i* and '
|
||||
'*j* are\n'
|
||||
' reduced to "len(s) - 1" if they are greater. If *i* or *j* '
|
||||
'are\n'
|
||||
' omitted or "None", they become "end" values (which end '
|
||||
'depends on\n'
|
||||
' the sign of *k*). Note, *k* cannot be zero. If *k* is '
|
||||
'"None", it\n'
|
||||
' is treated like "1".\n'
|
||||
'\n'
|
||||
'6. Concatenating immutable sequences always results in a new\n'
|
||||
' object. This means that building up a sequence by repeated\n'
|
||||
|
|
@ -12685,8 +12662,7 @@ topics = {'assert': '\n'
|
|||
' * The linspace recipe shows how to implement a lazy version '
|
||||
'of\n'
|
||||
' range that suitable for floating point applications.\n',
|
||||
'typesseq-mutable': '\n'
|
||||
'Mutable Sequence Types\n'
|
||||
'typesseq-mutable': 'Mutable Sequence Types\n'
|
||||
'**********************\n'
|
||||
'\n'
|
||||
'The operations in the following table are defined on '
|
||||
|
|
@ -12826,8 +12802,7 @@ topics = {'assert': '\n'
|
|||
'referenced multiple\n'
|
||||
' times, as explained for "s * n" under Common Sequence '
|
||||
'Operations.\n',
|
||||
'unary': '\n'
|
||||
'Unary arithmetic and bitwise operations\n'
|
||||
'unary': 'Unary arithmetic and bitwise operations\n'
|
||||
'***************************************\n'
|
||||
'\n'
|
||||
'All unary arithmetic and bitwise operations have the same '
|
||||
|
|
@ -12849,8 +12824,7 @@ topics = {'assert': '\n'
|
|||
'In all three cases, if the argument does not have the proper type, '
|
||||
'a\n'
|
||||
'"TypeError" exception is raised.\n',
|
||||
'while': '\n'
|
||||
'The "while" statement\n'
|
||||
'while': 'The "while" statement\n'
|
||||
'*********************\n'
|
||||
'\n'
|
||||
'The "while" statement is used for repeated execution as long as an\n'
|
||||
|
|
@ -12874,8 +12848,7 @@ topics = {'assert': '\n'
|
|||
'executed in the first suite skips the rest of the suite and goes '
|
||||
'back\n'
|
||||
'to testing the expression.\n',
|
||||
'with': '\n'
|
||||
'The "with" statement\n'
|
||||
'with': 'The "with" statement\n'
|
||||
'********************\n'
|
||||
'\n'
|
||||
'The "with" statement is used to wrap the execution of a block with\n'
|
||||
|
|
@ -12948,8 +12921,7 @@ topics = {'assert': '\n'
|
|||
' The specification, background, and examples for the Python '
|
||||
'"with"\n'
|
||||
' statement.\n',
|
||||
'yield': '\n'
|
||||
'The "yield" statement\n'
|
||||
'yield': 'The "yield" statement\n'
|
||||
'*********************\n'
|
||||
'\n'
|
||||
' yield_stmt ::= yield_expression\n'
|
||||
|
|
|
|||
Loading…
Reference in New Issue