<h2>Edit File - topics.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/pydoc_data/topics.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;"># -*- coding: utf-8 -*-
# Autogenerated by Sphinx on Sun Dec 23 16:24:21 2018
topics = {&#039;assert&#039;: &#039;The &quot;assert&quot; statement\n&#039;
           &#039;**********************\n&#039;
           &#039;\n&#039;
           &#039;Assert statements are a convenient way to insert debugging &#039;
           &#039;assertions\n&#039;
           &#039;into a program:\n&#039;
           &#039;\n&#039;
           &#039;   assert_stmt ::= &quot;assert&quot; expression [&quot;,&quot; expression]\n&#039;
           &#039;\n&#039;
           &#039;The simple form, &quot;assert expression&quot;, is equivalent to\n&#039;
           &#039;\n&#039;
           &#039;   if __debug__:\n&#039;
           &#039;       if not expression: raise AssertionError\n&#039;
           &#039;\n&#039;
           &#039;The extended form, &quot;assert expression1, expression2&quot;, is &#039;
           &#039;equivalent to\n&#039;
           &#039;\n&#039;
           &#039;   if __debug__:\n&#039;
           &#039;       if not expression1: raise AssertionError(expression2)\n&#039;
           &#039;\n&#039;
           &#039;These equivalences assume that &quot;__debug__&quot; and &quot;AssertionError&quot; &#039;
           &#039;refer\n&#039;
           &#039;to the built-in variables with those names.  In the current\n&#039;
           &#039;implementation, the built-in variable &quot;__debug__&quot; is &quot;True&quot; under\n&#039;
           &#039;normal circumstances, &quot;False&quot; when optimization is requested &#039;
           &#039;(command\n&#039;
           &#039;line option &quot;-O&quot;).  The current code generator emits no code for &#039;
           &#039;an\n&#039;
           &#039;assert statement when optimization is requested at compile time.  &#039;
           &#039;Note\n&#039;
           &#039;that it is unnecessary to include the source code for the &#039;
           &#039;expression\n&#039;
           &#039;that failed in the error message; it will be displayed as part of &#039;
           &#039;the\n&#039;
           &#039;stack trace.\n&#039;
           &#039;\n&#039;
           &#039;Assignments to &quot;__debug__&quot; are illegal.  The value for the &#039;
           &#039;built-in\n&#039;
           &#039;variable is determined when the interpreter starts.\n&#039;,
 &#039;assignment&#039;: &#039;Assignment statements\n&#039;
               &#039;*********************\n&#039;
               &#039;\n&#039;
               &#039;Assignment statements are used to (re)bind names to values and &#039;
               &#039;to\n&#039;
               &#039;modify attributes or items of mutable objects:\n&#039;
               &#039;\n&#039;
               &#039;   assignment_stmt ::= (target_list &quot;=&quot;)+ (starred_expression &#039;
               &#039;| yield_expression)\n&#039;
               &#039;   target_list     ::= target (&quot;,&quot; target)* [&quot;,&quot;]\n&#039;
               &#039;   target          ::= identifier\n&#039;
               &#039;              | &quot;(&quot; [target_list] &quot;)&quot;\n&#039;
               &#039;              | &quot;[&quot; [target_list] &quot;]&quot;\n&#039;
               &#039;              | attributeref\n&#039;
               &#039;              | subscription\n&#039;
               &#039;              | slicing\n&#039;
               &#039;              | &quot;*&quot; target\n&#039;
               &#039;\n&#039;
               &#039;(See section Primaries for the syntax definitions for &#039;
               &#039;*attributeref*,\n&#039;
               &#039;*subscription*, and *slicing*.)\n&#039;
               &#039;\n&#039;
               &#039;An assignment statement evaluates the expression list &#039;
               &#039;(remember that\n&#039;
               &#039;this can be a single expression or a comma-separated list, the &#039;
               &#039;latter\n&#039;
               &#039;yielding a tuple) and assigns the single resulting object to &#039;
               &#039;each of\n&#039;
               &#039;the target lists, from left to right.\n&#039;
               &#039;\n&#039;
               &#039;Assignment is defined recursively depending on the form of the &#039;
               &#039;target\n&#039;
               &#039;(list). When a target is part of a mutable object (an &#039;
               &#039;attribute\n&#039;
               &#039;reference, subscription or slicing), the mutable object must\n&#039;
               &#039;ultimately perform the assignment and decide about its &#039;
               &#039;validity, and\n&#039;
               &#039;may raise an exception if the assignment is unacceptable.  The &#039;
               &#039;rules\n&#039;
               &#039;observed by various types and the exceptions raised are given &#039;
               &#039;with the\n&#039;
               &#039;definition of the object types (see section The standard type\n&#039;
               &#039;hierarchy).\n&#039;
               &#039;\n&#039;
               &#039;Assignment of an object to a target list, optionally enclosed &#039;
               &#039;in\n&#039;
               &#039;parentheses or square brackets, is recursively defined as &#039;
               &#039;follows.\n&#039;
               &#039;\n&#039;
               &#039;* If the target list is a single target with no trailing &#039;
               &#039;comma,\n&#039;
               &#039;  optionally in parentheses, the object is assigned to that &#039;
               &#039;target.\n&#039;
               &#039;\n&#039;
               &#039;* Else: The object must be an iterable with the same number of &#039;
               &#039;items\n&#039;
               &#039;  as there are targets in the target list, and the items are &#039;
               &#039;assigned,\n&#039;
               &#039;  from left to right, to the corresponding targets.\n&#039;
               &#039;\n&#039;
               &#039;  * If the target list contains one target prefixed with an\n&#039;
               &#039;    asterisk, called a “starred” target: The object must be &#039;
               &#039;an\n&#039;
               &#039;    iterable with at least as many items as there are targets &#039;
               &#039;in the\n&#039;
               &#039;    target list, minus one.  The first items of the iterable &#039;
               &#039;are\n&#039;
               &#039;    assigned, from left to right, to the targets before the &#039;
               &#039;starred\n&#039;
               &#039;    target.  The final items of the iterable are assigned to &#039;
               &#039;the\n&#039;
               &#039;    targets after the starred target.  A list of the remaining &#039;
               &#039;items\n&#039;
               &#039;    in the iterable is then assigned to the starred target &#039;
               &#039;(the list\n&#039;
               &#039;    can be empty).\n&#039;
               &#039;\n&#039;
               &#039;  * Else: The object must be an iterable with the same number &#039;
               &#039;of\n&#039;
               &#039;    items as there are targets in the target list, and the &#039;
               &#039;items are\n&#039;
               &#039;    assigned, from left to right, to the corresponding &#039;
               &#039;targets.\n&#039;
               &#039;\n&#039;
               &#039;Assignment of an object to a single target is recursively &#039;
               &#039;defined as\n&#039;
               &#039;follows.\n&#039;
               &#039;\n&#039;
               &#039;* If the target is an identifier (name):\n&#039;
               &#039;\n&#039;
               &#039;  * If the name does not occur in a &quot;global&quot; or &quot;nonlocal&quot; &#039;
               &#039;statement\n&#039;
               &#039;    in the current code block: the name is bound to the object &#039;
               &#039;in the\n&#039;
               &#039;    current local namespace.\n&#039;
               &#039;\n&#039;
               &#039;  * Otherwise: the name is bound to the object in the global\n&#039;
               &#039;    namespace or the outer namespace determined by &#039;
               &#039;&quot;nonlocal&quot;,\n&#039;
               &#039;    respectively.\n&#039;
               &#039;\n&#039;
               &#039;  The name is rebound if it was already bound.  This may cause &#039;
               &#039;the\n&#039;
               &#039;  reference count for the object previously bound to the name &#039;
               &#039;to reach\n&#039;
               &#039;  zero, causing the object to be deallocated and its &#039;
               &#039;destructor (if it\n&#039;
               &#039;  has one) to be called.\n&#039;
               &#039;\n&#039;
               &#039;* If the target is an attribute reference: The primary &#039;
               &#039;expression in\n&#039;
               &#039;  the reference is evaluated.  It should yield an object with\n&#039;
               &#039;  assignable attributes; if this is not the case, &quot;TypeError&quot; &#039;
               &#039;is\n&#039;
               &#039;  raised.  That object is then asked to assign the assigned &#039;
               &#039;object to\n&#039;
               &#039;  the given attribute; if it cannot perform the assignment, it &#039;
               &#039;raises\n&#039;
               &#039;  an exception (usually but not necessarily &#039;
               &#039;&quot;AttributeError&quot;).\n&#039;
               &#039;\n&#039;
               &#039;  Note: If the object is a class instance and the attribute &#039;
               &#039;reference\n&#039;
               &#039;  occurs on both sides of the assignment operator, the RHS &#039;
               &#039;expression,\n&#039;
               &#039;  &quot;a.x&quot; can access either an instance attribute or (if no &#039;
               &#039;instance\n&#039;
               &#039;  attribute exists) a class attribute.  The LHS target &quot;a.x&quot; &#039;
               &#039;is always\n&#039;
               &#039;  set as an instance attribute, creating it if necessary.  &#039;
               &#039;Thus, the\n&#039;
               &#039;  two occurrences of &quot;a.x&quot; do not necessarily refer to the &#039;
               &#039;same\n&#039;
               &#039;  attribute: if the RHS expression refers to a class &#039;
               &#039;attribute, the\n&#039;
               &#039;  LHS creates a new instance attribute as the target of the\n&#039;
               &#039;  assignment:\n&#039;
               &#039;\n&#039;
               &#039;     class Cls:\n&#039;
               &#039;         x = 3             # class variable\n&#039;
               &#039;     inst = Cls()\n&#039;
               &#039;     inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x &#039;
               &#039;as 3\n&#039;
               &#039;\n&#039;
               &#039;  This description does not necessarily apply to descriptor\n&#039;
               &#039;  attributes, such as properties created with &quot;property()&quot;.\n&#039;
               &#039;\n&#039;
               &#039;* If the target is a subscription: The primary expression in &#039;
               &#039;the\n&#039;
               &#039;  reference is evaluated.  It should yield either a mutable &#039;
               &#039;sequence\n&#039;
               &#039;  object (such as a list) or a mapping object (such as a &#039;
               &#039;dictionary).\n&#039;
               &#039;  Next, the subscript expression is evaluated.\n&#039;
               &#039;\n&#039;
               &#039;  If the primary is a mutable sequence object (such as a &#039;
               &#039;list), the\n&#039;
               &#039;  subscript must yield an integer.  If it is negative, the &#039;
               &#039;sequence’s\n&#039;
               &#039;  length is added to it.  The resulting value must be a &#039;
               &#039;nonnegative\n&#039;
               &#039;  integer less than the sequence’s length, and the sequence is &#039;
               &#039;asked\n&#039;
               &#039;  to assign the assigned object to its item with that index.  &#039;
               &#039;If the\n&#039;
               &#039;  index is out of range, &quot;IndexError&quot; is raised (assignment to &#039;
               &#039;a\n&#039;
               &#039;  subscripted sequence cannot add new items to a list).\n&#039;
               &#039;\n&#039;
               &#039;  If the primary is a mapping object (such as a dictionary), &#039;
               &#039;the\n&#039;
               &#039;  subscript must have a type compatible with the mapping’s key &#039;
               &#039;type,\n&#039;
               &#039;  and the mapping is then asked to create a key/datum pair &#039;
               &#039;which maps\n&#039;
               &#039;  the subscript to the assigned object.  This can either &#039;
               &#039;replace an\n&#039;
               &#039;  existing key/value pair with the same key value, or insert a &#039;
               &#039;new\n&#039;
               &#039;  key/value pair (if no key with the same value existed).\n&#039;
               &#039;\n&#039;
               &#039;  For user-defined objects, the &quot;__setitem__()&quot; method is &#039;
               &#039;called with\n&#039;
               &#039;  appropriate arguments.\n&#039;
               &#039;\n&#039;
               &#039;* If the target is a slicing: The primary expression in the\n&#039;
               &#039;  reference is evaluated.  It should yield a mutable sequence &#039;
               &#039;object\n&#039;
               &#039;  (such as a list).  The assigned object should be a sequence &#039;
               &#039;object\n&#039;
               &#039;  of the same type.  Next, the lower and upper bound &#039;
               &#039;expressions are\n&#039;
               &#039;  evaluated, insofar they are present; defaults are zero and &#039;
               &#039;the\n&#039;
               &#039;  sequence’s length.  The bounds should evaluate to integers. &#039;
               &#039;If\n&#039;
               &#039;  either bound is negative, the sequence’s length is added to &#039;
               &#039;it.  The\n&#039;
               &#039;  resulting bounds are clipped to lie between zero and the &#039;
               &#039;sequence’s\n&#039;
               &#039;  length, inclusive.  Finally, the sequence object is asked to &#039;
               &#039;replace\n&#039;
               &#039;  the slice with the items of the assigned sequence.  The &#039;
               &#039;length of\n&#039;
               &#039;  the slice may be different from the length of the assigned &#039;
               &#039;sequence,\n&#039;
               &#039;  thus changing the length of the target sequence, if the &#039;
               &#039;target\n&#039;
               &#039;  sequence allows it.\n&#039;
               &#039;\n&#039;
               &#039;**CPython implementation detail:** In the current &#039;
               &#039;implementation, the\n&#039;
               &#039;syntax for targets is taken to be the same as for expressions, &#039;
               &#039;and\n&#039;
               &#039;invalid syntax is rejected during the code generation phase, &#039;
               &#039;causing\n&#039;
               &#039;less detailed error messages.\n&#039;
               &#039;\n&#039;
               &#039;Although the definition of assignment implies that overlaps &#039;
               &#039;between\n&#039;
               &#039;the left-hand side and the right-hand side are ‘simultaneous’ &#039;
               &#039;(for\n&#039;
               &#039;example &quot;a, b = b, a&quot; swaps two variables), overlaps *within* &#039;
               &#039;the\n&#039;
               &#039;collection of assigned-to variables occur left-to-right, &#039;
               &#039;sometimes\n&#039;
               &#039;resulting in confusion.  For instance, the following program &#039;
               &#039;prints\n&#039;
               &#039;&quot;[0, 2]&quot;:\n&#039;
               &#039;\n&#039;
               &#039;   x = [0, 1]\n&#039;
               &#039;   i = 0\n&#039;
               &#039;   i, x[i] = 1, 2         # i is updated, then x[i] is &#039;
               &#039;updated\n&#039;
               &#039;   print(x)\n&#039;
               &#039;\n&#039;
               &#039;See also:\n&#039;
               &#039;\n&#039;
               &#039;  **PEP 3132** - Extended Iterable Unpacking\n&#039;
               &#039;     The specification for the &quot;*target&quot; feature.\n&#039;
               &#039;\n&#039;
               &#039;\n&#039;
               &#039;Augmented assignment statements\n&#039;
               &#039;===============================\n&#039;
               &#039;\n&#039;
               &#039;Augmented assignment is the combination, in a single &#039;
               &#039;statement, of a\n&#039;
               &#039;binary operation and an assignment statement:\n&#039;
               &#039;\n&#039;
               &#039;   augmented_assignment_stmt ::= augtarget augop &#039;
               &#039;(expression_list | yield_expression)\n&#039;
               &#039;   augtarget                 ::= identifier | attributeref | &#039;
               &#039;subscription | slicing\n&#039;
               &#039;   augop                     ::= &quot;+=&quot; | &quot;-=&quot; | &quot;*=&quot; | &quot;@=&quot; | &#039;
               &#039;&quot;/=&quot; | &quot;//=&quot; | &quot;%=&quot; | &quot;**=&quot;\n&#039;
               &#039;             | &quot;&gt;&gt;=&quot; | &quot;&lt;&lt;=&quot; | &quot;&amp;=&quot; | &quot;^=&quot; | &quot;|=&quot;\n&#039;
               &#039;\n&#039;
               &#039;(See section Primaries for the syntax definitions of the last &#039;
               &#039;three\n&#039;
               &#039;symbols.)\n&#039;
               &#039;\n&#039;
               &#039;An augmented assignment evaluates the target (which, unlike &#039;
               &#039;normal\n&#039;
               &#039;assignment statements, cannot be an unpacking) and the &#039;
               &#039;expression\n&#039;
               &#039;list, performs the binary operation specific to the type of &#039;
               &#039;assignment\n&#039;
               &#039;on the two operands, and assigns the result to the original &#039;
               &#039;target.\n&#039;
               &#039;The target is only evaluated once.\n&#039;
               &#039;\n&#039;
               &#039;An augmented assignment expression like &quot;x += 1&quot; can be &#039;
               &#039;rewritten as\n&#039;
               &#039;&quot;x = x + 1&quot; to achieve a similar, but not exactly equal &#039;
               &#039;effect. In the\n&#039;
               &#039;augmented version, &quot;x&quot; is only evaluated once. Also, when &#039;
               &#039;possible,\n&#039;
               &#039;the actual operation is performed *in-place*, meaning that &#039;
               &#039;rather than\n&#039;
               &#039;creating a new object and assigning that to the target, the &#039;
               &#039;old object\n&#039;
               &#039;is modified instead.\n&#039;
               &#039;\n&#039;
               &#039;Unlike normal assignments, augmented assignments evaluate the &#039;
               &#039;left-\n&#039;
               &#039;hand side *before* evaluating the right-hand side.  For &#039;
               &#039;example, &quot;a[i]\n&#039;
               &#039;+= f(x)&quot; first looks-up &quot;a[i]&quot;, then it evaluates &quot;f(x)&quot; and &#039;
               &#039;performs\n&#039;
               &#039;the addition, and lastly, it writes the result back to &#039;
               &#039;&quot;a[i]&quot;.\n&#039;
               &#039;\n&#039;
               &#039;With the exception of assigning to tuples and multiple targets &#039;
               &#039;in a\n&#039;
               &#039;single statement, the assignment done by augmented assignment\n&#039;
               &#039;statements is handled the same way as normal assignments. &#039;
               &#039;Similarly,\n&#039;
               &#039;with the exception of the possible *in-place* behavior, the &#039;
               &#039;binary\n&#039;
               &#039;operation performed by augmented assignment is the same as the &#039;
               &#039;normal\n&#039;
               &#039;binary operations.\n&#039;
               &#039;\n&#039;
               &#039;For targets which are attribute references, the same caveat &#039;
               &#039;about\n&#039;
               &#039;class and instance attributes applies as for regular &#039;
               &#039;assignments.\n&#039;
               &#039;\n&#039;
               &#039;\n&#039;
               &#039;Annotated assignment statements\n&#039;
               &#039;===============================\n&#039;
               &#039;\n&#039;
               &#039;Annotation assignment is the combination, in a single &#039;
               &#039;statement, of a\n&#039;
               &#039;variable or attribute annotation and an optional assignment &#039;
               &#039;statement:\n&#039;
               &#039;\n&#039;
               &#039;   annotated_assignment_stmt ::= augtarget &quot;:&quot; expression [&quot;=&quot; &#039;
               &#039;expression]\n&#039;
               &#039;\n&#039;
               &#039;The difference from normal Assignment statements is that only &#039;
               &#039;single\n&#039;
               &#039;target and only single right hand side value is allowed.\n&#039;
               &#039;\n&#039;
               &#039;For simple names as assignment targets, if in class or module &#039;
               &#039;scope,\n&#039;
               &#039;the annotations are evaluated and stored in a special class or &#039;
               &#039;module\n&#039;
               &#039;attribute &quot;__annotations__&quot; that is a dictionary mapping from &#039;
               &#039;variable\n&#039;
               &#039;names (mangled if private) to evaluated annotations. This &#039;
               &#039;attribute is\n&#039;
               &#039;writable and is automatically created at the start of class or &#039;
               &#039;module\n&#039;
               &#039;body execution, if annotations are found statically.\n&#039;
               &#039;\n&#039;
               &#039;For expressions as assignment targets, the annotations are &#039;
               &#039;evaluated\n&#039;
               &#039;if in class or module scope, but not stored.\n&#039;
               &#039;\n&#039;
               &#039;If a name is annotated in a function scope, then this name is &#039;
               &#039;local\n&#039;
               &#039;for that scope. Annotations are never evaluated and stored in &#039;
               &#039;function\n&#039;
               &#039;scopes.\n&#039;
               &#039;\n&#039;
               &#039;If the right hand side is present, an annotated assignment &#039;
               &#039;performs\n&#039;
               &#039;the actual assignment before evaluating annotations (where\n&#039;
               &#039;applicable). If the right hand side is not present for an &#039;
               &#039;expression\n&#039;
               &#039;target, then the interpreter evaluates the target except for &#039;
               &#039;the last\n&#039;
               &#039;&quot;__setitem__()&quot; or &quot;__setattr__()&quot; call.\n&#039;
               &#039;\n&#039;
               &#039;See also:\n&#039;
               &#039;\n&#039;
               &#039;  **PEP 526** - Syntax for Variable Annotations\n&#039;
               &#039;     The proposal that added syntax for annotating the types &#039;
               &#039;of\n&#039;
               &#039;     variables (including class variables and instance &#039;
               &#039;variables),\n&#039;
               &#039;     instead of expressing them through comments.\n&#039;
               &#039;\n&#039;
               &#039;  **PEP 484** - Type hints\n&#039;
               &#039;     The proposal that added the &quot;typing&quot; module to provide a &#039;
               &#039;standard\n&#039;
               &#039;     syntax for type annotations that can be used in static &#039;
               &#039;analysis\n&#039;
               &#039;     tools and IDEs.\n&#039;,
 &#039;atom-identifiers&#039;: &#039;Identifiers (Names)\n&#039;
                     &#039;*******************\n&#039;
                     &#039;\n&#039;
                     &#039;An identifier occurring as an atom is a name.  See &#039;
                     &#039;section Identifiers\n&#039;
                     &#039;and keywords for lexical definition and section Naming &#039;
                     &#039;and binding for\n&#039;
                     &#039;documentation of naming and binding.\n&#039;
                     &#039;\n&#039;
                     &#039;When the name is bound to an object, evaluation of the &#039;
                     &#039;atom yields\n&#039;
                     &#039;that object. When a name is not bound, an attempt to &#039;
                     &#039;evaluate it\n&#039;
                     &#039;raises a &quot;NameError&quot; exception.\n&#039;
                     &#039;\n&#039;
                     &#039;**Private name mangling:** When an identifier that &#039;
                     &#039;textually occurs in\n&#039;
                     &#039;a class definition begins with two or more underscore &#039;
                     &#039;characters and\n&#039;
                     &#039;does not end in two or more underscores, it is &#039;
                     &#039;considered a *private\n&#039;
                     &#039;name* of that class. Private names are transformed to a &#039;
                     &#039;longer form\n&#039;
                     &#039;before code is generated for them.  The transformation &#039;
                     &#039;inserts the\n&#039;
                     &#039;class name, with leading underscores removed and a &#039;
                     &#039;single underscore\n&#039;
                     &#039;inserted, in front of the name.  For example, the &#039;
                     &#039;identifier &quot;__spam&quot;\n&#039;
                     &#039;occurring in a class named &quot;Ham&quot; will be transformed to &#039;
                     &#039;&quot;_Ham__spam&quot;.\n&#039;
                     &#039;This transformation is independent of the syntactical &#039;
                     &#039;context in which\n&#039;
                     &#039;the identifier is used.  If the transformed name is &#039;
                     &#039;extremely long\n&#039;
                     &#039;(longer than 255 characters), implementation defined &#039;
                     &#039;truncation may\n&#039;
                     &#039;happen. If the class name consists only of underscores, &#039;
                     &#039;no\n&#039;
                     &#039;transformation is done.\n&#039;,
 &#039;atom-literals&#039;: &#039;Literals\n&#039;
                  &#039;********\n&#039;
                  &#039;\n&#039;
                  &#039;Python supports string and bytes literals and various &#039;
                  &#039;numeric\n&#039;
                  &#039;literals:\n&#039;
                  &#039;\n&#039;
                  &#039;   literal ::= stringliteral | bytesliteral\n&#039;
                  &#039;               | integer | floatnumber | imagnumber\n&#039;
                  &#039;\n&#039;
                  &#039;Evaluation of a literal yields an object of the given type &#039;
                  &#039;(string,\n&#039;
                  &#039;bytes, integer, floating point number, complex number) with &#039;
                  &#039;the given\n&#039;
                  &#039;value.  The value may be approximated in the case of &#039;
                  &#039;floating point\n&#039;
                  &#039;and imaginary (complex) literals.  See section Literals for &#039;
                  &#039;details.\n&#039;
                  &#039;\n&#039;
                  &#039;All literals correspond to immutable data types, and hence &#039;
                  &#039;the\n&#039;
                  &#039;object’s identity is less important than its value.  &#039;
                  &#039;Multiple\n&#039;
                  &#039;evaluations of literals with the same value (either the &#039;
                  &#039;same\n&#039;
                  &#039;occurrence in the program text or a different occurrence) &#039;
                  &#039;may obtain\n&#039;
                  &#039;the same object or a different object with the same &#039;
                  &#039;value.\n&#039;,
 &#039;attribute-access&#039;: &#039;Customizing attribute access\n&#039;
                     &#039;****************************\n&#039;
                     &#039;\n&#039;
                     &#039;The following methods can be defined to customize the &#039;
                     &#039;meaning of\n&#039;
                     &#039;attribute access (use of, assignment to, or deletion of &#039;
                     &#039;&quot;x.name&quot;) for\n&#039;
                     &#039;class instances.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__getattr__(self, name)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called when the default attribute access fails with &#039;
                     &#039;an\n&#039;
                     &#039;   &quot;AttributeError&quot; (either &quot;__getattribute__()&quot; raises &#039;
                     &#039;an\n&#039;
                     &#039;   &quot;AttributeError&quot; because *name* is not an instance &#039;
                     &#039;attribute or an\n&#039;
                     &#039;   attribute in the class tree for &quot;self&quot;; or &#039;
                     &#039;&quot;__get__()&quot; of a *name*\n&#039;
                     &#039;   property raises &quot;AttributeError&quot;).  This method &#039;
                     &#039;should either\n&#039;
                     &#039;   return the (computed) attribute value or raise an &#039;
                     &#039;&quot;AttributeError&quot;\n&#039;
                     &#039;   exception.\n&#039;
                     &#039;\n&#039;
                     &#039;   Note that if the attribute is found through the &#039;
                     &#039;normal mechanism,\n&#039;
                     &#039;   &quot;__getattr__()&quot; is not called.  (This is an &#039;
                     &#039;intentional asymmetry\n&#039;
                     &#039;   between &quot;__getattr__()&quot; and &quot;__setattr__()&quot;.) This is &#039;
                     &#039;done both for\n&#039;
                     &#039;   efficiency reasons and because otherwise &#039;
                     &#039;&quot;__getattr__()&quot; would have\n&#039;
                     &#039;   no way to access other attributes of the instance.  &#039;
                     &#039;Note that at\n&#039;
                     &#039;   least for instance variables, you can fake total &#039;
                     &#039;control by not\n&#039;
                     &#039;   inserting any values in the instance attribute &#039;
                     &#039;dictionary (but\n&#039;
                     &#039;   instead inserting them in another object).  See the\n&#039;
                     &#039;   &quot;__getattribute__()&quot; method below for a way to &#039;
                     &#039;actually get total\n&#039;
                     &#039;   control over attribute access.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__getattribute__(self, name)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called unconditionally to implement attribute &#039;
                     &#039;accesses for\n&#039;
                     &#039;   instances of the class. If the class also defines &#039;
                     &#039;&quot;__getattr__()&quot;,\n&#039;
                     &#039;   the latter will not be called unless &#039;
                     &#039;&quot;__getattribute__()&quot; either\n&#039;
                     &#039;   calls it explicitly or raises an &quot;AttributeError&quot;. &#039;
                     &#039;This method\n&#039;
                     &#039;   should return the (computed) attribute value or raise &#039;
                     &#039;an\n&#039;
                     &#039;   &quot;AttributeError&quot; exception. In order to avoid &#039;
                     &#039;infinite recursion in\n&#039;
                     &#039;   this method, its implementation should always call &#039;
                     &#039;the base class\n&#039;
                     &#039;   method with the same name to access any attributes it &#039;
                     &#039;needs, for\n&#039;
                     &#039;   example, &quot;object.__getattribute__(self, name)&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;   Note: This method may still be bypassed when looking &#039;
                     &#039;up special\n&#039;
                     &#039;     methods as the result of implicit invocation via &#039;
                     &#039;language syntax\n&#039;
                     &#039;     or built-in functions. See Special method lookup.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__setattr__(self, name, value)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called when an attribute assignment is attempted.  &#039;
                     &#039;This is called\n&#039;
                     &#039;   instead of the normal mechanism (i.e. store the value &#039;
                     &#039;in the\n&#039;
                     &#039;   instance dictionary). *name* is the attribute name, &#039;
                     &#039;*value* is the\n&#039;
                     &#039;   value to be assigned to it.\n&#039;
                     &#039;\n&#039;
                     &#039;   If &quot;__setattr__()&quot; wants to assign to an instance &#039;
                     &#039;attribute, it\n&#039;
                     &#039;   should call the base class method with the same name, &#039;
                     &#039;for example,\n&#039;
                     &#039;   &quot;object.__setattr__(self, name, value)&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__delattr__(self, name)\n&#039;
                     &#039;\n&#039;
                     &#039;   Like &quot;__setattr__()&quot; but for attribute deletion &#039;
                     &#039;instead of\n&#039;
                     &#039;   assignment.  This should only be implemented if &quot;del &#039;
                     &#039;obj.name&quot; is\n&#039;
                     &#039;   meaningful for the object.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__dir__(self)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called when &quot;dir()&quot; is called on the object. A &#039;
                     &#039;sequence must be\n&#039;
                     &#039;   returned. &quot;dir()&quot; converts the returned sequence to a &#039;
                     &#039;list and\n&#039;
                     &#039;   sorts it.\n&#039;
                     &#039;\n&#039;
                     &#039;\n&#039;
                     &#039;Customizing module attribute access\n&#039;
                     &#039;===================================\n&#039;
                     &#039;\n&#039;
                     &#039;For a more fine grained customization of the module &#039;
                     &#039;behavior (setting\n&#039;
                     &#039;attributes, properties, etc.), one can set the &#039;
                     &#039;&quot;__class__&quot; attribute\n&#039;
                     &#039;of a module object to a subclass of &quot;types.ModuleType&quot;. &#039;
                     &#039;For example:\n&#039;
                     &#039;\n&#039;
                     &#039;   import sys\n&#039;
                     &#039;   from types import ModuleType\n&#039;
                     &#039;\n&#039;
                     &#039;   class VerboseModule(ModuleType):\n&#039;
                     &#039;       def __repr__(self):\n&#039;
                     &quot;           return f&#039;Verbose {self.__name__}&#039;\n&quot;
                     &#039;\n&#039;
                     &#039;       def __setattr__(self, attr, value):\n&#039;
                     &quot;           print(f&#039;Setting {attr}...&#039;)\n&quot;
                     &#039;           setattr(self, attr, value)\n&#039;
                     &#039;\n&#039;
                     &#039;   sys.modules[__name__].__class__ = VerboseModule\n&#039;
                     &#039;\n&#039;
                     &#039;Note: Setting module &quot;__class__&quot; only affects lookups &#039;
                     &#039;made using the\n&#039;
                     &#039;  attribute access syntax – directly accessing the &#039;
                     &#039;module globals\n&#039;
                     &#039;  (whether by code within the module, or via a reference &#039;
                     &#039;to the\n&#039;
                     &#039;  module’s globals dictionary) is unaffected.\n&#039;
                     &#039;\n&#039;
                     &#039;Changed in version 3.5: &quot;__class__&quot; module attribute is &#039;
                     &#039;now writable.\n&#039;
                     &#039;\n&#039;
                     &#039;\n&#039;
                     &#039;Implementing Descriptors\n&#039;
                     &#039;========================\n&#039;
                     &#039;\n&#039;
                     &#039;The following methods only apply when an instance of the &#039;
                     &#039;class\n&#039;
                     &#039;containing the method (a so-called *descriptor* class) &#039;
                     &#039;appears in an\n&#039;
                     &#039;*owner* class (the descriptor must be in either the &#039;
                     &#039;owner’s class\n&#039;
                     &#039;dictionary or in the class dictionary for one of its &#039;
                     &#039;parents).  In the\n&#039;
                     &#039;examples below, “the attribute” refers to the attribute &#039;
                     &#039;whose name is\n&#039;
                     &#039;the key of the property in the owner class’ &quot;__dict__&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__get__(self, instance, owner)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called to get the attribute of the owner class (class &#039;
                     &#039;attribute\n&#039;
                     &#039;   access) or of an instance of that class (instance &#039;
                     &#039;attribute\n&#039;
                     &#039;   access). *owner* is always the owner class, while &#039;
                     &#039;*instance* is the\n&#039;
                     &#039;   instance that the attribute was accessed through, or &#039;
                     &#039;&quot;None&quot; when\n&#039;
                     &#039;   the attribute is accessed through the *owner*.  This &#039;
                     &#039;method should\n&#039;
                     &#039;   return the (computed) attribute value or raise an &#039;
                     &#039;&quot;AttributeError&quot;\n&#039;
                     &#039;   exception.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__set__(self, instance, value)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called to set the attribute on an instance *instance* &#039;
                     &#039;of the owner\n&#039;
                     &#039;   class to a new value, *value*.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__delete__(self, instance)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called to delete the attribute on an instance &#039;
                     &#039;*instance* of the\n&#039;
                     &#039;   owner class.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__set_name__(self, owner, name)\n&#039;
                     &#039;\n&#039;
                     &#039;   Called at the time the owning class *owner* is &#039;
                     &#039;created. The\n&#039;
                     &#039;   descriptor has been assigned to *name*.\n&#039;
                     &#039;\n&#039;
                     &#039;   New in version 3.6.\n&#039;
                     &#039;\n&#039;
                     &#039;The attribute &quot;__objclass__&quot; is interpreted by the &#039;
                     &#039;&quot;inspect&quot; module as\n&#039;
                     &#039;specifying the class where this object was defined &#039;
                     &#039;(setting this\n&#039;
                     &#039;appropriately can assist in runtime introspection of &#039;
                     &#039;dynamic class\n&#039;
                     &#039;attributes). For callables, it may indicate that an &#039;
                     &#039;instance of the\n&#039;
                     &#039;given type (or a subclass) is expected or required as &#039;
                     &#039;the first\n&#039;
                     &#039;positional argument (for example, CPython sets this &#039;
                     &#039;attribute for\n&#039;
                     &#039;unbound methods that are implemented in C).\n&#039;
                     &#039;\n&#039;
                     &#039;\n&#039;
                     &#039;Invoking Descriptors\n&#039;
                     &#039;====================\n&#039;
                     &#039;\n&#039;
                     &#039;In general, a descriptor is an object attribute with &#039;
                     &#039;“binding\n&#039;
                     &#039;behavior”, one whose attribute access has been &#039;
                     &#039;overridden by methods\n&#039;
                     &#039;in the descriptor protocol:  &quot;__get__()&quot;, &quot;__set__()&quot;, &#039;
                     &#039;and\n&#039;
                     &#039;&quot;__delete__()&quot;. If any of those methods are defined for &#039;
                     &#039;an object, it\n&#039;
                     &#039;is said to be a descriptor.\n&#039;
                     &#039;\n&#039;
                     &#039;The default behavior for attribute access is to get, &#039;
                     &#039;set, or delete\n&#039;
                     &#039;the attribute from an object’s dictionary. For instance, &#039;
                     &#039;&quot;a.x&quot; has a\n&#039;
                     &#039;lookup chain starting with &quot;a.__dict__[\&#039;x\&#039;]&quot;, then\n&#039;
                     &#039;&quot;type(a).__dict__[\&#039;x\&#039;]&quot;, and continuing through the &#039;
                     &#039;base classes of\n&#039;
                     &#039;&quot;type(a)&quot; excluding metaclasses.\n&#039;
                     &#039;\n&#039;
                     &#039;However, if the looked-up value is an object defining &#039;
                     &#039;one of the\n&#039;
                     &#039;descriptor methods, then Python may override the default &#039;
                     &#039;behavior and\n&#039;
                     &#039;invoke the descriptor method instead.  Where this occurs &#039;
                     &#039;in the\n&#039;
                     &#039;precedence chain depends on which descriptor methods &#039;
                     &#039;were defined and\n&#039;
                     &#039;how they were called.\n&#039;
                     &#039;\n&#039;
                     &#039;The starting point for descriptor invocation is a &#039;
                     &#039;binding, &quot;a.x&quot;. How\n&#039;
                     &#039;the arguments are assembled depends on &quot;a&quot;:\n&#039;
                     &#039;\n&#039;
                     &#039;Direct Call\n&#039;
                     &#039;   The simplest and least common call is when user code &#039;
                     &#039;directly\n&#039;
                     &#039;   invokes a descriptor method:    &quot;x.__get__(a)&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;Instance Binding\n&#039;
                     &#039;   If binding to an object instance, &quot;a.x&quot; is &#039;
                     &#039;transformed into the\n&#039;
                     &#039;   call: &quot;type(a).__dict__[\&#039;x\&#039;].__get__(a, type(a))&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;Class Binding\n&#039;
                     &#039;   If binding to a class, &quot;A.x&quot; is transformed into the &#039;
                     &#039;call:\n&#039;
                     &#039;   &quot;A.__dict__[\&#039;x\&#039;].__get__(None, A)&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;Super Binding\n&#039;
                     &#039;   If &quot;a&quot; is an instance of &quot;super&quot;, then the binding &#039;
                     &#039;&quot;super(B,\n&#039;
                     &#039;   obj).m()&quot; searches &quot;obj.__class__.__mro__&quot; for the &#039;
                     &#039;base class &quot;A&quot;\n&#039;
                     &#039;   immediately preceding &quot;B&quot; and then invokes the &#039;
                     &#039;descriptor with the\n&#039;
                     &#039;   call: &quot;A.__dict__[\&#039;m\&#039;].__get__(obj, &#039;
                     &#039;obj.__class__)&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;For instance bindings, the precedence of descriptor &#039;
                     &#039;invocation depends\n&#039;
                     &#039;on the which descriptor methods are defined.  A &#039;
                     &#039;descriptor can define\n&#039;
                     &#039;any combination of &quot;__get__()&quot;, &quot;__set__()&quot; and &#039;
                     &#039;&quot;__delete__()&quot;.  If it\n&#039;
                     &#039;does not define &quot;__get__()&quot;, then accessing the &#039;
                     &#039;attribute will return\n&#039;
                     &#039;the descriptor object itself unless there is a value in &#039;
                     &#039;the object’s\n&#039;
                     &#039;instance dictionary.  If the descriptor defines &#039;
                     &#039;&quot;__set__()&quot; and/or\n&#039;
                     &#039;&quot;__delete__()&quot;, it is a data descriptor; if it defines &#039;
                     &#039;neither, it is\n&#039;
                     &#039;a non-data descriptor.  Normally, data descriptors &#039;
                     &#039;define both\n&#039;
                     &#039;&quot;__get__()&quot; and &quot;__set__()&quot;, while non-data descriptors &#039;
                     &#039;have just the\n&#039;
                     &#039;&quot;__get__()&quot; method.  Data descriptors with &quot;__set__()&quot; &#039;
                     &#039;and &quot;__get__()&quot;\n&#039;
                     &#039;defined always override a redefinition in an instance &#039;
                     &#039;dictionary.  In\n&#039;
                     &#039;contrast, non-data descriptors can be overridden by &#039;
                     &#039;instances.\n&#039;
                     &#039;\n&#039;
                     &#039;Python methods (including &quot;staticmethod()&quot; and &#039;
                     &#039;&quot;classmethod()&quot;) are\n&#039;
                     &#039;implemented as non-data descriptors.  Accordingly, &#039;
                     &#039;instances can\n&#039;
                     &#039;redefine and override methods.  This allows individual &#039;
                     &#039;instances to\n&#039;
                     &#039;acquire behaviors that differ from other instances of &#039;
                     &#039;the same class.\n&#039;
                     &#039;\n&#039;
                     &#039;The &quot;property()&quot; function is implemented as a data &#039;
                     &#039;descriptor.\n&#039;
                     &#039;Accordingly, instances cannot override the behavior of a &#039;
                     &#039;property.\n&#039;
                     &#039;\n&#039;
                     &#039;\n&#039;
                     &#039;__slots__\n&#039;
                     &#039;=========\n&#039;
                     &#039;\n&#039;
                     &#039;*__slots__* allow us to explicitly declare data members &#039;
                     &#039;(like\n&#039;
                     &#039;properties) and deny the creation of *__dict__* and &#039;
                     &#039;*__weakref__*\n&#039;
                     &#039;(unless explicitly declared in *__slots__* or available &#039;
                     &#039;in a parent.)\n&#039;
                     &#039;\n&#039;
                     &#039;The space saved over using *__dict__* can be &#039;
                     &#039;significant.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__slots__\n&#039;
                     &#039;\n&#039;
                     &#039;   This class variable can be assigned a string, &#039;
                     &#039;iterable, or sequence\n&#039;
                     &#039;   of strings with variable names used by instances.  &#039;
                     &#039;*__slots__*\n&#039;
                     &#039;   reserves space for the declared variables and &#039;
                     &#039;prevents the\n&#039;
                     &#039;   automatic creation of *__dict__* and *__weakref__* &#039;
                     &#039;for each\n&#039;
                     &#039;   instance.\n&#039;
                     &#039;\n&#039;
                     &#039;\n&#039;
                     &#039;Notes on using *__slots__*\n&#039;
                     &#039;--------------------------\n&#039;
                     &#039;\n&#039;
                     &#039;* When inheriting from a class without *__slots__*, the &#039;
                     &#039;*__dict__*\n&#039;
                     &#039;  and *__weakref__* attribute of the instances will &#039;
                     &#039;always be\n&#039;
                     &#039;  accessible.\n&#039;
                     &#039;\n&#039;
                     &#039;* Without a *__dict__* variable, instances cannot be &#039;
                     &#039;assigned new\n&#039;
                     &#039;  variables not listed in the *__slots__* definition.  &#039;
                     &#039;Attempts to\n&#039;
                     &#039;  assign to an unlisted variable name raises &#039;
                     &#039;&quot;AttributeError&quot;. If\n&#039;
                     &#039;  dynamic assignment of new variables is desired, then &#039;
                     &#039;add\n&#039;
                     &#039;  &quot;\&#039;__dict__\&#039;&quot; to the sequence of strings in the &#039;
                     &#039;*__slots__*\n&#039;
                     &#039;  declaration.\n&#039;
                     &#039;\n&#039;
                     &#039;* Without a *__weakref__* variable for each instance, &#039;
                     &#039;classes\n&#039;
                     &#039;  defining *__slots__* do not support weak references to &#039;
                     &#039;its\n&#039;
                     &#039;  instances. If weak reference support is needed, then &#039;
                     &#039;add\n&#039;
                     &#039;  &quot;\&#039;__weakref__\&#039;&quot; to the sequence of strings in the &#039;
                     &#039;*__slots__*\n&#039;
                     &#039;  declaration.\n&#039;
                     &#039;\n&#039;
                     &#039;* *__slots__* are implemented at the class level by &#039;
                     &#039;creating\n&#039;
                     &#039;  descriptors (Implementing Descriptors) for each &#039;
                     &#039;variable name.  As a\n&#039;
                     &#039;  result, class attributes cannot be used to set default &#039;
                     &#039;values for\n&#039;
                     &#039;  instance variables defined by *__slots__*; otherwise, &#039;
                     &#039;the class\n&#039;
                     &#039;  attribute would overwrite the descriptor assignment.\n&#039;
                     &#039;\n&#039;
                     &#039;* The action of a *__slots__* declaration is not limited &#039;
                     &#039;to the\n&#039;
                     &#039;  class where it is defined.  *__slots__* declared in &#039;
                     &#039;parents are\n&#039;
                     &#039;  available in child classes. However, child subclasses &#039;
                     &#039;will get a\n&#039;
                     &#039;  *__dict__* and *__weakref__* unless they also define &#039;
                     &#039;*__slots__*\n&#039;
                     &#039;  (which should only contain names of any *additional* &#039;
                     &#039;slots).\n&#039;
                     &#039;\n&#039;
                     &#039;* If a class defines a slot also defined in a base &#039;
                     &#039;class, the\n&#039;
                     &#039;  instance variable defined by the base class slot is &#039;
                     &#039;inaccessible\n&#039;
                     &#039;  (except by retrieving its descriptor directly from the &#039;
                     &#039;base class).\n&#039;
                     &#039;  This renders the meaning of the program undefined.  In &#039;
                     &#039;the future, a\n&#039;
                     &#039;  check may be added to prevent this.\n&#039;
                     &#039;\n&#039;
                     &#039;* Nonempty *__slots__* does not work for classes derived &#039;
                     &#039;from\n&#039;
                     &#039;  “variable-length” built-in types such as &quot;int&quot;, &#039;
                     &#039;&quot;bytes&quot; and &quot;tuple&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;* Any non-string iterable may be assigned to &#039;
                     &#039;*__slots__*. Mappings\n&#039;
                     &#039;  may also be used; however, in the future, special &#039;
                     &#039;meaning may be\n&#039;
                     &#039;  assigned to the values corresponding to each key.\n&#039;
                     &#039;\n&#039;
                     &#039;* *__class__* assignment works only if both classes have &#039;
                     &#039;the same\n&#039;
                     &#039;  *__slots__*.\n&#039;
                     &#039;\n&#039;
                     &#039;* Multiple inheritance with multiple slotted parent &#039;
                     &#039;classes can be\n&#039;
                     &#039;  used, but only one parent is allowed to have &#039;
                     &#039;attributes created by\n&#039;
                     &#039;  slots (the other bases must have empty slot layouts) - &#039;
                     &#039;violations\n&#039;
                     &#039;  raise &quot;TypeError&quot;.\n&#039;,
 &#039;attribute-references&#039;: &#039;Attribute references\n&#039;
                         &#039;********************\n&#039;
                         &#039;\n&#039;
                         &#039;An attribute reference is a primary followed by a &#039;
                         &#039;period and a name:\n&#039;
                         &#039;\n&#039;
                         &#039;   attributeref ::= primary &quot;.&quot; identifier\n&#039;
                         &#039;\n&#039;
                         &#039;The primary must evaluate to an object of a type &#039;
                         &#039;that supports\n&#039;
                         &#039;attribute references, which most objects do.  This &#039;
                         &#039;object is then\n&#039;
                         &#039;asked to produce the attribute whose name is the &#039;
                         &#039;identifier.  This\n&#039;
                         &#039;production can be customized by overriding the &#039;
                         &#039;&quot;__getattr__()&quot; method.\n&#039;
                         &#039;If this attribute is not available, the exception &#039;
                         &#039;&quot;AttributeError&quot; is\n&#039;
                         &#039;raised.  Otherwise, the type and value of the object &#039;
                         &#039;produced is\n&#039;
                         &#039;determined by the object.  Multiple evaluations of &#039;
                         &#039;the same attribute\n&#039;
                         &#039;reference may yield different objects.\n&#039;,
 &#039;augassign&#039;: &#039;Augmented assignment statements\n&#039;
              &#039;*******************************\n&#039;
              &#039;\n&#039;
              &#039;Augmented assignment is the combination, in a single statement, &#039;
              &#039;of a\n&#039;
              &#039;binary operation and an assignment statement:\n&#039;
              &#039;\n&#039;
              &#039;   augmented_assignment_stmt ::= augtarget augop &#039;
              &#039;(expression_list | yield_expression)\n&#039;
              &#039;   augtarget                 ::= identifier | attributeref | &#039;
              &#039;subscription | slicing\n&#039;
              &#039;   augop                     ::= &quot;+=&quot; | &quot;-=&quot; | &quot;*=&quot; | &quot;@=&quot; | &#039;
              &#039;&quot;/=&quot; | &quot;//=&quot; | &quot;%=&quot; | &quot;**=&quot;\n&#039;
              &#039;             | &quot;&gt;&gt;=&quot; | &quot;&lt;&lt;=&quot; | &quot;&amp;=&quot; | &quot;^=&quot; | &quot;|=&quot;\n&#039;
              &#039;\n&#039;
              &#039;(See section Primaries for the syntax definitions of the last &#039;
              &#039;three\n&#039;
              &#039;symbols.)\n&#039;
              &#039;\n&#039;
              &#039;An augmented assignment evaluates the target (which, unlike &#039;
              &#039;normal\n&#039;
              &#039;assignment statements, cannot be an unpacking) and the &#039;
              &#039;expression\n&#039;
              &#039;list, performs the binary operation specific to the type of &#039;
              &#039;assignment\n&#039;
              &#039;on the two operands, and assigns the result to the original &#039;
              &#039;target.\n&#039;
              &#039;The target is only evaluated once.\n&#039;
              &#039;\n&#039;
              &#039;An augmented assignment expression like &quot;x += 1&quot; can be &#039;
              &#039;rewritten as\n&#039;
              &#039;&quot;x = x + 1&quot; to achieve a similar, but not exactly equal effect. &#039;
              &#039;In the\n&#039;
              &#039;augmented version, &quot;x&quot; is only evaluated once. Also, when &#039;
              &#039;possible,\n&#039;
              &#039;the actual operation is performed *in-place*, meaning that &#039;
              &#039;rather than\n&#039;
              &#039;creating a new object and assigning that to the target, the old &#039;
              &#039;object\n&#039;
              &#039;is modified instead.\n&#039;
              &#039;\n&#039;
              &#039;Unlike normal assignments, augmented assignments evaluate the &#039;
              &#039;left-\n&#039;
              &#039;hand side *before* evaluating the right-hand side.  For &#039;
              &#039;example, &quot;a[i]\n&#039;
              &#039;+= f(x)&quot; first looks-up &quot;a[i]&quot;, then it evaluates &quot;f(x)&quot; and &#039;
              &#039;performs\n&#039;
              &#039;the addition, and lastly, it writes the result back to &quot;a[i]&quot;.\n&#039;
              &#039;\n&#039;
              &#039;With the exception of assigning to tuples and multiple targets &#039;
              &#039;in a\n&#039;
              &#039;single statement, the assignment done by augmented assignment\n&#039;
              &#039;statements is handled the same way as normal assignments. &#039;
              &#039;Similarly,\n&#039;
              &#039;with the exception of the possible *in-place* behavior, the &#039;
              &#039;binary\n&#039;
              &#039;operation performed by augmented assignment is the same as the &#039;
              &#039;normal\n&#039;
              &#039;binary operations.\n&#039;
              &#039;\n&#039;
              &#039;For targets which are attribute references, the same caveat &#039;
              &#039;about\n&#039;
              &#039;class and instance attributes applies as for regular &#039;
              &#039;assignments.\n&#039;,
 &#039;binary&#039;: &#039;Binary arithmetic operations\n&#039;
           &#039;****************************\n&#039;
           &#039;\n&#039;
           &#039;The binary arithmetic operations have the conventional priority\n&#039;
           &#039;levels.  Note that some of these operations also apply to certain &#039;
           &#039;non-\n&#039;
           &#039;numeric types.  Apart from the power operator, there are only two\n&#039;
           &#039;levels, one for multiplicative operators and one for additive\n&#039;
           &#039;operators:\n&#039;
           &#039;\n&#039;
           &#039;   m_expr ::= u_expr | m_expr &quot;*&quot; u_expr | m_expr &quot;@&quot; m_expr |\n&#039;
           &#039;              m_expr &quot;//&quot; u_expr | m_expr &quot;/&quot; u_expr |\n&#039;
           &#039;              m_expr &quot;%&quot; u_expr\n&#039;
           &#039;   a_expr ::= m_expr | a_expr &quot;+&quot; m_expr | a_expr &quot;-&quot; m_expr\n&#039;
           &#039;\n&#039;
           &#039;The &quot;*&quot; (multiplication) operator yields the product of its &#039;
           &#039;arguments.\n&#039;
           &#039;The arguments must either both be numbers, or one argument must be &#039;
           &#039;an\n&#039;
           &#039;integer and the other must be a sequence. In the former case, the\n&#039;
           &#039;numbers are converted to a common type and then multiplied &#039;
           &#039;together.\n&#039;
           &#039;In the latter case, sequence repetition is performed; a negative\n&#039;
           &#039;repetition factor yields an empty sequence.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;@&quot; (at) operator is intended to be used for matrix\n&#039;
           &#039;multiplication.  No builtin Python types implement this operator.\n&#039;
           &#039;\n&#039;
           &#039;New in version 3.5.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;/&quot; (division) and &quot;//&quot; (floor division) operators yield the\n&#039;
           &#039;quotient of their arguments.  The numeric arguments are first\n&#039;
           &#039;converted to a common type. Division of integers yields a float, &#039;
           &#039;while\n&#039;
           &#039;floor division of integers results in an integer; the result is &#039;
           &#039;that\n&#039;
           &#039;of mathematical division with the ‘floor’ function applied to the\n&#039;
           &#039;result.  Division by zero raises the &quot;ZeroDivisionError&quot; &#039;
           &#039;exception.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;%&quot; (modulo) operator yields the remainder from the division &#039;
           &#039;of\n&#039;
           &#039;the first argument by the second.  The numeric arguments are &#039;
           &#039;first\n&#039;
           &#039;converted to a common type.  A zero right argument raises the\n&#039;
           &#039;&quot;ZeroDivisionError&quot; exception.  The arguments may be floating &#039;
           &#039;point\n&#039;
           &#039;numbers, e.g., &quot;3.14%0.7&quot; equals &quot;0.34&quot; (since &quot;3.14&quot; equals &#039;
           &#039;&quot;4*0.7 +\n&#039;
           &#039;0.34&quot;.)  The modulo operator always yields a result with the same &#039;
           &#039;sign\n&#039;
           &#039;as its second operand (or zero); the absolute value of the result &#039;
           &#039;is\n&#039;
           &#039;strictly smaller than the absolute value of the second operand &#039;
           &#039;[1].\n&#039;
           &#039;\n&#039;
           &#039;The floor division and modulo operators are connected by the &#039;
           &#039;following\n&#039;
           &#039;identity: &quot;x == (x//y)*y + (x%y)&quot;.  Floor division and modulo are &#039;
           &#039;also\n&#039;
           &#039;connected with the built-in function &quot;divmod()&quot;: &quot;divmod(x, y) ==\n&#039;
           &#039;(x//y, x%y)&quot;. [2].\n&#039;
           &#039;\n&#039;
           &#039;In addition to performing the modulo operation on numbers, the &#039;
           &#039;&quot;%&quot;\n&#039;
           &#039;operator is also overloaded by string objects to perform &#039;
           &#039;old-style\n&#039;
           &#039;string formatting (also known as interpolation).  The syntax for\n&#039;
           &#039;string formatting is described in the Python Library Reference,\n&#039;
           &#039;section printf-style String Formatting.\n&#039;
           &#039;\n&#039;
           &#039;The floor division operator, the modulo operator, and the &#039;
           &#039;&quot;divmod()&quot;\n&#039;
           &#039;function are not defined for complex numbers.  Instead, convert to &#039;
           &#039;a\n&#039;
           &#039;floating point number using the &quot;abs()&quot; function if appropriate.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;+&quot; (addition) operator yields the sum of its arguments.  The\n&#039;
           &#039;arguments must either both be numbers or both be sequences of the &#039;
           &#039;same\n&#039;
           &#039;type.  In the former case, the numbers are converted to a common &#039;
           &#039;type\n&#039;
           &#039;and then added together. In the latter case, the sequences are\n&#039;
           &#039;concatenated.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;-&quot; (subtraction) operator yields the difference of its &#039;
           &#039;arguments.\n&#039;
           &#039;The numeric arguments are first converted to a common type.\n&#039;,
 &#039;bitwise&#039;: &#039;Binary bitwise operations\n&#039;
            &#039;*************************\n&#039;
            &#039;\n&#039;
            &#039;Each of the three bitwise operations has a different priority &#039;
            &#039;level:\n&#039;
            &#039;\n&#039;
            &#039;   and_expr ::= shift_expr | and_expr &quot;&amp;&quot; shift_expr\n&#039;
            &#039;   xor_expr ::= and_expr | xor_expr &quot;^&quot; and_expr\n&#039;
            &#039;   or_expr  ::= xor_expr | or_expr &quot;|&quot; xor_expr\n&#039;
            &#039;\n&#039;
            &#039;The &quot;&amp;&quot; operator yields the bitwise AND of its arguments, which &#039;
            &#039;must\n&#039;
            &#039;be integers.\n&#039;
            &#039;\n&#039;
            &#039;The &quot;^&quot; operator yields the bitwise XOR (exclusive OR) of its\n&#039;
            &#039;arguments, which must be integers.\n&#039;
            &#039;\n&#039;
            &#039;The &quot;|&quot; operator yields the bitwise (inclusive) OR of its &#039;
            &#039;arguments,\n&#039;
            &#039;which must be integers.\n&#039;,
 &#039;bltin-code-objects&#039;: &#039;Code Objects\n&#039;
                       &#039;************\n&#039;
                       &#039;\n&#039;
                       &#039;Code objects are used by the implementation to &#039;
                       &#039;represent “pseudo-\n&#039;
                       &#039;compiled” executable Python code such as a function &#039;
                       &#039;body. They differ\n&#039;
                       &#039;from function objects because they don’t contain a &#039;
                       &#039;reference to their\n&#039;
                       &#039;global execution environment.  Code objects are &#039;
                       &#039;returned by the built-\n&#039;
                       &#039;in &quot;compile()&quot; function and can be extracted from &#039;
                       &#039;function objects\n&#039;
                       &#039;through their &quot;__code__&quot; attribute. See also the &#039;
                       &#039;&quot;code&quot; module.\n&#039;
                       &#039;\n&#039;
                       &#039;A code object can be executed or evaluated by passing &#039;
                       &#039;it (instead of a\n&#039;
                       &#039;source string) to the &quot;exec()&quot; or &quot;eval()&quot;  built-in &#039;
                       &#039;functions.\n&#039;
                       &#039;\n&#039;
                       &#039;See The standard type hierarchy for more &#039;
                       &#039;information.\n&#039;,
 &#039;bltin-ellipsis-object&#039;: &#039;The Ellipsis Object\n&#039;
                          &#039;*******************\n&#039;
                          &#039;\n&#039;
                          &#039;This object is commonly used by slicing (see &#039;
                          &#039;Slicings).  It supports\n&#039;
                          &#039;no special operations.  There is exactly one &#039;
                          &#039;ellipsis object, named\n&#039;
                          &#039;&quot;Ellipsis&quot; (a built-in name).  &quot;type(Ellipsis)()&quot; &#039;
                          &#039;produces the\n&#039;
                          &#039;&quot;Ellipsis&quot; singleton.\n&#039;
                          &#039;\n&#039;
                          &#039;It is written as &quot;Ellipsis&quot; or &quot;...&quot;.\n&#039;,
 &#039;bltin-null-object&#039;: &#039;The Null Object\n&#039;
                      &#039;***************\n&#039;
                      &#039;\n&#039;
                      &#039;This object is returned by functions that don’t &#039;
                      &#039;explicitly return a\n&#039;
                      &#039;value.  It supports no special operations.  There is &#039;
                      &#039;exactly one null\n&#039;
                      &#039;object, named &quot;None&quot; (a built-in name).  &quot;type(None)()&quot; &#039;
                      &#039;produces the\n&#039;
                      &#039;same singleton.\n&#039;
                      &#039;\n&#039;
                      &#039;It is written as &quot;None&quot;.\n&#039;,
 &#039;bltin-type-objects&#039;: &#039;Type Objects\n&#039;
                       &#039;************\n&#039;
                       &#039;\n&#039;
                       &#039;Type objects represent the various object types.  An &#039;
                       &#039;object’s type is\n&#039;
                       &#039;accessed by the built-in function &quot;type()&quot;.  There are &#039;
                       &#039;no special\n&#039;
                       &#039;operations on types.  The standard module &quot;types&quot; &#039;
                       &#039;defines names for\n&#039;
                       &#039;all standard built-in types.\n&#039;
                       &#039;\n&#039;
                       &#039;Types are written like this: &quot;&lt;class \&#039;int\&#039;&gt;&quot;.\n&#039;,
 &#039;booleans&#039;: &#039;Boolean operations\n&#039;
             &#039;******************\n&#039;
             &#039;\n&#039;
             &#039;   or_test  ::= and_test | or_test &quot;or&quot; and_test\n&#039;
             &#039;   and_test ::= not_test | and_test &quot;and&quot; not_test\n&#039;
             &#039;   not_test ::= comparison | &quot;not&quot; not_test\n&#039;
             &#039;\n&#039;
             &#039;In the context of Boolean operations, and also when expressions &#039;
             &#039;are\n&#039;
             &#039;used by control flow statements, the following values are &#039;
             &#039;interpreted\n&#039;
             &#039;as false: &quot;False&quot;, &quot;None&quot;, numeric zero of all types, and empty\n&#039;
             &#039;strings and containers (including strings, tuples, lists,\n&#039;
             &#039;dictionaries, sets and frozensets).  All other values are &#039;
             &#039;interpreted\n&#039;
             &#039;as true.  User-defined objects can customize their truth value &#039;
             &#039;by\n&#039;
             &#039;providing a &quot;__bool__()&quot; method.\n&#039;
             &#039;\n&#039;
             &#039;The operator &quot;not&quot; yields &quot;True&quot; if its argument is false, &#039;
             &#039;&quot;False&quot;\n&#039;
             &#039;otherwise.\n&#039;
             &#039;\n&#039;
             &#039;The expression &quot;x and y&quot; first evaluates *x*; if *x* is false, &#039;
             &#039;its\n&#039;
             &#039;value is returned; otherwise, *y* is evaluated and the resulting &#039;
             &#039;value\n&#039;
             &#039;is returned.\n&#039;
             &#039;\n&#039;
             &#039;The expression &quot;x or y&quot; first evaluates *x*; if *x* is true, its &#039;
             &#039;value\n&#039;
             &#039;is returned; otherwise, *y* is evaluated and the resulting value &#039;
             &#039;is\n&#039;
             &#039;returned.\n&#039;
             &#039;\n&#039;
             &#039;Note that neither &quot;and&quot; nor &quot;or&quot; restrict the value and type &#039;
             &#039;they\n&#039;
             &#039;return to &quot;False&quot; and &quot;True&quot;, but rather return the last &#039;
             &#039;evaluated\n&#039;
             &#039;argument.  This is sometimes useful, e.g., if &quot;s&quot; is a string &#039;
             &#039;that\n&#039;
             &#039;should be replaced by a default value if it is empty, the &#039;
             &#039;expression\n&#039;
             &#039;&quot;s or \&#039;foo\&#039;&quot; yields the desired value.  Because &quot;not&quot; has to &#039;
             &#039;create a\n&#039;
             &#039;new value, it returns a boolean value regardless of the type of &#039;
             &#039;its\n&#039;
             &#039;argument (for example, &quot;not \&#039;foo\&#039;&quot; produces &quot;False&quot; rather &#039;
             &#039;than &quot;\&#039;\&#039;&quot;.)\n&#039;,
 &#039;break&#039;: &#039;The &quot;break&quot; statement\n&#039;
          &#039;*********************\n&#039;
          &#039;\n&#039;
          &#039;   break_stmt ::= &quot;break&quot;\n&#039;
          &#039;\n&#039;
          &#039;&quot;break&quot; may only occur syntactically nested in a &quot;for&quot; or &quot;while&quot;\n&#039;
          &#039;loop, but not nested in a function or class definition within that\n&#039;
          &#039;loop.\n&#039;
          &#039;\n&#039;
          &#039;It terminates the nearest enclosing loop, skipping the optional &#039;
          &#039;&quot;else&quot;\n&#039;
          &#039;clause if the loop has one.\n&#039;
          &#039;\n&#039;
          &#039;If a &quot;for&quot; loop is terminated by &quot;break&quot;, the loop control target\n&#039;
          &#039;keeps its current value.\n&#039;
          &#039;\n&#039;
          &#039;When &quot;break&quot; passes control out of a &quot;try&quot; statement with a &#039;
          &#039;&quot;finally&quot;\n&#039;
          &#039;clause, that &quot;finally&quot; clause is executed before really leaving &#039;
          &#039;the\n&#039;
          &#039;loop.\n&#039;,
 &#039;callable-types&#039;: &#039;Emulating callable objects\n&#039;
                   &#039;**************************\n&#039;
                   &#039;\n&#039;
                   &#039;object.__call__(self[, args...])\n&#039;
                   &#039;\n&#039;
                   &#039;   Called when the instance is “called” as a function; if &#039;
                   &#039;this method\n&#039;
                   &#039;   is defined, &quot;x(arg1, arg2, ...)&quot; is a shorthand for\n&#039;
                   &#039;   &quot;x.__call__(arg1, arg2, ...)&quot;.\n&#039;,
 &#039;calls&#039;: &#039;Calls\n&#039;
          &#039;*****\n&#039;
          &#039;\n&#039;
          &#039;A call calls a callable object (e.g., a *function*) with a &#039;
          &#039;possibly\n&#039;
          &#039;empty series of *arguments*:\n&#039;
          &#039;\n&#039;
          &#039;   call                 ::= primary &quot;(&quot; [argument_list [&quot;,&quot;] | &#039;
          &#039;comprehension] &quot;)&quot;\n&#039;
          &#039;   argument_list        ::= positional_arguments [&quot;,&quot; &#039;
          &#039;starred_and_keywords]\n&#039;
          &#039;                       [&quot;,&quot; keywords_arguments]\n&#039;
          &#039;                     | starred_and_keywords [&quot;,&quot; &#039;
          &#039;keywords_arguments]\n&#039;
          &#039;                     | keywords_arguments\n&#039;
          &#039;   positional_arguments ::= [&quot;*&quot;] expression (&quot;,&quot; [&quot;*&quot;] &#039;
          &#039;expression)*\n&#039;
          &#039;   starred_and_keywords ::= (&quot;*&quot; expression | keyword_item)\n&#039;
          &#039;                            (&quot;,&quot; &quot;*&quot; expression | &quot;,&quot; &#039;
          &#039;keyword_item)*\n&#039;
          &#039;   keywords_arguments   ::= (keyword_item | &quot;**&quot; expression)\n&#039;
          &#039;                          (&quot;,&quot; keyword_item | &quot;,&quot; &quot;**&quot; &#039;
          &#039;expression)*\n&#039;
          &#039;   keyword_item         ::= identifier &quot;=&quot; expression\n&#039;
          &#039;\n&#039;
          &#039;An optional trailing comma may be present after the positional and\n&#039;
          &#039;keyword arguments but does not affect the semantics.\n&#039;
          &#039;\n&#039;
          &#039;The primary must evaluate to a callable object (user-defined\n&#039;
          &#039;functions, built-in functions, methods of built-in objects, class\n&#039;
          &#039;objects, methods of class instances, and all objects having a\n&#039;
          &#039;&quot;__call__()&quot; method are callable).  All argument expressions are\n&#039;
          &#039;evaluated before the call is attempted.  Please refer to section\n&#039;
          &#039;Function definitions for the syntax of formal *parameter* lists.\n&#039;
          &#039;\n&#039;
          &#039;If keyword arguments are present, they are first converted to\n&#039;
          &#039;positional arguments, as follows.  First, a list of unfilled slots &#039;
          &#039;is\n&#039;
          &#039;created for the formal parameters.  If there are N positional\n&#039;
          &#039;arguments, they are placed in the first N slots.  Next, for each\n&#039;
          &#039;keyword argument, the identifier is used to determine the\n&#039;
          &#039;corresponding slot (if the identifier is the same as the first &#039;
          &#039;formal\n&#039;
          &#039;parameter name, the first slot is used, and so on).  If the slot &#039;
          &#039;is\n&#039;
          &#039;already filled, a &quot;TypeError&quot; exception is raised. Otherwise, the\n&#039;
          &#039;value of the argument is placed in the slot, filling it (even if &#039;
          &#039;the\n&#039;
          &#039;expression is &quot;None&quot;, it fills the slot).  When all arguments have\n&#039;
          &#039;been processed, the slots that are still unfilled are filled with &#039;
          &#039;the\n&#039;
          &#039;corresponding default value from the function definition.  &#039;
          &#039;(Default\n&#039;
          &#039;values are calculated, once, when the function is defined; thus, a\n&#039;
          &#039;mutable object such as a list or dictionary used as default value &#039;
          &#039;will\n&#039;
          &#039;be shared by all calls that don’t specify an argument value for &#039;
          &#039;the\n&#039;
          &#039;corresponding slot; this should usually be avoided.)  If there are &#039;
          &#039;any\n&#039;
          &#039;unfilled slots for which no default value is specified, a &#039;
          &#039;&quot;TypeError&quot;\n&#039;
          &#039;exception is raised.  Otherwise, the list of filled slots is used &#039;
          &#039;as\n&#039;
          &#039;the argument list for the call.\n&#039;
          &#039;\n&#039;
          &#039;**CPython implementation detail:** An implementation may provide\n&#039;
          &#039;built-in functions whose positional parameters do not have names, &#039;
          &#039;even\n&#039;
          &#039;if they are ‘named’ for the purpose of documentation, and which\n&#039;
          &#039;therefore cannot be supplied by keyword.  In CPython, this is the &#039;
          &#039;case\n&#039;
          &#039;for functions implemented in C that use &quot;PyArg_ParseTuple()&quot; to &#039;
          &#039;parse\n&#039;
          &#039;their arguments.\n&#039;
          &#039;\n&#039;
          &#039;If there are more positional arguments than there are formal &#039;
          &#039;parameter\n&#039;
          &#039;slots, a &quot;TypeError&quot; exception is raised, unless a formal &#039;
          &#039;parameter\n&#039;
          &#039;using the syntax &quot;*identifier&quot; is present; in this case, that &#039;
          &#039;formal\n&#039;
          &#039;parameter receives a tuple containing the excess positional &#039;
          &#039;arguments\n&#039;
          &#039;(or an empty tuple if there were no excess positional arguments).\n&#039;
          &#039;\n&#039;
          &#039;If any keyword argument does not correspond to a formal parameter\n&#039;
          &#039;name, a &quot;TypeError&quot; exception is raised, unless a formal parameter\n&#039;
          &#039;using the syntax &quot;**identifier&quot; is present; in this case, that &#039;
          &#039;formal\n&#039;
          &#039;parameter receives a dictionary containing the excess keyword\n&#039;
          &#039;arguments (using the keywords as keys and the argument values as\n&#039;
          &#039;corresponding values), or a (new) empty dictionary if there were &#039;
          &#039;no\n&#039;
          &#039;excess keyword arguments.\n&#039;
          &#039;\n&#039;
          &#039;If the syntax &quot;*expression&quot; appears in the function call, &#039;
          &#039;&quot;expression&quot;\n&#039;
          &#039;must evaluate to an *iterable*.  Elements from these iterables are\n&#039;
          &#039;treated as if they were additional positional arguments.  For the &#039;
          &#039;call\n&#039;
          &#039;&quot;f(x1, x2, *y, x3, x4)&quot;, if *y* evaluates to a sequence *y1*, …, &#039;
          &#039;*yM*,\n&#039;
          &#039;this is equivalent to a call with M+4 positional arguments *x1*, &#039;
          &#039;*x2*,\n&#039;
          &#039;*y1*, …, *yM*, *x3*, *x4*.\n&#039;
          &#039;\n&#039;
          &#039;A consequence of this is that although the &quot;*expression&quot; syntax &#039;
          &#039;may\n&#039;
          &#039;appear *after* explicit keyword arguments, it is processed &#039;
          &#039;*before*\n&#039;
          &#039;the keyword arguments (and any &quot;**expression&quot; arguments – see &#039;
          &#039;below).\n&#039;
          &#039;So:\n&#039;
          &#039;\n&#039;
          &#039;   &gt;&gt;&gt; def f(a, b):\n&#039;
          &#039;   ...     print(a, b)\n&#039;
          &#039;   ...\n&#039;
          &#039;   &gt;&gt;&gt; f(b=1, *(2,))\n&#039;
          &#039;   2 1\n&#039;
          &#039;   &gt;&gt;&gt; f(a=1, *(2,))\n&#039;
          &#039;   Traceback (most recent call last):\n&#039;
          &#039;     File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;\n&#039;
          &quot;   TypeError: f() got multiple values for keyword argument &#039;a&#039;\n&quot;
          &#039;   &gt;&gt;&gt; f(1, *(2,))\n&#039;
          &#039;   1 2\n&#039;
          &#039;\n&#039;
          &#039;It is unusual for both keyword arguments and the &quot;*expression&quot; &#039;
          &#039;syntax\n&#039;
          &#039;to be used in the same call, so in practice this confusion does &#039;
          &#039;not\n&#039;
          &#039;arise.\n&#039;
          &#039;\n&#039;
          &#039;If the syntax &quot;**expression&quot; appears in the function call,\n&#039;
          &#039;&quot;expression&quot; must evaluate to a *mapping*, the contents of which &#039;
          &#039;are\n&#039;
          &#039;treated as additional keyword arguments.  If a keyword is already\n&#039;
          &#039;present (as an explicit keyword argument, or from another &#039;
          &#039;unpacking),\n&#039;
          &#039;a &quot;TypeError&quot; exception is raised.\n&#039;
          &#039;\n&#039;
          &#039;Formal parameters using the syntax &quot;*identifier&quot; or &quot;**identifier&quot;\n&#039;
          &#039;cannot be used as positional argument slots or as keyword argument\n&#039;
          &#039;names.\n&#039;
          &#039;\n&#039;
          &#039;Changed in version 3.5: Function calls accept any number of &quot;*&quot; &#039;
          &#039;and\n&#039;
          &#039;&quot;**&quot; unpackings, positional arguments may follow iterable &#039;
          &#039;unpackings\n&#039;
          &#039;(&quot;*&quot;), and keyword arguments may follow dictionary unpackings &#039;
          &#039;(&quot;**&quot;).\n&#039;
          &#039;Originally proposed by **PEP 448**.\n&#039;
          &#039;\n&#039;
          &#039;A call always returns some value, possibly &quot;None&quot;, unless it raises &#039;
          &#039;an\n&#039;
          &#039;exception.  How this value is computed depends on the type of the\n&#039;
          &#039;callable object.\n&#039;
          &#039;\n&#039;
          &#039;If it is—\n&#039;
          &#039;\n&#039;
          &#039;a user-defined function:\n&#039;
          &#039;   The code block for the function is executed, passing it the\n&#039;
          &#039;   argument list.  The first thing the code block will do is bind &#039;
          &#039;the\n&#039;
          &#039;   formal parameters to the arguments; this is described in &#039;
          &#039;section\n&#039;
          &#039;   Function definitions.  When the code block executes a &quot;return&quot;\n&#039;
          &#039;   statement, this specifies the return value of the function &#039;
          &#039;call.\n&#039;
          &#039;\n&#039;
          &#039;a built-in function or method:\n&#039;
          &#039;   The result is up to the interpreter; see Built-in Functions for &#039;
          &#039;the\n&#039;
          &#039;   descriptions of built-in functions and methods.\n&#039;
          &#039;\n&#039;
          &#039;a class object:\n&#039;
          &#039;   A new instance of that class is returned.\n&#039;
          &#039;\n&#039;
          &#039;a class instance method:\n&#039;
          &#039;   The corresponding user-defined function is called, with an &#039;
          &#039;argument\n&#039;
          &#039;   list that is one longer than the argument list of the call: the\n&#039;
          &#039;   instance becomes the first argument.\n&#039;
          &#039;\n&#039;
          &#039;a class instance:\n&#039;
          &#039;   The class must define a &quot;__call__()&quot; method; the effect is then &#039;
          &#039;the\n&#039;
          &#039;   same as if that method was called.\n&#039;,
 &#039;class&#039;: &#039;Class definitions\n&#039;
          &#039;*****************\n&#039;
          &#039;\n&#039;
          &#039;A class definition defines a class object (see section The &#039;
          &#039;standard\n&#039;
          &#039;type hierarchy):\n&#039;
          &#039;\n&#039;
          &#039;   classdef    ::= [decorators] &quot;class&quot; classname [inheritance] &quot;:&quot; &#039;
          &#039;suite\n&#039;
          &#039;   inheritance ::= &quot;(&quot; [argument_list] &quot;)&quot;\n&#039;
          &#039;   classname   ::= identifier\n&#039;
          &#039;\n&#039;
          &#039;A class definition is an executable statement.  The inheritance &#039;
          &#039;list\n&#039;
          &#039;usually gives a list of base classes (see Metaclasses for more\n&#039;
          &#039;advanced uses), so each item in the list should evaluate to a &#039;
          &#039;class\n&#039;
          &#039;object which allows subclassing.  Classes without an inheritance &#039;
          &#039;list\n&#039;
          &#039;inherit, by default, from the base class &quot;object&quot;; hence,\n&#039;
          &#039;\n&#039;
          &#039;   class Foo:\n&#039;
          &#039;       pass\n&#039;
          &#039;\n&#039;
          &#039;is equivalent to\n&#039;
          &#039;\n&#039;
          &#039;   class Foo(object):\n&#039;
          &#039;       pass\n&#039;
          &#039;\n&#039;
          &#039;The class’s suite is then executed in a new execution frame (see\n&#039;
          &#039;Naming and binding), using a newly created local namespace and the\n&#039;
          &#039;original global namespace. (Usually, the suite contains mostly\n&#039;
          &#039;function definitions.)  When the class’s suite finishes execution, &#039;
          &#039;its\n&#039;
          &#039;execution frame is discarded but its local namespace is saved. [3] &#039;
          &#039;A\n&#039;
          &#039;class object is then created using the inheritance list for the &#039;
          &#039;base\n&#039;
          &#039;classes and the saved local namespace for the attribute &#039;
          &#039;dictionary.\n&#039;
          &#039;The class name is bound to this class object in the original local\n&#039;
          &#039;namespace.\n&#039;
          &#039;\n&#039;
          &#039;The order in which attributes are defined in the class body is\n&#039;
          &#039;preserved in the new class’s &quot;__dict__&quot;.  Note that this is &#039;
          &#039;reliable\n&#039;
          &#039;only right after the class is created and only for classes that &#039;
          &#039;were\n&#039;
          &#039;defined using the definition syntax.\n&#039;
          &#039;\n&#039;
          &#039;Class creation can be customized heavily using metaclasses.\n&#039;
          &#039;\n&#039;
          &#039;Classes can also be decorated: just like when decorating &#039;
          &#039;functions,\n&#039;
          &#039;\n&#039;
          &#039;   @f1(arg)\n&#039;
          &#039;   @f2\n&#039;
          &#039;   class Foo: pass\n&#039;
          &#039;\n&#039;
          &#039;is roughly equivalent to\n&#039;
          &#039;\n&#039;
          &#039;   class Foo: pass\n&#039;
          &#039;   Foo = f1(arg)(f2(Foo))\n&#039;
          &#039;\n&#039;
          &#039;The evaluation rules for the decorator expressions are the same as &#039;
          &#039;for\n&#039;
          &#039;function decorators.  The result is then bound to the class name.\n&#039;
          &#039;\n&#039;
          &#039;**Programmer’s note:** Variables defined in the class definition &#039;
          &#039;are\n&#039;
          &#039;class attributes; they are shared by instances.  Instance &#039;
          &#039;attributes\n&#039;
          &#039;can be set in a method with &quot;self.name = value&quot;.  Both class and\n&#039;
          &#039;instance attributes are accessible through the notation &#039;
          &#039;“&quot;self.name&quot;”,\n&#039;
          &#039;and an instance attribute hides a class attribute with the same &#039;
          &#039;name\n&#039;
          &#039;when accessed in this way.  Class attributes can be used as &#039;
          &#039;defaults\n&#039;
          &#039;for instance attributes, but using mutable values there can lead &#039;
          &#039;to\n&#039;
          &#039;unexpected results.  Descriptors can be used to create instance\n&#039;
          &#039;variables with different implementation details.\n&#039;
          &#039;\n&#039;
          &#039;See also:\n&#039;
          &#039;\n&#039;
          &#039;  **PEP 3115** - Metaclasses in Python 3000\n&#039;
          &#039;     The proposal that changed the declaration of metaclasses to &#039;
          &#039;the\n&#039;
          &#039;     current syntax, and the semantics for how classes with\n&#039;
          &#039;     metaclasses are constructed.\n&#039;
          &#039;\n&#039;
          &#039;  **PEP 3129** - Class Decorators\n&#039;
          &#039;     The proposal that added class decorators.  Function and &#039;
          &#039;method\n&#039;
          &#039;     decorators were introduced in **PEP 318**.\n&#039;,
 &#039;comparisons&#039;: &#039;Comparisons\n&#039;
                &#039;***********\n&#039;
                &#039;\n&#039;
                &#039;Unlike C, all comparison operations in Python have the same &#039;
                &#039;priority,\n&#039;
                &#039;which is lower than that of any arithmetic, shifting or &#039;
                &#039;bitwise\n&#039;
                &#039;operation.  Also unlike C, expressions like &quot;a &lt; b &lt; c&quot; have &#039;
                &#039;the\n&#039;
                &#039;interpretation that is conventional in mathematics:\n&#039;
                &#039;\n&#039;
                &#039;   comparison    ::= or_expr (comp_operator or_expr)*\n&#039;
                &#039;   comp_operator ::= &quot;&lt;&quot; | &quot;&gt;&quot; | &quot;==&quot; | &quot;&gt;=&quot; | &quot;&lt;=&quot; | &quot;!=&quot;\n&#039;
                &#039;                     | &quot;is&quot; [&quot;not&quot;] | [&quot;not&quot;] &quot;in&quot;\n&#039;
                &#039;\n&#039;
                &#039;Comparisons yield boolean values: &quot;True&quot; or &quot;False&quot;.\n&#039;
                &#039;\n&#039;
                &#039;Comparisons can be chained arbitrarily, e.g., &quot;x &lt; y &lt;= z&quot; &#039;
                &#039;is\n&#039;
                &#039;equivalent to &quot;x &lt; y and y &lt;= z&quot;, except that &quot;y&quot; is &#039;
                &#039;evaluated only\n&#039;
                &#039;once (but in both cases &quot;z&quot; is not evaluated at all when &quot;x &lt; &#039;
                &#039;y&quot; is\n&#039;
                &#039;found to be false).\n&#039;
                &#039;\n&#039;
                &#039;Formally, if *a*, *b*, *c*, …, *y*, *z* are expressions and &#039;
                &#039;*op1*,\n&#039;
                &#039;*op2*, …, *opN* are comparison operators, then &quot;a op1 b op2 c &#039;
                &#039;... y\n&#039;
                &#039;opN z&quot; is equivalent to &quot;a op1 b and b op2 c and ... y opN &#039;
                &#039;z&quot;, except\n&#039;
                &#039;that each expression is evaluated at most once.\n&#039;
                &#039;\n&#039;
                &#039;Note that &quot;a op1 b op2 c&quot; doesn’t imply any kind of &#039;
                &#039;comparison between\n&#039;
                &#039;*a* and *c*, so that, e.g., &quot;x &lt; y &gt; z&quot; is perfectly legal &#039;
                &#039;(though\n&#039;
                &#039;perhaps not pretty).\n&#039;
                &#039;\n&#039;
                &#039;\n&#039;
                &#039;Value comparisons\n&#039;
                &#039;=================\n&#039;
                &#039;\n&#039;
                &#039;The operators &quot;&lt;&quot;, &quot;&gt;&quot;, &quot;==&quot;, &quot;&gt;=&quot;, &quot;&lt;=&quot;, and &quot;!=&quot; compare &#039;
                &#039;the values\n&#039;
                &#039;of two objects.  The objects do not need to have the same &#039;
                &#039;type.\n&#039;
                &#039;\n&#039;
                &#039;Chapter Objects, values and types states that objects have a &#039;
                &#039;value (in\n&#039;
                &#039;addition to type and identity).  The value of an object is a &#039;
                &#039;rather\n&#039;
                &#039;abstract notion in Python: For example, there is no canonical &#039;
                &#039;access\n&#039;
                &#039;method for an object’s value.  Also, there is no requirement &#039;
                &#039;that the\n&#039;
                &#039;value of an object should be constructed in a particular way, &#039;
                &#039;e.g.\n&#039;
                &#039;comprised of all its data attributes. Comparison operators &#039;
                &#039;implement a\n&#039;
                &#039;particular notion of what the value of an object is.  One can &#039;
                &#039;think of\n&#039;
                &#039;them as defining the value of an object indirectly, by means &#039;
                &#039;of their\n&#039;
                &#039;comparison implementation.\n&#039;
                &#039;\n&#039;
                &#039;Because all types are (direct or indirect) subtypes of &#039;
                &#039;&quot;object&quot;, they\n&#039;
                &#039;inherit the default comparison behavior from &quot;object&quot;.  Types &#039;
                &#039;can\n&#039;
                &#039;customize their comparison behavior by implementing *rich &#039;
                &#039;comparison\n&#039;
                &#039;methods* like &quot;__lt__()&quot;, described in Basic customization.\n&#039;
                &#039;\n&#039;
                &#039;The default behavior for equality comparison (&quot;==&quot; and &quot;!=&quot;) &#039;
                &#039;is based\n&#039;
                &#039;on the identity of the objects.  Hence, equality comparison &#039;
                &#039;of\n&#039;
                &#039;instances with the same identity results in equality, and &#039;
                &#039;equality\n&#039;
                &#039;comparison of instances with different identities results in\n&#039;
                &#039;inequality.  A motivation for this default behavior is the &#039;
                &#039;desire that\n&#039;
                &#039;all objects should be reflexive (i.e. &quot;x is y&quot; implies &quot;x == &#039;
                &#039;y&quot;).\n&#039;
                &#039;\n&#039;
                &#039;A default order comparison (&quot;&lt;&quot;, &quot;&gt;&quot;, &quot;&lt;=&quot;, and &quot;&gt;=&quot;) is not &#039;
                &#039;provided;\n&#039;
                &#039;an attempt raises &quot;TypeError&quot;.  A motivation for this default &#039;
                &#039;behavior\n&#039;
                &#039;is the lack of a similar invariant as for equality.\n&#039;
                &#039;\n&#039;
                &#039;The behavior of the default equality comparison, that &#039;
                &#039;instances with\n&#039;
                &#039;different identities are always unequal, may be in contrast &#039;
                &#039;to what\n&#039;
                &#039;types will need that have a sensible definition of object &#039;
                &#039;value and\n&#039;
                &#039;value-based equality.  Such types will need to customize &#039;
                &#039;their\n&#039;
                &#039;comparison behavior, and in fact, a number of built-in types &#039;
                &#039;have done\n&#039;
                &#039;that.\n&#039;
                &#039;\n&#039;
                &#039;The following list describes the comparison behavior of the &#039;
                &#039;most\n&#039;
                &#039;important built-in types.\n&#039;
                &#039;\n&#039;
                &#039;* Numbers of built-in numeric types (Numeric Types — int, &#039;
                &#039;float,\n&#039;
                &#039;  complex) and of the standard library types &#039;
                &#039;&quot;fractions.Fraction&quot; and\n&#039;
                &#039;  &quot;decimal.Decimal&quot; can be compared within and across their &#039;
                &#039;types,\n&#039;
                &#039;  with the restriction that complex numbers do not support &#039;
                &#039;order\n&#039;
                &#039;  comparison.  Within the limits of the types involved, they &#039;
                &#039;compare\n&#039;
                &#039;  mathematically (algorithmically) correct without loss of &#039;
                &#039;precision.\n&#039;
                &#039;\n&#039;
                &#039;  The not-a-number values &quot;float(\&#039;NaN\&#039;)&quot; and &#039;
                &#039;&quot;Decimal(\&#039;NaN\&#039;)&quot; are\n&#039;
                &#039;  special.  They are identical to themselves (&quot;x is x&quot; is &#039;
                &#039;true) but\n&#039;
                &#039;  are not equal to themselves (&quot;x == x&quot; is false).  &#039;
                &#039;Additionally,\n&#039;
                &#039;  comparing any number to a not-a-number value will return &#039;
                &#039;&quot;False&quot;.\n&#039;
                &#039;  For example, both &quot;3 &lt; float(\&#039;NaN\&#039;)&quot; and &quot;float(\&#039;NaN\&#039;) &#039;
                &#039;&lt; 3&quot; will\n&#039;
                &#039;  return &quot;False&quot;.\n&#039;
                &#039;\n&#039;
                &#039;* Binary sequences (instances of &quot;bytes&quot; or &quot;bytearray&quot;) can &#039;
                &#039;be\n&#039;
                &#039;  compared within and across their types.  They compare\n&#039;
                &#039;  lexicographically using the numeric values of their &#039;
                &#039;elements.\n&#039;
                &#039;\n&#039;
                &#039;* Strings (instances of &quot;str&quot;) compare lexicographically &#039;
                &#039;using the\n&#039;
                &#039;  numerical Unicode code points (the result of the built-in &#039;
                &#039;function\n&#039;
                &#039;  &quot;ord()&quot;) of their characters. [3]\n&#039;
                &#039;\n&#039;
                &#039;  Strings and binary sequences cannot be directly compared.\n&#039;
                &#039;\n&#039;
                &#039;* Sequences (instances of &quot;tuple&quot;, &quot;list&quot;, or &quot;range&quot;) can &#039;
                &#039;be\n&#039;
                &#039;  compared only within each of their types, with the &#039;
                &#039;restriction that\n&#039;
                &#039;  ranges do not support order comparison.  Equality &#039;
                &#039;comparison across\n&#039;
                &#039;  these types results in inequality, and ordering comparison &#039;
                &#039;across\n&#039;
                &#039;  these types raises &quot;TypeError&quot;.\n&#039;
                &#039;\n&#039;
                &#039;  Sequences compare lexicographically using comparison of\n&#039;
                &#039;  corresponding elements, whereby reflexivity of the elements &#039;
                &#039;is\n&#039;
                &#039;  enforced.\n&#039;
                &#039;\n&#039;
                &#039;  In enforcing reflexivity of elements, the comparison of &#039;
                &#039;collections\n&#039;
                &#039;  assumes that for a collection element &quot;x&quot;, &quot;x == x&quot; is &#039;
                &#039;always true.\n&#039;
                &#039;  Based on that assumption, element identity is compared &#039;
                &#039;first, and\n&#039;
                &#039;  element comparison is performed only for distinct &#039;
                &#039;elements.  This\n&#039;
                &#039;  approach yields the same result as a strict element &#039;
                &#039;comparison\n&#039;
                &#039;  would, if the compared elements are reflexive.  For &#039;
                &#039;non-reflexive\n&#039;
                &#039;  elements, the result is different than for strict element\n&#039;
                &#039;  comparison, and may be surprising:  The non-reflexive &#039;
                &#039;not-a-number\n&#039;
                &#039;  values for example result in the following comparison &#039;
                &#039;behavior when\n&#039;
                &#039;  used in a list:\n&#039;
                &#039;\n&#039;
                &quot;     &gt;&gt;&gt; nan = float(&#039;NaN&#039;)\n&quot;
                &#039;     &gt;&gt;&gt; nan is nan\n&#039;
                &#039;     True\n&#039;
                &#039;     &gt;&gt;&gt; nan == nan\n&#039;
                &#039;     False                 &lt;-- the defined non-reflexive &#039;
                &#039;behavior of NaN\n&#039;
                &#039;     &gt;&gt;&gt; [nan] == [nan]\n&#039;
                &#039;     True                  &lt;-- list enforces reflexivity and &#039;
                &#039;tests identity first\n&#039;
                &#039;\n&#039;
                &#039;  Lexicographical comparison between built-in collections &#039;
                &#039;works as\n&#039;
                &#039;  follows:\n&#039;
                &#039;\n&#039;
                &#039;  * For two collections to compare equal, they must be of the &#039;
                &#039;same\n&#039;
                &#039;    type, have the same length, and each pair of &#039;
                &#039;corresponding\n&#039;
                &#039;    elements must compare equal (for example, &quot;[1,2] == &#039;
                &#039;(1,2)&quot; is\n&#039;
                &#039;    false because the type is not the same).\n&#039;
                &#039;\n&#039;
                &#039;  * Collections that support order comparison are ordered the &#039;
                &#039;same\n&#039;
                &#039;    as their first unequal elements (for example, &quot;[1,2,x] &lt;= &#039;
                &#039;[1,2,y]&quot;\n&#039;
                &#039;    has the same value as &quot;x &lt;= y&quot;).  If a corresponding &#039;
                &#039;element does\n&#039;
                &#039;    not exist, the shorter collection is ordered first (for &#039;
                &#039;example,\n&#039;
                &#039;    &quot;[1,2] &lt; [1,2,3]&quot; is true).\n&#039;
                &#039;\n&#039;
                &#039;* Mappings (instances of &quot;dict&quot;) compare equal if and only if &#039;
                &#039;they\n&#039;
                &#039;  have equal *(key, value)* pairs. Equality comparison of the &#039;
                &#039;keys and\n&#039;
                &#039;  values enforces reflexivity.\n&#039;
                &#039;\n&#039;
                &#039;  Order comparisons (&quot;&lt;&quot;, &quot;&gt;&quot;, &quot;&lt;=&quot;, and &quot;&gt;=&quot;) raise &#039;
                &#039;&quot;TypeError&quot;.\n&#039;
                &#039;\n&#039;
                &#039;* Sets (instances of &quot;set&quot; or &quot;frozenset&quot;) can be compared &#039;
                &#039;within\n&#039;
                &#039;  and across their types.\n&#039;
                &#039;\n&#039;
                &#039;  They define order comparison operators to mean subset and &#039;
                &#039;superset\n&#039;
                &#039;  tests.  Those relations do not define total orderings (for &#039;
                &#039;example,\n&#039;
                &#039;  the two sets &quot;{1,2}&quot; and &quot;{2,3}&quot; are not equal, nor subsets &#039;
                &#039;of one\n&#039;
                &#039;  another, nor supersets of one another).  Accordingly, sets &#039;
                &#039;are not\n&#039;
                &#039;  appropriate arguments for functions which depend on total &#039;
                &#039;ordering\n&#039;
                &#039;  (for example, &quot;min()&quot;, &quot;max()&quot;, and &quot;sorted()&quot; produce &#039;
                &#039;undefined\n&#039;
                &#039;  results given a list of sets as inputs).\n&#039;
                &#039;\n&#039;
                &#039;  Comparison of sets enforces reflexivity of its elements.\n&#039;
                &#039;\n&#039;
                &#039;* Most other built-in types have no comparison methods &#039;
                &#039;implemented,\n&#039;
                &#039;  so they inherit the default comparison behavior.\n&#039;
                &#039;\n&#039;
                &#039;User-defined classes that customize their comparison behavior &#039;
                &#039;should\n&#039;
                &#039;follow some consistency rules, if possible:\n&#039;
                &#039;\n&#039;
                &#039;* Equality comparison should be reflexive. In other words, &#039;
                &#039;identical\n&#039;
                &#039;  objects should compare equal:\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x is y&quot; implies &quot;x == y&quot;\n&#039;
                &#039;\n&#039;
                &#039;* Comparison should be symmetric. In other words, the &#039;
                &#039;following\n&#039;
                &#039;  expressions should have the same result:\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x == y&quot; and &quot;y == x&quot;\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x != y&quot; and &quot;y != x&quot;\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x &lt; y&quot; and &quot;y &gt; x&quot;\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x &lt;= y&quot; and &quot;y &gt;= x&quot;\n&#039;
                &#039;\n&#039;
                &#039;* Comparison should be transitive. The following &#039;
                &#039;(non-exhaustive)\n&#039;
                &#039;  examples illustrate that:\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x &gt; y and y &gt; z&quot; implies &quot;x &gt; z&quot;\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x &lt; y and y &lt;= z&quot; implies &quot;x &lt; z&quot;\n&#039;
                &#039;\n&#039;
                &#039;* Inverse comparison should result in the boolean negation. &#039;
                &#039;In other\n&#039;
                &#039;  words, the following expressions should have the same &#039;
                &#039;result:\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x == y&quot; and &quot;not x != y&quot;\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x &lt; y&quot; and &quot;not x &gt;= y&quot; (for total ordering)\n&#039;
                &#039;\n&#039;
                &#039;     &quot;x &gt; y&quot; and &quot;not x &lt;= y&quot; (for total ordering)\n&#039;
                &#039;\n&#039;
                &#039;  The last two expressions apply to totally ordered &#039;
                &#039;collections (e.g.\n&#039;
                &#039;  to sequences, but not to sets or mappings). See also the\n&#039;
                &#039;  &quot;total_ordering()&quot; decorator.\n&#039;
                &#039;\n&#039;
                &#039;* The &quot;hash()&quot; result should be consistent with equality. &#039;
                &#039;Objects\n&#039;
                &#039;  that are equal should either have the same hash value, or &#039;
                &#039;be marked\n&#039;
                &#039;  as unhashable.\n&#039;
                &#039;\n&#039;
                &#039;Python does not enforce these consistency rules. In fact, &#039;
                &#039;the\n&#039;
                &#039;not-a-number values are an example for not following these &#039;
                &#039;rules.\n&#039;
                &#039;\n&#039;
                &#039;\n&#039;
                &#039;Membership test operations\n&#039;
                &#039;==========================\n&#039;
                &#039;\n&#039;
                &#039;The operators &quot;in&quot; and &quot;not in&quot; test for membership.  &quot;x in &#039;
                &#039;s&quot;\n&#039;
                &#039;evaluates to &quot;True&quot; if *x* is a member of *s*, and &quot;False&quot; &#039;
                &#039;otherwise.\n&#039;
                &#039;&quot;x not in s&quot; returns the negation of &quot;x in s&quot;.  All built-in &#039;
                &#039;sequences\n&#039;
                &#039;and set types support this as well as dictionary, for which &#039;
                &#039;&quot;in&quot; tests\n&#039;
                &#039;whether the dictionary has a given key. For container types &#039;
                &#039;such as\n&#039;
                &#039;list, tuple, set, frozenset, dict, or collections.deque, the\n&#039;
                &#039;expression &quot;x in y&quot; is equivalent to &quot;any(x is e or x == e &#039;
                &#039;for e in\n&#039;
                &#039;y)&quot;.\n&#039;
                &#039;\n&#039;
                &#039;For the string and bytes types, &quot;x in y&quot; is &quot;True&quot; if and &#039;
                &#039;only if *x*\n&#039;
                &#039;is a substring of *y*.  An equivalent test is &quot;y.find(x) != &#039;
                &#039;-1&quot;.\n&#039;
                &#039;Empty strings are always considered to be a substring of any &#039;
                &#039;other\n&#039;
                &#039;string, so &quot;&quot;&quot; in &quot;abc&quot;&quot; will return &quot;True&quot;.\n&#039;
                &#039;\n&#039;
                &#039;For user-defined classes which define the &quot;__contains__()&quot; &#039;
                &#039;method, &quot;x\n&#039;
                &#039;in y&quot; returns &quot;True&quot; if &quot;y.__contains__(x)&quot; returns a true &#039;
                &#039;value, and\n&#039;
                &#039;&quot;False&quot; otherwise.\n&#039;
                &#039;\n&#039;
                &#039;For user-defined classes which do not define &quot;__contains__()&quot; &#039;
                &#039;but do\n&#039;
                &#039;define &quot;__iter__()&quot;, &quot;x in y&quot; is &quot;True&quot; if some value &quot;z&quot; &#039;
                &#039;with &quot;x ==\n&#039;
                &#039;z&quot; is produced while iterating over &quot;y&quot;.  If an exception is &#039;
                &#039;raised\n&#039;
                &#039;during the iteration, it is as if &quot;in&quot; raised that &#039;
                &#039;exception.\n&#039;
                &#039;\n&#039;
                &#039;Lastly, the old-style iteration protocol is tried: if a class &#039;
                &#039;defines\n&#039;
                &#039;&quot;__getitem__()&quot;, &quot;x in y&quot; is &quot;True&quot; if and only if there is a &#039;
                &#039;non-\n&#039;
                &#039;negative integer index *i* such that &quot;x == y[i]&quot;, and all &#039;
                &#039;lower\n&#039;
                &#039;integer indices do not raise &quot;IndexError&quot; exception.  (If any &#039;
                &#039;other\n&#039;
                &#039;exception is raised, it is as if &quot;in&quot; raised that &#039;
                &#039;exception).\n&#039;
                &#039;\n&#039;
                &#039;The operator &quot;not in&quot; is defined to have the inverse true &#039;
                &#039;value of\n&#039;
                &#039;&quot;in&quot;.\n&#039;
                &#039;\n&#039;
                &#039;\n&#039;
                &#039;Identity comparisons\n&#039;
                &#039;====================\n&#039;
                &#039;\n&#039;
                &#039;The operators &quot;is&quot; and &quot;is not&quot; test for object identity: &quot;x &#039;
                &#039;is y&quot; is\n&#039;
                &#039;true if and only if *x* and *y* are the same object.  Object &#039;
                &#039;identity\n&#039;
                &#039;is determined using the &quot;id()&quot; function.  &quot;x is not y&quot; yields &#039;
                &#039;the\n&#039;
                &#039;inverse truth value. [4]\n&#039;,
 &#039;compound&#039;: &#039;Compound statements\n&#039;
             &#039;*******************\n&#039;
             &#039;\n&#039;
             &#039;Compound statements contain (groups of) other statements; they &#039;
             &#039;affect\n&#039;
             &#039;or control the execution of those other statements in some way.  &#039;
             &#039;In\n&#039;
             &#039;general, compound statements span multiple lines, although in &#039;
             &#039;simple\n&#039;
             &#039;incarnations a whole compound statement may be contained in one &#039;
             &#039;line.\n&#039;
             &#039;\n&#039;
             &#039;The &quot;if&quot;, &quot;while&quot; and &quot;for&quot; statements implement traditional &#039;
             &#039;control\n&#039;
             &#039;flow constructs.  &quot;try&quot; specifies exception handlers and/or &#039;
             &#039;cleanup\n&#039;
             &#039;code for a group of statements, while the &quot;with&quot; statement &#039;
             &#039;allows the\n&#039;
             &#039;execution of initialization and finalization code around a block &#039;
             &#039;of\n&#039;
             &#039;code.  Function and class definitions are also syntactically &#039;
             &#039;compound\n&#039;
             &#039;statements.\n&#039;
             &#039;\n&#039;
             &#039;A compound statement consists of one or more ‘clauses.’  A &#039;
             &#039;clause\n&#039;
             &#039;consists of a header and a ‘suite.’  The clause headers of a\n&#039;
             &#039;particular compound statement are all at the same indentation &#039;
             &#039;level.\n&#039;
             &#039;Each clause header begins with a uniquely identifying keyword &#039;
             &#039;and ends\n&#039;
             &#039;with a colon.  A suite is a group of statements controlled by a\n&#039;
             &#039;clause.  A suite can be one or more semicolon-separated simple\n&#039;
             &#039;statements on the same line as the header, following the &#039;
             &#039;header’s\n&#039;
             &#039;colon, or it can be one or more indented statements on &#039;
             &#039;subsequent\n&#039;
             &#039;lines.  Only the latter form of a suite can contain nested &#039;
             &#039;compound\n&#039;
             &#039;statements; the following is illegal, mostly because it wouldn’t &#039;
             &#039;be\n&#039;
             &#039;clear to which &quot;if&quot; clause a following &quot;else&quot; clause would &#039;
             &#039;belong:\n&#039;
             &#039;\n&#039;
             &#039;   if test1: if test2: print(x)\n&#039;
             &#039;\n&#039;
             &#039;Also note that the semicolon binds tighter than the colon in &#039;
             &#039;this\n&#039;
             &#039;context, so that in the following example, either all or none of &#039;
             &#039;the\n&#039;
             &#039;&quot;print()&quot; calls are executed:\n&#039;
             &#039;\n&#039;
             &#039;   if x &lt; y &lt; z: print(x); print(y); print(z)\n&#039;
             &#039;\n&#039;
             &#039;Summarizing:\n&#039;
             &#039;\n&#039;
             &#039;   compound_stmt ::= if_stmt\n&#039;
             &#039;                     | while_stmt\n&#039;
             &#039;                     | for_stmt\n&#039;
             &#039;                     | try_stmt\n&#039;
             &#039;                     | with_stmt\n&#039;
             &#039;                     | funcdef\n&#039;
             &#039;                     | classdef\n&#039;
             &#039;                     | async_with_stmt\n&#039;
             &#039;                     | async_for_stmt\n&#039;
             &#039;                     | async_funcdef\n&#039;
             &#039;   suite         ::= stmt_list NEWLINE | NEWLINE INDENT &#039;
             &#039;statement+ DEDENT\n&#039;
             &#039;   statement     ::= stmt_list NEWLINE | compound_stmt\n&#039;
             &#039;   stmt_list     ::= simple_stmt (&quot;;&quot; simple_stmt)* [&quot;;&quot;]\n&#039;
             &#039;\n&#039;
             &#039;Note that statements always end in a &quot;NEWLINE&quot; possibly followed &#039;
             &#039;by a\n&#039;
             &#039;&quot;DEDENT&quot;.  Also note that optional continuation clauses always &#039;
             &#039;begin\n&#039;
             &#039;with a keyword that cannot start a statement, thus there are no\n&#039;
             &#039;ambiguities (the ‘dangling &quot;else&quot;’ problem is solved in Python &#039;
             &#039;by\n&#039;
             &#039;requiring nested &quot;if&quot; statements to be indented).\n&#039;
             &#039;\n&#039;
             &#039;The formatting of the grammar rules in the following sections &#039;
             &#039;places\n&#039;
             &#039;each clause on a separate line for clarity.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;if&quot; statement\n&#039;
             &#039;==================\n&#039;
             &#039;\n&#039;
             &#039;The &quot;if&quot; statement is used for conditional execution:\n&#039;
             &#039;\n&#039;
             &#039;   if_stmt ::= &quot;if&quot; expression &quot;:&quot; suite\n&#039;
             &#039;               (&quot;elif&quot; expression &quot;:&quot; suite)*\n&#039;
             &#039;               [&quot;else&quot; &quot;:&quot; suite]\n&#039;
             &#039;\n&#039;
             &#039;It selects exactly one of the suites by evaluating the &#039;
             &#039;expressions one\n&#039;
             &#039;by one until one is found to be true (see section Boolean &#039;
             &#039;operations\n&#039;
             &#039;for the definition of true and false); then that suite is &#039;
             &#039;executed\n&#039;
             &#039;(and no other part of the &quot;if&quot; statement is executed or &#039;
             &#039;evaluated).\n&#039;
             &#039;If all expressions are false, the suite of the &quot;else&quot; clause, &#039;
             &#039;if\n&#039;
             &#039;present, is executed.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;while&quot; statement\n&#039;
             &#039;=====================\n&#039;
             &#039;\n&#039;
             &#039;The &quot;while&quot; statement is used for repeated execution as long as &#039;
             &#039;an\n&#039;
             &#039;expression is true:\n&#039;
             &#039;\n&#039;
             &#039;   while_stmt ::= &quot;while&quot; expression &quot;:&quot; suite\n&#039;
             &#039;                  [&quot;else&quot; &quot;:&quot; suite]\n&#039;
             &#039;\n&#039;
             &#039;This repeatedly tests the expression and, if it is true, &#039;
             &#039;executes the\n&#039;
             &#039;first suite; if the expression is false (which may be the first &#039;
             &#039;time\n&#039;
             &#039;it is tested) the suite of the &quot;else&quot; clause, if present, is &#039;
             &#039;executed\n&#039;
             &#039;and the loop terminates.\n&#039;
             &#039;\n&#039;
             &#039;A &quot;break&quot; statement executed in the first suite terminates the &#039;
             &#039;loop\n&#039;
             &#039;without executing the &quot;else&quot; clause’s suite.  A &quot;continue&quot; &#039;
             &#039;statement\n&#039;
             &#039;executed in the first suite skips the rest of the suite and goes &#039;
             &#039;back\n&#039;
             &#039;to testing the expression.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;for&quot; statement\n&#039;
             &#039;===================\n&#039;
             &#039;\n&#039;
             &#039;The &quot;for&quot; statement is used to iterate over the elements of a &#039;
             &#039;sequence\n&#039;
             &#039;(such as a string, tuple or list) or other iterable object:\n&#039;
             &#039;\n&#039;
             &#039;   for_stmt ::= &quot;for&quot; target_list &quot;in&quot; expression_list &quot;:&quot; &#039;
             &#039;suite\n&#039;
             &#039;                [&quot;else&quot; &quot;:&quot; suite]\n&#039;
             &#039;\n&#039;
             &#039;The expression list is evaluated once; it should yield an &#039;
             &#039;iterable\n&#039;
             &#039;object.  An iterator is created for the result of the\n&#039;
             &#039;&quot;expression_list&quot;.  The suite is then executed once for each &#039;
             &#039;item\n&#039;
             &#039;provided by the iterator, in the order returned by the &#039;
             &#039;iterator.  Each\n&#039;
             &#039;item in turn is assigned to the target list using the standard &#039;
             &#039;rules\n&#039;
             &#039;for assignments (see Assignment statements), and then the suite &#039;
             &#039;is\n&#039;
             &#039;executed.  When the items are exhausted (which is immediately &#039;
             &#039;when the\n&#039;
             &#039;sequence is empty or an iterator raises a &quot;StopIteration&quot; &#039;
             &#039;exception),\n&#039;
             &#039;the suite in the &quot;else&quot; clause, if present, is executed, and the &#039;
             &#039;loop\n&#039;
             &#039;terminates.\n&#039;
             &#039;\n&#039;
             &#039;A &quot;break&quot; statement executed in the first suite terminates the &#039;
             &#039;loop\n&#039;
             &#039;without executing the &quot;else&quot; clause’s suite.  A &quot;continue&quot; &#039;
             &#039;statement\n&#039;
             &#039;executed in the first suite skips the rest of the suite and &#039;
             &#039;continues\n&#039;
             &#039;with the next item, or with the &quot;else&quot; clause if there is no &#039;
             &#039;next\n&#039;
             &#039;item.\n&#039;
             &#039;\n&#039;
             &#039;The for-loop makes assignments to the variables(s) in the target &#039;
             &#039;list.\n&#039;
             &#039;This overwrites all previous assignments to those variables &#039;
             &#039;including\n&#039;
             &#039;those made in the suite of the for-loop:\n&#039;
             &#039;\n&#039;
             &#039;   for i in range(10):\n&#039;
             &#039;       print(i)\n&#039;
             &#039;       i = 5             # this will not affect the for-loop\n&#039;
             &#039;                         # because i will be overwritten with &#039;
             &#039;the next\n&#039;
             &#039;                         # index in the range\n&#039;
             &#039;\n&#039;
             &#039;Names in the target list are not deleted when the loop is &#039;
             &#039;finished,\n&#039;
             &#039;but if the sequence is empty, they will not have been assigned &#039;
             &#039;to at\n&#039;
             &#039;all by the loop.  Hint: the built-in function &quot;range()&quot; returns &#039;
             &#039;an\n&#039;
             &#039;iterator of integers suitable to emulate the effect of Pascal’s &#039;
             &#039;&quot;for i\n&#039;
             &#039;:= a to b do&quot;; e.g., &quot;list(range(3))&quot; returns the list &quot;[0, 1, &#039;
             &#039;2]&quot;.\n&#039;
             &#039;\n&#039;
             &#039;Note: There is a subtlety when the sequence is being modified by &#039;
             &#039;the\n&#039;
             &#039;  loop (this can only occur for mutable sequences, e.g. lists).  &#039;
             &#039;An\n&#039;
             &#039;  internal counter is used to keep track of which item is used &#039;
             &#039;next,\n&#039;
             &#039;  and this is incremented on each iteration.  When this counter &#039;
             &#039;has\n&#039;
             &#039;  reached the length of the sequence the loop terminates.  This &#039;
             &#039;means\n&#039;
             &#039;  that if the suite deletes the current (or a previous) item &#039;
             &#039;from the\n&#039;
             &#039;  sequence, the next item will be skipped (since it gets the &#039;
             &#039;index of\n&#039;
             &#039;  the current item which has already been treated).  Likewise, &#039;
             &#039;if the\n&#039;
             &#039;  suite inserts an item in the sequence before the current item, &#039;
             &#039;the\n&#039;
             &#039;  current item will be treated again the next time through the &#039;
             &#039;loop.\n&#039;
             &#039;  This can lead to nasty bugs that can be avoided by making a\n&#039;
             &#039;  temporary copy using a slice of the whole sequence, e.g.,\n&#039;
             &#039;\n&#039;
             &#039;     for x in a[:]:\n&#039;
             &#039;         if x &lt; 0: a.remove(x)\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;try&quot; statement\n&#039;
             &#039;===================\n&#039;
             &#039;\n&#039;
             &#039;The &quot;try&quot; statement specifies exception handlers and/or cleanup &#039;
             &#039;code\n&#039;
             &#039;for a group of statements:\n&#039;
             &#039;\n&#039;
             &#039;   try_stmt  ::= try1_stmt | try2_stmt\n&#039;
             &#039;   try1_stmt ::= &quot;try&quot; &quot;:&quot; suite\n&#039;
             &#039;                 (&quot;except&quot; [expression [&quot;as&quot; identifier]] &quot;:&quot; &#039;
             &#039;suite)+\n&#039;
             &#039;                 [&quot;else&quot; &quot;:&quot; suite]\n&#039;
             &#039;                 [&quot;finally&quot; &quot;:&quot; suite]\n&#039;
             &#039;   try2_stmt ::= &quot;try&quot; &quot;:&quot; suite\n&#039;
             &#039;                 &quot;finally&quot; &quot;:&quot; suite\n&#039;
             &#039;\n&#039;
             &#039;The &quot;except&quot; clause(s) specify one or more exception handlers. &#039;
             &#039;When no\n&#039;
             &#039;exception occurs in the &quot;try&quot; clause, no exception handler is\n&#039;
             &#039;executed. When an exception occurs in the &quot;try&quot; suite, a search &#039;
             &#039;for an\n&#039;
             &#039;exception handler is started.  This search inspects the except &#039;
             &#039;clauses\n&#039;
             &#039;in turn until one is found that matches the exception.  An &#039;
             &#039;expression-\n&#039;
             &#039;less except clause, if present, must be last; it matches any\n&#039;
             &#039;exception.  For an except clause with an expression, that &#039;
             &#039;expression\n&#039;
             &#039;is evaluated, and the clause matches the exception if the &#039;
             &#039;resulting\n&#039;
             &#039;object is “compatible” with the exception.  An object is &#039;
             &#039;compatible\n&#039;
             &#039;with an exception if it is the class or a base class of the &#039;
             &#039;exception\n&#039;
             &#039;object or a tuple containing an item compatible with the &#039;
             &#039;exception.\n&#039;
             &#039;\n&#039;
             &#039;If no except clause matches the exception, the search for an &#039;
             &#039;exception\n&#039;
             &#039;handler continues in the surrounding code and on the invocation &#039;
             &#039;stack.\n&#039;
             &#039;[1]\n&#039;
             &#039;\n&#039;
             &#039;If the evaluation of an expression in the header of an except &#039;
             &#039;clause\n&#039;
             &#039;raises an exception, the original search for a handler is &#039;
             &#039;canceled and\n&#039;
             &#039;a search starts for the new exception in the surrounding code &#039;
             &#039;and on\n&#039;
             &#039;the call stack (it is treated as if the entire &quot;try&quot; statement &#039;
             &#039;raised\n&#039;
             &#039;the exception).\n&#039;
             &#039;\n&#039;
             &#039;When a matching except clause is found, the exception is &#039;
             &#039;assigned to\n&#039;
             &#039;the target specified after the &quot;as&quot; keyword in that except &#039;
             &#039;clause, if\n&#039;
             &#039;present, and the except clause’s suite is executed.  All except\n&#039;
             &#039;clauses must have an executable block.  When the end of this &#039;
             &#039;block is\n&#039;
             &#039;reached, execution continues normally after the entire try &#039;
             &#039;statement.\n&#039;
             &#039;(This means that if two nested handlers exist for the same &#039;
             &#039;exception,\n&#039;
             &#039;and the exception occurs in the try clause of the inner handler, &#039;
             &#039;the\n&#039;
             &#039;outer handler will not handle the exception.)\n&#039;
             &#039;\n&#039;
             &#039;When an exception has been assigned using &quot;as target&quot;, it is &#039;
             &#039;cleared\n&#039;
             &#039;at the end of the except clause.  This is as if\n&#039;
             &#039;\n&#039;
             &#039;   except E as N:\n&#039;
             &#039;       foo\n&#039;
             &#039;\n&#039;
             &#039;was translated to\n&#039;
             &#039;\n&#039;
             &#039;   except E as N:\n&#039;
             &#039;       try:\n&#039;
             &#039;           foo\n&#039;
             &#039;       finally:\n&#039;
             &#039;           del N\n&#039;
             &#039;\n&#039;
             &#039;This means the exception must be assigned to a different name to &#039;
             &#039;be\n&#039;
             &#039;able to refer to it after the except clause.  Exceptions are &#039;
             &#039;cleared\n&#039;
             &#039;because with the traceback attached to them, they form a &#039;
             &#039;reference\n&#039;
             &#039;cycle with the stack frame, keeping all locals in that frame &#039;
             &#039;alive\n&#039;
             &#039;until the next garbage collection occurs.\n&#039;
             &#039;\n&#039;
             &#039;Before an except clause’s suite is executed, details about the\n&#039;
             &#039;exception are stored in the &quot;sys&quot; module and can be accessed &#039;
             &#039;via\n&#039;
             &#039;&quot;sys.exc_info()&quot;. &quot;sys.exc_info()&quot; returns a 3-tuple consisting &#039;
             &#039;of the\n&#039;
             &#039;exception class, the exception instance and a traceback object &#039;
             &#039;(see\n&#039;
             &#039;section The standard type hierarchy) identifying the point in &#039;
             &#039;the\n&#039;
             &#039;program where the exception occurred.  &quot;sys.exc_info()&quot; values &#039;
             &#039;are\n&#039;
             &#039;restored to their previous values (before the call) when &#039;
             &#039;returning\n&#039;
             &#039;from a function that handled an exception.\n&#039;
             &#039;\n&#039;
             &#039;The optional &quot;else&quot; clause is executed if the control flow &#039;
             &#039;leaves the\n&#039;
             &#039;&quot;try&quot; suite, no exception was raised, and no &quot;return&quot;, &#039;
             &#039;&quot;continue&quot;, or\n&#039;
             &#039;&quot;break&quot; statement was executed.  Exceptions in the &quot;else&quot; clause &#039;
             &#039;are\n&#039;
             &#039;not handled by the preceding &quot;except&quot; clauses.\n&#039;
             &#039;\n&#039;
             &#039;If &quot;finally&quot; is present, it specifies a ‘cleanup’ handler.  The &#039;
             &#039;&quot;try&quot;\n&#039;
             &#039;clause is executed, including any &quot;except&quot; and &quot;else&quot; clauses.  &#039;
             &#039;If an\n&#039;
             &#039;exception occurs in any of the clauses and is not handled, the\n&#039;
             &#039;exception is temporarily saved. The &quot;finally&quot; clause is &#039;
             &#039;executed.  If\n&#039;
             &#039;there is a saved exception it is re-raised at the end of the &#039;
             &#039;&quot;finally&quot;\n&#039;
             &#039;clause.  If the &quot;finally&quot; clause raises another exception, the &#039;
             &#039;saved\n&#039;
             &#039;exception is set as the context of the new exception. If the &#039;
             &#039;&quot;finally&quot;\n&#039;
             &#039;clause executes a &quot;return&quot; or &quot;break&quot; statement, the saved &#039;
             &#039;exception\n&#039;
             &#039;is discarded:\n&#039;
             &#039;\n&#039;
             &#039;   &gt;&gt;&gt; def f():\n&#039;
             &#039;   ...     try:\n&#039;
             &#039;   ...         1/0\n&#039;
             &#039;   ...     finally:\n&#039;
             &#039;   ...         return 42\n&#039;
             &#039;   ...\n&#039;
             &#039;   &gt;&gt;&gt; f()\n&#039;
             &#039;   42\n&#039;
             &#039;\n&#039;
             &#039;The exception information is not available to the program &#039;
             &#039;during\n&#039;
             &#039;execution of the &quot;finally&quot; clause.\n&#039;
             &#039;\n&#039;
             &#039;When a &quot;return&quot;, &quot;break&quot; or &quot;continue&quot; statement is executed in &#039;
             &#039;the\n&#039;
             &#039;&quot;try&quot; suite of a &quot;try&quot;…&quot;finally&quot; statement, the &quot;finally&quot; clause &#039;
             &#039;is\n&#039;
             &#039;also executed ‘on the way out.’ A &quot;continue&quot; statement is &#039;
             &#039;illegal in\n&#039;
             &#039;the &quot;finally&quot; clause. (The reason is a problem with the current\n&#039;
             &#039;implementation — this restriction may be lifted in the future).\n&#039;
             &#039;\n&#039;
             &#039;The return value of a function is determined by the last &#039;
             &#039;&quot;return&quot;\n&#039;
             &#039;statement executed.  Since the &quot;finally&quot; clause always executes, &#039;
             &#039;a\n&#039;
             &#039;&quot;return&quot; statement executed in the &quot;finally&quot; clause will always &#039;
             &#039;be the\n&#039;
             &#039;last one executed:\n&#039;
             &#039;\n&#039;
             &#039;   &gt;&gt;&gt; def foo():\n&#039;
             &#039;   ...     try:\n&#039;
             &quot;   ...         return &#039;try&#039;\n&quot;
             &#039;   ...     finally:\n&#039;
             &quot;   ...         return &#039;finally&#039;\n&quot;
             &#039;   ...\n&#039;
             &#039;   &gt;&gt;&gt; foo()\n&#039;
             &quot;   &#039;finally&#039;\n&quot;
             &#039;\n&#039;
             &#039;Additional information on exceptions can be found in section\n&#039;
             &#039;Exceptions, and information on using the &quot;raise&quot; statement to &#039;
             &#039;generate\n&#039;
             &#039;exceptions may be found in section The raise statement.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;with&quot; statement\n&#039;
             &#039;====================\n&#039;
             &#039;\n&#039;
             &#039;The &quot;with&quot; statement is used to wrap the execution of a block &#039;
             &#039;with\n&#039;
             &#039;methods defined by a context manager (see section With &#039;
             &#039;Statement\n&#039;
             &#039;Context Managers). This allows common &quot;try&quot;…&quot;except&quot;…&quot;finally&quot; &#039;
             &#039;usage\n&#039;
             &#039;patterns to be encapsulated for convenient reuse.\n&#039;
             &#039;\n&#039;
             &#039;   with_stmt ::= &quot;with&quot; with_item (&quot;,&quot; with_item)* &quot;:&quot; suite\n&#039;
             &#039;   with_item ::= expression [&quot;as&quot; target]\n&#039;
             &#039;\n&#039;
             &#039;The execution of the &quot;with&quot; statement with one “item” proceeds &#039;
             &#039;as\n&#039;
             &#039;follows:\n&#039;
             &#039;\n&#039;
             &#039;1. The context expression (the expression given in the &#039;
             &#039;&quot;with_item&quot;)\n&#039;
             &#039;   is evaluated to obtain a context manager.\n&#039;
             &#039;\n&#039;
             &#039;2. The context manager’s &quot;__exit__()&quot; is loaded for later use.\n&#039;
             &#039;\n&#039;
             &#039;3. The context manager’s &quot;__enter__()&quot; method is invoked.\n&#039;
             &#039;\n&#039;
             &#039;4. If a target was included in the &quot;with&quot; statement, the return\n&#039;
             &#039;   value from &quot;__enter__()&quot; is assigned to it.\n&#039;
             &#039;\n&#039;
             &#039;   Note: The &quot;with&quot; statement guarantees that if the &#039;
             &#039;&quot;__enter__()&quot;\n&#039;
             &#039;     method returns without an error, then &quot;__exit__()&quot; will &#039;
             &#039;always be\n&#039;
             &#039;     called. Thus, if an error occurs during the assignment to &#039;
             &#039;the\n&#039;
             &#039;     target list, it will be treated the same as an error &#039;
             &#039;occurring\n&#039;
             &#039;     within the suite would be. See step 6 below.\n&#039;
             &#039;\n&#039;
             &#039;5. The suite is executed.\n&#039;
             &#039;\n&#039;
             &#039;6. The context manager’s &quot;__exit__()&quot; method is invoked.  If an\n&#039;
             &#039;   exception caused the suite to be exited, its type, value, &#039;
             &#039;and\n&#039;
             &#039;   traceback are passed as arguments to &quot;__exit__()&quot;. Otherwise, &#039;
             &#039;three\n&#039;
             &#039;   &quot;None&quot; arguments are supplied.\n&#039;
             &#039;\n&#039;
             &#039;   If the suite was exited due to an exception, and the return &#039;
             &#039;value\n&#039;
             &#039;   from the &quot;__exit__()&quot; method was false, the exception is &#039;
             &#039;reraised.\n&#039;
             &#039;   If the return value was true, the exception is suppressed, &#039;
             &#039;and\n&#039;
             &#039;   execution continues with the statement following the &quot;with&quot;\n&#039;
             &#039;   statement.\n&#039;
             &#039;\n&#039;
             &#039;   If the suite was exited for any reason other than an &#039;
             &#039;exception, the\n&#039;
             &#039;   return value from &quot;__exit__()&quot; is ignored, and execution &#039;
             &#039;proceeds\n&#039;
             &#039;   at the normal location for the kind of exit that was taken.\n&#039;
             &#039;\n&#039;
             &#039;With more than one item, the context managers are processed as &#039;
             &#039;if\n&#039;
             &#039;multiple &quot;with&quot; statements were nested:\n&#039;
             &#039;\n&#039;
             &#039;   with A() as a, B() as b:\n&#039;
             &#039;       suite\n&#039;
             &#039;\n&#039;
             &#039;is equivalent to\n&#039;
             &#039;\n&#039;
             &#039;   with A() as a:\n&#039;
             &#039;       with B() as b:\n&#039;
             &#039;           suite\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.1: Support for multiple context &#039;
             &#039;expressions.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 343** - The “with” statement\n&#039;
             &#039;     The specification, background, and examples for the Python &#039;
             &#039;&quot;with&quot;\n&#039;
             &#039;     statement.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Function definitions\n&#039;
             &#039;====================\n&#039;
             &#039;\n&#039;
             &#039;A function definition defines a user-defined function object &#039;
             &#039;(see\n&#039;
             &#039;section The standard type hierarchy):\n&#039;
             &#039;\n&#039;
             &#039;   funcdef                 ::= [decorators] &quot;def&quot; funcname &quot;(&quot; &#039;
             &#039;[parameter_list] &quot;)&quot;\n&#039;
             &#039;               [&quot;-&gt;&quot; expression] &quot;:&quot; suite\n&#039;
             &#039;   decorators              ::= decorator+\n&#039;
             &#039;   decorator               ::= &quot;@&quot; dotted_name [&quot;(&quot; &#039;
             &#039;[argument_list [&quot;,&quot;]] &quot;)&quot;] NEWLINE\n&#039;
             &#039;   dotted_name             ::= identifier (&quot;.&quot; identifier)*\n&#039;
             &#039;   parameter_list          ::= defparameter (&quot;,&quot; defparameter)* &#039;
             &#039;[&quot;,&quot; [parameter_list_starargs]]\n&#039;
             &#039;                      | parameter_list_starargs\n&#039;
             &#039;   parameter_list_starargs ::= &quot;*&quot; [parameter] (&quot;,&quot; &#039;
             &#039;defparameter)* [&quot;,&quot; [&quot;**&quot; parameter [&quot;,&quot;]]]\n&#039;
             &#039;                               | &quot;**&quot; parameter [&quot;,&quot;]\n&#039;
             &#039;   parameter               ::= identifier [&quot;:&quot; expression]\n&#039;
             &#039;   defparameter            ::= parameter [&quot;=&quot; expression]\n&#039;
             &#039;   funcname                ::= identifier\n&#039;
             &#039;\n&#039;
             &#039;A function definition is an executable statement.  Its execution &#039;
             &#039;binds\n&#039;
             &#039;the function name in the current local namespace to a function &#039;
             &#039;object\n&#039;
             &#039;(a wrapper around the executable code for the function).  This\n&#039;
             &#039;function object contains a reference to the current global &#039;
             &#039;namespace\n&#039;
             &#039;as the global namespace to be used when the function is called.\n&#039;
             &#039;\n&#039;
             &#039;The function definition does not execute the function body; this &#039;
             &#039;gets\n&#039;
             &#039;executed only when the function is called. [2]\n&#039;
             &#039;\n&#039;
             &#039;A function definition may be wrapped by one or more *decorator*\n&#039;
             &#039;expressions. Decorator expressions are evaluated when the &#039;
             &#039;function is\n&#039;
             &#039;defined, in the scope that contains the function definition.  &#039;
             &#039;The\n&#039;
             &#039;result must be a callable, which is invoked with the function &#039;
             &#039;object\n&#039;
             &#039;as the only argument. The returned value is bound to the &#039;
             &#039;function name\n&#039;
             &#039;instead of the function object.  Multiple decorators are applied &#039;
             &#039;in\n&#039;
             &#039;nested fashion. For example, the following code\n&#039;
             &#039;\n&#039;
             &#039;   @f1(arg)\n&#039;
             &#039;   @f2\n&#039;
             &#039;   def func(): pass\n&#039;
             &#039;\n&#039;
             &#039;is roughly equivalent to\n&#039;
             &#039;\n&#039;
             &#039;   def func(): pass\n&#039;
             &#039;   func = f1(arg)(f2(func))\n&#039;
             &#039;\n&#039;
             &#039;except that the original function is not temporarily bound to &#039;
             &#039;the name\n&#039;
             &#039;&quot;func&quot;.\n&#039;
             &#039;\n&#039;
             &#039;When one or more *parameters* have the form *parameter* &quot;=&quot;\n&#039;
             &#039;*expression*, the function is said to have “default parameter &#039;
             &#039;values.”\n&#039;
             &#039;For a parameter with a default value, the corresponding &#039;
             &#039;*argument* may\n&#039;
             &#039;be omitted from a call, in which case the parameter’s default &#039;
             &#039;value is\n&#039;
             &#039;substituted.  If a parameter has a default value, all following\n&#039;
             &#039;parameters up until the “&quot;*&quot;” must also have a default value — &#039;
             &#039;this is\n&#039;
             &#039;a syntactic restriction that is not expressed by the grammar.\n&#039;
             &#039;\n&#039;
             &#039;**Default parameter values are evaluated from left to right when &#039;
             &#039;the\n&#039;
             &#039;function definition is executed.** This means that the &#039;
             &#039;expression is\n&#039;
             &#039;evaluated once, when the function is defined, and that the same &#039;
             &#039;“pre-\n&#039;
             &#039;computed” value is used for each call.  This is especially &#039;
             &#039;important\n&#039;
             &#039;to understand when a default parameter is a mutable object, such &#039;
             &#039;as a\n&#039;
             &#039;list or a dictionary: if the function modifies the object (e.g. &#039;
             &#039;by\n&#039;
             &#039;appending an item to a list), the default value is in effect &#039;
             &#039;modified.\n&#039;
             &#039;This is generally not what was intended.  A way around this is &#039;
             &#039;to use\n&#039;
             &#039;&quot;None&quot; as the default, and explicitly test for it in the body of &#039;
             &#039;the\n&#039;
             &#039;function, e.g.:\n&#039;
             &#039;\n&#039;
             &#039;   def whats_on_the_telly(penguin=None):\n&#039;
             &#039;       if penguin is None:\n&#039;
             &#039;           penguin = []\n&#039;
             &#039;       penguin.append(&quot;property of the zoo&quot;)\n&#039;
             &#039;       return penguin\n&#039;
             &#039;\n&#039;
             &#039;Function call semantics are described in more detail in section &#039;
             &#039;Calls.\n&#039;
             &#039;A function call always assigns values to all parameters &#039;
             &#039;mentioned in\n&#039;
             &#039;the parameter list, either from position arguments, from &#039;
             &#039;keyword\n&#039;
             &#039;arguments, or from default values.  If the form “&quot;*identifier&quot;” &#039;
             &#039;is\n&#039;
             &#039;present, it is initialized to a tuple receiving any excess &#039;
             &#039;positional\n&#039;
             &#039;parameters, defaulting to the empty tuple. If the form\n&#039;
             &#039;“&quot;**identifier&quot;” is present, it is initialized to a new ordered\n&#039;
             &#039;mapping receiving any excess keyword arguments, defaulting to a &#039;
             &#039;new\n&#039;
             &#039;empty mapping of the same type.  Parameters after “&quot;*&quot;” or\n&#039;
             &#039;“&quot;*identifier&quot;” are keyword-only parameters and may only be &#039;
             &#039;passed\n&#039;
             &#039;used keyword arguments.\n&#039;
             &#039;\n&#039;
             &#039;Parameters may have annotations of the form “&quot;: expression&quot;” &#039;
             &#039;following\n&#039;
             &#039;the parameter name.  Any parameter may have an annotation even &#039;
             &#039;those\n&#039;
             &#039;of the form &quot;*identifier&quot; or &quot;**identifier&quot;.  Functions may &#039;
             &#039;have\n&#039;
             &#039;“return” annotation of the form “&quot;-&gt; expression&quot;” after the &#039;
             &#039;parameter\n&#039;
             &#039;list.  These annotations can be any valid Python expression and &#039;
             &#039;are\n&#039;
             &#039;evaluated when the function definition is executed.  Annotations &#039;
             &#039;may\n&#039;
             &#039;be evaluated in a different order than they appear in the source &#039;
             &#039;code.\n&#039;
             &#039;The presence of annotations does not change the semantics of a\n&#039;
             &#039;function.  The annotation values are available as values of a\n&#039;
             &#039;dictionary keyed by the parameters’ names in the &#039;
             &#039;&quot;__annotations__&quot;\n&#039;
             &#039;attribute of the function object.\n&#039;
             &#039;\n&#039;
             &#039;It is also possible to create anonymous functions (functions not &#039;
             &#039;bound\n&#039;
             &#039;to a name), for immediate use in expressions.  This uses lambda\n&#039;
             &#039;expressions, described in section Lambdas.  Note that the &#039;
             &#039;lambda\n&#039;
             &#039;expression is merely a shorthand for a simplified function &#039;
             &#039;definition;\n&#039;
             &#039;a function defined in a “&quot;def&quot;” statement can be passed around &#039;
             &#039;or\n&#039;
             &#039;assigned to another name just like a function defined by a &#039;
             &#039;lambda\n&#039;
             &#039;expression.  The “&quot;def&quot;” form is actually more powerful since &#039;
             &#039;it\n&#039;
             &#039;allows the execution of multiple statements and annotations.\n&#039;
             &#039;\n&#039;
             &#039;**Programmer’s note:** Functions are first-class objects.  A &#039;
             &#039;“&quot;def&quot;”\n&#039;
             &#039;statement executed inside a function definition defines a local\n&#039;
             &#039;function that can be returned or passed around.  Free variables &#039;
             &#039;used\n&#039;
             &#039;in the nested function can access the local variables of the &#039;
             &#039;function\n&#039;
             &#039;containing the def.  See section Naming and binding for &#039;
             &#039;details.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 3107** - Function Annotations\n&#039;
             &#039;     The original specification for function annotations.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Class definitions\n&#039;
             &#039;=================\n&#039;
             &#039;\n&#039;
             &#039;A class definition defines a class object (see section The &#039;
             &#039;standard\n&#039;
             &#039;type hierarchy):\n&#039;
             &#039;\n&#039;
             &#039;   classdef    ::= [decorators] &quot;class&quot; classname [inheritance] &#039;
             &#039;&quot;:&quot; suite\n&#039;
             &#039;   inheritance ::= &quot;(&quot; [argument_list] &quot;)&quot;\n&#039;
             &#039;   classname   ::= identifier\n&#039;
             &#039;\n&#039;
             &#039;A class definition is an executable statement.  The inheritance &#039;
             &#039;list\n&#039;
             &#039;usually gives a list of base classes (see Metaclasses for more\n&#039;
             &#039;advanced uses), so each item in the list should evaluate to a &#039;
             &#039;class\n&#039;
             &#039;object which allows subclassing.  Classes without an inheritance &#039;
             &#039;list\n&#039;
             &#039;inherit, by default, from the base class &quot;object&quot;; hence,\n&#039;
             &#039;\n&#039;
             &#039;   class Foo:\n&#039;
             &#039;       pass\n&#039;
             &#039;\n&#039;
             &#039;is equivalent to\n&#039;
             &#039;\n&#039;
             &#039;   class Foo(object):\n&#039;
             &#039;       pass\n&#039;
             &#039;\n&#039;
             &#039;The class’s suite is then executed in a new execution frame &#039;
             &#039;(see\n&#039;
             &#039;Naming and binding), using a newly created local namespace and &#039;
             &#039;the\n&#039;
             &#039;original global namespace. (Usually, the suite contains mostly\n&#039;
             &#039;function definitions.)  When the class’s suite finishes &#039;
             &#039;execution, its\n&#039;
             &#039;execution frame is discarded but its local namespace is saved. &#039;
             &#039;[3] A\n&#039;
             &#039;class object is then created using the inheritance list for the &#039;
             &#039;base\n&#039;
             &#039;classes and the saved local namespace for the attribute &#039;
             &#039;dictionary.\n&#039;
             &#039;The class name is bound to this class object in the original &#039;
             &#039;local\n&#039;
             &#039;namespace.\n&#039;
             &#039;\n&#039;
             &#039;The order in which attributes are defined in the class body is\n&#039;
             &#039;preserved in the new class’s &quot;__dict__&quot;.  Note that this is &#039;
             &#039;reliable\n&#039;
             &#039;only right after the class is created and only for classes that &#039;
             &#039;were\n&#039;
             &#039;defined using the definition syntax.\n&#039;
             &#039;\n&#039;
             &#039;Class creation can be customized heavily using metaclasses.\n&#039;
             &#039;\n&#039;
             &#039;Classes can also be decorated: just like when decorating &#039;
             &#039;functions,\n&#039;
             &#039;\n&#039;
             &#039;   @f1(arg)\n&#039;
             &#039;   @f2\n&#039;
             &#039;   class Foo: pass\n&#039;
             &#039;\n&#039;
             &#039;is roughly equivalent to\n&#039;
             &#039;\n&#039;
             &#039;   class Foo: pass\n&#039;
             &#039;   Foo = f1(arg)(f2(Foo))\n&#039;
             &#039;\n&#039;
             &#039;The evaluation rules for the decorator expressions are the same &#039;
             &#039;as for\n&#039;
             &#039;function decorators.  The result is then bound to the class &#039;
             &#039;name.\n&#039;
             &#039;\n&#039;
             &#039;**Programmer’s note:** Variables defined in the class definition &#039;
             &#039;are\n&#039;
             &#039;class attributes; they are shared by instances.  Instance &#039;
             &#039;attributes\n&#039;
             &#039;can be set in a method with &quot;self.name = value&quot;.  Both class &#039;
             &#039;and\n&#039;
             &#039;instance attributes are accessible through the notation &#039;
             &#039;“&quot;self.name&quot;”,\n&#039;
             &#039;and an instance attribute hides a class attribute with the same &#039;
             &#039;name\n&#039;
             &#039;when accessed in this way.  Class attributes can be used as &#039;
             &#039;defaults\n&#039;
             &#039;for instance attributes, but using mutable values there can lead &#039;
             &#039;to\n&#039;
             &#039;unexpected results.  Descriptors can be used to create instance\n&#039;
             &#039;variables with different implementation details.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 3115** - Metaclasses in Python 3000\n&#039;
             &#039;     The proposal that changed the declaration of metaclasses to &#039;
             &#039;the\n&#039;
             &#039;     current syntax, and the semantics for how classes with\n&#039;
             &#039;     metaclasses are constructed.\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 3129** - Class Decorators\n&#039;
             &#039;     The proposal that added class decorators.  Function and &#039;
             &#039;method\n&#039;
             &#039;     decorators were introduced in **PEP 318**.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Coroutines\n&#039;
             &#039;==========\n&#039;
             &#039;\n&#039;
             &#039;New in version 3.5.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Coroutine function definition\n&#039;
             &#039;-----------------------------\n&#039;
             &#039;\n&#039;
             &#039;   async_funcdef ::= [decorators] &quot;async&quot; &quot;def&quot; funcname &quot;(&quot; &#039;
             &#039;[parameter_list] &quot;)&quot;\n&#039;
             &#039;                     [&quot;-&gt;&quot; expression] &quot;:&quot; suite\n&#039;
             &#039;\n&#039;
             &#039;Execution of Python coroutines can be suspended and resumed at &#039;
             &#039;many\n&#039;
             &#039;points (see *coroutine*).  In the body of a coroutine, any &#039;
             &#039;&quot;await&quot; and\n&#039;
             &#039;&quot;async&quot; identifiers become reserved keywords; &quot;await&quot; &#039;
             &#039;expressions,\n&#039;
             &#039;&quot;async for&quot; and &quot;async with&quot; can only be used in coroutine &#039;
             &#039;bodies.\n&#039;
             &#039;\n&#039;
             &#039;Functions defined with &quot;async def&quot; syntax are always coroutine\n&#039;
             &#039;functions, even if they do not contain &quot;await&quot; or &quot;async&quot; &#039;
             &#039;keywords.\n&#039;
             &#039;\n&#039;
             &#039;It is a &quot;SyntaxError&quot; to use &quot;yield from&quot; expressions in &quot;async &#039;
             &#039;def&quot;\n&#039;
             &#039;coroutines.\n&#039;
             &#039;\n&#039;
             &#039;An example of a coroutine function:\n&#039;
             &#039;\n&#039;
             &#039;   async def func(param1, param2):\n&#039;
             &#039;       do_stuff()\n&#039;
             &#039;       await some_coroutine()\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;async for&quot; statement\n&#039;
             &#039;-------------------------\n&#039;
             &#039;\n&#039;
             &#039;   async_for_stmt ::= &quot;async&quot; for_stmt\n&#039;
             &#039;\n&#039;
             &#039;An *asynchronous iterable* is able to call asynchronous code in &#039;
             &#039;its\n&#039;
             &#039;*iter* implementation, and *asynchronous iterator* can call\n&#039;
             &#039;asynchronous code in its *next* method.\n&#039;
             &#039;\n&#039;
             &#039;The &quot;async for&quot; statement allows convenient iteration over\n&#039;
             &#039;asynchronous iterators.\n&#039;
             &#039;\n&#039;
             &#039;The following code:\n&#039;
             &#039;\n&#039;
             &#039;   async for TARGET in ITER:\n&#039;
             &#039;       BLOCK\n&#039;
             &#039;   else:\n&#039;
             &#039;       BLOCK2\n&#039;
             &#039;\n&#039;
             &#039;Is semantically equivalent to:\n&#039;
             &#039;\n&#039;
             &#039;   iter = (ITER)\n&#039;
             &#039;   iter = type(iter).__aiter__(iter)\n&#039;
             &#039;   running = True\n&#039;
             &#039;   while running:\n&#039;
             &#039;       try:\n&#039;
             &#039;           TARGET = await type(iter).__anext__(iter)\n&#039;
             &#039;       except StopAsyncIteration:\n&#039;
             &#039;           running = False\n&#039;
             &#039;       else:\n&#039;
             &#039;           BLOCK\n&#039;
             &#039;   else:\n&#039;
             &#039;       BLOCK2\n&#039;
             &#039;\n&#039;
             &#039;See also &quot;__aiter__()&quot; and &quot;__anext__()&quot; for details.\n&#039;
             &#039;\n&#039;
             &#039;It is a &quot;SyntaxError&quot; to use &quot;async for&quot; statement outside of &#039;
             &#039;an\n&#039;
             &#039;&quot;async def&quot; function.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;The &quot;async with&quot; statement\n&#039;
             &#039;--------------------------\n&#039;
             &#039;\n&#039;
             &#039;   async_with_stmt ::= &quot;async&quot; with_stmt\n&#039;
             &#039;\n&#039;
             &#039;An *asynchronous context manager* is a *context manager* that is &#039;
             &#039;able\n&#039;
             &#039;to suspend execution in its *enter* and *exit* methods.\n&#039;
             &#039;\n&#039;
             &#039;The following code:\n&#039;
             &#039;\n&#039;
             &#039;   async with EXPR as VAR:\n&#039;
             &#039;       BLOCK\n&#039;
             &#039;\n&#039;
             &#039;Is semantically equivalent to:\n&#039;
             &#039;\n&#039;
             &#039;   mgr = (EXPR)\n&#039;
             &#039;   aexit = type(mgr).__aexit__\n&#039;
             &#039;   aenter = type(mgr).__aenter__(mgr)\n&#039;
             &#039;\n&#039;
             &#039;   VAR = await aenter\n&#039;
             &#039;   try:\n&#039;
             &#039;       BLOCK\n&#039;
             &#039;   except:\n&#039;
             &#039;       if not await aexit(mgr, *sys.exc_info()):\n&#039;
             &#039;           raise\n&#039;
             &#039;   else:\n&#039;
             &#039;       await aexit(mgr, None, None, None)\n&#039;
             &#039;\n&#039;
             &#039;See also &quot;__aenter__()&quot; and &quot;__aexit__()&quot; for details.\n&#039;
             &#039;\n&#039;
             &#039;It is a &quot;SyntaxError&quot; to use &quot;async with&quot; statement outside of &#039;
             &#039;an\n&#039;
             &#039;&quot;async def&quot; function.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 492** - Coroutines with async and await syntax\n&#039;
             &#039;     The proposal that made coroutines a proper standalone &#039;
             &#039;concept in\n&#039;
             &#039;     Python, and added supporting syntax.\n&#039;
             &#039;\n&#039;
             &#039;-[ Footnotes ]-\n&#039;
             &#039;\n&#039;
             &#039;[1] The exception is propagated to the invocation stack unless\n&#039;
             &#039;    there is a &quot;finally&quot; clause which happens to raise another\n&#039;
             &#039;    exception. That new exception causes the old one to be &#039;
             &#039;lost.\n&#039;
             &#039;\n&#039;
             &#039;[2] A string literal appearing as the first statement in the\n&#039;
             &#039;    function body is transformed into the function’s &quot;__doc__&quot;\n&#039;
             &#039;    attribute and therefore the function’s *docstring*.\n&#039;
             &#039;\n&#039;
             &#039;[3] A string literal appearing as the first statement in the &#039;
             &#039;class\n&#039;
             &#039;    body is transformed into the namespace’s &quot;__doc__&quot; item and\n&#039;
             &#039;    therefore the class’s *docstring*.\n&#039;,
 &#039;context-managers&#039;: &#039;With Statement Context Managers\n&#039;
                     &#039;*******************************\n&#039;
                     &#039;\n&#039;
                     &#039;A *context manager* is an object that defines the &#039;
                     &#039;runtime context to\n&#039;
                     &#039;be established when executing a &quot;with&quot; statement. The &#039;
                     &#039;context manager\n&#039;
                     &#039;handles the entry into, and the exit from, the desired &#039;
                     &#039;runtime context\n&#039;
                     &#039;for the execution of the block of code.  Context &#039;
                     &#039;managers are normally\n&#039;
                     &#039;invoked using the &quot;with&quot; statement (described in section &#039;
                     &#039;The with\n&#039;
                     &#039;statement), but can also be used by directly invoking &#039;
                     &#039;their methods.\n&#039;
                     &#039;\n&#039;
                     &#039;Typical uses of context managers include saving and &#039;
                     &#039;restoring various\n&#039;
                     &#039;kinds of global state, locking and unlocking resources, &#039;
                     &#039;closing opened\n&#039;
                     &#039;files, etc.\n&#039;
                     &#039;\n&#039;
                     &#039;For more information on context managers, see Context &#039;
                     &#039;Manager Types.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__enter__(self)\n&#039;
                     &#039;\n&#039;
                     &#039;   Enter the runtime context related to this object. The &#039;
                     &#039;&quot;with&quot;\n&#039;
                     &#039;   statement will bind this method’s return value to the &#039;
                     &#039;target(s)\n&#039;
                     &#039;   specified in the &quot;as&quot; clause of the statement, if &#039;
                     &#039;any.\n&#039;
                     &#039;\n&#039;
                     &#039;object.__exit__(self, exc_type, exc_value, traceback)\n&#039;
                     &#039;\n&#039;
                     &#039;   Exit the runtime context related to this object. The &#039;
                     &#039;parameters\n&#039;
                     &#039;   describe the exception that caused the context to be &#039;
                     &#039;exited. If the\n&#039;
                     &#039;   context was exited without an exception, all three &#039;
                     &#039;arguments will\n&#039;
                     &#039;   be &quot;None&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;   If an exception is supplied, and the method wishes to &#039;
                     &#039;suppress the\n&#039;
                     &#039;   exception (i.e., prevent it from being propagated), &#039;
                     &#039;it should\n&#039;
                     &#039;   return a true value. Otherwise, the exception will be &#039;
                     &#039;processed\n&#039;
                     &#039;   normally upon exit from this method.\n&#039;
                     &#039;\n&#039;
                     &#039;   Note that &quot;__exit__()&quot; methods should not reraise the &#039;
                     &#039;passed-in\n&#039;
                     &#039;   exception; this is the caller’s responsibility.\n&#039;
                     &#039;\n&#039;
                     &#039;See also:\n&#039;
                     &#039;\n&#039;
                     &#039;  **PEP 343** - The “with” statement\n&#039;
                     &#039;     The specification, background, and examples for the &#039;
                     &#039;Python &quot;with&quot;\n&#039;
                     &#039;     statement.\n&#039;,
 &#039;continue&#039;: &#039;The &quot;continue&quot; statement\n&#039;
             &#039;************************\n&#039;
             &#039;\n&#039;
             &#039;   continue_stmt ::= &quot;continue&quot;\n&#039;
             &#039;\n&#039;
             &#039;&quot;continue&quot; may only occur syntactically nested in a &quot;for&quot; or &#039;
             &#039;&quot;while&quot;\n&#039;
             &#039;loop, but not nested in a function or class definition or &#039;
             &#039;&quot;finally&quot;\n&#039;
             &#039;clause within that loop.  It continues with the next cycle of &#039;
             &#039;the\n&#039;
             &#039;nearest enclosing loop.\n&#039;
             &#039;\n&#039;
             &#039;When &quot;continue&quot; passes control out of a &quot;try&quot; statement with a\n&#039;
             &#039;&quot;finally&quot; clause, that &quot;finally&quot; clause is executed before &#039;
             &#039;really\n&#039;
             &#039;starting the next loop cycle.\n&#039;,
 &#039;conversions&#039;: &#039;Arithmetic conversions\n&#039;
                &#039;**********************\n&#039;
                &#039;\n&#039;
                &#039;When a description of an arithmetic operator below uses the &#039;
                &#039;phrase\n&#039;
                &#039;“the numeric arguments are converted to a common type,” this &#039;
                &#039;means\n&#039;
                &#039;that the operator implementation for built-in types works as &#039;
                &#039;follows:\n&#039;
                &#039;\n&#039;
                &#039;* If either argument is a complex number, the other is &#039;
                &#039;converted to\n&#039;
                &#039;  complex;\n&#039;
                &#039;\n&#039;
                &#039;* otherwise, if either argument is a floating point number, &#039;
                &#039;the\n&#039;
                &#039;  other is converted to floating point;\n&#039;
                &#039;\n&#039;
                &#039;* otherwise, both must be integers and no conversion is &#039;
                &#039;necessary.\n&#039;
                &#039;\n&#039;
                &#039;Some additional rules apply for certain operators (e.g., a &#039;
                &#039;string as a\n&#039;
                &#039;left argument to the ‘%’ operator).  Extensions must define &#039;
                &#039;their own\n&#039;
                &#039;conversion behavior.\n&#039;,
 &#039;customization&#039;: &#039;Basic customization\n&#039;
                  &#039;*******************\n&#039;
                  &#039;\n&#039;
                  &#039;object.__new__(cls[, ...])\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to create a new instance of class *cls*.  &#039;
                  &#039;&quot;__new__()&quot; is a\n&#039;
                  &#039;   static method (special-cased so you need not declare it &#039;
                  &#039;as such)\n&#039;
                  &#039;   that takes the class of which an instance was requested &#039;
                  &#039;as its\n&#039;
                  &#039;   first argument.  The remaining arguments are those &#039;
                  &#039;passed to the\n&#039;
                  &#039;   object constructor expression (the call to the class).  &#039;
                  &#039;The return\n&#039;
                  &#039;   value of &quot;__new__()&quot; should be the new object instance &#039;
                  &#039;(usually an\n&#039;
                  &#039;   instance of *cls*).\n&#039;
                  &#039;\n&#039;
                  &#039;   Typical implementations create a new instance of the &#039;
                  &#039;class by\n&#039;
                  &#039;   invoking the superclass’s &quot;__new__()&quot; method using\n&#039;
                  &#039;   &quot;super().__new__(cls[, ...])&quot; with appropriate arguments &#039;
                  &#039;and then\n&#039;
                  &#039;   modifying the newly-created instance as necessary before &#039;
                  &#039;returning\n&#039;
                  &#039;   it.\n&#039;
                  &#039;\n&#039;
                  &#039;   If &quot;__new__()&quot; returns an instance of *cls*, then the &#039;
                  &#039;new\n&#039;
                  &#039;   instance’s &quot;__init__()&quot; method will be invoked like\n&#039;
                  &#039;   &quot;__init__(self[, ...])&quot;, where *self* is the new &#039;
                  &#039;instance and the\n&#039;
                  &#039;   remaining arguments are the same as were passed to &#039;
                  &#039;&quot;__new__()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   If &quot;__new__()&quot; does not return an instance of *cls*, &#039;
                  &#039;then the new\n&#039;
                  &#039;   instance’s &quot;__init__()&quot; method will not be invoked.\n&#039;
                  &#039;\n&#039;
                  &#039;   &quot;__new__()&quot; is intended mainly to allow subclasses of &#039;
                  &#039;immutable\n&#039;
                  &#039;   types (like int, str, or tuple) to customize instance &#039;
                  &#039;creation.  It\n&#039;
                  &#039;   is also commonly overridden in custom metaclasses in &#039;
                  &#039;order to\n&#039;
                  &#039;   customize class creation.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__init__(self[, ...])\n&#039;
                  &#039;\n&#039;
                  &#039;   Called after the instance has been created (by &#039;
                  &#039;&quot;__new__()&quot;), but\n&#039;
                  &#039;   before it is returned to the caller.  The arguments are &#039;
                  &#039;those\n&#039;
                  &#039;   passed to the class constructor expression.  If a base &#039;
                  &#039;class has an\n&#039;
                  &#039;   &quot;__init__()&quot; method, the derived class’s &quot;__init__()&quot; &#039;
                  &#039;method, if\n&#039;
                  &#039;   any, must explicitly call it to ensure proper &#039;
                  &#039;initialization of the\n&#039;
                  &#039;   base class part of the instance; for example:\n&#039;
                  &#039;   &quot;super().__init__([args...])&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   Because &quot;__new__()&quot; and &quot;__init__()&quot; work together in &#039;
                  &#039;constructing\n&#039;
                  &#039;   objects (&quot;__new__()&quot; to create it, and &quot;__init__()&quot; to &#039;
                  &#039;customize\n&#039;
                  &#039;   it), no non-&quot;None&quot; value may be returned by &#039;
                  &#039;&quot;__init__()&quot;; doing so\n&#039;
                  &#039;   will cause a &quot;TypeError&quot; to be raised at runtime.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__del__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called when the instance is about to be destroyed.  This &#039;
                  &#039;is also\n&#039;
                  &#039;   called a finalizer or (improperly) a destructor.  If a &#039;
                  &#039;base class\n&#039;
                  &#039;   has a &quot;__del__()&quot; method, the derived class’s &#039;
                  &#039;&quot;__del__()&quot; method,\n&#039;
                  &#039;   if any, must explicitly call it to ensure proper &#039;
                  &#039;deletion of the\n&#039;
                  &#039;   base class part of the instance.\n&#039;
                  &#039;\n&#039;
                  &#039;   It is possible (though not recommended!) for the &#039;
                  &#039;&quot;__del__()&quot; method\n&#039;
                  &#039;   to postpone destruction of the instance by creating a &#039;
                  &#039;new reference\n&#039;
                  &#039;   to it.  This is called object *resurrection*.  It is\n&#039;
                  &#039;   implementation-dependent whether &quot;__del__()&quot; is called a &#039;
                  &#039;second\n&#039;
                  &#039;   time when a resurrected object is about to be destroyed; &#039;
                  &#039;the\n&#039;
                  &#039;   current *CPython* implementation only calls it once.\n&#039;
                  &#039;\n&#039;
                  &#039;   It is not guaranteed that &quot;__del__()&quot; methods are called &#039;
                  &#039;for\n&#039;
                  &#039;   objects that still exist when the interpreter exits.\n&#039;
                  &#039;\n&#039;
                  &#039;   Note: &quot;del x&quot; doesn’t directly call &quot;x.__del__()&quot; — the &#039;
                  &#039;former\n&#039;
                  &#039;     decrements the reference count for &quot;x&quot; by one, and the &#039;
                  &#039;latter is\n&#039;
                  &#039;     only called when &quot;x&quot;’s reference count reaches zero.\n&#039;
                  &#039;\n&#039;
                  &#039;   **CPython implementation detail:** It is possible for a &#039;
                  &#039;reference\n&#039;
                  &#039;   cycle to prevent the reference count of an object from &#039;
                  &#039;going to\n&#039;
                  &#039;   zero.  In this case, the cycle will be later detected &#039;
                  &#039;and deleted\n&#039;
                  &#039;   by the *cyclic garbage collector*.  A common cause of &#039;
                  &#039;reference\n&#039;
                  &#039;   cycles is when an exception has been caught in a local &#039;
                  &#039;variable.\n&#039;
                  &#039;   The frame’s locals then reference the exception, which &#039;
                  &#039;references\n&#039;
                  &#039;   its own traceback, which references the locals of all &#039;
                  &#039;frames caught\n&#039;
                  &#039;   in the traceback.\n&#039;
                  &#039;\n&#039;
                  &#039;   See also: Documentation for the &quot;gc&quot; module.\n&#039;
                  &#039;\n&#039;
                  &#039;   Warning: Due to the precarious circumstances under &#039;
                  &#039;which\n&#039;
                  &#039;     &quot;__del__()&quot; methods are invoked, exceptions that occur &#039;
                  &#039;during\n&#039;
                  &#039;     their execution are ignored, and a warning is printed &#039;
                  &#039;to\n&#039;
                  &#039;     &quot;sys.stderr&quot; instead. In particular:\n&#039;
                  &#039;\n&#039;
                  &#039;     * &quot;__del__()&quot; can be invoked when arbitrary code is &#039;
                  &#039;being\n&#039;
                  &#039;       executed, including from any arbitrary thread.  If &#039;
                  &#039;&quot;__del__()&quot;\n&#039;
                  &#039;       needs to take a lock or invoke any other blocking &#039;
                  &#039;resource, it\n&#039;
                  &#039;       may deadlock as the resource may already be taken by &#039;
                  &#039;the code\n&#039;
                  &#039;       that gets interrupted to execute &quot;__del__()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;     * &quot;__del__()&quot; can be executed during interpreter &#039;
                  &#039;shutdown.  As\n&#039;
                  &#039;       a consequence, the global variables it needs to &#039;
                  &#039;access\n&#039;
                  &#039;       (including other modules) may already have been &#039;
                  &#039;deleted or set\n&#039;
                  &#039;       to &quot;None&quot;. Python guarantees that globals whose name &#039;
                  &#039;begins\n&#039;
                  &#039;       with a single underscore are deleted from their &#039;
                  &#039;module before\n&#039;
                  &#039;       other globals are deleted; if no other references to &#039;
                  &#039;such\n&#039;
                  &#039;       globals exist, this may help in assuring that &#039;
                  &#039;imported modules\n&#039;
                  &#039;       are still available at the time when the &quot;__del__()&quot; &#039;
                  &#039;method is\n&#039;
                  &#039;       called.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__repr__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by the &quot;repr()&quot; built-in function to compute the &#039;
                  &#039;“official”\n&#039;
                  &#039;   string representation of an object.  If at all possible, &#039;
                  &#039;this\n&#039;
                  &#039;   should look like a valid Python expression that could be &#039;
                  &#039;used to\n&#039;
                  &#039;   recreate an object with the same value (given an &#039;
                  &#039;appropriate\n&#039;
                  &#039;   environment).  If this is not possible, a string of the &#039;
                  &#039;form\n&#039;
                  &#039;   &quot;&lt;...some useful description...&gt;&quot; should be returned. &#039;
                  &#039;The return\n&#039;
                  &#039;   value must be a string object. If a class defines &#039;
                  &#039;&quot;__repr__()&quot; but\n&#039;
                  &#039;   not &quot;__str__()&quot;, then &quot;__repr__()&quot; is also used when an &#039;
                  &#039;“informal”\n&#039;
                  &#039;   string representation of instances of that class is &#039;
                  &#039;required.\n&#039;
                  &#039;\n&#039;
                  &#039;   This is typically used for debugging, so it is important &#039;
                  &#039;that the\n&#039;
                  &#039;   representation is information-rich and unambiguous.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__str__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by &quot;str(object)&quot; and the built-in functions &#039;
                  &#039;&quot;format()&quot; and\n&#039;
                  &#039;   &quot;print()&quot; to compute the “informal” or nicely printable &#039;
                  &#039;string\n&#039;
                  &#039;   representation of an object.  The return value must be a &#039;
                  &#039;string\n&#039;
                  &#039;   object.\n&#039;
                  &#039;\n&#039;
                  &#039;   This method differs from &quot;object.__repr__()&quot; in that &#039;
                  &#039;there is no\n&#039;
                  &#039;   expectation that &quot;__str__()&quot; return a valid Python &#039;
                  &#039;expression: a\n&#039;
                  &#039;   more convenient or concise representation can be used.\n&#039;
                  &#039;\n&#039;
                  &#039;   The default implementation defined by the built-in type &#039;
                  &#039;&quot;object&quot;\n&#039;
                  &#039;   calls &quot;object.__repr__()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__bytes__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by bytes to compute a byte-string representation &#039;
                  &#039;of an\n&#039;
                  &#039;   object. This should return a &quot;bytes&quot; object.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__format__(self, format_spec)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by the &quot;format()&quot; built-in function, and by &#039;
                  &#039;extension,\n&#039;
                  &#039;   evaluation of formatted string literals and the &#039;
                  &#039;&quot;str.format()&quot;\n&#039;
                  &#039;   method, to produce a “formatted” string representation &#039;
                  &#039;of an\n&#039;
                  &#039;   object. The &quot;format_spec&quot; argument is a string that &#039;
                  &#039;contains a\n&#039;
                  &#039;   description of the formatting options desired. The &#039;
                  &#039;interpretation\n&#039;
                  &#039;   of the &quot;format_spec&quot; argument is up to the type &#039;
                  &#039;implementing\n&#039;
                  &#039;   &quot;__format__()&quot;, however most classes will either &#039;
                  &#039;delegate\n&#039;
                  &#039;   formatting to one of the built-in types, or use a &#039;
                  &#039;similar\n&#039;
                  &#039;   formatting option syntax.\n&#039;
                  &#039;\n&#039;
                  &#039;   See Format Specification Mini-Language for a description &#039;
                  &#039;of the\n&#039;
                  &#039;   standard formatting syntax.\n&#039;
                  &#039;\n&#039;
                  &#039;   The return value must be a string object.\n&#039;
                  &#039;\n&#039;
                  &#039;   Changed in version 3.4: The __format__ method of &#039;
                  &#039;&quot;object&quot; itself\n&#039;
                  &#039;   raises a &quot;TypeError&quot; if passed any non-empty string.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__lt__(self, other)\n&#039;
                  &#039;object.__le__(self, other)\n&#039;
                  &#039;object.__eq__(self, other)\n&#039;
                  &#039;object.__ne__(self, other)\n&#039;
                  &#039;object.__gt__(self, other)\n&#039;
                  &#039;object.__ge__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   These are the so-called “rich comparison” methods. The\n&#039;
                  &#039;   correspondence between operator symbols and method names &#039;
                  &#039;is as\n&#039;
                  &#039;   follows: &quot;x&lt;y&quot; calls &quot;x.__lt__(y)&quot;, &quot;x&lt;=y&quot; calls &#039;
                  &#039;&quot;x.__le__(y)&quot;,\n&#039;
                  &#039;   &quot;x==y&quot; calls &quot;x.__eq__(y)&quot;, &quot;x!=y&quot; calls &quot;x.__ne__(y)&quot;, &#039;
                  &#039;&quot;x&gt;y&quot; calls\n&#039;
                  &#039;   &quot;x.__gt__(y)&quot;, and &quot;x&gt;=y&quot; calls &quot;x.__ge__(y)&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   A rich comparison method may return the singleton &#039;
                  &#039;&quot;NotImplemented&quot;\n&#039;
                  &#039;   if it does not implement the operation for a given pair &#039;
                  &#039;of\n&#039;
                  &#039;   arguments. By convention, &quot;False&quot; and &quot;True&quot; are &#039;
                  &#039;returned for a\n&#039;
                  &#039;   successful comparison. However, these methods can return &#039;
                  &#039;any value,\n&#039;
                  &#039;   so if the comparison operator is used in a Boolean &#039;
                  &#039;context (e.g.,\n&#039;
                  &#039;   in the condition of an &quot;if&quot; statement), Python will call &#039;
                  &#039;&quot;bool()&quot;\n&#039;
                  &#039;   on the value to determine if the result is true or &#039;
                  &#039;false.\n&#039;
                  &#039;\n&#039;
                  &#039;   By default, &quot;__ne__()&quot; delegates to &quot;__eq__()&quot; and &#039;
                  &#039;inverts the\n&#039;
                  &#039;   result unless it is &quot;NotImplemented&quot;.  There are no &#039;
                  &#039;other implied\n&#039;
                  &#039;   relationships among the comparison operators, for &#039;
                  &#039;example, the\n&#039;
                  &#039;   truth of &quot;(x&lt;y or x==y)&quot; does not imply &quot;x&lt;=y&quot;. To &#039;
                  &#039;automatically\n&#039;
                  &#039;   generate ordering operations from a single root &#039;
                  &#039;operation, see\n&#039;
                  &#039;   &quot;functools.total_ordering()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   See the paragraph on &quot;__hash__()&quot; for some important &#039;
                  &#039;notes on\n&#039;
                  &#039;   creating *hashable* objects which support custom &#039;
                  &#039;comparison\n&#039;
                  &#039;   operations and are usable as dictionary keys.\n&#039;
                  &#039;\n&#039;
                  &#039;   There are no swapped-argument versions of these methods &#039;
                  &#039;(to be used\n&#039;
                  &#039;   when the left argument does not support the operation &#039;
                  &#039;but the right\n&#039;
                  &#039;   argument does); rather, &quot;__lt__()&quot; and &quot;__gt__()&quot; are &#039;
                  &#039;each other’s\n&#039;
                  &#039;   reflection, &quot;__le__()&quot; and &quot;__ge__()&quot; are each other’s &#039;
                  &#039;reflection,\n&#039;
                  &#039;   and &quot;__eq__()&quot; and &quot;__ne__()&quot; are their own reflection. &#039;
                  &#039;If the\n&#039;
                  &#039;   operands are of different types, and right operand’s &#039;
                  &#039;type is a\n&#039;
                  &#039;   direct or indirect subclass of the left operand’s type, &#039;
                  &#039;the\n&#039;
                  &#039;   reflected method of the right operand has priority, &#039;
                  &#039;otherwise the\n&#039;
                  &#039;   left operand’s method has priority.  Virtual subclassing &#039;
                  &#039;is not\n&#039;
                  &#039;   considered.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__hash__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by built-in function &quot;hash()&quot; and for operations &#039;
                  &#039;on members\n&#039;
                  &#039;   of hashed collections including &quot;set&quot;, &quot;frozenset&quot;, and &#039;
                  &#039;&quot;dict&quot;.\n&#039;
                  &#039;   &quot;__hash__()&quot; should return an integer. The only required &#039;
                  &#039;property\n&#039;
                  &#039;   is that objects which compare equal have the same hash &#039;
                  &#039;value; it is\n&#039;
                  &#039;   advised to mix together the hash values of the &#039;
                  &#039;components of the\n&#039;
                  &#039;   object that also play a part in comparison of objects by &#039;
                  &#039;packing\n&#039;
                  &#039;   them into a tuple and hashing the tuple. Example:\n&#039;
                  &#039;\n&#039;
                  &#039;      def __hash__(self):\n&#039;
                  &#039;          return hash((self.name, self.nick, self.color))\n&#039;
                  &#039;\n&#039;
                  &#039;   Note: &quot;hash()&quot; truncates the value returned from an &#039;
                  &#039;object’s\n&#039;
                  &#039;     custom &quot;__hash__()&quot; method to the size of a &#039;
                  &#039;&quot;Py_ssize_t&quot;.  This\n&#039;
                  &#039;     is typically 8 bytes on 64-bit builds and 4 bytes on &#039;
                  &#039;32-bit\n&#039;
                  &#039;     builds. If an object’s   &quot;__hash__()&quot; must &#039;
                  &#039;interoperate on builds\n&#039;
                  &#039;     of different bit sizes, be sure to check the width on &#039;
                  &#039;all\n&#039;
                  &#039;     supported builds.  An easy way to do this is with &#039;
                  &#039;&quot;python -c\n&#039;
                  &#039;     &quot;import sys; print(sys.hash_info.width)&quot;&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   If a class does not define an &quot;__eq__()&quot; method it &#039;
                  &#039;should not\n&#039;
                  &#039;   define a &quot;__hash__()&quot; operation either; if it defines &#039;
                  &#039;&quot;__eq__()&quot;\n&#039;
                  &#039;   but not &quot;__hash__()&quot;, its instances will not be usable &#039;
                  &#039;as items in\n&#039;
                  &#039;   hashable collections.  If a class defines mutable &#039;
                  &#039;objects and\n&#039;
                  &#039;   implements an &quot;__eq__()&quot; method, it should not &#039;
                  &#039;implement\n&#039;
                  &#039;   &quot;__hash__()&quot;, since the implementation of hashable &#039;
                  &#039;collections\n&#039;
                  &#039;   requires that a key’s hash value is immutable (if the &#039;
                  &#039;object’s hash\n&#039;
                  &#039;   value changes, it will be in the wrong hash bucket).\n&#039;
                  &#039;\n&#039;
                  &#039;   User-defined classes have &quot;__eq__()&quot; and &quot;__hash__()&quot; &#039;
                  &#039;methods by\n&#039;
                  &#039;   default; with them, all objects compare unequal (except &#039;
                  &#039;with\n&#039;
                  &#039;   themselves) and &quot;x.__hash__()&quot; returns an appropriate &#039;
                  &#039;value such\n&#039;
                  &#039;   that &quot;x == y&quot; implies both that &quot;x is y&quot; and &quot;hash(x) == &#039;
                  &#039;hash(y)&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   A class that overrides &quot;__eq__()&quot; and does not define &#039;
                  &#039;&quot;__hash__()&quot;\n&#039;
                  &#039;   will have its &quot;__hash__()&quot; implicitly set to &quot;None&quot;.  &#039;
                  &#039;When the\n&#039;
                  &#039;   &quot;__hash__()&quot; method of a class is &quot;None&quot;, instances of &#039;
                  &#039;the class\n&#039;
                  &#039;   will raise an appropriate &quot;TypeError&quot; when a program &#039;
                  &#039;attempts to\n&#039;
                  &#039;   retrieve their hash value, and will also be correctly &#039;
                  &#039;identified as\n&#039;
                  &#039;   unhashable when checking &quot;isinstance(obj, &#039;
                  &#039;collections.Hashable)&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   If a class that overrides &quot;__eq__()&quot; needs to retain &#039;
                  &#039;the\n&#039;
                  &#039;   implementation of &quot;__hash__()&quot; from a parent class, the &#039;
                  &#039;interpreter\n&#039;
                  &#039;   must be told this explicitly by setting &quot;__hash__ =\n&#039;
                  &#039;   &lt;ParentClass&gt;.__hash__&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   If a class that does not override &quot;__eq__()&quot; wishes to &#039;
                  &#039;suppress\n&#039;
                  &#039;   hash support, it should include &quot;__hash__ = None&quot; in the &#039;
                  &#039;class\n&#039;
                  &#039;   definition. A class which defines its own &quot;__hash__()&quot; &#039;
                  &#039;that\n&#039;
                  &#039;   explicitly raises a &quot;TypeError&quot; would be incorrectly &#039;
                  &#039;identified as\n&#039;
                  &#039;   hashable by an &quot;isinstance(obj, collections.Hashable)&quot; &#039;
                  &#039;call.\n&#039;
                  &#039;\n&#039;
                  &#039;   Note: By default, the &quot;__hash__()&quot; values of str, bytes &#039;
                  &#039;and\n&#039;
                  &#039;     datetime objects are “salted” with an unpredictable &#039;
                  &#039;random value.\n&#039;
                  &#039;     Although they remain constant within an individual &#039;
                  &#039;Python\n&#039;
                  &#039;     process, they are not predictable between repeated &#039;
                  &#039;invocations of\n&#039;
                  &#039;     Python.This is intended to provide protection against &#039;
                  &#039;a denial-\n&#039;
                  &#039;     of-service caused by carefully-chosen inputs that &#039;
                  &#039;exploit the\n&#039;
                  &#039;     worst case performance of a dict insertion, O(n^2) &#039;
                  &#039;complexity.\n&#039;
                  &#039;     See &#039;
                  &#039;http://www.ocert.org/advisories/ocert-2011-003.html for\n&#039;
                  &#039;     details.Changing hash values affects the iteration &#039;
                  &#039;order of\n&#039;
                  &#039;     dicts, sets and other mappings.  Python has never made &#039;
                  &#039;guarantees\n&#039;
                  &#039;     about this ordering (and it typically varies between &#039;
                  &#039;32-bit and\n&#039;
                  &#039;     64-bit builds).See also &quot;PYTHONHASHSEED&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   Changed in version 3.3: Hash randomization is enabled by &#039;
                  &#039;default.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__bool__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement truth value testing and the built-in &#039;
                  &#039;operation\n&#039;
                  &#039;   &quot;bool()&quot;; should return &quot;False&quot; or &quot;True&quot;.  When this &#039;
                  &#039;method is not\n&#039;
                  &#039;   defined, &quot;__len__()&quot; is called, if it is defined, and &#039;
                  &#039;the object is\n&#039;
                  &#039;   considered true if its result is nonzero.  If a class &#039;
                  &#039;defines\n&#039;
                  &#039;   neither &quot;__len__()&quot; nor &quot;__bool__()&quot;, all its instances &#039;
                  &#039;are\n&#039;
                  &#039;   considered true.\n&#039;,
 &#039;debugger&#039;: &#039;&quot;pdb&quot; — The Python Debugger\n&#039;
             &#039;***************************\n&#039;
             &#039;\n&#039;
             &#039;**Source code:** Lib/pdb.py\n&#039;
             &#039;\n&#039;
             &#039;======================================================================\n&#039;
             &#039;\n&#039;
             &#039;The module &quot;pdb&quot; defines an interactive source code debugger &#039;
             &#039;for\n&#039;
             &#039;Python programs.  It supports setting (conditional) breakpoints &#039;
             &#039;and\n&#039;
             &#039;single stepping at the source line level, inspection of stack &#039;
             &#039;frames,\n&#039;
             &#039;source code listing, and evaluation of arbitrary Python code in &#039;
             &#039;the\n&#039;
             &#039;context of any stack frame.  It also supports post-mortem &#039;
             &#039;debugging\n&#039;
             &#039;and can be called under program control.\n&#039;
             &#039;\n&#039;
             &#039;The debugger is extensible – it is actually defined as the &#039;
             &#039;class\n&#039;
             &#039;&quot;Pdb&quot;. This is currently undocumented but easily understood by &#039;
             &#039;reading\n&#039;
             &#039;the source.  The extension interface uses the modules &quot;bdb&quot; and &#039;
             &#039;&quot;cmd&quot;.\n&#039;
             &#039;\n&#039;
             &#039;The debugger’s prompt is &quot;(Pdb)&quot;. Typical usage to run a program &#039;
             &#039;under\n&#039;
             &#039;control of the debugger is:\n&#039;
             &#039;\n&#039;
             &#039;   &gt;&gt;&gt; import pdb\n&#039;
             &#039;   &gt;&gt;&gt; import mymodule\n&#039;
             &quot;   &gt;&gt;&gt; pdb.run(&#039;mymodule.test()&#039;)\n&quot;
             &#039;   &gt; &lt;string&gt;(0)?()\n&#039;
             &#039;   (Pdb) continue\n&#039;
             &#039;   &gt; &lt;string&gt;(1)?()\n&#039;
             &#039;   (Pdb) continue\n&#039;
             &quot;   NameError: &#039;spam&#039;\n&quot;
             &#039;   &gt; &lt;string&gt;(1)?()\n&#039;
             &#039;   (Pdb)\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.3: Tab-completion via the &quot;readline&quot; module &#039;
             &#039;is\n&#039;
             &#039;available for commands and command arguments, e.g. the current &#039;
             &#039;global\n&#039;
             &#039;and local names are offered as arguments of the &quot;p&quot; command.\n&#039;
             &#039;\n&#039;
             &#039;&quot;pdb.py&quot; can also be invoked as a script to debug other &#039;
             &#039;scripts.  For\n&#039;
             &#039;example:\n&#039;
             &#039;\n&#039;
             &#039;   python3 -m pdb myscript.py\n&#039;
             &#039;\n&#039;
             &#039;When invoked as a script, pdb will automatically enter &#039;
             &#039;post-mortem\n&#039;
             &#039;debugging if the program being debugged exits abnormally.  After &#039;
             &#039;post-\n&#039;
             &#039;mortem debugging (or after normal exit of the program), pdb &#039;
             &#039;will\n&#039;
             &#039;restart the program.  Automatic restarting preserves pdb’s state &#039;
             &#039;(such\n&#039;
             &#039;as breakpoints) and in most cases is more useful than quitting &#039;
             &#039;the\n&#039;
             &#039;debugger upon program’s exit.\n&#039;
             &#039;\n&#039;
             &#039;New in version 3.2: &quot;pdb.py&quot; now accepts a &quot;-c&quot; option that &#039;
             &#039;executes\n&#039;
             &#039;commands as if given in a &quot;.pdbrc&quot; file, see Debugger Commands.\n&#039;
             &#039;\n&#039;
             &#039;The typical usage to break into the debugger from a running &#039;
             &#039;program is\n&#039;
             &#039;to insert\n&#039;
             &#039;\n&#039;
             &#039;   import pdb; pdb.set_trace()\n&#039;
             &#039;\n&#039;
             &#039;at the location you want to break into the debugger.  You can &#039;
             &#039;then\n&#039;
             &#039;step through the code following this statement, and continue &#039;
             &#039;running\n&#039;
             &#039;without the debugger using the &quot;continue&quot; command.\n&#039;
             &#039;\n&#039;
             &#039;The typical usage to inspect a crashed program is:\n&#039;
             &#039;\n&#039;
             &#039;   &gt;&gt;&gt; import pdb\n&#039;
             &#039;   &gt;&gt;&gt; import mymodule\n&#039;
             &#039;   &gt;&gt;&gt; mymodule.test()\n&#039;
             &#039;   Traceback (most recent call last):\n&#039;
             &#039;     File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;\n&#039;
             &#039;     File &quot;./mymodule.py&quot;, line 4, in test\n&#039;
             &#039;       test2()\n&#039;
             &#039;     File &quot;./mymodule.py&quot;, line 3, in test2\n&#039;
             &#039;       print(spam)\n&#039;
             &#039;   NameError: spam\n&#039;
             &#039;   &gt;&gt;&gt; pdb.pm()\n&#039;
             &#039;   &gt; ./mymodule.py(3)test2()\n&#039;
             &#039;   -&gt; print(spam)\n&#039;
             &#039;   (Pdb)\n&#039;
             &#039;\n&#039;
             &#039;The module defines the following functions; each enters the &#039;
             &#039;debugger\n&#039;
             &#039;in a slightly different way:\n&#039;
             &#039;\n&#039;
             &#039;pdb.run(statement, globals=None, locals=None)\n&#039;
             &#039;\n&#039;
             &#039;   Execute the *statement* (given as a string or a code object) &#039;
             &#039;under\n&#039;
             &#039;   debugger control.  The debugger prompt appears before any &#039;
             &#039;code is\n&#039;
             &#039;   executed; you can set breakpoints and type &quot;continue&quot;, or you &#039;
             &#039;can\n&#039;
             &#039;   step through the statement using &quot;step&quot; or &quot;next&quot; (all these\n&#039;
             &#039;   commands are explained below).  The optional *globals* and &#039;
             &#039;*locals*\n&#039;
             &#039;   arguments specify the environment in which the code is &#039;
             &#039;executed; by\n&#039;
             &#039;   default the dictionary of the module &quot;__main__&quot; is used.  &#039;
             &#039;(See the\n&#039;
             &#039;   explanation of the built-in &quot;exec()&quot; or &quot;eval()&quot; functions.)\n&#039;
             &#039;\n&#039;
             &#039;pdb.runeval(expression, globals=None, locals=None)\n&#039;
             &#039;\n&#039;
             &#039;   Evaluate the *expression* (given as a string or a code &#039;
             &#039;object)\n&#039;
             &#039;   under debugger control.  When &quot;runeval()&quot; returns, it returns &#039;
             &#039;the\n&#039;
             &#039;   value of the expression.  Otherwise this function is similar &#039;
             &#039;to\n&#039;
             &#039;   &quot;run()&quot;.\n&#039;
             &#039;\n&#039;
             &#039;pdb.runcall(function, *args, **kwds)\n&#039;
             &#039;\n&#039;
             &#039;   Call the *function* (a function or method object, not a &#039;
             &#039;string)\n&#039;
             &#039;   with the given arguments.  When &quot;runcall()&quot; returns, it &#039;
             &#039;returns\n&#039;
             &#039;   whatever the function call returned.  The debugger prompt &#039;
             &#039;appears\n&#039;
             &#039;   as soon as the function is entered.\n&#039;
             &#039;\n&#039;
             &#039;pdb.set_trace()\n&#039;
             &#039;\n&#039;
             &#039;   Enter the debugger at the calling stack frame.  This is &#039;
             &#039;useful to\n&#039;
             &#039;   hard-code a breakpoint at a given point in a program, even if &#039;
             &#039;the\n&#039;
             &#039;   code is not otherwise being debugged (e.g. when an assertion\n&#039;
             &#039;   fails).\n&#039;
             &#039;\n&#039;
             &#039;pdb.post_mortem(traceback=None)\n&#039;
             &#039;\n&#039;
             &#039;   Enter post-mortem debugging of the given *traceback* object.  &#039;
             &#039;If no\n&#039;
             &#039;   *traceback* is given, it uses the one of the exception that &#039;
             &#039;is\n&#039;
             &#039;   currently being handled (an exception must be being handled &#039;
             &#039;if the\n&#039;
             &#039;   default is to be used).\n&#039;
             &#039;\n&#039;
             &#039;pdb.pm()\n&#039;
             &#039;\n&#039;
             &#039;   Enter post-mortem debugging of the traceback found in\n&#039;
             &#039;   &quot;sys.last_traceback&quot;.\n&#039;
             &#039;\n&#039;
             &#039;The &quot;run*&quot; functions and &quot;set_trace()&quot; are aliases for &#039;
             &#039;instantiating\n&#039;
             &#039;the &quot;Pdb&quot; class and calling the method of the same name.  If you &#039;
             &#039;want\n&#039;
             &#039;to access further features, you have to do this yourself:\n&#039;
             &#039;\n&#039;
             &quot;class pdb.Pdb(completekey=&#039;tab&#039;, stdin=None, stdout=None, &quot;
             &#039;skip=None, nosigint=False, readrc=True)\n&#039;
             &#039;\n&#039;
             &#039;   &quot;Pdb&quot; is the debugger class.\n&#039;
             &#039;\n&#039;
             &#039;   The *completekey*, *stdin* and *stdout* arguments are passed &#039;
             &#039;to the\n&#039;
             &#039;   underlying &quot;cmd.Cmd&quot; class; see the description there.\n&#039;
             &#039;\n&#039;
             &#039;   The *skip* argument, if given, must be an iterable of &#039;
             &#039;glob-style\n&#039;
             &#039;   module name patterns.  The debugger will not step into frames &#039;
             &#039;that\n&#039;
             &#039;   originate in a module that matches one of these patterns. &#039;
             &#039;[1]\n&#039;
             &#039;\n&#039;
             &#039;   By default, Pdb sets a handler for the SIGINT signal (which &#039;
             &#039;is sent\n&#039;
             &#039;   when the user presses &quot;Ctrl-C&quot; on the console) when you give &#039;
             &#039;a\n&#039;
             &#039;   &quot;continue&quot; command. This allows you to break into the &#039;
             &#039;debugger\n&#039;
             &#039;   again by pressing &quot;Ctrl-C&quot;.  If you want Pdb not to touch &#039;
             &#039;the\n&#039;
             &#039;   SIGINT handler, set *nosigint* to true.\n&#039;
             &#039;\n&#039;
             &#039;   The *readrc* argument defaults to true and controls whether &#039;
             &#039;Pdb\n&#039;
             &#039;   will load .pdbrc files from the filesystem.\n&#039;
             &#039;\n&#039;
             &#039;   Example call to enable tracing with *skip*:\n&#039;
             &#039;\n&#039;
             &quot;      import pdb; pdb.Pdb(skip=[&#039;django.*&#039;]).set_trace()\n&quot;
             &#039;\n&#039;
             &#039;   New in version 3.1: The *skip* argument.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2: The *nosigint* argument.  Previously, a &#039;
             &#039;SIGINT\n&#039;
             &#039;   handler was never set by Pdb.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 3.6: The *readrc* argument.\n&#039;
             &#039;\n&#039;
             &#039;   run(statement, globals=None, locals=None)\n&#039;
             &#039;   runeval(expression, globals=None, locals=None)\n&#039;
             &#039;   runcall(function, *args, **kwds)\n&#039;
             &#039;   set_trace()\n&#039;
             &#039;\n&#039;
             &#039;      See the documentation for the functions explained above.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Debugger Commands\n&#039;
             &#039;=================\n&#039;
             &#039;\n&#039;
             &#039;The commands recognized by the debugger are listed below.  Most\n&#039;
             &#039;commands can be abbreviated to one or two letters as indicated; &#039;
             &#039;e.g.\n&#039;
             &#039;&quot;h(elp)&quot; means that either &quot;h&quot; or &quot;help&quot; can be used to enter &#039;
             &#039;the help\n&#039;
             &#039;command (but not &quot;he&quot; or &quot;hel&quot;, nor &quot;H&quot; or &quot;Help&quot; or &quot;HELP&quot;).\n&#039;
             &#039;Arguments to commands must be separated by whitespace (spaces &#039;
             &#039;or\n&#039;
             &#039;tabs).  Optional arguments are enclosed in square brackets &#039;
             &#039;(&quot;[]&quot;) in\n&#039;
             &#039;the command syntax; the square brackets must not be typed.\n&#039;
             &#039;Alternatives in the command syntax are separated by a vertical &#039;
             &#039;bar\n&#039;
             &#039;(&quot;|&quot;).\n&#039;
             &#039;\n&#039;
             &#039;Entering a blank line repeats the last command entered.  &#039;
             &#039;Exception: if\n&#039;
             &#039;the last command was a &quot;list&quot; command, the next 11 lines are &#039;
             &#039;listed.\n&#039;
             &#039;\n&#039;
             &#039;Commands that the debugger doesn’t recognize are assumed to be &#039;
             &#039;Python\n&#039;
             &#039;statements and are executed in the context of the program being\n&#039;
             &#039;debugged.  Python statements can also be prefixed with an &#039;
             &#039;exclamation\n&#039;
             &#039;point (&quot;!&quot;).  This is a powerful way to inspect the program &#039;
             &#039;being\n&#039;
             &#039;debugged; it is even possible to change a variable or call a &#039;
             &#039;function.\n&#039;
             &#039;When an exception occurs in such a statement, the exception name &#039;
             &#039;is\n&#039;
             &#039;printed but the debugger’s state is not changed.\n&#039;
             &#039;\n&#039;
             &#039;The debugger supports aliases.  Aliases can have parameters &#039;
             &#039;which\n&#039;
             &#039;allows one a certain level of adaptability to the context under\n&#039;
             &#039;examination.\n&#039;
             &#039;\n&#039;
             &#039;Multiple commands may be entered on a single line, separated by &#039;
             &#039;&quot;;;&quot;.\n&#039;
             &#039;(A single &quot;;&quot; is not used as it is the separator for multiple &#039;
             &#039;commands\n&#039;
             &#039;in a line that is passed to the Python parser.)  No intelligence &#039;
             &#039;is\n&#039;
             &#039;applied to separating the commands; the input is split at the &#039;
             &#039;first\n&#039;
             &#039;&quot;;;&quot; pair, even if it is in the middle of a quoted string.\n&#039;
             &#039;\n&#039;
             &#039;If a file &quot;.pdbrc&quot; exists in the user’s home directory or in &#039;
             &#039;the\n&#039;
             &#039;current directory, it is read in and executed as if it had been &#039;
             &#039;typed\n&#039;
             &#039;at the debugger prompt.  This is particularly useful for &#039;
             &#039;aliases.  If\n&#039;
             &#039;both files exist, the one in the home directory is read first &#039;
             &#039;and\n&#039;
             &#039;aliases defined there can be overridden by the local file.\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.2: &quot;.pdbrc&quot; can now contain commands that\n&#039;
             &#039;continue debugging, such as &quot;continue&quot; or &quot;next&quot;.  Previously, &#039;
             &#039;these\n&#039;
             &#039;commands had no effect.\n&#039;
             &#039;\n&#039;
             &#039;h(elp) [command]\n&#039;
             &#039;\n&#039;
             &#039;   Without argument, print the list of available commands.  With &#039;
             &#039;a\n&#039;
             &#039;   *command* as argument, print help about that command.  &quot;help &#039;
             &#039;pdb&quot;\n&#039;
             &#039;   displays the full documentation (the docstring of the &quot;pdb&quot;\n&#039;
             &#039;   module).  Since the *command* argument must be an identifier, &#039;
             &#039;&quot;help\n&#039;
             &#039;   exec&quot; must be entered to get help on the &quot;!&quot; command.\n&#039;
             &#039;\n&#039;
             &#039;w(here)\n&#039;
             &#039;\n&#039;
             &#039;   Print a stack trace, with the most recent frame at the &#039;
             &#039;bottom.  An\n&#039;
             &#039;   arrow indicates the current frame, which determines the &#039;
             &#039;context of\n&#039;
             &#039;   most commands.\n&#039;
             &#039;\n&#039;
             &#039;d(own) [count]\n&#039;
             &#039;\n&#039;
             &#039;   Move the current frame *count* (default one) levels down in &#039;
             &#039;the\n&#039;
             &#039;   stack trace (to a newer frame).\n&#039;
             &#039;\n&#039;
             &#039;u(p) [count]\n&#039;
             &#039;\n&#039;
             &#039;   Move the current frame *count* (default one) levels up in the &#039;
             &#039;stack\n&#039;
             &#039;   trace (to an older frame).\n&#039;
             &#039;\n&#039;
             &#039;b(reak) [([filename:]lineno | function) [, condition]]\n&#039;
             &#039;\n&#039;
             &#039;   With a *lineno* argument, set a break there in the current &#039;
             &#039;file.\n&#039;
             &#039;   With a *function* argument, set a break at the first &#039;
             &#039;executable\n&#039;
             &#039;   statement within that function.  The line number may be &#039;
             &#039;prefixed\n&#039;
             &#039;   with a filename and a colon, to specify a breakpoint in &#039;
             &#039;another\n&#039;
             &#039;   file (probably one that hasn’t been loaded yet).  The file &#039;
             &#039;is\n&#039;
             &#039;   searched on &quot;sys.path&quot;.  Note that each breakpoint is &#039;
             &#039;assigned a\n&#039;
             &#039;   number to which all the other breakpoint commands refer.\n&#039;
             &#039;\n&#039;
             &#039;   If a second argument is present, it is an expression which &#039;
             &#039;must\n&#039;
             &#039;   evaluate to true before the breakpoint is honored.\n&#039;
             &#039;\n&#039;
             &#039;   Without argument, list all breaks, including for each &#039;
             &#039;breakpoint,\n&#039;
             &#039;   the number of times that breakpoint has been hit, the &#039;
             &#039;current\n&#039;
             &#039;   ignore count, and the associated condition if any.\n&#039;
             &#039;\n&#039;
             &#039;tbreak [([filename:]lineno | function) [, condition]]\n&#039;
             &#039;\n&#039;
             &#039;   Temporary breakpoint, which is removed automatically when it &#039;
             &#039;is\n&#039;
             &#039;   first hit. The arguments are the same as for &quot;break&quot;.\n&#039;
             &#039;\n&#039;
             &#039;cl(ear) [filename:lineno | bpnumber [bpnumber ...]]\n&#039;
             &#039;\n&#039;
             &#039;   With a *filename:lineno* argument, clear all the breakpoints &#039;
             &#039;at\n&#039;
             &#039;   this line. With a space separated list of breakpoint numbers, &#039;
             &#039;clear\n&#039;
             &#039;   those breakpoints. Without argument, clear all breaks (but &#039;
             &#039;first\n&#039;
             &#039;   ask confirmation).\n&#039;
             &#039;\n&#039;
             &#039;disable [bpnumber [bpnumber ...]]\n&#039;
             &#039;\n&#039;
             &#039;   Disable the breakpoints given as a space separated list of\n&#039;
             &#039;   breakpoint numbers.  Disabling a breakpoint means it cannot &#039;
             &#039;cause\n&#039;
             &#039;   the program to stop execution, but unlike clearing a &#039;
             &#039;breakpoint, it\n&#039;
             &#039;   remains in the list of breakpoints and can be (re-)enabled.\n&#039;
             &#039;\n&#039;
             &#039;enable [bpnumber [bpnumber ...]]\n&#039;
             &#039;\n&#039;
             &#039;   Enable the breakpoints specified.\n&#039;
             &#039;\n&#039;
             &#039;ignore bpnumber [count]\n&#039;
             &#039;\n&#039;
             &#039;   Set the ignore count for the given breakpoint number.  If &#039;
             &#039;count is\n&#039;
             &#039;   omitted, the ignore count is set to 0.  A breakpoint becomes &#039;
             &#039;active\n&#039;
             &#039;   when the ignore count is zero.  When non-zero, the count is\n&#039;
             &#039;   decremented each time the breakpoint is reached and the &#039;
             &#039;breakpoint\n&#039;
             &#039;   is not disabled and any associated condition evaluates to &#039;
             &#039;true.\n&#039;
             &#039;\n&#039;
             &#039;condition bpnumber [condition]\n&#039;
             &#039;\n&#039;
             &#039;   Set a new *condition* for the breakpoint, an expression which &#039;
             &#039;must\n&#039;
             &#039;   evaluate to true before the breakpoint is honored.  If &#039;
             &#039;*condition*\n&#039;
             &#039;   is absent, any existing condition is removed; i.e., the &#039;
             &#039;breakpoint\n&#039;
             &#039;   is made unconditional.\n&#039;
             &#039;\n&#039;
             &#039;commands [bpnumber]\n&#039;
             &#039;\n&#039;
             &#039;   Specify a list of commands for breakpoint number *bpnumber*.  &#039;
             &#039;The\n&#039;
             &#039;   commands themselves appear on the following lines.  Type a &#039;
             &#039;line\n&#039;
             &#039;   containing just &quot;end&quot; to terminate the commands. An example:\n&#039;
             &#039;\n&#039;
             &#039;      (Pdb) commands 1\n&#039;
             &#039;      (com) p some_variable\n&#039;
             &#039;      (com) end\n&#039;
             &#039;      (Pdb)\n&#039;
             &#039;\n&#039;
             &#039;   To remove all commands from a breakpoint, type commands and &#039;
             &#039;follow\n&#039;
             &#039;   it immediately with &quot;end&quot;; that is, give no commands.\n&#039;
             &#039;\n&#039;
             &#039;   With no *bpnumber* argument, commands refers to the last &#039;
             &#039;breakpoint\n&#039;
             &#039;   set.\n&#039;
             &#039;\n&#039;
             &#039;   You can use breakpoint commands to start your program up &#039;
             &#039;again.\n&#039;
             &#039;   Simply use the continue command, or step, or any other &#039;
             &#039;command that\n&#039;
             &#039;   resumes execution.\n&#039;
             &#039;\n&#039;
             &#039;   Specifying any command resuming execution (currently &#039;
             &#039;continue,\n&#039;
             &#039;   step, next, return, jump, quit and their abbreviations) &#039;
             &#039;terminates\n&#039;
             &#039;   the command list (as if that command was immediately followed &#039;
             &#039;by\n&#039;
             &#039;   end). This is because any time you resume execution (even &#039;
             &#039;with a\n&#039;
             &#039;   simple next or step), you may encounter another &#039;
             &#039;breakpoint—which\n&#039;
             &#039;   could have its own command list, leading to ambiguities about &#039;
             &#039;which\n&#039;
             &#039;   list to execute.\n&#039;
             &#039;\n&#039;
             &#039;   If you use the ‘silent’ command in the command list, the &#039;
             &#039;usual\n&#039;
             &#039;   message about stopping at a breakpoint is not printed.  This &#039;
             &#039;may be\n&#039;
             &#039;   desirable for breakpoints that are to print a specific &#039;
             &#039;message and\n&#039;
             &#039;   then continue.  If none of the other commands print anything, &#039;
             &#039;you\n&#039;
             &#039;   see no sign that the breakpoint was reached.\n&#039;
             &#039;\n&#039;
             &#039;s(tep)\n&#039;
             &#039;\n&#039;
             &#039;   Execute the current line, stop at the first possible &#039;
             &#039;occasion\n&#039;
             &#039;   (either in a function that is called or on the next line in &#039;
             &#039;the\n&#039;
             &#039;   current function).\n&#039;
             &#039;\n&#039;
             &#039;n(ext)\n&#039;
             &#039;\n&#039;
             &#039;   Continue execution until the next line in the current &#039;
             &#039;function is\n&#039;
             &#039;   reached or it returns.  (The difference between &quot;next&quot; and &#039;
             &#039;&quot;step&quot;\n&#039;
             &#039;   is that &quot;step&quot; stops inside a called function, while &quot;next&quot;\n&#039;
             &#039;   executes called functions at (nearly) full speed, only &#039;
             &#039;stopping at\n&#039;
             &#039;   the next line in the current function.)\n&#039;
             &#039;\n&#039;
             &#039;unt(il) [lineno]\n&#039;
             &#039;\n&#039;
             &#039;   Without argument, continue execution until the line with a &#039;
             &#039;number\n&#039;
             &#039;   greater than the current one is reached.\n&#039;
             &#039;\n&#039;
             &#039;   With a line number, continue execution until a line with a &#039;
             &#039;number\n&#039;
             &#039;   greater or equal to that is reached.  In both cases, also &#039;
             &#039;stop when\n&#039;
             &#039;   the current frame returns.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 3.2: Allow giving an explicit line &#039;
             &#039;number.\n&#039;
             &#039;\n&#039;
             &#039;r(eturn)\n&#039;
             &#039;\n&#039;
             &#039;   Continue execution until the current function returns.\n&#039;
             &#039;\n&#039;
             &#039;c(ont(inue))\n&#039;
             &#039;\n&#039;
             &#039;   Continue execution, only stop when a breakpoint is &#039;
             &#039;encountered.\n&#039;
             &#039;\n&#039;
             &#039;j(ump) lineno\n&#039;
             &#039;\n&#039;
             &#039;   Set the next line that will be executed.  Only available in &#039;
             &#039;the\n&#039;
             &#039;   bottom-most frame.  This lets you jump back and execute code &#039;
             &#039;again,\n&#039;
             &#039;   or jump forward to skip code that you don’t want to run.\n&#039;
             &#039;\n&#039;
             &#039;   It should be noted that not all jumps are allowed – for &#039;
             &#039;instance it\n&#039;
             &#039;   is not possible to jump into the middle of a &quot;for&quot; loop or &#039;
             &#039;out of a\n&#039;
             &#039;   &quot;finally&quot; clause.\n&#039;
             &#039;\n&#039;
             &#039;l(ist) [first[, last]]\n&#039;
             &#039;\n&#039;
             &#039;   List source code for the current file.  Without arguments, &#039;
             &#039;list 11\n&#039;
             &#039;   lines around the current line or continue the previous &#039;
             &#039;listing.\n&#039;
             &#039;   With &quot;.&quot; as argument, list 11 lines around the current line.  &#039;
             &#039;With\n&#039;
             &#039;   one argument, list 11 lines around at that line.  With two\n&#039;
             &#039;   arguments, list the given range; if the second argument is &#039;
             &#039;less\n&#039;
             &#039;   than the first, it is interpreted as a count.\n&#039;
             &#039;\n&#039;
             &#039;   The current line in the current frame is indicated by &quot;-&gt;&quot;.  &#039;
             &#039;If an\n&#039;
             &#039;   exception is being debugged, the line where the exception &#039;
             &#039;was\n&#039;
             &#039;   originally raised or propagated is indicated by &quot;&gt;&gt;&quot;, if it &#039;
             &#039;differs\n&#039;
             &#039;   from the current line.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2: The &quot;&gt;&gt;&quot; marker.\n&#039;
             &#039;\n&#039;
             &#039;ll | longlist\n&#039;
             &#039;\n&#039;
             &#039;   List all source code for the current function or frame.\n&#039;
             &#039;   Interesting lines are marked as for &quot;list&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2.\n&#039;
             &#039;\n&#039;
             &#039;a(rgs)\n&#039;
             &#039;\n&#039;
             &#039;   Print the argument list of the current function.\n&#039;
             &#039;\n&#039;
             &#039;p expression\n&#039;
             &#039;\n&#039;
             &#039;   Evaluate the *expression* in the current context and print &#039;
             &#039;its\n&#039;
             &#039;   value.\n&#039;
             &#039;\n&#039;
             &#039;   Note: &quot;print()&quot; can also be used, but is not a debugger &#039;
             &#039;command —\n&#039;
             &#039;     this executes the Python &quot;print()&quot; function.\n&#039;
             &#039;\n&#039;
             &#039;pp expression\n&#039;
             &#039;\n&#039;
             &#039;   Like the &quot;p&quot; command, except the value of the expression is &#039;
             &#039;pretty-\n&#039;
             &#039;   printed using the &quot;pprint&quot; module.\n&#039;
             &#039;\n&#039;
             &#039;whatis expression\n&#039;
             &#039;\n&#039;
             &#039;   Print the type of the *expression*.\n&#039;
             &#039;\n&#039;
             &#039;source expression\n&#039;
             &#039;\n&#039;
             &#039;   Try to get source code for the given object and display it.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2.\n&#039;
             &#039;\n&#039;
             &#039;display [expression]\n&#039;
             &#039;\n&#039;
             &#039;   Display the value of the expression if it changed, each time\n&#039;
             &#039;   execution stops in the current frame.\n&#039;
             &#039;\n&#039;
             &#039;   Without expression, list all display expressions for the &#039;
             &#039;current\n&#039;
             &#039;   frame.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2.\n&#039;
             &#039;\n&#039;
             &#039;undisplay [expression]\n&#039;
             &#039;\n&#039;
             &#039;   Do not display the expression any more in the current frame.\n&#039;
             &#039;   Without expression, clear all display expressions for the &#039;
             &#039;current\n&#039;
             &#039;   frame.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2.\n&#039;
             &#039;\n&#039;
             &#039;interact\n&#039;
             &#039;\n&#039;
             &#039;   Start an interactive interpreter (using the &quot;code&quot; module) &#039;
             &#039;whose\n&#039;
             &#039;   global namespace contains all the (global and local) names &#039;
             &#039;found in\n&#039;
             &#039;   the current scope.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.2.\n&#039;
             &#039;\n&#039;
             &#039;alias [name [command]]\n&#039;
             &#039;\n&#039;
             &#039;   Create an alias called *name* that executes *command*.  The &#039;
             &#039;command\n&#039;
             &#039;   must *not* be enclosed in quotes.  Replaceable parameters can &#039;
             &#039;be\n&#039;
             &#039;   indicated by &quot;%1&quot;, &quot;%2&quot;, and so on, while &quot;%*&quot; is replaced by &#039;
             &#039;all\n&#039;
             &#039;   the parameters. If no command is given, the current alias &#039;
             &#039;for\n&#039;
             &#039;   *name* is shown. If no arguments are given, all aliases are &#039;
             &#039;listed.\n&#039;
             &#039;\n&#039;
             &#039;   Aliases may be nested and can contain anything that can be &#039;
             &#039;legally\n&#039;
             &#039;   typed at the pdb prompt.  Note that internal pdb commands &#039;
             &#039;*can* be\n&#039;
             &#039;   overridden by aliases.  Such a command is then hidden until &#039;
             &#039;the\n&#039;
             &#039;   alias is removed.  Aliasing is recursively applied to the &#039;
             &#039;first\n&#039;
             &#039;   word of the command line; all other words in the line are &#039;
             &#039;left\n&#039;
             &#039;   alone.\n&#039;
             &#039;\n&#039;
             &#039;   As an example, here are two useful aliases (especially when &#039;
             &#039;placed\n&#039;
             &#039;   in the &quot;.pdbrc&quot; file):\n&#039;
             &#039;\n&#039;
             &#039;      # Print instance variables (usage &quot;pi classInst&quot;)\n&#039;
             &#039;      alias pi for k in %1.__dict__.keys(): &#039;
             &#039;print(&quot;%1.&quot;,k,&quot;=&quot;,%1.__dict__[k])\n&#039;
             &#039;      # Print instance variables in self\n&#039;
             &#039;      alias ps pi self\n&#039;
             &#039;\n&#039;
             &#039;unalias name\n&#039;
             &#039;\n&#039;
             &#039;   Delete the specified alias.\n&#039;
             &#039;\n&#039;
             &#039;! statement\n&#039;
             &#039;\n&#039;
             &#039;   Execute the (one-line) *statement* in the context of the &#039;
             &#039;current\n&#039;
             &#039;   stack frame. The exclamation point can be omitted unless the &#039;
             &#039;first\n&#039;
             &#039;   word of the statement resembles a debugger command.  To set &#039;
             &#039;a\n&#039;
             &#039;   global variable, you can prefix the assignment command with &#039;
             &#039;a\n&#039;
             &#039;   &quot;global&quot; statement on the same line, e.g.:\n&#039;
             &#039;\n&#039;
             &quot;      (Pdb) global list_options; list_options = [&#039;-l&#039;]\n&quot;
             &#039;      (Pdb)\n&#039;
             &#039;\n&#039;
             &#039;run [args ...]\n&#039;
             &#039;restart [args ...]\n&#039;
             &#039;\n&#039;
             &#039;   Restart the debugged Python program.  If an argument is &#039;
             &#039;supplied,\n&#039;
             &#039;   it is split with &quot;shlex&quot; and the result is used as the new\n&#039;
             &#039;   &quot;sys.argv&quot;. History, breakpoints, actions and debugger &#039;
             &#039;options are\n&#039;
             &#039;   preserved. &quot;restart&quot; is an alias for &quot;run&quot;.\n&#039;
             &#039;\n&#039;
             &#039;q(uit)\n&#039;
             &#039;\n&#039;
             &#039;   Quit from the debugger.  The program being executed is &#039;
             &#039;aborted.\n&#039;
             &#039;\n&#039;
             &#039;-[ Footnotes ]-\n&#039;
             &#039;\n&#039;
             &#039;[1] Whether a frame is considered to originate in a certain &#039;
             &#039;module\n&#039;
             &#039;    is determined by the &quot;__name__&quot; in the frame globals.\n&#039;,
 &#039;del&#039;: &#039;The &quot;del&quot; statement\n&#039;
        &#039;*******************\n&#039;
        &#039;\n&#039;
        &#039;   del_stmt ::= &quot;del&quot; target_list\n&#039;
        &#039;\n&#039;
        &#039;Deletion is recursively defined very similar to the way assignment &#039;
        &#039;is\n&#039;
        &#039;defined. Rather than spelling it out in full details, here are some\n&#039;
        &#039;hints.\n&#039;
        &#039;\n&#039;
        &#039;Deletion of a target list recursively deletes each target, from left\n&#039;
        &#039;to right.\n&#039;
        &#039;\n&#039;
        &#039;Deletion of a name removes the binding of that name from the local &#039;
        &#039;or\n&#039;
        &#039;global namespace, depending on whether the name occurs in a &quot;global&quot;\n&#039;
        &#039;statement in the same code block.  If the name is unbound, a\n&#039;
        &#039;&quot;NameError&quot; exception will be raised.\n&#039;
        &#039;\n&#039;
        &#039;Deletion of attribute references, subscriptions and slicings is &#039;
        &#039;passed\n&#039;
        &#039;to the primary object involved; deletion of a slicing is in general\n&#039;
        &#039;equivalent to assignment of an empty slice of the right type (but &#039;
        &#039;even\n&#039;
        &#039;this is determined by the sliced object).\n&#039;
        &#039;\n&#039;
        &#039;Changed in version 3.2: Previously it was illegal to delete a name\n&#039;
        &#039;from the local namespace if it occurs as a free variable in a nested\n&#039;
        &#039;block.\n&#039;,
 &#039;dict&#039;: &#039;Dictionary displays\n&#039;
         &#039;*******************\n&#039;
         &#039;\n&#039;
         &#039;A dictionary display is a possibly empty series of key/datum pairs\n&#039;
         &#039;enclosed in curly braces:\n&#039;
         &#039;\n&#039;
         &#039;   dict_display       ::= &quot;{&quot; [key_datum_list | dict_comprehension] &#039;
         &#039;&quot;}&quot;\n&#039;
         &#039;   key_datum_list     ::= key_datum (&quot;,&quot; key_datum)* [&quot;,&quot;]\n&#039;
         &#039;   key_datum          ::= expression &quot;:&quot; expression | &quot;**&quot; or_expr\n&#039;
         &#039;   dict_comprehension ::= expression &quot;:&quot; expression comp_for\n&#039;
         &#039;\n&#039;
         &#039;A dictionary display yields a new dictionary object.\n&#039;
         &#039;\n&#039;
         &#039;If a comma-separated sequence of key/datum pairs is given, they are\n&#039;
         &#039;evaluated from left to right to define the entries of the &#039;
         &#039;dictionary:\n&#039;
         &#039;each key object is used as a key into the dictionary to store the\n&#039;
         &#039;corresponding datum.  This means that you can specify the same key\n&#039;
         &#039;multiple times in the key/datum list, and the final dictionary’s &#039;
         &#039;value\n&#039;
         &#039;for that key will be the last one given.\n&#039;
         &#039;\n&#039;
         &#039;A double asterisk &quot;**&quot; denotes *dictionary unpacking*. Its operand\n&#039;
         &#039;must be a *mapping*.  Each mapping item is added to the new\n&#039;
         &#039;dictionary.  Later values replace values already set by earlier\n&#039;
         &#039;key/datum pairs and earlier dictionary unpackings.\n&#039;
         &#039;\n&#039;
         &#039;New in version 3.5: Unpacking into dictionary displays, originally\n&#039;
         &#039;proposed by **PEP 448**.\n&#039;
         &#039;\n&#039;
         &#039;A dict comprehension, in contrast to list and set comprehensions,\n&#039;
         &#039;needs two expressions separated with a colon followed by the usual\n&#039;
         &#039;“for” and “if” clauses. When the comprehension is run, the &#039;
         &#039;resulting\n&#039;
         &#039;key and value elements are inserted in the new dictionary in the &#039;
         &#039;order\n&#039;
         &#039;they are produced.\n&#039;
         &#039;\n&#039;
         &#039;Restrictions on the types of the key values are listed earlier in\n&#039;
         &#039;section The standard type hierarchy.  (To summarize, the key type\n&#039;
         &#039;should be *hashable*, which excludes all mutable objects.)  Clashes\n&#039;
         &#039;between duplicate keys are not detected; the last datum (textually\n&#039;
         &#039;rightmost in the display) stored for a given key value prevails.\n&#039;,
 &#039;dynamic-features&#039;: &#039;Interaction with dynamic features\n&#039;
                     &#039;*********************************\n&#039;
                     &#039;\n&#039;
                     &#039;Name resolution of free variables occurs at runtime, not &#039;
                     &#039;at compile\n&#039;
                     &#039;time. This means that the following code will print 42:\n&#039;
                     &#039;\n&#039;
                     &#039;   i = 10\n&#039;
                     &#039;   def f():\n&#039;
                     &#039;       print(i)\n&#039;
                     &#039;   i = 42\n&#039;
                     &#039;   f()\n&#039;
                     &#039;\n&#039;
                     &#039;The &quot;eval()&quot; and &quot;exec()&quot; functions do not have access &#039;
                     &#039;to the full\n&#039;
                     &#039;environment for resolving names.  Names may be resolved &#039;
                     &#039;in the local\n&#039;
                     &#039;and global namespaces of the caller.  Free variables are &#039;
                     &#039;not resolved\n&#039;
                     &#039;in the nearest enclosing namespace, but in the global &#039;
                     &#039;namespace.  [1]\n&#039;
                     &#039;The &quot;exec()&quot; and &quot;eval()&quot; functions have optional &#039;
                     &#039;arguments to\n&#039;
                     &#039;override the global and local namespace.  If only one &#039;
                     &#039;namespace is\n&#039;
                     &#039;specified, it is used for both.\n&#039;,
 &#039;else&#039;: &#039;The &quot;if&quot; statement\n&#039;
         &#039;******************\n&#039;
         &#039;\n&#039;
         &#039;The &quot;if&quot; statement is used for conditional execution:\n&#039;
         &#039;\n&#039;
         &#039;   if_stmt ::= &quot;if&quot; expression &quot;:&quot; suite\n&#039;
         &#039;               (&quot;elif&quot; expression &quot;:&quot; suite)*\n&#039;
         &#039;               [&quot;else&quot; &quot;:&quot; suite]\n&#039;
         &#039;\n&#039;
         &#039;It selects exactly one of the suites by evaluating the expressions &#039;
         &#039;one\n&#039;
         &#039;by one until one is found to be true (see section Boolean &#039;
         &#039;operations\n&#039;
         &#039;for the definition of true and false); then that suite is executed\n&#039;
         &#039;(and no other part of the &quot;if&quot; statement is executed or evaluated).\n&#039;
         &#039;If all expressions are false, the suite of the &quot;else&quot; clause, if\n&#039;
         &#039;present, is executed.\n&#039;,
 &#039;exceptions&#039;: &#039;Exceptions\n&#039;
               &#039;**********\n&#039;
               &#039;\n&#039;
               &#039;Exceptions are a means of breaking out of the normal flow of &#039;
               &#039;control\n&#039;
               &#039;of a code block in order to handle errors or other &#039;
               &#039;exceptional\n&#039;
               &#039;conditions.  An exception is *raised* at the point where the &#039;
               &#039;error is\n&#039;
               &#039;detected; it may be *handled* by the surrounding code block or &#039;
               &#039;by any\n&#039;
               &#039;code block that directly or indirectly invoked the code block &#039;
               &#039;where\n&#039;
               &#039;the error occurred.\n&#039;
               &#039;\n&#039;
               &#039;The Python interpreter raises an exception when it detects a &#039;
               &#039;run-time\n&#039;
               &#039;error (such as division by zero).  A Python program can also\n&#039;
               &#039;explicitly raise an exception with the &quot;raise&quot; statement. &#039;
               &#039;Exception\n&#039;
               &#039;handlers are specified with the &quot;try&quot; … &quot;except&quot; statement.  &#039;
               &#039;The\n&#039;
               &#039;&quot;finally&quot; clause of such a statement can be used to specify &#039;
               &#039;cleanup\n&#039;
               &#039;code which does not handle the exception, but is executed &#039;
               &#039;whether an\n&#039;
               &#039;exception occurred or not in the preceding code.\n&#039;
               &#039;\n&#039;
               &#039;Python uses the “termination” model of error handling: an &#039;
               &#039;exception\n&#039;
               &#039;handler can find out what happened and continue execution at &#039;
               &#039;an outer\n&#039;
               &#039;level, but it cannot repair the cause of the error and retry &#039;
               &#039;the\n&#039;
               &#039;failing operation (except by re-entering the offending piece &#039;
               &#039;of code\n&#039;
               &#039;from the top).\n&#039;
               &#039;\n&#039;
               &#039;When an exception is not handled at all, the interpreter &#039;
               &#039;terminates\n&#039;
               &#039;execution of the program, or returns to its interactive main &#039;
               &#039;loop.  In\n&#039;
               &#039;either case, it prints a stack backtrace, except when the &#039;
               &#039;exception is\n&#039;
               &#039;&quot;SystemExit&quot;.\n&#039;
               &#039;\n&#039;
               &#039;Exceptions are identified by class instances.  The &quot;except&quot; &#039;
               &#039;clause is\n&#039;
               &#039;selected depending on the class of the instance: it must &#039;
               &#039;reference the\n&#039;
               &#039;class of the instance or a base class thereof.  The instance &#039;
               &#039;can be\n&#039;
               &#039;received by the handler and can carry additional information &#039;
               &#039;about the\n&#039;
               &#039;exceptional condition.\n&#039;
               &#039;\n&#039;
               &#039;Note: Exception messages are not part of the Python API.  &#039;
               &#039;Their\n&#039;
               &#039;  contents may change from one version of Python to the next &#039;
               &#039;without\n&#039;
               &#039;  warning and should not be relied on by code which will run &#039;
               &#039;under\n&#039;
               &#039;  multiple versions of the interpreter.\n&#039;
               &#039;\n&#039;
               &#039;See also the description of the &quot;try&quot; statement in section The &#039;
               &#039;try\n&#039;
               &#039;statement and &quot;raise&quot; statement in section The raise &#039;
               &#039;statement.\n&#039;
               &#039;\n&#039;
               &#039;-[ Footnotes ]-\n&#039;
               &#039;\n&#039;
               &#039;[1] This limitation occurs because the code that is executed &#039;
               &#039;by\n&#039;
               &#039;    these operations is not available at the time the module &#039;
               &#039;is\n&#039;
               &#039;    compiled.\n&#039;,
 &#039;execmodel&#039;: &#039;Execution model\n&#039;
              &#039;***************\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Structure of a program\n&#039;
              &#039;======================\n&#039;
              &#039;\n&#039;
              &#039;A Python program is constructed from code blocks. A *block* is &#039;
              &#039;a piece\n&#039;
              &#039;of Python program text that is executed as a unit. The &#039;
              &#039;following are\n&#039;
              &#039;blocks: a module, a function body, and a class definition. &#039;
              &#039;Each\n&#039;
              &#039;command typed interactively is a block.  A script file (a file &#039;
              &#039;given\n&#039;
              &#039;as standard input to the interpreter or specified as a command &#039;
              &#039;line\n&#039;
              &#039;argument to the interpreter) is a code block.  A script command &#039;
              &#039;(a\n&#039;
              &#039;command specified on the interpreter command line with the &#039;
              &#039;&quot;-c&quot;\n&#039;
              &#039;option) is a code block.  The string argument passed to the &#039;
              &#039;built-in\n&#039;
              &#039;functions &quot;eval()&quot; and &quot;exec()&quot; is a code block.\n&#039;
              &#039;\n&#039;
              &#039;A code block is executed in an *execution frame*.  A frame &#039;
              &#039;contains\n&#039;
              &#039;some administrative information (used for debugging) and &#039;
              &#039;determines\n&#039;
              &#039;where and how execution continues after the code block’s &#039;
              &#039;execution has\n&#039;
              &#039;completed.\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Naming and binding\n&#039;
              &#039;==================\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Binding of names\n&#039;
              &#039;----------------\n&#039;
              &#039;\n&#039;
              &#039;*Names* refer to objects.  Names are introduced by name &#039;
              &#039;binding\n&#039;
              &#039;operations.\n&#039;
              &#039;\n&#039;
              &#039;The following constructs bind names: formal parameters to &#039;
              &#039;functions,\n&#039;
              &#039;&quot;import&quot; statements, class and function definitions (these bind &#039;
              &#039;the\n&#039;
              &#039;class or function name in the defining block), and targets that &#039;
              &#039;are\n&#039;
              &#039;identifiers if occurring in an assignment, &quot;for&quot; loop header, &#039;
              &#039;or after\n&#039;
              &#039;&quot;as&quot; in a &quot;with&quot; statement or &quot;except&quot; clause. The &quot;import&quot; &#039;
              &#039;statement\n&#039;
              &#039;of the form &quot;from ... import *&quot; binds all names defined in the\n&#039;
              &#039;imported module, except those beginning with an underscore.  &#039;
              &#039;This form\n&#039;
              &#039;may only be used at the module level.\n&#039;
              &#039;\n&#039;
              &#039;A target occurring in a &quot;del&quot; statement is also considered &#039;
              &#039;bound for\n&#039;
              &#039;this purpose (though the actual semantics are to unbind the &#039;
              &#039;name).\n&#039;
              &#039;\n&#039;
              &#039;Each assignment or import statement occurs within a block &#039;
              &#039;defined by a\n&#039;
              &#039;class or function definition or at the module level (the &#039;
              &#039;top-level\n&#039;
              &#039;code block).\n&#039;
              &#039;\n&#039;
              &#039;If a name is bound in a block, it is a local variable of that &#039;
              &#039;block,\n&#039;
              &#039;unless declared as &quot;nonlocal&quot; or &quot;global&quot;.  If a name is bound &#039;
              &#039;at the\n&#039;
              &#039;module level, it is a global variable.  (The variables of the &#039;
              &#039;module\n&#039;
              &#039;code block are local and global.)  If a variable is used in a &#039;
              &#039;code\n&#039;
              &#039;block but not defined there, it is a *free variable*.\n&#039;
              &#039;\n&#039;
              &#039;Each occurrence of a name in the program text refers to the &#039;
              &#039;*binding*\n&#039;
              &#039;of that name established by the following name resolution &#039;
              &#039;rules.\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Resolution of names\n&#039;
              &#039;-------------------\n&#039;
              &#039;\n&#039;
              &#039;A *scope* defines the visibility of a name within a block.  If &#039;
              &#039;a local\n&#039;
              &#039;variable is defined in a block, its scope includes that block.  &#039;
              &#039;If the\n&#039;
              &#039;definition occurs in a function block, the scope extends to any &#039;
              &#039;blocks\n&#039;
              &#039;contained within the defining one, unless a contained block &#039;
              &#039;introduces\n&#039;
              &#039;a different binding for the name.\n&#039;
              &#039;\n&#039;
              &#039;When a name is used in a code block, it is resolved using the &#039;
              &#039;nearest\n&#039;
              &#039;enclosing scope.  The set of all such scopes visible to a code &#039;
              &#039;block\n&#039;
              &#039;is called the block’s *environment*.\n&#039;
              &#039;\n&#039;
              &#039;When a name is not found at all, a &quot;NameError&quot; exception is &#039;
              &#039;raised. If\n&#039;
              &#039;the current scope is a function scope, and the name refers to a &#039;
              &#039;local\n&#039;
              &#039;variable that has not yet been bound to a value at the point &#039;
              &#039;where the\n&#039;
              &#039;name is used, an &quot;UnboundLocalError&quot; exception is raised.\n&#039;
              &#039;&quot;UnboundLocalError&quot; is a subclass of &quot;NameError&quot;.\n&#039;
              &#039;\n&#039;
              &#039;If a name binding operation occurs anywhere within a code &#039;
              &#039;block, all\n&#039;
              &#039;uses of the name within the block are treated as references to &#039;
              &#039;the\n&#039;
              &#039;current block.  This can lead to errors when a name is used &#039;
              &#039;within a\n&#039;
              &#039;block before it is bound.  This rule is subtle.  Python lacks\n&#039;
              &#039;declarations and allows name binding operations to occur &#039;
              &#039;anywhere\n&#039;
              &#039;within a code block.  The local variables of a code block can &#039;
              &#039;be\n&#039;
              &#039;determined by scanning the entire text of the block for name &#039;
              &#039;binding\n&#039;
              &#039;operations.\n&#039;
              &#039;\n&#039;
              &#039;If the &quot;global&quot; statement occurs within a block, all uses of &#039;
              &#039;the name\n&#039;
              &#039;specified in the statement refer to the binding of that name in &#039;
              &#039;the\n&#039;
              &#039;top-level namespace.  Names are resolved in the top-level &#039;
              &#039;namespace by\n&#039;
              &#039;searching the global namespace, i.e. the namespace of the &#039;
              &#039;module\n&#039;
              &#039;containing the code block, and the builtins namespace, the &#039;
              &#039;namespace\n&#039;
              &#039;of the module &quot;builtins&quot;.  The global namespace is searched &#039;
              &#039;first.  If\n&#039;
              &#039;the name is not found there, the builtins namespace is &#039;
              &#039;searched.  The\n&#039;
              &#039;&quot;global&quot; statement must precede all uses of the name.\n&#039;
              &#039;\n&#039;
              &#039;The &quot;global&quot; statement has the same scope as a name binding &#039;
              &#039;operation\n&#039;
              &#039;in the same block.  If the nearest enclosing scope for a free &#039;
              &#039;variable\n&#039;
              &#039;contains a global statement, the free variable is treated as a &#039;
              &#039;global.\n&#039;
              &#039;\n&#039;
              &#039;The &quot;nonlocal&quot; statement causes corresponding names to refer &#039;
              &#039;to\n&#039;
              &#039;previously bound variables in the nearest enclosing function &#039;
              &#039;scope.\n&#039;
              &#039;&quot;SyntaxError&quot; is raised at compile time if the given name does &#039;
              &#039;not\n&#039;
              &#039;exist in any enclosing function scope.\n&#039;
              &#039;\n&#039;
              &#039;The namespace for a module is automatically created the first &#039;
              &#039;time a\n&#039;
              &#039;module is imported.  The main module for a script is always &#039;
              &#039;called\n&#039;
              &#039;&quot;__main__&quot;.\n&#039;
              &#039;\n&#039;
              &#039;Class definition blocks and arguments to &quot;exec()&quot; and &quot;eval()&quot; &#039;
              &#039;are\n&#039;
              &#039;special in the context of name resolution. A class definition &#039;
              &#039;is an\n&#039;
              &#039;executable statement that may use and define names. These &#039;
              &#039;references\n&#039;
              &#039;follow the normal rules for name resolution with an exception &#039;
              &#039;that\n&#039;
              &#039;unbound local variables are looked up in the global namespace. &#039;
              &#039;The\n&#039;
              &#039;namespace of the class definition becomes the attribute &#039;
              &#039;dictionary of\n&#039;
              &#039;the class. The scope of names defined in a class block is &#039;
              &#039;limited to\n&#039;
              &#039;the class block; it does not extend to the code blocks of &#039;
              &#039;methods –\n&#039;
              &#039;this includes comprehensions and generator expressions since &#039;
              &#039;they are\n&#039;
              &#039;implemented using a function scope.  This means that the &#039;
              &#039;following\n&#039;
              &#039;will fail:\n&#039;
              &#039;\n&#039;
              &#039;   class A:\n&#039;
              &#039;       a = 42\n&#039;
              &#039;       b = list(a + i for i in range(10))\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Builtins and restricted execution\n&#039;
              &#039;---------------------------------\n&#039;
              &#039;\n&#039;
              &#039;**CPython implementation detail:** Users should not touch\n&#039;
              &#039;&quot;__builtins__&quot;; it is strictly an implementation detail.  &#039;
              &#039;Users\n&#039;
              &#039;wanting to override values in the builtins namespace should &#039;
              &#039;&quot;import&quot;\n&#039;
              &#039;the &quot;builtins&quot; module and modify its attributes appropriately.\n&#039;
              &#039;\n&#039;
              &#039;The builtins namespace associated with the execution of a code &#039;
              &#039;block\n&#039;
              &#039;is actually found by looking up the name &quot;__builtins__&quot; in its &#039;
              &#039;global\n&#039;
              &#039;namespace; this should be a dictionary or a module (in the &#039;
              &#039;latter case\n&#039;
              &#039;the module’s dictionary is used).  By default, when in the &#039;
              &#039;&quot;__main__&quot;\n&#039;
              &#039;module, &quot;__builtins__&quot; is the built-in module &quot;builtins&quot;; when &#039;
              &#039;in any\n&#039;
              &#039;other module, &quot;__builtins__&quot; is an alias for the dictionary of &#039;
              &#039;the\n&#039;
              &#039;&quot;builtins&quot; module itself.\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Interaction with dynamic features\n&#039;
              &#039;---------------------------------\n&#039;
              &#039;\n&#039;
              &#039;Name resolution of free variables occurs at runtime, not at &#039;
              &#039;compile\n&#039;
              &#039;time. This means that the following code will print 42:\n&#039;
              &#039;\n&#039;
              &#039;   i = 10\n&#039;
              &#039;   def f():\n&#039;
              &#039;       print(i)\n&#039;
              &#039;   i = 42\n&#039;
              &#039;   f()\n&#039;
              &#039;\n&#039;
              &#039;The &quot;eval()&quot; and &quot;exec()&quot; functions do not have access to the &#039;
              &#039;full\n&#039;
              &#039;environment for resolving names.  Names may be resolved in the &#039;
              &#039;local\n&#039;
              &#039;and global namespaces of the caller.  Free variables are not &#039;
              &#039;resolved\n&#039;
              &#039;in the nearest enclosing namespace, but in the global &#039;
              &#039;namespace.  [1]\n&#039;
              &#039;The &quot;exec()&quot; and &quot;eval()&quot; functions have optional arguments to\n&#039;
              &#039;override the global and local namespace.  If only one namespace &#039;
              &#039;is\n&#039;
              &#039;specified, it is used for both.\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Exceptions\n&#039;
              &#039;==========\n&#039;
              &#039;\n&#039;
              &#039;Exceptions are a means of breaking out of the normal flow of &#039;
              &#039;control\n&#039;
              &#039;of a code block in order to handle errors or other exceptional\n&#039;
              &#039;conditions.  An exception is *raised* at the point where the &#039;
              &#039;error is\n&#039;
              &#039;detected; it may be *handled* by the surrounding code block or &#039;
              &#039;by any\n&#039;
              &#039;code block that directly or indirectly invoked the code block &#039;
              &#039;where\n&#039;
              &#039;the error occurred.\n&#039;
              &#039;\n&#039;
              &#039;The Python interpreter raises an exception when it detects a &#039;
              &#039;run-time\n&#039;
              &#039;error (such as division by zero).  A Python program can also\n&#039;
              &#039;explicitly raise an exception with the &quot;raise&quot; statement. &#039;
              &#039;Exception\n&#039;
              &#039;handlers are specified with the &quot;try&quot; … &quot;except&quot; statement.  &#039;
              &#039;The\n&#039;
              &#039;&quot;finally&quot; clause of such a statement can be used to specify &#039;
              &#039;cleanup\n&#039;
              &#039;code which does not handle the exception, but is executed &#039;
              &#039;whether an\n&#039;
              &#039;exception occurred or not in the preceding code.\n&#039;
              &#039;\n&#039;
              &#039;Python uses the “termination” model of error handling: an &#039;
              &#039;exception\n&#039;
              &#039;handler can find out what happened and continue execution at an &#039;
              &#039;outer\n&#039;
              &#039;level, but it cannot repair the cause of the error and retry &#039;
              &#039;the\n&#039;
              &#039;failing operation (except by re-entering the offending piece of &#039;
              &#039;code\n&#039;
              &#039;from the top).\n&#039;
              &#039;\n&#039;
              &#039;When an exception is not handled at all, the interpreter &#039;
              &#039;terminates\n&#039;
              &#039;execution of the program, or returns to its interactive main &#039;
              &#039;loop.  In\n&#039;
              &#039;either case, it prints a stack backtrace, except when the &#039;
              &#039;exception is\n&#039;
              &#039;&quot;SystemExit&quot;.\n&#039;
              &#039;\n&#039;
              &#039;Exceptions are identified by class instances.  The &quot;except&quot; &#039;
              &#039;clause is\n&#039;
              &#039;selected depending on the class of the instance: it must &#039;
              &#039;reference the\n&#039;
              &#039;class of the instance or a base class thereof.  The instance &#039;
              &#039;can be\n&#039;
              &#039;received by the handler and can carry additional information &#039;
              &#039;about the\n&#039;
              &#039;exceptional condition.\n&#039;
              &#039;\n&#039;
              &#039;Note: Exception messages are not part of the Python API.  &#039;
              &#039;Their\n&#039;
              &#039;  contents may change from one version of Python to the next &#039;
              &#039;without\n&#039;
              &#039;  warning and should not be relied on by code which will run &#039;
              &#039;under\n&#039;
              &#039;  multiple versions of the interpreter.\n&#039;
              &#039;\n&#039;
              &#039;See also the description of the &quot;try&quot; statement in section The &#039;
              &#039;try\n&#039;
              &#039;statement and &quot;raise&quot; statement in section The raise &#039;
              &#039;statement.\n&#039;
              &#039;\n&#039;
              &#039;-[ Footnotes ]-\n&#039;
              &#039;\n&#039;
              &#039;[1] This limitation occurs because the code that is executed &#039;
              &#039;by\n&#039;
              &#039;    these operations is not available at the time the module &#039;
              &#039;is\n&#039;
              &#039;    compiled.\n&#039;,
 &#039;exprlists&#039;: &#039;Expression lists\n&#039;
              &#039;****************\n&#039;
              &#039;\n&#039;
              &#039;   expression_list    ::= expression (&quot;,&quot; expression)* [&quot;,&quot;]\n&#039;
              &#039;   starred_list       ::= starred_item (&quot;,&quot; starred_item)* &#039;
              &#039;[&quot;,&quot;]\n&#039;
              &#039;   starred_expression ::= expression | (starred_item &quot;,&quot;)* &#039;
              &#039;[starred_item]\n&#039;
              &#039;   starred_item       ::= expression | &quot;*&quot; or_expr\n&#039;
              &#039;\n&#039;
              &#039;Except when part of a list or set display, an expression list\n&#039;
              &#039;containing at least one comma yields a tuple.  The length of &#039;
              &#039;the tuple\n&#039;
              &#039;is the number of expressions in the list.  The expressions are\n&#039;
              &#039;evaluated from left to right.\n&#039;
              &#039;\n&#039;
              &#039;An asterisk &quot;*&quot; denotes *iterable unpacking*.  Its operand must &#039;
              &#039;be an\n&#039;
              &#039;*iterable*.  The iterable is expanded into a sequence of items, &#039;
              &#039;which\n&#039;
              &#039;are included in the new tuple, list, or set, at the site of &#039;
              &#039;the\n&#039;
              &#039;unpacking.\n&#039;
              &#039;\n&#039;
              &#039;New in version 3.5: Iterable unpacking in expression lists, &#039;
              &#039;originally\n&#039;
              &#039;proposed by **PEP 448**.\n&#039;
              &#039;\n&#039;
              &#039;The trailing comma is required only to create a single tuple &#039;
              &#039;(a.k.a. a\n&#039;
              &#039;*singleton*); it is optional in all other cases.  A single &#039;
              &#039;expression\n&#039;
              &#039;without a trailing comma doesn’t create a tuple, but rather &#039;
              &#039;yields the\n&#039;
              &#039;value of that expression. (To create an empty tuple, use an &#039;
              &#039;empty pair\n&#039;
              &#039;of parentheses: &quot;()&quot;.)\n&#039;,
 &#039;floating&#039;: &#039;Floating point literals\n&#039;
             &#039;***********************\n&#039;
             &#039;\n&#039;
             &#039;Floating point literals are described by the following lexical\n&#039;
             &#039;definitions:\n&#039;
             &#039;\n&#039;
             &#039;   floatnumber   ::= pointfloat | exponentfloat\n&#039;
             &#039;   pointfloat    ::= [digitpart] fraction | digitpart &quot;.&quot;\n&#039;
             &#039;   exponentfloat ::= (digitpart | pointfloat) exponent\n&#039;
             &#039;   digitpart     ::= digit ([&quot;_&quot;] digit)*\n&#039;
             &#039;   fraction      ::= &quot;.&quot; digitpart\n&#039;
             &#039;   exponent      ::= (&quot;e&quot; | &quot;E&quot;) [&quot;+&quot; | &quot;-&quot;] digitpart\n&#039;
             &#039;\n&#039;
             &#039;Note that the integer and exponent parts are always interpreted &#039;
             &#039;using\n&#039;
             &#039;radix 10. For example, &quot;077e010&quot; is legal, and denotes the same &#039;
             &#039;number\n&#039;
             &#039;as &quot;77e10&quot;. The allowed range of floating point literals is\n&#039;
             &#039;implementation-dependent.  As in integer literals, underscores &#039;
             &#039;are\n&#039;
             &#039;supported for digit grouping.\n&#039;
             &#039;\n&#039;
             &#039;Some examples of floating point literals:\n&#039;
             &#039;\n&#039;
             &#039;   3.14    10.    .001    1e100    3.14e-10    0e0    &#039;
             &#039;3.14_15_93\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.6: Underscores are now allowed for &#039;
             &#039;grouping\n&#039;
             &#039;purposes in literals.\n&#039;,
 &#039;for&#039;: &#039;The &quot;for&quot; statement\n&#039;
        &#039;*******************\n&#039;
        &#039;\n&#039;
        &#039;The &quot;for&quot; statement is used to iterate over the elements of a &#039;
        &#039;sequence\n&#039;
        &#039;(such as a string, tuple or list) or other iterable object:\n&#039;
        &#039;\n&#039;
        &#039;   for_stmt ::= &quot;for&quot; target_list &quot;in&quot; expression_list &quot;:&quot; suite\n&#039;
        &#039;                [&quot;else&quot; &quot;:&quot; suite]\n&#039;
        &#039;\n&#039;
        &#039;The expression list is evaluated once; it should yield an iterable\n&#039;
        &#039;object.  An iterator is created for the result of the\n&#039;
        &#039;&quot;expression_list&quot;.  The suite is then executed once for each item\n&#039;
        &#039;provided by the iterator, in the order returned by the iterator.  &#039;
        &#039;Each\n&#039;
        &#039;item in turn is assigned to the target list using the standard rules\n&#039;
        &#039;for assignments (see Assignment statements), and then the suite is\n&#039;
        &#039;executed.  When the items are exhausted (which is immediately when &#039;
        &#039;the\n&#039;
        &#039;sequence is empty or an iterator raises a &quot;StopIteration&quot; &#039;
        &#039;exception),\n&#039;
        &#039;the suite in the &quot;else&quot; clause, if present, is executed, and the &#039;
        &#039;loop\n&#039;
        &#039;terminates.\n&#039;
        &#039;\n&#039;
        &#039;A &quot;break&quot; statement executed in the first suite terminates the loop\n&#039;
        &#039;without executing the &quot;else&quot; clause’s suite.  A &quot;continue&quot; statement\n&#039;
        &#039;executed in the first suite skips the rest of the suite and &#039;
        &#039;continues\n&#039;
        &#039;with the next item, or with the &quot;else&quot; clause if there is no next\n&#039;
        &#039;item.\n&#039;
        &#039;\n&#039;
        &#039;The for-loop makes assignments to the variables(s) in the target &#039;
        &#039;list.\n&#039;
        &#039;This overwrites all previous assignments to those variables &#039;
        &#039;including\n&#039;
        &#039;those made in the suite of the for-loop:\n&#039;
        &#039;\n&#039;
        &#039;   for i in range(10):\n&#039;
        &#039;       print(i)\n&#039;
        &#039;       i = 5             # this will not affect the for-loop\n&#039;
        &#039;                         # because i will be overwritten with the &#039;
        &#039;next\n&#039;
        &#039;                         # index in the range\n&#039;
        &#039;\n&#039;
        &#039;Names in the target list are not deleted when the loop is finished,\n&#039;
        &#039;but if the sequence is empty, they will not have been assigned to at\n&#039;
        &#039;all by the loop.  Hint: the built-in function &quot;range()&quot; returns an\n&#039;
        &#039;iterator of integers suitable to emulate the effect of Pascal’s &quot;for &#039;
        &#039;i\n&#039;
        &#039;:= a to b do&quot;; e.g., &quot;list(range(3))&quot; returns the list &quot;[0, 1, 2]&quot;.\n&#039;
        &#039;\n&#039;
        &#039;Note: There is a subtlety when the sequence is being modified by the\n&#039;
        &#039;  loop (this can only occur for mutable sequences, e.g. lists).  An\n&#039;
        &#039;  internal counter is used to keep track of which item is used next,\n&#039;
        &#039;  and this is incremented on each iteration.  When this counter has\n&#039;
        &#039;  reached the length of the sequence the loop terminates.  This &#039;
        &#039;means\n&#039;
        &#039;  that if the suite deletes the current (or a previous) item from &#039;
        &#039;the\n&#039;
        &#039;  sequence, the next item will be skipped (since it gets the index &#039;
        &#039;of\n&#039;
        &#039;  the current item which has already been treated).  Likewise, if &#039;
        &#039;the\n&#039;
        &#039;  suite inserts an item in the sequence before the current item, the\n&#039;
        &#039;  current item will be treated again the next time through the loop.\n&#039;
        &#039;  This can lead to nasty bugs that can be avoided by making a\n&#039;
        &#039;  temporary copy using a slice of the whole sequence, e.g.,\n&#039;
        &#039;\n&#039;
        &#039;     for x in a[:]:\n&#039;
        &#039;         if x &lt; 0: a.remove(x)\n&#039;,
 &#039;formatstrings&#039;: &#039;Format String Syntax\n&#039;
                  &#039;********************\n&#039;
                  &#039;\n&#039;
                  &#039;The &quot;str.format()&quot; method and the &quot;Formatter&quot; class share &#039;
                  &#039;the same\n&#039;
                  &#039;syntax for format strings (although in the case of &#039;
                  &#039;&quot;Formatter&quot;,\n&#039;
                  &#039;subclasses can define their own format string syntax).  The &#039;
                  &#039;syntax is\n&#039;
                  &#039;related to that of formatted string literals, but there &#039;
                  &#039;are\n&#039;
                  &#039;differences.\n&#039;
                  &#039;\n&#039;
                  &#039;Format strings contain “replacement fields” surrounded by &#039;
                  &#039;curly braces\n&#039;
                  &#039;&quot;{}&quot;. Anything that is not contained in braces is &#039;
                  &#039;considered literal\n&#039;
                  &#039;text, which is copied unchanged to the output.  If you need &#039;
                  &#039;to include\n&#039;
                  &#039;a brace character in the literal text, it can be escaped by &#039;
                  &#039;doubling:\n&#039;
                  &#039;&quot;{{&quot; and &quot;}}&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;The grammar for a replacement field is as follows:\n&#039;
                  &#039;\n&#039;
                  &#039;      replacement_field ::= &quot;{&quot; [field_name] [&quot;!&quot; &#039;
                  &#039;conversion] [&quot;:&quot; format_spec] &quot;}&quot;\n&#039;
                  &#039;      field_name        ::= arg_name (&quot;.&quot; attribute_name | &#039;
                  &#039;&quot;[&quot; element_index &quot;]&quot;)*\n&#039;
                  &#039;      arg_name          ::= [identifier | digit+]\n&#039;
                  &#039;      attribute_name    ::= identifier\n&#039;
                  &#039;      element_index     ::= digit+ | index_string\n&#039;
                  &#039;      index_string      ::= &lt;any source character except &#039;
                  &#039;&quot;]&quot;&gt; +\n&#039;
                  &#039;      conversion        ::= &quot;r&quot; | &quot;s&quot; | &quot;a&quot;\n&#039;
                  &#039;      format_spec       ::= &lt;described in the next &#039;
                  &#039;section&gt;\n&#039;
                  &#039;\n&#039;
                  &#039;In less formal terms, the replacement field can start with &#039;
                  &#039;a\n&#039;
                  &#039;*field_name* that specifies the object whose value is to be &#039;
                  &#039;formatted\n&#039;
                  &#039;and inserted into the output instead of the replacement &#039;
                  &#039;field. The\n&#039;
                  &#039;*field_name* is optionally followed by a  *conversion* &#039;
                  &#039;field, which is\n&#039;
                  &#039;preceded by an exclamation point &quot;\&#039;!\&#039;&quot;, and a &#039;
                  &#039;*format_spec*, which is\n&#039;
                  &#039;preceded by a colon &quot;\&#039;:\&#039;&quot;.  These specify a non-default &#039;
                  &#039;format for the\n&#039;
                  &#039;replacement value.\n&#039;
                  &#039;\n&#039;
                  &#039;See also the Format Specification Mini-Language section.\n&#039;
                  &#039;\n&#039;
                  &#039;The *field_name* itself begins with an *arg_name* that is &#039;
                  &#039;either a\n&#039;
                  &#039;number or a keyword.  If it’s a number, it refers to a &#039;
                  &#039;positional\n&#039;
                  &#039;argument, and if it’s a keyword, it refers to a named &#039;
                  &#039;keyword\n&#039;
                  &#039;argument.  If the numerical arg_names in a format string &#039;
                  &#039;are 0, 1, 2,\n&#039;
                  &#039;… in sequence, they can all be omitted (not just some) and &#039;
                  &#039;the numbers\n&#039;
                  &#039;0, 1, 2, … will be automatically inserted in that order. &#039;
                  &#039;Because\n&#039;
                  &#039;*arg_name* is not quote-delimited, it is not possible to &#039;
                  &#039;specify\n&#039;
                  &#039;arbitrary dictionary keys (e.g., the strings &quot;\&#039;10\&#039;&quot; or &#039;
                  &#039;&quot;\&#039;:-]\&#039;&quot;) within\n&#039;
                  &#039;a format string. The *arg_name* can be followed by any &#039;
                  &#039;number of index\n&#039;
                  &#039;or attribute expressions. An expression of the form &#039;
                  &#039;&quot;\&#039;.name\&#039;&quot; selects\n&#039;
                  &#039;the named attribute using &quot;getattr()&quot;, while an expression &#039;
                  &#039;of the form\n&#039;
                  &#039;&quot;\&#039;[index]\&#039;&quot; does an index lookup using &quot;__getitem__()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;Changed in version 3.1: The positional argument specifiers &#039;
                  &#039;can be\n&#039;
                  &#039;omitted for &quot;str.format()&quot;, so &quot;\&#039;{} {}\&#039;.format(a, b)&quot; is &#039;
                  &#039;equivalent to\n&#039;
                  &#039;&quot;\&#039;{0} {1}\&#039;.format(a, b)&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;Changed in version 3.4: The positional argument specifiers &#039;
                  &#039;can be\n&#039;
                  &#039;omitted for &quot;Formatter&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;Some simple format string examples:\n&#039;
                  &#039;\n&#039;
                  &#039;   &quot;First, thou shalt count to {0}&quot;  # References first &#039;
                  &#039;positional argument\n&#039;
                  &#039;   &quot;Bring me a {}&quot;                   # Implicitly &#039;
                  &#039;references the first positional argument\n&#039;
                  &#039;   &quot;From {} to {}&quot;                   # Same as &quot;From {0} to &#039;
                  &#039;{1}&quot;\n&#039;
                  &#039;   &quot;My quest is {name}&quot;              # References keyword &#039;
                  &quot;argument &#039;name&#039;\n&quot;
                  &#039;   &quot;Weight in tons {0.weight}&quot;       # \&#039;weight\&#039; attribute &#039;
                  &#039;of first positional arg\n&#039;
                  &#039;   &quot;Units destroyed: {players[0]}&quot;   # First element of &#039;
                  &quot;keyword argument &#039;players&#039;.\n&quot;
                  &#039;\n&#039;
                  &#039;The *conversion* field causes a type coercion before &#039;
                  &#039;formatting.\n&#039;
                  &#039;Normally, the job of formatting a value is done by the &#039;
                  &#039;&quot;__format__()&quot;\n&#039;
                  &#039;method of the value itself.  However, in some cases it is &#039;
                  &#039;desirable to\n&#039;
                  &#039;force a type to be formatted as a string, overriding its &#039;
                  &#039;own\n&#039;
                  &#039;definition of formatting.  By converting the value to a &#039;
                  &#039;string before\n&#039;
                  &#039;calling &quot;__format__()&quot;, the normal formatting logic is &#039;
                  &#039;bypassed.\n&#039;
                  &#039;\n&#039;
                  &#039;Three conversion flags are currently supported: &quot;\&#039;!s\&#039;&quot; &#039;
                  &#039;which calls\n&#039;
                  &#039;&quot;str()&quot; on the value, &quot;\&#039;!r\&#039;&quot; which calls &quot;repr()&quot; and &#039;
                  &#039;&quot;\&#039;!a\&#039;&quot; which\n&#039;
                  &#039;calls &quot;ascii()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;Some examples:\n&#039;
                  &#039;\n&#039;
                  &#039;   &quot;Harold\&#039;s a clever {0!s}&quot;        # Calls str() on the &#039;
                  &#039;argument first\n&#039;
                  &#039;   &quot;Bring out the holy {name!r}&quot;    # Calls repr() on the &#039;
                  &#039;argument first\n&#039;
                  &#039;   &quot;More {!a}&quot;                      # Calls ascii() on the &#039;
                  &#039;argument first\n&#039;
                  &#039;\n&#039;
                  &#039;The *format_spec* field contains a specification of how the &#039;
                  &#039;value\n&#039;
                  &#039;should be presented, including such details as field width, &#039;
                  &#039;alignment,\n&#039;
                  &#039;padding, decimal precision and so on.  Each value type can &#039;
                  &#039;define its\n&#039;
                  &#039;own “formatting mini-language” or interpretation of the &#039;
                  &#039;*format_spec*.\n&#039;
                  &#039;\n&#039;
                  &#039;Most built-in types support a common formatting &#039;
                  &#039;mini-language, which\n&#039;
                  &#039;is described in the next section.\n&#039;
                  &#039;\n&#039;
                  &#039;A *format_spec* field can also include nested replacement &#039;
                  &#039;fields\n&#039;
                  &#039;within it. These nested replacement fields may contain a &#039;
                  &#039;field name,\n&#039;
                  &#039;conversion flag and format specification, but deeper &#039;
                  &#039;nesting is not\n&#039;
                  &#039;allowed.  The replacement fields within the format_spec &#039;
                  &#039;are\n&#039;
                  &#039;substituted before the *format_spec* string is interpreted. &#039;
                  &#039;This\n&#039;
                  &#039;allows the formatting of a value to be dynamically &#039;
                  &#039;specified.\n&#039;
                  &#039;\n&#039;
                  &#039;See the Format examples section for some examples.\n&#039;
                  &#039;\n&#039;
                  &#039;\n&#039;
                  &#039;Format Specification Mini-Language\n&#039;
                  &#039;==================================\n&#039;
                  &#039;\n&#039;
                  &#039;“Format specifications” are used within replacement fields &#039;
                  &#039;contained\n&#039;
                  &#039;within a format string to define how individual values are &#039;
                  &#039;presented\n&#039;
                  &#039;(see Format String Syntax and Formatted string literals). &#039;
                  &#039;They can\n&#039;
                  &#039;also be passed directly to the built-in &quot;format()&quot; &#039;
                  &#039;function.  Each\n&#039;
                  &#039;formattable type may define how the format specification is &#039;
                  &#039;to be\n&#039;
                  &#039;interpreted.\n&#039;
                  &#039;\n&#039;
                  &#039;Most built-in types implement the following options for &#039;
                  &#039;format\n&#039;
                  &#039;specifications, although some of the formatting options are &#039;
                  &#039;only\n&#039;
                  &#039;supported by the numeric types.\n&#039;
                  &#039;\n&#039;
                  &#039;A general convention is that an empty format string (&quot;&quot;&quot;&quot;) &#039;
                  &#039;produces\n&#039;
                  &#039;the same result as if you had called &quot;str()&quot; on the value. &#039;
                  &#039;A non-empty\n&#039;
                  &#039;format string typically modifies the result.\n&#039;
                  &#039;\n&#039;
                  &#039;The general form of a *standard format specifier* is:\n&#039;
                  &#039;\n&#039;
                  &#039;   format_spec     ::= &#039;
                  &#039;[[fill]align][sign][#][0][width][grouping_option][.precision][type]\n&#039;
                  &#039;   fill            ::= &lt;any character&gt;\n&#039;
                  &#039;   align           ::= &quot;&lt;&quot; | &quot;&gt;&quot; | &quot;=&quot; | &quot;^&quot;\n&#039;
                  &#039;   sign            ::= &quot;+&quot; | &quot;-&quot; | &quot; &quot;\n&#039;
                  &#039;   width           ::= digit+\n&#039;
                  &#039;   grouping_option ::= &quot;_&quot; | &quot;,&quot;\n&#039;
                  &#039;   precision       ::= digit+\n&#039;
                  &#039;   type            ::= &quot;b&quot; | &quot;c&quot; | &quot;d&quot; | &quot;e&quot; | &quot;E&quot; | &quot;f&quot; | &#039;
                  &#039;&quot;F&quot; | &quot;g&quot; | &quot;G&quot; | &quot;n&quot; | &quot;o&quot; | &quot;s&quot; | &quot;x&quot; | &quot;X&quot; | &quot;%&quot;\n&#039;
                  &#039;\n&#039;
                  &#039;If a valid *align* value is specified, it can be preceded &#039;
                  &#039;by a *fill*\n&#039;
                  &#039;character that can be any character and defaults to a space &#039;
                  &#039;if\n&#039;
                  &#039;omitted. It is not possible to use a literal curly brace &#039;
                  &#039;(“&quot;{&quot;” or\n&#039;
                  &#039;“&quot;}&quot;”) as the *fill* character in a formatted string &#039;
                  &#039;literal or when\n&#039;
                  &#039;using the &quot;str.format()&quot; method.  However, it is possible &#039;
                  &#039;to insert a\n&#039;
                  &#039;curly brace with a nested replacement field.  This &#039;
                  &#039;limitation doesn’t\n&#039;
                  &#039;affect the &quot;format()&quot; function.\n&#039;
                  &#039;\n&#039;
                  &#039;The meaning of the various alignment options is as &#039;
                  &#039;follows:\n&#039;
                  &#039;\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | Option    | &#039;
                  &#039;Meaning                                                    &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+===========+============================================================+\n&#039;
                  &#039;   | &quot;\&#039;&lt;\&#039;&quot;     | Forces the field to be left-aligned &#039;
                  &#039;within the available   |\n&#039;
                  &#039;   |           | space (this is the default for most &#039;
                  &#039;objects).              |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;&gt;\&#039;&quot;     | Forces the field to be right-aligned &#039;
                  &#039;within the available  |\n&#039;
                  &#039;   |           | space (this is the default for &#039;
                  &#039;numbers).                   |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;=\&#039;&quot;     | Forces the padding to be placed after &#039;
                  &#039;the sign (if any)    |\n&#039;
                  &#039;   |           | but before the digits.  This is used for &#039;
                  &#039;printing fields   |\n&#039;
                  &#039;   |           | in the form ‘+000000120’. This alignment &#039;
                  &#039;option is only    |\n&#039;
                  &#039;   |           | valid for numeric types.  It becomes the &#039;
                  &#039;default when ‘0’  |\n&#039;
                  &#039;   |           | immediately precedes the field &#039;
                  &#039;width.                      |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;^\&#039;&quot;     | Forces the field to be centered within &#039;
                  &#039;the available       |\n&#039;
                  &#039;   |           | &#039;
                  &#039;space.                                                     &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;\n&#039;
                  &#039;Note that unless a minimum field width is defined, the &#039;
                  &#039;field width\n&#039;
                  &#039;will always be the same size as the data to fill it, so &#039;
                  &#039;that the\n&#039;
                  &#039;alignment option has no meaning in this case.\n&#039;
                  &#039;\n&#039;
                  &#039;The *sign* option is only valid for number types, and can &#039;
                  &#039;be one of\n&#039;
                  &#039;the following:\n&#039;
                  &#039;\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | Option    | &#039;
                  &#039;Meaning                                                    &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+===========+============================================================+\n&#039;
                  &#039;   | &quot;\&#039;+\&#039;&quot;     | indicates that a sign should be used for &#039;
                  &#039;both positive as  |\n&#039;
                  &#039;   |           | well as negative &#039;
                  &#039;numbers.                                  |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;-\&#039;&quot;     | indicates that a sign should be used &#039;
                  &#039;only for negative     |\n&#039;
                  &#039;   |           | numbers (this is the default &#039;
                  &#039;behavior).                    |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | space     | indicates that a leading space should be &#039;
                  &#039;used on positive  |\n&#039;
                  &#039;   |           | numbers, and a minus sign on negative &#039;
                  &#039;numbers.             |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;\n&#039;
                  &#039;The &quot;\&#039;#\&#039;&quot; option causes the “alternate form” to be used &#039;
                  &#039;for the\n&#039;
                  &#039;conversion.  The alternate form is defined differently for &#039;
                  &#039;different\n&#039;
                  &#039;types.  This option is only valid for integer, float, &#039;
                  &#039;complex and\n&#039;
                  &#039;Decimal types. For integers, when binary, octal, or &#039;
                  &#039;hexadecimal output\n&#039;
                  &#039;is used, this option adds the prefix respective &quot;\&#039;0b\&#039;&quot;, &#039;
                  &#039;&quot;\&#039;0o\&#039;&quot;, or\n&#039;
                  &#039;&quot;\&#039;0x\&#039;&quot; to the output value. For floats, complex and &#039;
                  &#039;Decimal the\n&#039;
                  &#039;alternate form causes the result of the conversion to &#039;
                  &#039;always contain a\n&#039;
                  &#039;decimal-point character, even if no digits follow it. &#039;
                  &#039;Normally, a\n&#039;
                  &#039;decimal-point character appears in the result of these &#039;
                  &#039;conversions\n&#039;
                  &#039;only if a digit follows it. In addition, for &quot;\&#039;g\&#039;&quot; and &#039;
                  &#039;&quot;\&#039;G\&#039;&quot;\n&#039;
                  &#039;conversions, trailing zeros are not removed from the &#039;
                  &#039;result.\n&#039;
                  &#039;\n&#039;
                  &#039;The &quot;\&#039;,\&#039;&quot; option signals the use of a comma for a &#039;
                  &#039;thousands separator.\n&#039;
                  &#039;For a locale aware separator, use the &quot;\&#039;n\&#039;&quot; integer &#039;
                  &#039;presentation type\n&#039;
                  &#039;instead.\n&#039;
                  &#039;\n&#039;
                  &#039;Changed in version 3.1: Added the &quot;\&#039;,\&#039;&quot; option (see also &#039;
                  &#039;**PEP 378**).\n&#039;
                  &#039;\n&#039;
                  &#039;The &quot;\&#039;_\&#039;&quot; option signals the use of an underscore for a &#039;
                  &#039;thousands\n&#039;
                  &#039;separator for floating point presentation types and for &#039;
                  &#039;integer\n&#039;
                  &#039;presentation type &quot;\&#039;d\&#039;&quot;.  For integer presentation types &#039;
                  &#039;&quot;\&#039;b\&#039;&quot;, &quot;\&#039;o\&#039;&quot;,\n&#039;
                  &#039;&quot;\&#039;x\&#039;&quot;, and &quot;\&#039;X\&#039;&quot;, underscores will be inserted every 4 &#039;
                  &#039;digits.  For\n&#039;
                  &#039;other presentation types, specifying this option is an &#039;
                  &#039;error.\n&#039;
                  &#039;\n&#039;
                  &#039;Changed in version 3.6: Added the &quot;\&#039;_\&#039;&quot; option (see also &#039;
                  &#039;**PEP 515**).\n&#039;
                  &#039;\n&#039;
                  &#039;*width* is a decimal integer defining the minimum field &#039;
                  &#039;width.  If not\n&#039;
                  &#039;specified, then the field width will be determined by the &#039;
                  &#039;content.\n&#039;
                  &#039;\n&#039;
                  &#039;When no explicit alignment is given, preceding the *width* &#039;
                  &#039;field by a\n&#039;
                  &#039;zero (&quot;\&#039;0\&#039;&quot;) character enables sign-aware zero-padding &#039;
                  &#039;for numeric\n&#039;
                  &#039;types.  This is equivalent to a *fill* character of &quot;\&#039;0\&#039;&quot; &#039;
                  &#039;with an\n&#039;
                  &#039;*alignment* type of &quot;\&#039;=\&#039;&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;The *precision* is a decimal number indicating how many &#039;
                  &#039;digits should\n&#039;
                  &#039;be displayed after the decimal point for a floating point &#039;
                  &#039;value\n&#039;
                  &#039;formatted with &quot;\&#039;f\&#039;&quot; and &quot;\&#039;F\&#039;&quot;, or before and after the &#039;
                  &#039;decimal point\n&#039;
                  &#039;for a floating point value formatted with &quot;\&#039;g\&#039;&quot; or &#039;
                  &#039;&quot;\&#039;G\&#039;&quot;.  For non-\n&#039;
                  &#039;number types the field indicates the maximum field size - &#039;
                  &#039;in other\n&#039;
                  &#039;words, how many characters will be used from the field &#039;
                  &#039;content. The\n&#039;
                  &#039;*precision* is not allowed for integer values.\n&#039;
                  &#039;\n&#039;
                  &#039;Finally, the *type* determines how the data should be &#039;
                  &#039;presented.\n&#039;
                  &#039;\n&#039;
                  &#039;The available string presentation types are:\n&#039;
                  &#039;\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | Type      | &#039;
                  &#039;Meaning                                                    &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+===========+============================================================+\n&#039;
                  &#039;   | &quot;\&#039;s\&#039;&quot;     | String format. This is the default type &#039;
                  &#039;for strings and    |\n&#039;
                  &#039;   |           | may be &#039;
                  &#039;omitted.                                            |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | None      | The same as &#039;
                  &#039;&quot;\&#039;s\&#039;&quot;.                                         |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;\n&#039;
                  &#039;The available integer presentation types are:\n&#039;
                  &#039;\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | Type      | &#039;
                  &#039;Meaning                                                    &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+===========+============================================================+\n&#039;
                  &#039;   | &quot;\&#039;b\&#039;&quot;     | Binary format. Outputs the number in &#039;
                  &#039;base 2.               |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;c\&#039;&quot;     | Character. Converts the integer to the &#039;
                  &#039;corresponding       |\n&#039;
                  &#039;   |           | unicode character before &#039;
                  &#039;printing.                         |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;d\&#039;&quot;     | Decimal Integer. Outputs the number in &#039;
                  &#039;base 10.            |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;o\&#039;&quot;     | Octal format. Outputs the number in base &#039;
                  &#039;8.                |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;x\&#039;&quot;     | Hex format. Outputs the number in base &#039;
                  &#039;16, using lower-    |\n&#039;
                  &#039;   |           | case letters for the digits above &#039;
                  &#039;9.                       |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;X\&#039;&quot;     | Hex format. Outputs the number in base &#039;
                  &#039;16, using upper-    |\n&#039;
                  &#039;   |           | case letters for the digits above &#039;
                  &#039;9.                       |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;n\&#039;&quot;     | Number. This is the same as &quot;\&#039;d\&#039;&quot;, &#039;
                  &#039;except that it uses the |\n&#039;
                  &#039;   |           | current locale setting to insert the &#039;
                  &#039;appropriate number    |\n&#039;
                  &#039;   |           | separator &#039;
                  &#039;characters.                                      |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | None      | The same as &#039;
                  &#039;&quot;\&#039;d\&#039;&quot;.                                         |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;\n&#039;
                  &#039;In addition to the above presentation types, integers can &#039;
                  &#039;be formatted\n&#039;
                  &#039;with the floating point presentation types listed below &#039;
                  &#039;(except &quot;\&#039;n\&#039;&quot;\n&#039;
                  &#039;and &quot;None&quot;). When doing so, &quot;float()&quot; is used to convert &#039;
                  &#039;the integer\n&#039;
                  &#039;to a floating point number before formatting.\n&#039;
                  &#039;\n&#039;
                  &#039;The available presentation types for floating point and &#039;
                  &#039;decimal values\n&#039;
                  &#039;are:\n&#039;
                  &#039;\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | Type      | &#039;
                  &#039;Meaning                                                    &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+===========+============================================================+\n&#039;
                  &#039;   | &quot;\&#039;e\&#039;&quot;     | Exponent notation. Prints the number in &#039;
                  &#039;scientific         |\n&#039;
                  &#039;   |           | notation using the letter ‘e’ to indicate &#039;
                  &#039;the exponent.    |\n&#039;
                  &#039;   |           | The default precision is &#039;
                  &#039;&quot;6&quot;.                              |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;E\&#039;&quot;     | Exponent notation. Same as &quot;\&#039;e\&#039;&quot; &#039;
                  &#039;except it uses an upper   |\n&#039;
                  &#039;   |           | case ‘E’ as the separator &#039;
                  &#039;character.                       |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;f\&#039;&quot;     | Fixed-point notation. Displays the &#039;
                  &#039;number as a fixed-point |\n&#039;
                  &#039;   |           | number. The default precision is &#039;
                  &#039;&quot;6&quot;.                      |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;F\&#039;&quot;     | Fixed-point notation. Same as &quot;\&#039;f\&#039;&quot;, &#039;
                  &#039;but converts &quot;nan&quot; to |\n&#039;
                  &#039;   |           | &quot;NAN&quot; and &quot;inf&quot; to &#039;
                  &#039;&quot;INF&quot;.                                  |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;g\&#039;&quot;     | General format.  For a given precision &#039;
                  &#039;&quot;p &gt;= 1&quot;, this      |\n&#039;
                  &#039;   |           | rounds the number to &quot;p&quot; significant &#039;
                  &#039;digits and then       |\n&#039;
                  &#039;   |           | formats the result in either fixed-point &#039;
                  &#039;format or in      |\n&#039;
                  &#039;   |           | scientific notation, depending on its &#039;
                  &#039;magnitude.  The      |\n&#039;
                  &#039;   |           | precise rules are as follows: suppose that &#039;
                  &#039;the result      |\n&#039;
                  &#039;   |           | formatted with presentation type &quot;\&#039;e\&#039;&quot; &#039;
                  &#039;and precision &quot;p-1&quot; |\n&#039;
                  &#039;   |           | would have exponent &quot;exp&quot;.  Then if &quot;-4 &lt;= &#039;
                  &#039;exp &lt; p&quot;, the   |\n&#039;
                  &#039;   |           | number is formatted with presentation type &#039;
                  &#039;&quot;\&#039;f\&#039;&quot; and       |\n&#039;
                  &#039;   |           | precision &quot;p-1-exp&quot;.  Otherwise, the &#039;
                  &#039;number is formatted   |\n&#039;
                  &#039;   |           | with presentation type &quot;\&#039;e\&#039;&quot; and &#039;
                  &#039;precision &quot;p-1&quot;. In both  |\n&#039;
                  &#039;   |           | cases insignificant trailing zeros are &#039;
                  &#039;removed from the    |\n&#039;
                  &#039;   |           | significand, and the decimal point is also &#039;
                  &#039;removed if      |\n&#039;
                  &#039;   |           | there are no remaining digits following &#039;
                  &#039;it.  Positive and  |\n&#039;
                  &#039;   |           | negative infinity, positive and negative &#039;
                  &#039;zero, and nans,   |\n&#039;
                  &#039;   |           | are formatted as &quot;inf&quot;, &quot;-inf&quot;, &quot;0&quot;, &quot;-0&quot; &#039;
                  &#039;and &quot;nan&quot;        |\n&#039;
                  &#039;   |           | respectively, regardless of the &#039;
                  &#039;precision.  A precision of |\n&#039;
                  &#039;   |           | &quot;0&quot; is treated as equivalent to a &#039;
                  &#039;precision of &quot;1&quot;. The    |\n&#039;
                  &#039;   |           | default precision is &#039;
                  &#039;&quot;6&quot;.                                  |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;G\&#039;&quot;     | General format. Same as &quot;\&#039;g\&#039;&quot; except &#039;
                  &#039;switches to &quot;\&#039;E\&#039;&quot; if  |\n&#039;
                  &#039;   |           | the number gets too large. The &#039;
                  &#039;representations of infinity |\n&#039;
                  &#039;   |           | and NaN are uppercased, &#039;
                  &#039;too.                               |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;n\&#039;&quot;     | Number. This is the same as &quot;\&#039;g\&#039;&quot;, &#039;
                  &#039;except that it uses the |\n&#039;
                  &#039;   |           | current locale setting to insert the &#039;
                  &#039;appropriate number    |\n&#039;
                  &#039;   |           | separator &#039;
                  &#039;characters.                                      |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;%\&#039;&quot;     | Percentage. Multiplies the number by 100 &#039;
                  &#039;and displays in   |\n&#039;
                  &#039;   |           | fixed (&quot;\&#039;f\&#039;&quot;) format, followed by a &#039;
                  &#039;percent sign.          |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | None      | Similar to &quot;\&#039;g\&#039;&quot;, except that &#039;
                  &#039;fixed-point notation, when   |\n&#039;
                  &#039;   |           | used, has at least one digit past the &#039;
                  &#039;decimal point. The   |\n&#039;
                  &#039;   |           | default precision is as high as needed to &#039;
                  &#039;represent the    |\n&#039;
                  &#039;   |           | particular value. The overall effect is to &#039;
                  &#039;match the       |\n&#039;
                  &#039;   |           | output of &quot;str()&quot; as altered by the other &#039;
                  &#039;format           |\n&#039;
                  &#039;   |           | &#039;
                  &#039;modifiers.                                                 &#039;
                  &#039;|\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;\n&#039;
                  &#039;\n&#039;
                  &#039;Format examples\n&#039;
                  &#039;===============\n&#039;
                  &#039;\n&#039;
                  &#039;This section contains examples of the &quot;str.format()&quot; syntax &#039;
                  &#039;and\n&#039;
                  &#039;comparison with the old &quot;%&quot;-formatting.\n&#039;
                  &#039;\n&#039;
                  &#039;In most of the cases the syntax is similar to the old &#039;
                  &#039;&quot;%&quot;-formatting,\n&#039;
                  &#039;with the addition of the &quot;{}&quot; and with &quot;:&quot; used instead of &#039;
                  &#039;&quot;%&quot;. For\n&#039;
                  &#039;example, &quot;\&#039;%03.2f\&#039;&quot; can be translated to &quot;\&#039;{:03.2f}\&#039;&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;The new format syntax also supports new and different &#039;
                  &#039;options, shown\n&#039;
                  &#039;in the following examples.\n&#039;
                  &#039;\n&#039;
                  &#039;Accessing arguments by position:\n&#039;
                  &#039;\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;{0}, {1}, {2}&#039;.format(&#039;a&#039;, &#039;b&#039;, &#039;c&#039;)\n&quot;
                  &quot;   &#039;a, b, c&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{}, {}, {}&#039;.format(&#039;a&#039;, &#039;b&#039;, &#039;c&#039;)  # 3.1+ only\n&quot;
                  &quot;   &#039;a, b, c&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{2}, {1}, {0}&#039;.format(&#039;a&#039;, &#039;b&#039;, &#039;c&#039;)\n&quot;
                  &quot;   &#039;c, b, a&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{2}, {1}, {0}&#039;.format(*&#039;abc&#039;)      # unpacking &quot;
                  &#039;argument sequence\n&#039;
                  &quot;   &#039;c, b, a&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{0}{1}{0}&#039;.format(&#039;abra&#039;, &#039;cad&#039;)   # arguments&#039; &quot;
                  &#039;indices can be repeated\n&#039;
                  &quot;   &#039;abracadabra&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Accessing arguments by name:\n&#039;
                  &#039;\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;Coordinates: {latitude}, &quot;
                  &quot;{longitude}&#039;.format(latitude=&#039;37.24N&#039;, &quot;
                  &quot;longitude=&#039;-115.81W&#039;)\n&quot;
                  &quot;   &#039;Coordinates: 37.24N, -115.81W&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; coord = {&#039;latitude&#039;: &#039;37.24N&#039;, &#039;longitude&#039;: &quot;
                  &quot;&#039;-115.81W&#039;}\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;Coordinates: {latitude}, &quot;
                  &quot;{longitude}&#039;.format(**coord)\n&quot;
                  &quot;   &#039;Coordinates: 37.24N, -115.81W&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Accessing arguments’ attributes:\n&#039;
                  &#039;\n&#039;
                  &#039;   &gt;&gt;&gt; c = 3-5j\n&#039;
                  &quot;   &gt;&gt;&gt; (&#039;The complex number {0} is formed from the real &quot;
                  &quot;part {0.real} &#039;\n&quot;
                  &quot;   ...  &#039;and the imaginary part {0.imag}.&#039;).format(c)\n&quot;
                  &quot;   &#039;The complex number (3-5j) is formed from the real part &quot;
                  &quot;3.0 and the imaginary part -5.0.&#039;\n&quot;
                  &#039;   &gt;&gt;&gt; class Point:\n&#039;
                  &#039;   ...     def __init__(self, x, y):\n&#039;
                  &#039;   ...         self.x, self.y = x, y\n&#039;
                  &#039;   ...     def __str__(self):\n&#039;
                  &quot;   ...         return &#039;Point({self.x}, &quot;
                  &quot;{self.y})&#039;.format(self=self)\n&quot;
                  &#039;   ...\n&#039;
                  &#039;   &gt;&gt;&gt; str(Point(4, 2))\n&#039;
                  &quot;   &#039;Point(4, 2)&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Accessing arguments’ items:\n&#039;
                  &#039;\n&#039;
                  &#039;   &gt;&gt;&gt; coord = (3, 5)\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;X: {0[0]};  Y: {0[1]}&#039;.format(coord)\n&quot;
                  &quot;   &#039;X: 3;  Y: 5&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Replacing &quot;%s&quot; and &quot;%r&quot;:\n&#039;
                  &#039;\n&#039;
                  &#039;   &gt;&gt;&gt; &quot;repr() shows quotes: {!r}; str() doesn\&#039;t: &#039;
                  &#039;{!s}&quot;.format(\&#039;test1\&#039;, \&#039;test2\&#039;)\n&#039;
                  &#039;   &quot;repr() shows quotes: \&#039;test1\&#039;; str() doesn\&#039;t: test2&quot;\n&#039;
                  &#039;\n&#039;
                  &#039;Aligning the text and specifying a width:\n&#039;
                  &#039;\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;{:&lt;30}&#039;.format(&#039;left aligned&#039;)\n&quot;
                  &quot;   &#039;left aligned                  &#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{:&gt;30}&#039;.format(&#039;right aligned&#039;)\n&quot;
                  &quot;   &#039;                 right aligned&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{:^30}&#039;.format(&#039;centered&#039;)\n&quot;
                  &quot;   &#039;           centered           &#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{:*^30}&#039;.format(&#039;centered&#039;)  # use &#039;*&#039; as a fill &quot;
                  &#039;char\n&#039;
                  &quot;   &#039;***********centered***********&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Replacing &quot;%+f&quot;, &quot;%-f&quot;, and &quot;% f&quot; and specifying a sign:\n&#039;
                  &#039;\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;{:+f}; {:+f}&#039;.format(3.14, -3.14)  # show it &quot;
                  &#039;always\n&#039;
                  &quot;   &#039;+3.140000; -3.140000&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{: f}; {: f}&#039;.format(3.14, -3.14)  # show a space &quot;
                  &#039;for positive numbers\n&#039;
                  &quot;   &#039; 3.140000; -3.140000&#039;\n&quot;
                  &quot;   &gt;&gt;&gt; &#039;{:-f}; {:-f}&#039;.format(3.14, -3.14)  # show only the &quot;
                  &quot;minus -- same as &#039;{:f}; {:f}&#039;\n&quot;
                  &quot;   &#039;3.140000; -3.140000&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Replacing &quot;%x&quot; and &quot;%o&quot; and converting the value to &#039;
                  &#039;different bases:\n&#039;
                  &#039;\n&#039;
                  &#039;   &gt;&gt;&gt; # format also supports binary numbers\n&#039;
                  &#039;   &gt;&gt;&gt; &quot;int: {0:d};  hex: {0:x};  oct: {0:o};  bin: &#039;
                  &#039;{0:b}&quot;.format(42)\n&#039;
                  &quot;   &#039;int: 42;  hex: 2a;  oct: 52;  bin: 101010&#039;\n&quot;
                  &#039;   &gt;&gt;&gt; # with 0x, 0o, or 0b as prefix:\n&#039;
                  &#039;   &gt;&gt;&gt; &quot;int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: &#039;
                  &#039;{0:#b}&quot;.format(42)\n&#039;
                  &quot;   &#039;int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Using the comma as a thousands separator:\n&#039;
                  &#039;\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;{:,}&#039;.format(1234567890)\n&quot;
                  &quot;   &#039;1,234,567,890&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Expressing a percentage:\n&#039;
                  &#039;\n&#039;
                  &#039;   &gt;&gt;&gt; points = 19\n&#039;
                  &#039;   &gt;&gt;&gt; total = 22\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;Correct answers: {:.2%}&#039;.format(points/total)\n&quot;
                  &quot;   &#039;Correct answers: 86.36%&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Using type-specific formatting:\n&#039;
                  &#039;\n&#039;
                  &#039;   &gt;&gt;&gt; import datetime\n&#039;
                  &#039;   &gt;&gt;&gt; d = datetime.datetime(2010, 7, 4, 12, 15, 58)\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;{:%Y-%m-%d %H:%M:%S}&#039;.format(d)\n&quot;
                  &quot;   &#039;2010-07-04 12:15:58&#039;\n&quot;
                  &#039;\n&#039;
                  &#039;Nesting arguments and more complex examples:\n&#039;
                  &#039;\n&#039;
                  &quot;   &gt;&gt;&gt; for align, text in zip(&#039;&lt;^&gt;&#039;, [&#039;left&#039;, &#039;center&#039;, &quot;
                  &quot;&#039;right&#039;]):\n&quot;
                  &quot;   ...     &#039;{0:{fill}{align}16}&#039;.format(text, fill=align, &quot;
                  &#039;align=align)\n&#039;
                  &#039;   ...\n&#039;
                  &quot;   &#039;left&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&#039;\n&quot;
                  &quot;   &#039;^^^^^center^^^^^&#039;\n&quot;
                  &quot;   &#039;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;right&#039;\n&quot;
                  &#039;   &gt;&gt;&gt;\n&#039;
                  &#039;   &gt;&gt;&gt; octets = [192, 168, 0, 1]\n&#039;
                  &quot;   &gt;&gt;&gt; &#039;{:02X}{:02X}{:02X}{:02X}&#039;.format(*octets)\n&quot;
                  &quot;   &#039;C0A80001&#039;\n&quot;
                  &#039;   &gt;&gt;&gt; int(_, 16)\n&#039;
                  &#039;   3232235521\n&#039;
                  &#039;   &gt;&gt;&gt;\n&#039;
                  &#039;   &gt;&gt;&gt; width = 5\n&#039;
                  &#039;   &gt;&gt;&gt; for num in range(5,12): \n&#039;
                  &quot;   ...     for base in &#039;dXob&#039;:\n&quot;
                  &quot;   ...         print(&#039;{0:{width}{base}}&#039;.format(num, &quot;
                  &quot;base=base, width=width), end=&#039; &#039;)\n&quot;
                  &#039;   ...     print()\n&#039;
                  &#039;   ...\n&#039;
                  &#039;       5     5     5   101\n&#039;
                  &#039;       6     6     6   110\n&#039;
                  &#039;       7     7     7   111\n&#039;
                  &#039;       8     8    10  1000\n&#039;
                  &#039;       9     9    11  1001\n&#039;
                  &#039;      10     A    12  1010\n&#039;
                  &#039;      11     B    13  1011\n&#039;,
 &#039;function&#039;: &#039;Function definitions\n&#039;
             &#039;********************\n&#039;
             &#039;\n&#039;
             &#039;A function definition defines a user-defined function object &#039;
             &#039;(see\n&#039;
             &#039;section The standard type hierarchy):\n&#039;
             &#039;\n&#039;
             &#039;   funcdef                 ::= [decorators] &quot;def&quot; funcname &quot;(&quot; &#039;
             &#039;[parameter_list] &quot;)&quot;\n&#039;
             &#039;               [&quot;-&gt;&quot; expression] &quot;:&quot; suite\n&#039;
             &#039;   decorators              ::= decorator+\n&#039;
             &#039;   decorator               ::= &quot;@&quot; dotted_name [&quot;(&quot; &#039;
             &#039;[argument_list [&quot;,&quot;]] &quot;)&quot;] NEWLINE\n&#039;
             &#039;   dotted_name             ::= identifier (&quot;.&quot; identifier)*\n&#039;
             &#039;   parameter_list          ::= defparameter (&quot;,&quot; defparameter)* &#039;
             &#039;[&quot;,&quot; [parameter_list_starargs]]\n&#039;
             &#039;                      | parameter_list_starargs\n&#039;
             &#039;   parameter_list_starargs ::= &quot;*&quot; [parameter] (&quot;,&quot; &#039;
             &#039;defparameter)* [&quot;,&quot; [&quot;**&quot; parameter [&quot;,&quot;]]]\n&#039;
             &#039;                               | &quot;**&quot; parameter [&quot;,&quot;]\n&#039;
             &#039;   parameter               ::= identifier [&quot;:&quot; expression]\n&#039;
             &#039;   defparameter            ::= parameter [&quot;=&quot; expression]\n&#039;
             &#039;   funcname                ::= identifier\n&#039;
             &#039;\n&#039;
             &#039;A function definition is an executable statement.  Its execution &#039;
             &#039;binds\n&#039;
             &#039;the function name in the current local namespace to a function &#039;
             &#039;object\n&#039;
             &#039;(a wrapper around the executable code for the function).  This\n&#039;
             &#039;function object contains a reference to the current global &#039;
             &#039;namespace\n&#039;
             &#039;as the global namespace to be used when the function is called.\n&#039;
             &#039;\n&#039;
             &#039;The function definition does not execute the function body; this &#039;
             &#039;gets\n&#039;
             &#039;executed only when the function is called. [2]\n&#039;
             &#039;\n&#039;
             &#039;A function definition may be wrapped by one or more *decorator*\n&#039;
             &#039;expressions. Decorator expressions are evaluated when the &#039;
             &#039;function is\n&#039;
             &#039;defined, in the scope that contains the function definition.  &#039;
             &#039;The\n&#039;
             &#039;result must be a callable, which is invoked with the function &#039;
             &#039;object\n&#039;
             &#039;as the only argument. The returned value is bound to the &#039;
             &#039;function name\n&#039;
             &#039;instead of the function object.  Multiple decorators are applied &#039;
             &#039;in\n&#039;
             &#039;nested fashion. For example, the following code\n&#039;
             &#039;\n&#039;
             &#039;   @f1(arg)\n&#039;
             &#039;   @f2\n&#039;
             &#039;   def func(): pass\n&#039;
             &#039;\n&#039;
             &#039;is roughly equivalent to\n&#039;
             &#039;\n&#039;
             &#039;   def func(): pass\n&#039;
             &#039;   func = f1(arg)(f2(func))\n&#039;
             &#039;\n&#039;
             &#039;except that the original function is not temporarily bound to &#039;
             &#039;the name\n&#039;
             &#039;&quot;func&quot;.\n&#039;
             &#039;\n&#039;
             &#039;When one or more *parameters* have the form *parameter* &quot;=&quot;\n&#039;
             &#039;*expression*, the function is said to have “default parameter &#039;
             &#039;values.”\n&#039;
             &#039;For a parameter with a default value, the corresponding &#039;
             &#039;*argument* may\n&#039;
             &#039;be omitted from a call, in which case the parameter’s default &#039;
             &#039;value is\n&#039;
             &#039;substituted.  If a parameter has a default value, all following\n&#039;
             &#039;parameters up until the “&quot;*&quot;” must also have a default value — &#039;
             &#039;this is\n&#039;
             &#039;a syntactic restriction that is not expressed by the grammar.\n&#039;
             &#039;\n&#039;
             &#039;**Default parameter values are evaluated from left to right when &#039;
             &#039;the\n&#039;
             &#039;function definition is executed.** This means that the &#039;
             &#039;expression is\n&#039;
             &#039;evaluated once, when the function is defined, and that the same &#039;
             &#039;“pre-\n&#039;
             &#039;computed” value is used for each call.  This is especially &#039;
             &#039;important\n&#039;
             &#039;to understand when a default parameter is a mutable object, such &#039;
             &#039;as a\n&#039;
             &#039;list or a dictionary: if the function modifies the object (e.g. &#039;
             &#039;by\n&#039;
             &#039;appending an item to a list), the default value is in effect &#039;
             &#039;modified.\n&#039;
             &#039;This is generally not what was intended.  A way around this is &#039;
             &#039;to use\n&#039;
             &#039;&quot;None&quot; as the default, and explicitly test for it in the body of &#039;
             &#039;the\n&#039;
             &#039;function, e.g.:\n&#039;
             &#039;\n&#039;
             &#039;   def whats_on_the_telly(penguin=None):\n&#039;
             &#039;       if penguin is None:\n&#039;
             &#039;           penguin = []\n&#039;
             &#039;       penguin.append(&quot;property of the zoo&quot;)\n&#039;
             &#039;       return penguin\n&#039;
             &#039;\n&#039;
             &#039;Function call semantics are described in more detail in section &#039;
             &#039;Calls.\n&#039;
             &#039;A function call always assigns values to all parameters &#039;
             &#039;mentioned in\n&#039;
             &#039;the parameter list, either from position arguments, from &#039;
             &#039;keyword\n&#039;
             &#039;arguments, or from default values.  If the form “&quot;*identifier&quot;” &#039;
             &#039;is\n&#039;
             &#039;present, it is initialized to a tuple receiving any excess &#039;
             &#039;positional\n&#039;
             &#039;parameters, defaulting to the empty tuple. If the form\n&#039;
             &#039;“&quot;**identifier&quot;” is present, it is initialized to a new ordered\n&#039;
             &#039;mapping receiving any excess keyword arguments, defaulting to a &#039;
             &#039;new\n&#039;
             &#039;empty mapping of the same type.  Parameters after “&quot;*&quot;” or\n&#039;
             &#039;“&quot;*identifier&quot;” are keyword-only parameters and may only be &#039;
             &#039;passed\n&#039;
             &#039;used keyword arguments.\n&#039;
             &#039;\n&#039;
             &#039;Parameters may have annotations of the form “&quot;: expression&quot;” &#039;
             &#039;following\n&#039;
             &#039;the parameter name.  Any parameter may have an annotation even &#039;
             &#039;those\n&#039;
             &#039;of the form &quot;*identifier&quot; or &quot;**identifier&quot;.  Functions may &#039;
             &#039;have\n&#039;
             &#039;“return” annotation of the form “&quot;-&gt; expression&quot;” after the &#039;
             &#039;parameter\n&#039;
             &#039;list.  These annotations can be any valid Python expression and &#039;
             &#039;are\n&#039;
             &#039;evaluated when the function definition is executed.  Annotations &#039;
             &#039;may\n&#039;
             &#039;be evaluated in a different order than they appear in the source &#039;
             &#039;code.\n&#039;
             &#039;The presence of annotations does not change the semantics of a\n&#039;
             &#039;function.  The annotation values are available as values of a\n&#039;
             &#039;dictionary keyed by the parameters’ names in the &#039;
             &#039;&quot;__annotations__&quot;\n&#039;
             &#039;attribute of the function object.\n&#039;
             &#039;\n&#039;
             &#039;It is also possible to create anonymous functions (functions not &#039;
             &#039;bound\n&#039;
             &#039;to a name), for immediate use in expressions.  This uses lambda\n&#039;
             &#039;expressions, described in section Lambdas.  Note that the &#039;
             &#039;lambda\n&#039;
             &#039;expression is merely a shorthand for a simplified function &#039;
             &#039;definition;\n&#039;
             &#039;a function defined in a “&quot;def&quot;” statement can be passed around &#039;
             &#039;or\n&#039;
             &#039;assigned to another name just like a function defined by a &#039;
             &#039;lambda\n&#039;
             &#039;expression.  The “&quot;def&quot;” form is actually more powerful since &#039;
             &#039;it\n&#039;
             &#039;allows the execution of multiple statements and annotations.\n&#039;
             &#039;\n&#039;
             &#039;**Programmer’s note:** Functions are first-class objects.  A &#039;
             &#039;“&quot;def&quot;”\n&#039;
             &#039;statement executed inside a function definition defines a local\n&#039;
             &#039;function that can be returned or passed around.  Free variables &#039;
             &#039;used\n&#039;
             &#039;in the nested function can access the local variables of the &#039;
             &#039;function\n&#039;
             &#039;containing the def.  See section Naming and binding for &#039;
             &#039;details.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 3107** - Function Annotations\n&#039;
             &#039;     The original specification for function annotations.\n&#039;,
 &#039;global&#039;: &#039;The &quot;global&quot; statement\n&#039;
           &#039;**********************\n&#039;
           &#039;\n&#039;
           &#039;   global_stmt ::= &quot;global&quot; identifier (&quot;,&quot; identifier)*\n&#039;
           &#039;\n&#039;
           &#039;The &quot;global&quot; statement is a declaration which holds for the &#039;
           &#039;entire\n&#039;
           &#039;current code block.  It means that the listed identifiers are to &#039;
           &#039;be\n&#039;
           &#039;interpreted as globals.  It would be impossible to assign to a &#039;
           &#039;global\n&#039;
           &#039;variable without &quot;global&quot;, although free variables may refer to\n&#039;
           &#039;globals without being declared global.\n&#039;
           &#039;\n&#039;
           &#039;Names listed in a &quot;global&quot; statement must not be used in the same &#039;
           &#039;code\n&#039;
           &#039;block textually preceding that &quot;global&quot; statement.\n&#039;
           &#039;\n&#039;
           &#039;Names listed in a &quot;global&quot; statement must not be defined as &#039;
           &#039;formal\n&#039;
           &#039;parameters or in a &quot;for&quot; loop control target, &quot;class&quot; definition,\n&#039;
           &#039;function definition, &quot;import&quot; statement, or variable annotation.\n&#039;
           &#039;\n&#039;
           &#039;**CPython implementation detail:** The current implementation does &#039;
           &#039;not\n&#039;
           &#039;enforce some of these restrictions, but programs should not abuse &#039;
           &#039;this\n&#039;
           &#039;freedom, as future implementations may enforce them or silently &#039;
           &#039;change\n&#039;
           &#039;the meaning of the program.\n&#039;
           &#039;\n&#039;
           &#039;**Programmer’s note:** &quot;global&quot; is a directive to the parser.  It\n&#039;
           &#039;applies only to code parsed at the same time as the &quot;global&quot;\n&#039;
           &#039;statement. In particular, a &quot;global&quot; statement contained in a &#039;
           &#039;string\n&#039;
           &#039;or code object supplied to the built-in &quot;exec()&quot; function does &#039;
           &#039;not\n&#039;
           &#039;affect the code block *containing* the function call, and code\n&#039;
           &#039;contained in such a string is unaffected by &quot;global&quot; statements in &#039;
           &#039;the\n&#039;
           &#039;code containing the function call.  The same applies to the &#039;
           &#039;&quot;eval()&quot;\n&#039;
           &#039;and &quot;compile()&quot; functions.\n&#039;,
 &#039;id-classes&#039;: &#039;Reserved classes of identifiers\n&#039;
               &#039;*******************************\n&#039;
               &#039;\n&#039;
               &#039;Certain classes of identifiers (besides keywords) have &#039;
               &#039;special\n&#039;
               &#039;meanings.  These classes are identified by the patterns of &#039;
               &#039;leading and\n&#039;
               &#039;trailing underscore characters:\n&#039;
               &#039;\n&#039;
               &#039;&quot;_*&quot;\n&#039;
               &#039;   Not imported by &quot;from module import *&quot;.  The special &#039;
               &#039;identifier &quot;_&quot;\n&#039;
               &#039;   is used in the interactive interpreter to store the result &#039;
               &#039;of the\n&#039;
               &#039;   last evaluation; it is stored in the &quot;builtins&quot; module.  &#039;
               &#039;When not\n&#039;
               &#039;   in interactive mode, &quot;_&quot; has no special meaning and is not &#039;
               &#039;defined.\n&#039;
               &#039;   See section The import statement.\n&#039;
               &#039;\n&#039;
               &#039;   Note: The name &quot;_&quot; is often used in conjunction with\n&#039;
               &#039;     internationalization; refer to the documentation for the\n&#039;
               &#039;     &quot;gettext&quot; module for more information on this &#039;
               &#039;convention.\n&#039;
               &#039;\n&#039;
               &#039;&quot;__*__&quot;\n&#039;
               &#039;   System-defined names. These names are defined by the &#039;
               &#039;interpreter\n&#039;
               &#039;   and its implementation (including the standard library).  &#039;
               &#039;Current\n&#039;
               &#039;   system names are discussed in the Special method names &#039;
               &#039;section and\n&#039;
               &#039;   elsewhere.  More will likely be defined in future versions &#039;
               &#039;of\n&#039;
               &#039;   Python.  *Any* use of &quot;__*__&quot; names, in any context, that &#039;
               &#039;does not\n&#039;
               &#039;   follow explicitly documented use, is subject to breakage &#039;
               &#039;without\n&#039;
               &#039;   warning.\n&#039;
               &#039;\n&#039;
               &#039;&quot;__*&quot;\n&#039;
               &#039;   Class-private names.  Names in this category, when used &#039;
               &#039;within the\n&#039;
               &#039;   context of a class definition, are re-written to use a &#039;
               &#039;mangled form\n&#039;
               &#039;   to help avoid name clashes between “private” attributes of &#039;
               &#039;base and\n&#039;
               &#039;   derived classes. See section Identifiers (Names).\n&#039;,
 &#039;identifiers&#039;: &#039;Identifiers and keywords\n&#039;
                &#039;************************\n&#039;
                &#039;\n&#039;
                &#039;Identifiers (also referred to as *names*) are described by &#039;
                &#039;the\n&#039;
                &#039;following lexical definitions.\n&#039;
                &#039;\n&#039;
                &#039;The syntax of identifiers in Python is based on the Unicode &#039;
                &#039;standard\n&#039;
                &#039;annex UAX-31, with elaboration and changes as defined below; &#039;
                &#039;see also\n&#039;
                &#039;**PEP 3131** for further details.\n&#039;
                &#039;\n&#039;
                &#039;Within the ASCII range (U+0001..U+007F), the valid characters &#039;
                &#039;for\n&#039;
                &#039;identifiers are the same as in Python 2.x: the uppercase and &#039;
                &#039;lowercase\n&#039;
                &#039;letters &quot;A&quot; through &quot;Z&quot;, the underscore &quot;_&quot; and, except for &#039;
                &#039;the first\n&#039;
                &#039;character, the digits &quot;0&quot; through &quot;9&quot;.\n&#039;
                &#039;\n&#039;
                &#039;Python 3.0 introduces additional characters from outside the &#039;
                &#039;ASCII\n&#039;
                &#039;range (see **PEP 3131**).  For these characters, the &#039;
                &#039;classification\n&#039;
                &#039;uses the version of the Unicode Character Database as &#039;
                &#039;included in the\n&#039;
                &#039;&quot;unicodedata&quot; module.\n&#039;
                &#039;\n&#039;
                &#039;Identifiers are unlimited in length.  Case is significant.\n&#039;
                &#039;\n&#039;
                &#039;   identifier   ::= xid_start xid_continue*\n&#039;
                &#039;   id_start     ::= &lt;all characters in general categories Lu, &#039;
                &#039;Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the &#039;
                &#039;Other_ID_Start property&gt;\n&#039;
                &#039;   id_continue  ::= &lt;all characters in id_start, plus &#039;
                &#039;characters in the categories Mn, Mc, Nd, Pc and others with &#039;
                &#039;the Other_ID_Continue property&gt;\n&#039;
                &#039;   xid_start    ::= &lt;all characters in id_start whose NFKC &#039;
                &#039;normalization is in &quot;id_start xid_continue*&quot;&gt;\n&#039;
                &#039;   xid_continue ::= &lt;all characters in id_continue whose NFKC &#039;
                &#039;normalization is in &quot;id_continue*&quot;&gt;\n&#039;
                &#039;\n&#039;
                &#039;The Unicode category codes mentioned above stand for:\n&#039;
                &#039;\n&#039;
                &#039;* *Lu* - uppercase letters\n&#039;
                &#039;\n&#039;
                &#039;* *Ll* - lowercase letters\n&#039;
                &#039;\n&#039;
                &#039;* *Lt* - titlecase letters\n&#039;
                &#039;\n&#039;
                &#039;* *Lm* - modifier letters\n&#039;
                &#039;\n&#039;
                &#039;* *Lo* - other letters\n&#039;
                &#039;\n&#039;
                &#039;* *Nl* - letter numbers\n&#039;
                &#039;\n&#039;
                &#039;* *Mn* - nonspacing marks\n&#039;
                &#039;\n&#039;
                &#039;* *Mc* - spacing combining marks\n&#039;
                &#039;\n&#039;
                &#039;* *Nd* - decimal numbers\n&#039;
                &#039;\n&#039;
                &#039;* *Pc* - connector punctuations\n&#039;
                &#039;\n&#039;
                &#039;* *Other_ID_Start* - explicit list of characters in &#039;
                &#039;PropList.txt to\n&#039;
                &#039;  support backwards compatibility\n&#039;
                &#039;\n&#039;
                &#039;* *Other_ID_Continue* - likewise\n&#039;
                &#039;\n&#039;
                &#039;All identifiers are converted into the normal form NFKC while &#039;
                &#039;parsing;\n&#039;
                &#039;comparison of identifiers is based on NFKC.\n&#039;
                &#039;\n&#039;
                &#039;A non-normative HTML file listing all valid identifier &#039;
                &#039;characters for\n&#039;
                &#039;Unicode 4.1 can be found at https://www.dcl.hpi.uni-\n&#039;
                &#039;potsdam.de/home/loewis/table-3131.html.\n&#039;
                &#039;\n&#039;
                &#039;\n&#039;
                &#039;Keywords\n&#039;
                &#039;========\n&#039;
                &#039;\n&#039;
                &#039;The following identifiers are used as reserved words, or &#039;
                &#039;*keywords* of\n&#039;
                &#039;the language, and cannot be used as ordinary identifiers.  &#039;
                &#039;They must\n&#039;
                &#039;be spelled exactly as written here:\n&#039;
                &#039;\n&#039;
                &#039;   False      class      finally    is         return\n&#039;
                &#039;   None       continue   for        lambda     try\n&#039;
                &#039;   True       def        from       nonlocal   while\n&#039;
                &#039;   and        del        global     not        with\n&#039;
                &#039;   as         elif       if         or         yield\n&#039;
                &#039;   assert     else       import     pass\n&#039;
                &#039;   break      except     in         raise\n&#039;
                &#039;\n&#039;
                &#039;\n&#039;
                &#039;Reserved classes of identifiers\n&#039;
                &#039;===============================\n&#039;
                &#039;\n&#039;
                &#039;Certain classes of identifiers (besides keywords) have &#039;
                &#039;special\n&#039;
                &#039;meanings.  These classes are identified by the patterns of &#039;
                &#039;leading and\n&#039;
                &#039;trailing underscore characters:\n&#039;
                &#039;\n&#039;
                &#039;&quot;_*&quot;\n&#039;
                &#039;   Not imported by &quot;from module import *&quot;.  The special &#039;
                &#039;identifier &quot;_&quot;\n&#039;
                &#039;   is used in the interactive interpreter to store the result &#039;
                &#039;of the\n&#039;
                &#039;   last evaluation; it is stored in the &quot;builtins&quot; module.  &#039;
                &#039;When not\n&#039;
                &#039;   in interactive mode, &quot;_&quot; has no special meaning and is not &#039;
                &#039;defined.\n&#039;
                &#039;   See section The import statement.\n&#039;
                &#039;\n&#039;
                &#039;   Note: The name &quot;_&quot; is often used in conjunction with\n&#039;
                &#039;     internationalization; refer to the documentation for &#039;
                &#039;the\n&#039;
                &#039;     &quot;gettext&quot; module for more information on this &#039;
                &#039;convention.\n&#039;
                &#039;\n&#039;
                &#039;&quot;__*__&quot;\n&#039;
                &#039;   System-defined names. These names are defined by the &#039;
                &#039;interpreter\n&#039;
                &#039;   and its implementation (including the standard library).  &#039;
                &#039;Current\n&#039;
                &#039;   system names are discussed in the Special method names &#039;
                &#039;section and\n&#039;
                &#039;   elsewhere.  More will likely be defined in future versions &#039;
                &#039;of\n&#039;
                &#039;   Python.  *Any* use of &quot;__*__&quot; names, in any context, that &#039;
                &#039;does not\n&#039;
                &#039;   follow explicitly documented use, is subject to breakage &#039;
                &#039;without\n&#039;
                &#039;   warning.\n&#039;
                &#039;\n&#039;
                &#039;&quot;__*&quot;\n&#039;
                &#039;   Class-private names.  Names in this category, when used &#039;
                &#039;within the\n&#039;
                &#039;   context of a class definition, are re-written to use a &#039;
                &#039;mangled form\n&#039;
                &#039;   to help avoid name clashes between “private” attributes of &#039;
                &#039;base and\n&#039;
                &#039;   derived classes. See section Identifiers (Names).\n&#039;,
 &#039;if&#039;: &#039;The &quot;if&quot; statement\n&#039;
       &#039;******************\n&#039;
       &#039;\n&#039;
       &#039;The &quot;if&quot; statement is used for conditional execution:\n&#039;
       &#039;\n&#039;
       &#039;   if_stmt ::= &quot;if&quot; expression &quot;:&quot; suite\n&#039;
       &#039;               (&quot;elif&quot; expression &quot;:&quot; suite)*\n&#039;
       &#039;               [&quot;else&quot; &quot;:&quot; suite]\n&#039;
       &#039;\n&#039;
       &#039;It selects exactly one of the suites by evaluating the expressions &#039;
       &#039;one\n&#039;
       &#039;by one until one is found to be true (see section Boolean operations\n&#039;
       &#039;for the definition of true and false); then that suite is executed\n&#039;
       &#039;(and no other part of the &quot;if&quot; statement is executed or evaluated).\n&#039;
       &#039;If all expressions are false, the suite of the &quot;else&quot; clause, if\n&#039;
       &#039;present, is executed.\n&#039;,
 &#039;imaginary&#039;: &#039;Imaginary literals\n&#039;
              &#039;******************\n&#039;
              &#039;\n&#039;
              &#039;Imaginary literals are described by the following lexical &#039;
              &#039;definitions:\n&#039;
              &#039;\n&#039;
              &#039;   imagnumber ::= (floatnumber | digitpart) (&quot;j&quot; | &quot;J&quot;)\n&#039;
              &#039;\n&#039;
              &#039;An imaginary literal yields a complex number with a real part &#039;
              &#039;of 0.0.\n&#039;
              &#039;Complex numbers are represented as a pair of floating point &#039;
              &#039;numbers\n&#039;
              &#039;and have the same restrictions on their range.  To create a &#039;
              &#039;complex\n&#039;
              &#039;number with a nonzero real part, add a floating point number to &#039;
              &#039;it,\n&#039;
              &#039;e.g., &quot;(3+4j)&quot;.  Some examples of imaginary literals:\n&#039;
              &#039;\n&#039;
              &#039;   3.14j   10.j    10j     .001j   1e100j   3.14e-10j   &#039;
              &#039;3.14_15_93j\n&#039;,
 &#039;import&#039;: &#039;The &quot;import&quot; statement\n&#039;
           &#039;**********************\n&#039;
           &#039;\n&#039;
           &#039;   import_stmt     ::= &quot;import&quot; module [&quot;as&quot; identifier] (&quot;,&quot; &#039;
           &#039;module [&quot;as&quot; identifier])*\n&#039;
           &#039;                   | &quot;from&quot; relative_module &quot;import&quot; identifier &#039;
           &#039;[&quot;as&quot; identifier]\n&#039;
           &#039;                   (&quot;,&quot; identifier [&quot;as&quot; identifier])*\n&#039;
           &#039;                   | &quot;from&quot; relative_module &quot;import&quot; &quot;(&quot; &#039;
           &#039;identifier [&quot;as&quot; identifier]\n&#039;
           &#039;                   (&quot;,&quot; identifier [&quot;as&quot; identifier])* [&quot;,&quot;] &quot;)&quot;\n&#039;
           &#039;                   | &quot;from&quot; module &quot;import&quot; &quot;*&quot;\n&#039;
           &#039;   module          ::= (identifier &quot;.&quot;)* identifier\n&#039;
           &#039;   relative_module ::= &quot;.&quot;* module | &quot;.&quot;+\n&#039;
           &#039;\n&#039;
           &#039;The basic import statement (no &quot;from&quot; clause) is executed in two\n&#039;
           &#039;steps:\n&#039;
           &#039;\n&#039;
           &#039;1. find a module, loading and initializing it if necessary\n&#039;
           &#039;\n&#039;
           &#039;2. define a name or names in the local namespace for the scope\n&#039;
           &#039;   where the &quot;import&quot; statement occurs.\n&#039;
           &#039;\n&#039;
           &#039;When the statement contains multiple clauses (separated by commas) &#039;
           &#039;the\n&#039;
           &#039;two steps are carried out separately for each clause, just as &#039;
           &#039;though\n&#039;
           &#039;the clauses had been separated out into individual import &#039;
           &#039;statements.\n&#039;
           &#039;\n&#039;
           &#039;The details of the first step, finding and loading modules are\n&#039;
           &#039;described in greater detail in the section on the import system, &#039;
           &#039;which\n&#039;
           &#039;also describes the various types of packages and modules that can &#039;
           &#039;be\n&#039;
           &#039;imported, as well as all the hooks that can be used to customize &#039;
           &#039;the\n&#039;
           &#039;import system. Note that failures in this step may indicate &#039;
           &#039;either\n&#039;
           &#039;that the module could not be located, *or* that an error occurred\n&#039;
           &#039;while initializing the module, which includes execution of the\n&#039;
           &#039;module’s code.\n&#039;
           &#039;\n&#039;
           &#039;If the requested module is retrieved successfully, it will be &#039;
           &#039;made\n&#039;
           &#039;available in the local namespace in one of three ways:\n&#039;
           &#039;\n&#039;
           &#039;* If the module name is followed by &quot;as&quot;, then the name following\n&#039;
           &#039;  &quot;as&quot; is bound directly to the imported module.\n&#039;
           &#039;\n&#039;
           &#039;* If no other name is specified, and the module being imported is &#039;
           &#039;a\n&#039;
           &#039;  top level module, the module’s name is bound in the local &#039;
           &#039;namespace\n&#039;
           &#039;  as a reference to the imported module\n&#039;
           &#039;\n&#039;
           &#039;* If the module being imported is *not* a top level module, then &#039;
           &#039;the\n&#039;
           &#039;  name of the top level package that contains the module is bound &#039;
           &#039;in\n&#039;
           &#039;  the local namespace as a reference to the top level package. &#039;
           &#039;The\n&#039;
           &#039;  imported module must be accessed using its full qualified name\n&#039;
           &#039;  rather than directly\n&#039;
           &#039;\n&#039;
           &#039;The &quot;from&quot; form uses a slightly more complex process:\n&#039;
           &#039;\n&#039;
           &#039;1. find the module specified in the &quot;from&quot; clause, loading and\n&#039;
           &#039;   initializing it if necessary;\n&#039;
           &#039;\n&#039;
           &#039;2. for each of the identifiers specified in the &quot;import&quot; clauses:\n&#039;
           &#039;\n&#039;
           &#039;   1. check if the imported module has an attribute by that name\n&#039;
           &#039;\n&#039;
           &#039;   2. if not, attempt to import a submodule with that name and &#039;
           &#039;then\n&#039;
           &#039;      check the imported module again for that attribute\n&#039;
           &#039;\n&#039;
           &#039;   3. if the attribute is not found, &quot;ImportError&quot; is raised.\n&#039;
           &#039;\n&#039;
           &#039;   4. otherwise, a reference to that value is stored in the local\n&#039;
           &#039;      namespace, using the name in the &quot;as&quot; clause if it is &#039;
           &#039;present,\n&#039;
           &#039;      otherwise using the attribute name\n&#039;
           &#039;\n&#039;
           &#039;Examples:\n&#039;
           &#039;\n&#039;
           &#039;   import foo                 # foo imported and bound locally\n&#039;
           &#039;   import foo.bar.baz         # foo.bar.baz imported, foo bound &#039;
           &#039;locally\n&#039;
           &#039;   import foo.bar.baz as fbb  # foo.bar.baz imported and bound as &#039;
           &#039;fbb\n&#039;
           &#039;   from foo.bar import baz    # foo.bar.baz imported and bound as &#039;
           &#039;baz\n&#039;
           &#039;   from foo import attr       # foo imported and foo.attr bound as &#039;
           &#039;attr\n&#039;
           &#039;\n&#039;
           &#039;If the list of identifiers is replaced by a star (&quot;\&#039;*\&#039;&quot;), all &#039;
           &#039;public\n&#039;
           &#039;names defined in the module are bound in the local namespace for &#039;
           &#039;the\n&#039;
           &#039;scope where the &quot;import&quot; statement occurs.\n&#039;
           &#039;\n&#039;
           &#039;The *public names* defined by a module are determined by checking &#039;
           &#039;the\n&#039;
           &#039;module’s namespace for a variable named &quot;__all__&quot;; if defined, it &#039;
           &#039;must\n&#039;
           &#039;be a sequence of strings which are names defined or imported by &#039;
           &#039;that\n&#039;
           &#039;module.  The names given in &quot;__all__&quot; are all considered public &#039;
           &#039;and\n&#039;
           &#039;are required to exist.  If &quot;__all__&quot; is not defined, the set of &#039;
           &#039;public\n&#039;
           &#039;names includes all names found in the module’s namespace which do &#039;
           &#039;not\n&#039;
           &#039;begin with an underscore character (&quot;\&#039;_\&#039;&quot;).  &quot;__all__&quot; should &#039;
           &#039;contain\n&#039;
           &#039;the entire public API. It is intended to avoid accidentally &#039;
           &#039;exporting\n&#039;
           &#039;items that are not part of the API (such as library modules which &#039;
           &#039;were\n&#039;
           &#039;imported and used within the module).\n&#039;
           &#039;\n&#039;
           &#039;The wild card form of import — &quot;from module import *&quot; — is only\n&#039;
           &#039;allowed at the module level.  Attempting to use it in class or\n&#039;
           &#039;function definitions will raise a &quot;SyntaxError&quot;.\n&#039;
           &#039;\n&#039;
           &#039;When specifying what module to import you do not have to specify &#039;
           &#039;the\n&#039;
           &#039;absolute name of the module. When a module or package is &#039;
           &#039;contained\n&#039;
           &#039;within another package it is possible to make a relative import &#039;
           &#039;within\n&#039;
           &#039;the same top package without having to mention the package name. &#039;
           &#039;By\n&#039;
           &#039;using leading dots in the specified module or package after &quot;from&quot; &#039;
           &#039;you\n&#039;
           &#039;can specify how high to traverse up the current package hierarchy\n&#039;
           &#039;without specifying exact names. One leading dot means the current\n&#039;
           &#039;package where the module making the import exists. Two dots means &#039;
           &#039;up\n&#039;
           &#039;one package level. Three dots is up two levels, etc. So if you &#039;
           &#039;execute\n&#039;
           &#039;&quot;from . import mod&quot; from a module in the &quot;pkg&quot; package then you &#039;
           &#039;will\n&#039;
           &#039;end up importing &quot;pkg.mod&quot;. If you execute &quot;from ..subpkg2 import &#039;
           &#039;mod&quot;\n&#039;
           &#039;from within &quot;pkg.subpkg1&quot; you will import &quot;pkg.subpkg2.mod&quot;. The\n&#039;
           &#039;specification for relative imports is contained within **PEP &#039;
           &#039;328**.\n&#039;
           &#039;\n&#039;
           &#039;&quot;importlib.import_module()&quot; is provided to support applications &#039;
           &#039;that\n&#039;
           &#039;determine dynamically the modules to be loaded.\n&#039;
           &#039;\n&#039;
           &#039;\n&#039;
           &#039;Future statements\n&#039;
           &#039;=================\n&#039;
           &#039;\n&#039;
           &#039;A *future statement* is a directive to the compiler that a &#039;
           &#039;particular\n&#039;
           &#039;module should be compiled using syntax or semantics that will be\n&#039;
           &#039;available in a specified future release of Python where the &#039;
           &#039;feature\n&#039;
           &#039;becomes standard.\n&#039;
           &#039;\n&#039;
           &#039;The future statement is intended to ease migration to future &#039;
           &#039;versions\n&#039;
           &#039;of Python that introduce incompatible changes to the language.  &#039;
           &#039;It\n&#039;
           &#039;allows use of the new features on a per-module basis before the\n&#039;
           &#039;release in which the feature becomes standard.\n&#039;
           &#039;\n&#039;
           &#039;   future_stmt ::= &quot;from&quot; &quot;__future__&quot; &quot;import&quot; feature [&quot;as&quot; &#039;
           &#039;identifier]\n&#039;
           &#039;                   (&quot;,&quot; feature [&quot;as&quot; identifier])*\n&#039;
           &#039;                   | &quot;from&quot; &quot;__future__&quot; &quot;import&quot; &quot;(&quot; feature &#039;
           &#039;[&quot;as&quot; identifier]\n&#039;
           &#039;                   (&quot;,&quot; feature [&quot;as&quot; identifier])* [&quot;,&quot;] &quot;)&quot;\n&#039;
           &#039;   feature     ::= identifier\n&#039;
           &#039;\n&#039;
           &#039;A future statement must appear near the top of the module.  The &#039;
           &#039;only\n&#039;
           &#039;lines that can appear before a future statement are:\n&#039;
           &#039;\n&#039;
           &#039;* the module docstring (if any),\n&#039;
           &#039;\n&#039;
           &#039;* comments,\n&#039;
           &#039;\n&#039;
           &#039;* blank lines, and\n&#039;
           &#039;\n&#039;
           &#039;* other future statements.\n&#039;
           &#039;\n&#039;
           &#039;The features recognized by Python 3.0 are &quot;absolute_import&quot;,\n&#039;
           &#039;&quot;division&quot;, &quot;generators&quot;, &quot;unicode_literals&quot;, &quot;print_function&quot;,\n&#039;
           &#039;&quot;nested_scopes&quot; and &quot;with_statement&quot;.  They are all redundant &#039;
           &#039;because\n&#039;
           &#039;they are always enabled, and only kept for backwards &#039;
           &#039;compatibility.\n&#039;
           &#039;\n&#039;
           &#039;A future statement is recognized and treated specially at compile\n&#039;
           &#039;time: Changes to the semantics of core constructs are often\n&#039;
           &#039;implemented by generating different code.  It may even be the &#039;
           &#039;case\n&#039;
           &#039;that a new feature introduces new incompatible syntax (such as a &#039;
           &#039;new\n&#039;
           &#039;reserved word), in which case the compiler may need to parse the\n&#039;
           &#039;module differently.  Such decisions cannot be pushed off until\n&#039;
           &#039;runtime.\n&#039;
           &#039;\n&#039;
           &#039;For any given release, the compiler knows which feature names &#039;
           &#039;have\n&#039;
           &#039;been defined, and raises a compile-time error if a future &#039;
           &#039;statement\n&#039;
           &#039;contains a feature not known to it.\n&#039;
           &#039;\n&#039;
           &#039;The direct runtime semantics are the same as for any import &#039;
           &#039;statement:\n&#039;
           &#039;there is a standard module &quot;__future__&quot;, described later, and it &#039;
           &#039;will\n&#039;
           &#039;be imported in the usual way at the time the future statement is\n&#039;
           &#039;executed.\n&#039;
           &#039;\n&#039;
           &#039;The interesting runtime semantics depend on the specific feature\n&#039;
           &#039;enabled by the future statement.\n&#039;
           &#039;\n&#039;
           &#039;Note that there is nothing special about the statement:\n&#039;
           &#039;\n&#039;
           &#039;   import __future__ [as name]\n&#039;
           &#039;\n&#039;
           &#039;That is not a future statement; it’s an ordinary import statement &#039;
           &#039;with\n&#039;
           &#039;no special semantics or syntax restrictions.\n&#039;
           &#039;\n&#039;
           &#039;Code compiled by calls to the built-in functions &quot;exec()&quot; and\n&#039;
           &#039;&quot;compile()&quot; that occur in a module &quot;M&quot; containing a future &#039;
           &#039;statement\n&#039;
           &#039;will, by default, use the new syntax or semantics associated with &#039;
           &#039;the\n&#039;
           &#039;future statement.  This can be controlled by optional arguments &#039;
           &#039;to\n&#039;
           &#039;&quot;compile()&quot; — see the documentation of that function for details.\n&#039;
           &#039;\n&#039;
           &#039;A future statement typed at an interactive interpreter prompt &#039;
           &#039;will\n&#039;
           &#039;take effect for the rest of the interpreter session.  If an\n&#039;
           &#039;interpreter is started with the &quot;-i&quot; option, is passed a script &#039;
           &#039;name\n&#039;
           &#039;to execute, and the script includes a future statement, it will be &#039;
           &#039;in\n&#039;
           &#039;effect in the interactive session started after the script is\n&#039;
           &#039;executed.\n&#039;
           &#039;\n&#039;
           &#039;See also:\n&#039;
           &#039;\n&#039;
           &#039;  **PEP 236** - Back to the __future__\n&#039;
           &#039;     The original proposal for the __future__ mechanism.\n&#039;,
 &#039;in&#039;: &#039;Membership test operations\n&#039;
       &#039;**************************\n&#039;
       &#039;\n&#039;
       &#039;The operators &quot;in&quot; and &quot;not in&quot; test for membership.  &quot;x in s&quot;\n&#039;
       &#039;evaluates to &quot;True&quot; if *x* is a member of *s*, and &quot;False&quot; otherwise.\n&#039;
       &#039;&quot;x not in s&quot; returns the negation of &quot;x in s&quot;.  All built-in &#039;
       &#039;sequences\n&#039;
       &#039;and set types support this as well as dictionary, for which &quot;in&quot; &#039;
       &#039;tests\n&#039;
       &#039;whether the dictionary has a given key. For container types such as\n&#039;
       &#039;list, tuple, set, frozenset, dict, or collections.deque, the\n&#039;
       &#039;expression &quot;x in y&quot; is equivalent to &quot;any(x is e or x == e for e in\n&#039;
       &#039;y)&quot;.\n&#039;
       &#039;\n&#039;
       &#039;For the string and bytes types, &quot;x in y&quot; is &quot;True&quot; if and only if *x*\n&#039;
       &#039;is a substring of *y*.  An equivalent test is &quot;y.find(x) != -1&quot;.\n&#039;
       &#039;Empty strings are always considered to be a substring of any other\n&#039;
       &#039;string, so &quot;&quot;&quot; in &quot;abc&quot;&quot; will return &quot;True&quot;.\n&#039;
       &#039;\n&#039;
       &#039;For user-defined classes which define the &quot;__contains__()&quot; method, &quot;x\n&#039;
       &#039;in y&quot; returns &quot;True&quot; if &quot;y.__contains__(x)&quot; returns a true value, and\n&#039;
       &#039;&quot;False&quot; otherwise.\n&#039;
       &#039;\n&#039;
       &#039;For user-defined classes which do not define &quot;__contains__()&quot; but do\n&#039;
       &#039;define &quot;__iter__()&quot;, &quot;x in y&quot; is &quot;True&quot; if some value &quot;z&quot; with &quot;x ==\n&#039;
       &#039;z&quot; is produced while iterating over &quot;y&quot;.  If an exception is raised\n&#039;
       &#039;during the iteration, it is as if &quot;in&quot; raised that exception.\n&#039;
       &#039;\n&#039;
       &#039;Lastly, the old-style iteration protocol is tried: if a class defines\n&#039;
       &#039;&quot;__getitem__()&quot;, &quot;x in y&quot; is &quot;True&quot; if and only if there is a non-\n&#039;
       &#039;negative integer index *i* such that &quot;x == y[i]&quot;, and all lower\n&#039;
       &#039;integer indices do not raise &quot;IndexError&quot; exception.  (If any other\n&#039;
       &#039;exception is raised, it is as if &quot;in&quot; raised that exception).\n&#039;
       &#039;\n&#039;
       &#039;The operator &quot;not in&quot; is defined to have the inverse true value of\n&#039;
       &#039;&quot;in&quot;.\n&#039;,
 &#039;integers&#039;: &#039;Integer literals\n&#039;
             &#039;****************\n&#039;
             &#039;\n&#039;
             &#039;Integer literals are described by the following lexical &#039;
             &#039;definitions:\n&#039;
             &#039;\n&#039;
             &#039;   integer      ::= decinteger | bininteger | octinteger | &#039;
             &#039;hexinteger\n&#039;
             &#039;   decinteger   ::= nonzerodigit ([&quot;_&quot;] digit)* | &quot;0&quot;+ ([&quot;_&quot;] &#039;
             &#039;&quot;0&quot;)*\n&#039;
             &#039;   bininteger   ::= &quot;0&quot; (&quot;b&quot; | &quot;B&quot;) ([&quot;_&quot;] bindigit)+\n&#039;
             &#039;   octinteger   ::= &quot;0&quot; (&quot;o&quot; | &quot;O&quot;) ([&quot;_&quot;] octdigit)+\n&#039;
             &#039;   hexinteger   ::= &quot;0&quot; (&quot;x&quot; | &quot;X&quot;) ([&quot;_&quot;] hexdigit)+\n&#039;
             &#039;   nonzerodigit ::= &quot;1&quot;...&quot;9&quot;\n&#039;
             &#039;   digit        ::= &quot;0&quot;...&quot;9&quot;\n&#039;
             &#039;   bindigit     ::= &quot;0&quot; | &quot;1&quot;\n&#039;
             &#039;   octdigit     ::= &quot;0&quot;...&quot;7&quot;\n&#039;
             &#039;   hexdigit     ::= digit | &quot;a&quot;...&quot;f&quot; | &quot;A&quot;...&quot;F&quot;\n&#039;
             &#039;\n&#039;
             &#039;There is no limit for the length of integer literals apart from &#039;
             &#039;what\n&#039;
             &#039;can be stored in available memory.\n&#039;
             &#039;\n&#039;
             &#039;Underscores are ignored for determining the numeric value of &#039;
             &#039;the\n&#039;
             &#039;literal.  They can be used to group digits for enhanced &#039;
             &#039;readability.\n&#039;
             &#039;One underscore can occur between digits, and after base &#039;
             &#039;specifiers\n&#039;
             &#039;like &quot;0x&quot;.\n&#039;
             &#039;\n&#039;
             &#039;Note that leading zeros in a non-zero decimal number are not &#039;
             &#039;allowed.\n&#039;
             &#039;This is for disambiguation with C-style octal literals, which &#039;
             &#039;Python\n&#039;
             &#039;used before version 3.0.\n&#039;
             &#039;\n&#039;
             &#039;Some examples of integer literals:\n&#039;
             &#039;\n&#039;
             &#039;   7     2147483647                        0o177    0b100110111\n&#039;
             &#039;   3     79228162514264337593543950336     0o377    0xdeadbeef\n&#039;
             &#039;         100_000_000_000                   0b_1110_0101\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.6: Underscores are now allowed for &#039;
             &#039;grouping\n&#039;
             &#039;purposes in literals.\n&#039;,
 &#039;lambda&#039;: &#039;Lambdas\n&#039;
           &#039;*******\n&#039;
           &#039;\n&#039;
           &#039;   lambda_expr        ::= &quot;lambda&quot; [parameter_list] &quot;:&quot; &#039;
           &#039;expression\n&#039;
           &#039;   lambda_expr_nocond ::= &quot;lambda&quot; [parameter_list] &quot;:&quot; &#039;
           &#039;expression_nocond\n&#039;
           &#039;\n&#039;
           &#039;Lambda expressions (sometimes called lambda forms) are used to &#039;
           &#039;create\n&#039;
           &#039;anonymous functions. The expression &quot;lambda parameters: &#039;
           &#039;expression&quot;\n&#039;
           &#039;yields a function object.  The unnamed object behaves like a &#039;
           &#039;function\n&#039;
           &#039;object defined with:\n&#039;
           &#039;\n&#039;
           &#039;   def &lt;lambda&gt;(parameters):\n&#039;
           &#039;       return expression\n&#039;
           &#039;\n&#039;
           &#039;See section Function definitions for the syntax of parameter &#039;
           &#039;lists.\n&#039;
           &#039;Note that functions created with lambda expressions cannot &#039;
           &#039;contain\n&#039;
           &#039;statements or annotations.\n&#039;,
 &#039;lists&#039;: &#039;List displays\n&#039;
          &#039;*************\n&#039;
          &#039;\n&#039;
          &#039;A list display is a possibly empty series of expressions enclosed &#039;
          &#039;in\n&#039;
          &#039;square brackets:\n&#039;
          &#039;\n&#039;
          &#039;   list_display ::= &quot;[&quot; [starred_list | comprehension] &quot;]&quot;\n&#039;
          &#039;\n&#039;
          &#039;A list display yields a new list object, the contents being &#039;
          &#039;specified\n&#039;
          &#039;by either a list of expressions or a comprehension.  When a comma-\n&#039;
          &#039;separated list of expressions is supplied, its elements are &#039;
          &#039;evaluated\n&#039;
          &#039;from left to right and placed into the list object in that order.\n&#039;
          &#039;When a comprehension is supplied, the list is constructed from the\n&#039;
          &#039;elements resulting from the comprehension.\n&#039;,
 &#039;naming&#039;: &#039;Naming and binding\n&#039;
           &#039;******************\n&#039;
           &#039;\n&#039;
           &#039;\n&#039;
           &#039;Binding of names\n&#039;
           &#039;================\n&#039;
           &#039;\n&#039;
           &#039;*Names* refer to objects.  Names are introduced by name binding\n&#039;
           &#039;operations.\n&#039;
           &#039;\n&#039;
           &#039;The following constructs bind names: formal parameters to &#039;
           &#039;functions,\n&#039;
           &#039;&quot;import&quot; statements, class and function definitions (these bind &#039;
           &#039;the\n&#039;
           &#039;class or function name in the defining block), and targets that &#039;
           &#039;are\n&#039;
           &#039;identifiers if occurring in an assignment, &quot;for&quot; loop header, or &#039;
           &#039;after\n&#039;
           &#039;&quot;as&quot; in a &quot;with&quot; statement or &quot;except&quot; clause. The &quot;import&quot; &#039;
           &#039;statement\n&#039;
           &#039;of the form &quot;from ... import *&quot; binds all names defined in the\n&#039;
           &#039;imported module, except those beginning with an underscore.  This &#039;
           &#039;form\n&#039;
           &#039;may only be used at the module level.\n&#039;
           &#039;\n&#039;
           &#039;A target occurring in a &quot;del&quot; statement is also considered bound &#039;
           &#039;for\n&#039;
           &#039;this purpose (though the actual semantics are to unbind the &#039;
           &#039;name).\n&#039;
           &#039;\n&#039;
           &#039;Each assignment or import statement occurs within a block defined &#039;
           &#039;by a\n&#039;
           &#039;class or function definition or at the module level (the &#039;
           &#039;top-level\n&#039;
           &#039;code block).\n&#039;
           &#039;\n&#039;
           &#039;If a name is bound in a block, it is a local variable of that &#039;
           &#039;block,\n&#039;
           &#039;unless declared as &quot;nonlocal&quot; or &quot;global&quot;.  If a name is bound at &#039;
           &#039;the\n&#039;
           &#039;module level, it is a global variable.  (The variables of the &#039;
           &#039;module\n&#039;
           &#039;code block are local and global.)  If a variable is used in a &#039;
           &#039;code\n&#039;
           &#039;block but not defined there, it is a *free variable*.\n&#039;
           &#039;\n&#039;
           &#039;Each occurrence of a name in the program text refers to the &#039;
           &#039;*binding*\n&#039;
           &#039;of that name established by the following name resolution rules.\n&#039;
           &#039;\n&#039;
           &#039;\n&#039;
           &#039;Resolution of names\n&#039;
           &#039;===================\n&#039;
           &#039;\n&#039;
           &#039;A *scope* defines the visibility of a name within a block.  If a &#039;
           &#039;local\n&#039;
           &#039;variable is defined in a block, its scope includes that block.  If &#039;
           &#039;the\n&#039;
           &#039;definition occurs in a function block, the scope extends to any &#039;
           &#039;blocks\n&#039;
           &#039;contained within the defining one, unless a contained block &#039;
           &#039;introduces\n&#039;
           &#039;a different binding for the name.\n&#039;
           &#039;\n&#039;
           &#039;When a name is used in a code block, it is resolved using the &#039;
           &#039;nearest\n&#039;
           &#039;enclosing scope.  The set of all such scopes visible to a code &#039;
           &#039;block\n&#039;
           &#039;is called the block’s *environment*.\n&#039;
           &#039;\n&#039;
           &#039;When a name is not found at all, a &quot;NameError&quot; exception is &#039;
           &#039;raised. If\n&#039;
           &#039;the current scope is a function scope, and the name refers to a &#039;
           &#039;local\n&#039;
           &#039;variable that has not yet been bound to a value at the point where &#039;
           &#039;the\n&#039;
           &#039;name is used, an &quot;UnboundLocalError&quot; exception is raised.\n&#039;
           &#039;&quot;UnboundLocalError&quot; is a subclass of &quot;NameError&quot;.\n&#039;
           &#039;\n&#039;
           &#039;If a name binding operation occurs anywhere within a code block, &#039;
           &#039;all\n&#039;
           &#039;uses of the name within the block are treated as references to &#039;
           &#039;the\n&#039;
           &#039;current block.  This can lead to errors when a name is used within &#039;
           &#039;a\n&#039;
           &#039;block before it is bound.  This rule is subtle.  Python lacks\n&#039;
           &#039;declarations and allows name binding operations to occur anywhere\n&#039;
           &#039;within a code block.  The local variables of a code block can be\n&#039;
           &#039;determined by scanning the entire text of the block for name &#039;
           &#039;binding\n&#039;
           &#039;operations.\n&#039;
           &#039;\n&#039;
           &#039;If the &quot;global&quot; statement occurs within a block, all uses of the &#039;
           &#039;name\n&#039;
           &#039;specified in the statement refer to the binding of that name in &#039;
           &#039;the\n&#039;
           &#039;top-level namespace.  Names are resolved in the top-level &#039;
           &#039;namespace by\n&#039;
           &#039;searching the global namespace, i.e. the namespace of the module\n&#039;
           &#039;containing the code block, and the builtins namespace, the &#039;
           &#039;namespace\n&#039;
           &#039;of the module &quot;builtins&quot;.  The global namespace is searched &#039;
           &#039;first.  If\n&#039;
           &#039;the name is not found there, the builtins namespace is searched.  &#039;
           &#039;The\n&#039;
           &#039;&quot;global&quot; statement must precede all uses of the name.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;global&quot; statement has the same scope as a name binding &#039;
           &#039;operation\n&#039;
           &#039;in the same block.  If the nearest enclosing scope for a free &#039;
           &#039;variable\n&#039;
           &#039;contains a global statement, the free variable is treated as a &#039;
           &#039;global.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;nonlocal&quot; statement causes corresponding names to refer to\n&#039;
           &#039;previously bound variables in the nearest enclosing function &#039;
           &#039;scope.\n&#039;
           &#039;&quot;SyntaxError&quot; is raised at compile time if the given name does &#039;
           &#039;not\n&#039;
           &#039;exist in any enclosing function scope.\n&#039;
           &#039;\n&#039;
           &#039;The namespace for a module is automatically created the first time &#039;
           &#039;a\n&#039;
           &#039;module is imported.  The main module for a script is always &#039;
           &#039;called\n&#039;
           &#039;&quot;__main__&quot;.\n&#039;
           &#039;\n&#039;
           &#039;Class definition blocks and arguments to &quot;exec()&quot; and &quot;eval()&quot; &#039;
           &#039;are\n&#039;
           &#039;special in the context of name resolution. A class definition is &#039;
           &#039;an\n&#039;
           &#039;executable statement that may use and define names. These &#039;
           &#039;references\n&#039;
           &#039;follow the normal rules for name resolution with an exception &#039;
           &#039;that\n&#039;
           &#039;unbound local variables are looked up in the global namespace. &#039;
           &#039;The\n&#039;
           &#039;namespace of the class definition becomes the attribute dictionary &#039;
           &#039;of\n&#039;
           &#039;the class. The scope of names defined in a class block is limited &#039;
           &#039;to\n&#039;
           &#039;the class block; it does not extend to the code blocks of methods &#039;
           &#039;–\n&#039;
           &#039;this includes comprehensions and generator expressions since they &#039;
           &#039;are\n&#039;
           &#039;implemented using a function scope.  This means that the &#039;
           &#039;following\n&#039;
           &#039;will fail:\n&#039;
           &#039;\n&#039;
           &#039;   class A:\n&#039;
           &#039;       a = 42\n&#039;
           &#039;       b = list(a + i for i in range(10))\n&#039;
           &#039;\n&#039;
           &#039;\n&#039;
           &#039;Builtins and restricted execution\n&#039;
           &#039;=================================\n&#039;
           &#039;\n&#039;
           &#039;**CPython implementation detail:** Users should not touch\n&#039;
           &#039;&quot;__builtins__&quot;; it is strictly an implementation detail.  Users\n&#039;
           &#039;wanting to override values in the builtins namespace should &#039;
           &#039;&quot;import&quot;\n&#039;
           &#039;the &quot;builtins&quot; module and modify its attributes appropriately.\n&#039;
           &#039;\n&#039;
           &#039;The builtins namespace associated with the execution of a code &#039;
           &#039;block\n&#039;
           &#039;is actually found by looking up the name &quot;__builtins__&quot; in its &#039;
           &#039;global\n&#039;
           &#039;namespace; this should be a dictionary or a module (in the latter &#039;
           &#039;case\n&#039;
           &#039;the module’s dictionary is used).  By default, when in the &#039;
           &#039;&quot;__main__&quot;\n&#039;
           &#039;module, &quot;__builtins__&quot; is the built-in module &quot;builtins&quot;; when in &#039;
           &#039;any\n&#039;
           &#039;other module, &quot;__builtins__&quot; is an alias for the dictionary of &#039;
           &#039;the\n&#039;
           &#039;&quot;builtins&quot; module itself.\n&#039;
           &#039;\n&#039;
           &#039;\n&#039;
           &#039;Interaction with dynamic features\n&#039;
           &#039;=================================\n&#039;
           &#039;\n&#039;
           &#039;Name resolution of free variables occurs at runtime, not at &#039;
           &#039;compile\n&#039;
           &#039;time. This means that the following code will print 42:\n&#039;
           &#039;\n&#039;
           &#039;   i = 10\n&#039;
           &#039;   def f():\n&#039;
           &#039;       print(i)\n&#039;
           &#039;   i = 42\n&#039;
           &#039;   f()\n&#039;
           &#039;\n&#039;
           &#039;The &quot;eval()&quot; and &quot;exec()&quot; functions do not have access to the &#039;
           &#039;full\n&#039;
           &#039;environment for resolving names.  Names may be resolved in the &#039;
           &#039;local\n&#039;
           &#039;and global namespaces of the caller.  Free variables are not &#039;
           &#039;resolved\n&#039;
           &#039;in the nearest enclosing namespace, but in the global namespace.  &#039;
           &#039;[1]\n&#039;
           &#039;The &quot;exec()&quot; and &quot;eval()&quot; functions have optional arguments to\n&#039;
           &#039;override the global and local namespace.  If only one namespace &#039;
           &#039;is\n&#039;
           &#039;specified, it is used for both.\n&#039;,
 &#039;nonlocal&#039;: &#039;The &quot;nonlocal&quot; statement\n&#039;
             &#039;************************\n&#039;
             &#039;\n&#039;
             &#039;   nonlocal_stmt ::= &quot;nonlocal&quot; identifier (&quot;,&quot; identifier)*\n&#039;
             &#039;\n&#039;
             &#039;The &quot;nonlocal&quot; statement causes the listed identifiers to refer &#039;
             &#039;to\n&#039;
             &#039;previously bound variables in the nearest enclosing scope &#039;
             &#039;excluding\n&#039;
             &#039;globals. This is important because the default behavior for &#039;
             &#039;binding is\n&#039;
             &#039;to search the local namespace first.  The statement allows\n&#039;
             &#039;encapsulated code to rebind variables outside of the local &#039;
             &#039;scope\n&#039;
             &#039;besides the global (module) scope.\n&#039;
             &#039;\n&#039;
             &#039;Names listed in a &quot;nonlocal&quot; statement, unlike those listed in &#039;
             &#039;a\n&#039;
             &#039;&quot;global&quot; statement, must refer to pre-existing bindings in an\n&#039;
             &#039;enclosing scope (the scope in which a new binding should be &#039;
             &#039;created\n&#039;
             &#039;cannot be determined unambiguously).\n&#039;
             &#039;\n&#039;
             &#039;Names listed in a &quot;nonlocal&quot; statement must not collide with &#039;
             &#039;pre-\n&#039;
             &#039;existing bindings in the local scope.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 3104** - Access to Names in Outer Scopes\n&#039;
             &#039;     The specification for the &quot;nonlocal&quot; statement.\n&#039;,
 &#039;numbers&#039;: &#039;Numeric literals\n&#039;
            &#039;****************\n&#039;
            &#039;\n&#039;
            &#039;There are three types of numeric literals: integers, floating &#039;
            &#039;point\n&#039;
            &#039;numbers, and imaginary numbers.  There are no complex literals\n&#039;
            &#039;(complex numbers can be formed by adding a real number and an\n&#039;
            &#039;imaginary number).\n&#039;
            &#039;\n&#039;
            &#039;Note that numeric literals do not include a sign; a phrase like &#039;
            &#039;&quot;-1&quot;\n&#039;
            &#039;is actually an expression composed of the unary operator ‘&quot;-&quot;‘ &#039;
            &#039;and the\n&#039;
            &#039;literal &quot;1&quot;.\n&#039;,
 &#039;numeric-types&#039;: &#039;Emulating numeric types\n&#039;
                  &#039;***********************\n&#039;
                  &#039;\n&#039;
                  &#039;The following methods can be defined to emulate numeric &#039;
                  &#039;objects.\n&#039;
                  &#039;Methods corresponding to operations that are not supported &#039;
                  &#039;by the\n&#039;
                  &#039;particular kind of number implemented (e.g., bitwise &#039;
                  &#039;operations for\n&#039;
                  &#039;non-integral numbers) should be left undefined.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__add__(self, other)\n&#039;
                  &#039;object.__sub__(self, other)\n&#039;
                  &#039;object.__mul__(self, other)\n&#039;
                  &#039;object.__matmul__(self, other)\n&#039;
                  &#039;object.__truediv__(self, other)\n&#039;
                  &#039;object.__floordiv__(self, other)\n&#039;
                  &#039;object.__mod__(self, other)\n&#039;
                  &#039;object.__divmod__(self, other)\n&#039;
                  &#039;object.__pow__(self, other[, modulo])\n&#039;
                  &#039;object.__lshift__(self, other)\n&#039;
                  &#039;object.__rshift__(self, other)\n&#039;
                  &#039;object.__and__(self, other)\n&#039;
                  &#039;object.__xor__(self, other)\n&#039;
                  &#039;object.__or__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   These methods are called to implement the binary &#039;
                  &#039;arithmetic\n&#039;
                  &#039;   operations (&quot;+&quot;, &quot;-&quot;, &quot;*&quot;, &quot;@&quot;, &quot;/&quot;, &quot;//&quot;, &quot;%&quot;, &#039;
                  &#039;&quot;divmod()&quot;,\n&#039;
                  &#039;   &quot;pow()&quot;, &quot;**&quot;, &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;).  For &#039;
                  &#039;instance, to\n&#039;
                  &#039;   evaluate the expression &quot;x + y&quot;, where *x* is an &#039;
                  &#039;instance of a\n&#039;
                  &#039;   class that has an &quot;__add__()&quot; method, &quot;x.__add__(y)&quot; is &#039;
                  &#039;called.\n&#039;
                  &#039;   The &quot;__divmod__()&quot; method should be the equivalent to &#039;
                  &#039;using\n&#039;
                  &#039;   &quot;__floordiv__()&quot; and &quot;__mod__()&quot;; it should not be &#039;
                  &#039;related to\n&#039;
                  &#039;   &quot;__truediv__()&quot;.  Note that &quot;__pow__()&quot; should be &#039;
                  &#039;defined to accept\n&#039;
                  &#039;   an optional third argument if the ternary version of the &#039;
                  &#039;built-in\n&#039;
                  &#039;   &quot;pow()&quot; function is to be supported.\n&#039;
                  &#039;\n&#039;
                  &#039;   If one of those methods does not support the operation &#039;
                  &#039;with the\n&#039;
                  &#039;   supplied arguments, it should return &quot;NotImplemented&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__radd__(self, other)\n&#039;
                  &#039;object.__rsub__(self, other)\n&#039;
                  &#039;object.__rmul__(self, other)\n&#039;
                  &#039;object.__rmatmul__(self, other)\n&#039;
                  &#039;object.__rtruediv__(self, other)\n&#039;
                  &#039;object.__rfloordiv__(self, other)\n&#039;
                  &#039;object.__rmod__(self, other)\n&#039;
                  &#039;object.__rdivmod__(self, other)\n&#039;
                  &#039;object.__rpow__(self, other)\n&#039;
                  &#039;object.__rlshift__(self, other)\n&#039;
                  &#039;object.__rrshift__(self, other)\n&#039;
                  &#039;object.__rand__(self, other)\n&#039;
                  &#039;object.__rxor__(self, other)\n&#039;
                  &#039;object.__ror__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   These methods are called to implement the binary &#039;
                  &#039;arithmetic\n&#039;
                  &#039;   operations (&quot;+&quot;, &quot;-&quot;, &quot;*&quot;, &quot;@&quot;, &quot;/&quot;, &quot;//&quot;, &quot;%&quot;, &#039;
                  &#039;&quot;divmod()&quot;,\n&#039;
                  &#039;   &quot;pow()&quot;, &quot;**&quot;, &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;) with reflected &#039;
                  &#039;(swapped)\n&#039;
                  &#039;   operands.  These functions are only called if the left &#039;
                  &#039;operand does\n&#039;
                  &#039;   not support the corresponding operation [3] and the &#039;
                  &#039;operands are of\n&#039;
                  &#039;   different types. [4] For instance, to evaluate the &#039;
                  &#039;expression &quot;x -\n&#039;
                  &#039;   y&quot;, where *y* is an instance of a class that has an &#039;
                  &#039;&quot;__rsub__()&quot;\n&#039;
                  &#039;   method, &quot;y.__rsub__(x)&quot; is called if &quot;x.__sub__(y)&quot; &#039;
                  &#039;returns\n&#039;
                  &#039;   *NotImplemented*.\n&#039;
                  &#039;\n&#039;
                  &#039;   Note that ternary &quot;pow()&quot; will not try calling &#039;
                  &#039;&quot;__rpow__()&quot; (the\n&#039;
                  &#039;   coercion rules would become too complicated).\n&#039;
                  &#039;\n&#039;
                  &#039;   Note: If the right operand’s type is a subclass of the &#039;
                  &#039;left\n&#039;
                  &#039;     operand’s type and that subclass provides the &#039;
                  &#039;reflected method\n&#039;
                  &#039;     for the operation, this method will be called before &#039;
                  &#039;the left\n&#039;
                  &#039;     operand’s non-reflected method.  This behavior allows &#039;
                  &#039;subclasses\n&#039;
                  &#039;     to override their ancestors’ operations.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__iadd__(self, other)\n&#039;
                  &#039;object.__isub__(self, other)\n&#039;
                  &#039;object.__imul__(self, other)\n&#039;
                  &#039;object.__imatmul__(self, other)\n&#039;
                  &#039;object.__itruediv__(self, other)\n&#039;
                  &#039;object.__ifloordiv__(self, other)\n&#039;
                  &#039;object.__imod__(self, other)\n&#039;
                  &#039;object.__ipow__(self, other[, modulo])\n&#039;
                  &#039;object.__ilshift__(self, other)\n&#039;
                  &#039;object.__irshift__(self, other)\n&#039;
                  &#039;object.__iand__(self, other)\n&#039;
                  &#039;object.__ixor__(self, other)\n&#039;
                  &#039;object.__ior__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   These methods are called to implement the augmented &#039;
                  &#039;arithmetic\n&#039;
                  &#039;   assignments (&quot;+=&quot;, &quot;-=&quot;, &quot;*=&quot;, &quot;@=&quot;, &quot;/=&quot;, &quot;//=&quot;, &quot;%=&quot;, &#039;
                  &#039;&quot;**=&quot;,\n&#039;
                  &#039;   &quot;&lt;&lt;=&quot;, &quot;&gt;&gt;=&quot;, &quot;&amp;=&quot;, &quot;^=&quot;, &quot;|=&quot;).  These methods should &#039;
                  &#039;attempt to\n&#039;
                  &#039;   do the operation in-place (modifying *self*) and return &#039;
                  &#039;the result\n&#039;
                  &#039;   (which could be, but does not have to be, *self*).  If a &#039;
                  &#039;specific\n&#039;
                  &#039;   method is not defined, the augmented assignment falls &#039;
                  &#039;back to the\n&#039;
                  &#039;   normal methods.  For instance, if *x* is an instance of &#039;
                  &#039;a class\n&#039;
                  &#039;   with an &quot;__iadd__()&quot; method, &quot;x += y&quot; is equivalent to &#039;
                  &#039;&quot;x =\n&#039;
                  &#039;   x.__iadd__(y)&quot; . Otherwise, &quot;x.__add__(y)&quot; and &#039;
                  &#039;&quot;y.__radd__(x)&quot; are\n&#039;
                  &#039;   considered, as with the evaluation of &quot;x + y&quot;. In &#039;
                  &#039;certain\n&#039;
                  &#039;   situations, augmented assignment can result in &#039;
                  &#039;unexpected errors\n&#039;
                  &#039;   (see Why does a_tuple[i] += [‘item’] raise an exception &#039;
                  &#039;when the\n&#039;
                  &#039;   addition works?), but this behavior is in fact part of &#039;
                  &#039;the data\n&#039;
                  &#039;   model.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__neg__(self)\n&#039;
                  &#039;object.__pos__(self)\n&#039;
                  &#039;object.__abs__(self)\n&#039;
                  &#039;object.__invert__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement the unary arithmetic operations &#039;
                  &#039;(&quot;-&quot;, &quot;+&quot;,\n&#039;
                  &#039;   &quot;abs()&quot; and &quot;~&quot;).\n&#039;
                  &#039;\n&#039;
                  &#039;object.__complex__(self)\n&#039;
                  &#039;object.__int__(self)\n&#039;
                  &#039;object.__float__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement the built-in functions &quot;complex()&quot;, &#039;
                  &#039;&quot;int()&quot; and\n&#039;
                  &#039;   &quot;float()&quot;.  Should return a value of the appropriate &#039;
                  &#039;type.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__index__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement &quot;operator.index()&quot;, and whenever &#039;
                  &#039;Python needs\n&#039;
                  &#039;   to losslessly convert the numeric object to an integer &#039;
                  &#039;object (such\n&#039;
                  &#039;   as in slicing, or in the built-in &quot;bin()&quot;, &quot;hex()&quot; and &#039;
                  &#039;&quot;oct()&quot;\n&#039;
                  &#039;   functions). Presence of this method indicates that the &#039;
                  &#039;numeric\n&#039;
                  &#039;   object is an integer type.  Must return an integer.\n&#039;
                  &#039;\n&#039;
                  &#039;   Note: In order to have a coherent integer type class, &#039;
                  &#039;when\n&#039;
                  &#039;     &quot;__index__()&quot; is defined &quot;__int__()&quot; should also be &#039;
                  &#039;defined, and\n&#039;
                  &#039;     both should return the same value.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__round__(self[, ndigits])\n&#039;
                  &#039;object.__trunc__(self)\n&#039;
                  &#039;object.__floor__(self)\n&#039;
                  &#039;object.__ceil__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement the built-in function &quot;round()&quot; and &#039;
                  &#039;&quot;math&quot;\n&#039;
                  &#039;   functions &quot;trunc()&quot;, &quot;floor()&quot; and &quot;ceil()&quot;. Unless &#039;
                  &#039;*ndigits* is\n&#039;
                  &#039;   passed to &quot;__round__()&quot; all these methods should return &#039;
                  &#039;the value\n&#039;
                  &#039;   of the object truncated to an &quot;Integral&quot; (typically an &#039;
                  &#039;&quot;int&quot;).\n&#039;
                  &#039;\n&#039;
                  &#039;   If &quot;__int__()&quot; is not defined then the built-in function &#039;
                  &#039;&quot;int()&quot;\n&#039;
                  &#039;   falls back to &quot;__trunc__()&quot;.\n&#039;,
 &#039;objects&#039;: &#039;Objects, values and types\n&#039;
            &#039;*************************\n&#039;
            &#039;\n&#039;
            &#039;*Objects* are Python’s abstraction for data.  All data in a &#039;
            &#039;Python\n&#039;
            &#039;program is represented by objects or by relations between &#039;
            &#039;objects. (In\n&#039;
            &#039;a sense, and in conformance to Von Neumann’s model of a “stored\n&#039;
            &#039;program computer,” code is also represented by objects.)\n&#039;
            &#039;\n&#039;
            &#039;Every object has an identity, a type and a value.  An object’s\n&#039;
            &#039;*identity* never changes once it has been created; you may think &#039;
            &#039;of it\n&#039;
            &#039;as the object’s address in memory.  The ‘&quot;is&quot;’ operator compares &#039;
            &#039;the\n&#039;
            &#039;identity of two objects; the &quot;id()&quot; function returns an integer\n&#039;
            &#039;representing its identity.\n&#039;
            &#039;\n&#039;
            &#039;**CPython implementation detail:** For CPython, &quot;id(x)&quot; is the &#039;
            &#039;memory\n&#039;
            &#039;address where &quot;x&quot; is stored.\n&#039;
            &#039;\n&#039;
            &#039;An object’s type determines the operations that the object &#039;
            &#039;supports\n&#039;
            &#039;(e.g., “does it have a length?”) and also defines the possible &#039;
            &#039;values\n&#039;
            &#039;for objects of that type.  The &quot;type()&quot; function returns an &#039;
            &#039;object’s\n&#039;
            &#039;type (which is an object itself).  Like its identity, an &#039;
            &#039;object’s\n&#039;
            &#039;*type* is also unchangeable. [1]\n&#039;
            &#039;\n&#039;
            &#039;The *value* of some objects can change.  Objects whose value can\n&#039;
            &#039;change are said to be *mutable*; objects whose value is &#039;
            &#039;unchangeable\n&#039;
            &#039;once they are created are called *immutable*. (The value of an\n&#039;
            &#039;immutable container object that contains a reference to a &#039;
            &#039;mutable\n&#039;
            &#039;object can change when the latter’s value is changed; however &#039;
            &#039;the\n&#039;
            &#039;container is still considered immutable, because the collection &#039;
            &#039;of\n&#039;
            &#039;objects it contains cannot be changed.  So, immutability is not\n&#039;
            &#039;strictly the same as having an unchangeable value, it is more &#039;
            &#039;subtle.)\n&#039;
            &#039;An object’s mutability is determined by its type; for instance,\n&#039;
            &#039;numbers, strings and tuples are immutable, while dictionaries &#039;
            &#039;and\n&#039;
            &#039;lists are mutable.\n&#039;
            &#039;\n&#039;
            &#039;Objects are never explicitly destroyed; however, when they &#039;
            &#039;become\n&#039;
            &#039;unreachable they may be garbage-collected.  An implementation is\n&#039;
            &#039;allowed to postpone garbage collection or omit it altogether — it &#039;
            &#039;is a\n&#039;
            &#039;matter of implementation quality how garbage collection is\n&#039;
            &#039;implemented, as long as no objects are collected that are still\n&#039;
            &#039;reachable.\n&#039;
            &#039;\n&#039;
            &#039;**CPython implementation detail:** CPython currently uses a &#039;
            &#039;reference-\n&#039;
            &#039;counting scheme with (optional) delayed detection of cyclically &#039;
            &#039;linked\n&#039;
            &#039;garbage, which collects most objects as soon as they become\n&#039;
            &#039;unreachable, but is not guaranteed to collect garbage containing\n&#039;
            &#039;circular references.  See the documentation of the &quot;gc&quot; module &#039;
            &#039;for\n&#039;
            &#039;information on controlling the collection of cyclic garbage. &#039;
            &#039;Other\n&#039;
            &#039;implementations act differently and CPython may change. Do not &#039;
            &#039;depend\n&#039;
            &#039;on immediate finalization of objects when they become unreachable &#039;
            &#039;(so\n&#039;
            &#039;you should always close files explicitly).\n&#039;
            &#039;\n&#039;
            &#039;Note that the use of the implementation’s tracing or debugging\n&#039;
            &#039;facilities may keep objects alive that would normally be &#039;
            &#039;collectable.\n&#039;
            &#039;Also note that catching an exception with a ‘&quot;try&quot;…&quot;except&quot;’ &#039;
            &#039;statement\n&#039;
            &#039;may keep objects alive.\n&#039;
            &#039;\n&#039;
            &#039;Some objects contain references to “external” resources such as &#039;
            &#039;open\n&#039;
            &#039;files or windows.  It is understood that these resources are &#039;
            &#039;freed\n&#039;
            &#039;when the object is garbage-collected, but since garbage &#039;
            &#039;collection is\n&#039;
            &#039;not guaranteed to happen, such objects also provide an explicit &#039;
            &#039;way to\n&#039;
            &#039;release the external resource, usually a &quot;close()&quot; method. &#039;
            &#039;Programs\n&#039;
            &#039;are strongly recommended to explicitly close such objects.  The\n&#039;
            &#039;‘&quot;try&quot;…&quot;finally&quot;’ statement and the ‘&quot;with&quot;’ statement provide\n&#039;
            &#039;convenient ways to do this.\n&#039;
            &#039;\n&#039;
            &#039;Some objects contain references to other objects; these are &#039;
            &#039;called\n&#039;
            &#039;*containers*. Examples of containers are tuples, lists and\n&#039;
            &#039;dictionaries.  The references are part of a container’s value.  &#039;
            &#039;In\n&#039;
            &#039;most cases, when we talk about the value of a container, we imply &#039;
            &#039;the\n&#039;
            &#039;values, not the identities of the contained objects; however, &#039;
            &#039;when we\n&#039;
            &#039;talk about the mutability of a container, only the identities of &#039;
            &#039;the\n&#039;
            &#039;immediately contained objects are implied.  So, if an immutable\n&#039;
            &#039;container (like a tuple) contains a reference to a mutable &#039;
            &#039;object, its\n&#039;
            &#039;value changes if that mutable object is changed.\n&#039;
            &#039;\n&#039;
            &#039;Types affect almost all aspects of object behavior.  Even the\n&#039;
            &#039;importance of object identity is affected in some sense: for &#039;
            &#039;immutable\n&#039;
            &#039;types, operations that compute new values may actually return a\n&#039;
            &#039;reference to any existing object with the same type and value, &#039;
            &#039;while\n&#039;
            &#039;for mutable objects this is not allowed.  E.g., after &quot;a = 1; b = &#039;
            &#039;1&quot;,\n&#039;
            &#039;&quot;a&quot; and &quot;b&quot; may or may not refer to the same object with the &#039;
            &#039;value\n&#039;
            &#039;one, depending on the implementation, but after &quot;c = []; d = []&quot;, &#039;
            &#039;&quot;c&quot;\n&#039;
            &#039;and &quot;d&quot; are guaranteed to refer to two different, unique, newly\n&#039;
            &#039;created empty lists. (Note that &quot;c = d = []&quot; assigns the same &#039;
            &#039;object\n&#039;
            &#039;to both &quot;c&quot; and &quot;d&quot;.)\n&#039;,
 &#039;operator-summary&#039;: &#039;Operator precedence\n&#039;
                     &#039;*******************\n&#039;
                     &#039;\n&#039;
                     &#039;The following table summarizes the operator precedence &#039;
                     &#039;in Python, from\n&#039;
                     &#039;lowest precedence (least binding) to highest precedence &#039;
                     &#039;(most\n&#039;
                     &#039;binding).  Operators in the same box have the same &#039;
                     &#039;precedence.  Unless\n&#039;
                     &#039;the syntax is explicitly given, operators are binary.  &#039;
                     &#039;Operators in\n&#039;
                     &#039;the same box group left to right (except for &#039;
                     &#039;exponentiation, which\n&#039;
                     &#039;groups from right to left).\n&#039;
                     &#039;\n&#039;
                     &#039;Note that comparisons, membership tests, and identity &#039;
                     &#039;tests, all have\n&#039;
                     &#039;the same precedence and have a left-to-right chaining &#039;
                     &#039;feature as\n&#039;
                     &#039;described in the Comparisons section.\n&#039;
                     &#039;\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| Operator                                        | &#039;
                     &#039;Description                           |\n&#039;
                     &#039;+=================================================+=======================================+\n&#039;
                     &#039;| &quot;lambda&quot;                                        | &#039;
                     &#039;Lambda expression                     |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;if&quot; – &quot;else&quot;                                   | &#039;
                     &#039;Conditional expression                |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;or&quot;                                            | &#039;
                     &#039;Boolean OR                            |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;and&quot;                                           | &#039;
                     &#039;Boolean AND                           |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;not&quot; &quot;x&quot;                                       | &#039;
                     &#039;Boolean NOT                           |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;in&quot;, &quot;not in&quot;, &quot;is&quot;, &quot;is not&quot;, &quot;&lt;&quot;, &quot;&lt;=&quot;, &quot;&gt;&quot;, | &#039;
                     &#039;Comparisons, including membership     |\n&#039;
                     &#039;| &quot;&gt;=&quot;, &quot;!=&quot;, &quot;==&quot;                                | &#039;
                     &#039;tests and identity tests              |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;|&quot;                                             | &#039;
                     &#039;Bitwise OR                            |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;^&quot;                                             | &#039;
                     &#039;Bitwise XOR                           |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;&amp;&quot;                                             | &#039;
                     &#039;Bitwise AND                           |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;                                      | &#039;
                     &#039;Shifts                                |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;+&quot;, &quot;-&quot;                                        | &#039;
                     &#039;Addition and subtraction              |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;*&quot;, &quot;@&quot;, &quot;/&quot;, &quot;//&quot;, &quot;%&quot;                        | &#039;
                     &#039;Multiplication, matrix                |\n&#039;
                     &#039;|                                                 | &#039;
                     &#039;multiplication, division, floor       |\n&#039;
                     &#039;|                                                 | &#039;
                     &#039;division, remainder [5]               |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;+x&quot;, &quot;-x&quot;, &quot;~x&quot;                                | &#039;
                     &#039;Positive, negative, bitwise NOT       |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;**&quot;                                            | &#039;
                     &#039;Exponentiation [6]                    |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;await&quot; &quot;x&quot;                                     | &#039;
                     &#039;Await expression                      |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;x[index]&quot;, &quot;x[index:index]&quot;,                   | &#039;
                     &#039;Subscription, slicing, call,          |\n&#039;
                     &#039;| &quot;x(arguments...)&quot;, &quot;x.attribute&quot;                | &#039;
                     &#039;attribute reference                   |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;| &quot;(expressions...)&quot;, &quot;[expressions...]&quot;, &quot;{key:  | &#039;
                     &#039;Binding or tuple display, list        |\n&#039;
                     &#039;| value...}&quot;, &quot;{expressions...}&quot;                  | &#039;
                     &#039;display, dictionary display, set      |\n&#039;
                     &#039;|                                                 | &#039;
                     &#039;display                               |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;\n&#039;
                     &#039;-[ Footnotes ]-\n&#039;
                     &#039;\n&#039;
                     &#039;[1] While &quot;abs(x%y) &lt; abs(y)&quot; is true mathematically, &#039;
                     &#039;for floats\n&#039;
                     &#039;    it may not be true numerically due to roundoff.  For &#039;
                     &#039;example, and\n&#039;
                     &#039;    assuming a platform on which a Python float is an &#039;
                     &#039;IEEE 754 double-\n&#039;
                     &#039;    precision number, in order that &quot;-1e-100 % 1e100&quot; &#039;
                     &#039;have the same\n&#039;
                     &#039;    sign as &quot;1e100&quot;, the computed result is &quot;-1e-100 + &#039;
                     &#039;1e100&quot;, which\n&#039;
                     &#039;    is numerically exactly equal to &quot;1e100&quot;.  The &#039;
                     &#039;function\n&#039;
                     &#039;    &quot;math.fmod()&quot; returns a result whose sign matches &#039;
                     &#039;the sign of the\n&#039;
                     &#039;    first argument instead, and so returns &quot;-1e-100&quot; in &#039;
                     &#039;this case.\n&#039;
                     &#039;    Which approach is more appropriate depends on the &#039;
                     &#039;application.\n&#039;
                     &#039;\n&#039;
                     &#039;[2] If x is very close to an exact integer multiple of &#039;
                     &#039;y, it’s\n&#039;
                     &#039;    possible for &quot;x//y&quot; to be one larger than &#039;
                     &#039;&quot;(x-x%y)//y&quot; due to\n&#039;
                     &#039;    rounding.  In such cases, Python returns the latter &#039;
                     &#039;result, in\n&#039;
                     &#039;    order to preserve that &quot;divmod(x,y)[0] * y + x % y&quot; &#039;
                     &#039;be very close\n&#039;
                     &#039;    to &quot;x&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;[3] The Unicode standard distinguishes between *code &#039;
                     &#039;points* (e.g.\n&#039;
                     &#039;    U+0041) and *abstract characters* (e.g. “LATIN &#039;
                     &#039;CAPITAL LETTER A”).\n&#039;
                     &#039;    While most abstract characters in Unicode are only &#039;
                     &#039;represented\n&#039;
                     &#039;    using one code point, there is a number of abstract &#039;
                     &#039;characters\n&#039;
                     &#039;    that can in addition be represented using a sequence &#039;
                     &#039;of more than\n&#039;
                     &#039;    one code point.  For example, the abstract character &#039;
                     &#039;“LATIN\n&#039;
                     &#039;    CAPITAL LETTER C WITH CEDILLA” can be represented as &#039;
                     &#039;a single\n&#039;
                     &#039;    *precomposed character* at code position U+00C7, or &#039;
                     &#039;as a sequence\n&#039;
                     &#039;    of a *base character* at code position U+0043 (LATIN &#039;
                     &#039;CAPITAL\n&#039;
                     &#039;    LETTER C), followed by a *combining character* at &#039;
                     &#039;code position\n&#039;
                     &#039;    U+0327 (COMBINING CEDILLA).\n&#039;
                     &#039;\n&#039;
                     &#039;    The comparison operators on strings compare at the &#039;
                     &#039;level of\n&#039;
                     &#039;    Unicode code points. This may be counter-intuitive &#039;
                     &#039;to humans.  For\n&#039;
                     &#039;    example, &quot;&quot;\\u00C7&quot; == &quot;\\u0043\\u0327&quot;&quot; is &quot;False&quot;, &#039;
                     &#039;even though both\n&#039;
                     &#039;    strings represent the same abstract character “LATIN &#039;
                     &#039;CAPITAL\n&#039;
                     &#039;    LETTER C WITH CEDILLA”.\n&#039;
                     &#039;\n&#039;
                     &#039;    To compare strings at the level of abstract &#039;
                     &#039;characters (that is,\n&#039;
                     &#039;    in a way intuitive to humans), use &#039;
                     &#039;&quot;unicodedata.normalize()&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;[4] Due to automatic garbage-collection, free lists, and &#039;
                     &#039;the\n&#039;
                     &#039;    dynamic nature of descriptors, you may notice &#039;
                     &#039;seemingly unusual\n&#039;
                     &#039;    behaviour in certain uses of the &quot;is&quot; operator, like &#039;
                     &#039;those\n&#039;
                     &#039;    involving comparisons between instance methods, or &#039;
                     &#039;constants.\n&#039;
                     &#039;    Check their documentation for more info.\n&#039;
                     &#039;\n&#039;
                     &#039;[5] The &quot;%&quot; operator is also used for string formatting; &#039;
                     &#039;the same\n&#039;
                     &#039;    precedence applies.\n&#039;
                     &#039;\n&#039;
                     &#039;[6] The power operator &quot;**&quot; binds less tightly than an &#039;
                     &#039;arithmetic\n&#039;
                     &#039;    or bitwise unary operator on its right, that is, &#039;
                     &#039;&quot;2**-1&quot; is &quot;0.5&quot;.\n&#039;,
 &#039;pass&#039;: &#039;The &quot;pass&quot; statement\n&#039;
         &#039;********************\n&#039;
         &#039;\n&#039;
         &#039;   pass_stmt ::= &quot;pass&quot;\n&#039;
         &#039;\n&#039;
         &#039;&quot;pass&quot; is a null operation — when it is executed, nothing happens. &#039;
         &#039;It\n&#039;
         &#039;is useful as a placeholder when a statement is required &#039;
         &#039;syntactically,\n&#039;
         &#039;but no code needs to be executed, for example:\n&#039;
         &#039;\n&#039;
         &#039;   def f(arg): pass    # a function that does nothing (yet)\n&#039;
         &#039;\n&#039;
         &#039;   class C: pass       # a class with no methods (yet)\n&#039;,
 &#039;power&#039;: &#039;The power operator\n&#039;
          &#039;******************\n&#039;
          &#039;\n&#039;
          &#039;The power operator binds more tightly than unary operators on its\n&#039;
          &#039;left; it binds less tightly than unary operators on its right.  &#039;
          &#039;The\n&#039;
          &#039;syntax is:\n&#039;
          &#039;\n&#039;
          &#039;   power ::= (await_expr | primary) [&quot;**&quot; u_expr]\n&#039;
          &#039;\n&#039;
          &#039;Thus, in an unparenthesized sequence of power and unary operators, &#039;
          &#039;the\n&#039;
          &#039;operators are evaluated from right to left (this does not &#039;
          &#039;constrain\n&#039;
          &#039;the evaluation order for the operands): &quot;-1**2&quot; results in &quot;-1&quot;.\n&#039;
          &#039;\n&#039;
          &#039;The power operator has the same semantics as the built-in &quot;pow()&quot;\n&#039;
          &#039;function, when called with two arguments: it yields its left &#039;
          &#039;argument\n&#039;
          &#039;raised to the power of its right argument.  The numeric arguments &#039;
          &#039;are\n&#039;
          &#039;first converted to a common type, and the result is of that type.\n&#039;
          &#039;\n&#039;
          &#039;For int operands, the result has the same type as the operands &#039;
          &#039;unless\n&#039;
          &#039;the second argument is negative; in that case, all arguments are\n&#039;
          &#039;converted to float and a float result is delivered. For example,\n&#039;
          &#039;&quot;10**2&quot; returns &quot;100&quot;, but &quot;10**-2&quot; returns &quot;0.01&quot;.\n&#039;
          &#039;\n&#039;
          &#039;Raising &quot;0.0&quot; to a negative power results in a &#039;
          &#039;&quot;ZeroDivisionError&quot;.\n&#039;
          &#039;Raising a negative number to a fractional power results in a &#039;
          &#039;&quot;complex&quot;\n&#039;
          &#039;number. (In earlier versions it raised a &quot;ValueError&quot;.)\n&#039;,
 &#039;raise&#039;: &#039;The &quot;raise&quot; statement\n&#039;
          &#039;*********************\n&#039;
          &#039;\n&#039;
          &#039;   raise_stmt ::= &quot;raise&quot; [expression [&quot;from&quot; expression]]\n&#039;
          &#039;\n&#039;
          &#039;If no expressions are present, &quot;raise&quot; re-raises the last &#039;
          &#039;exception\n&#039;
          &#039;that was active in the current scope.  If no exception is active &#039;
          &#039;in\n&#039;
          &#039;the current scope, a &quot;RuntimeError&quot; exception is raised indicating\n&#039;
          &#039;that this is an error.\n&#039;
          &#039;\n&#039;
          &#039;Otherwise, &quot;raise&quot; evaluates the first expression as the exception\n&#039;
          &#039;object.  It must be either a subclass or an instance of\n&#039;
          &#039;&quot;BaseException&quot;. If it is a class, the exception instance will be\n&#039;
          &#039;obtained when needed by instantiating the class with no arguments.\n&#039;
          &#039;\n&#039;
          &#039;The *type* of the exception is the exception instance’s class, the\n&#039;
          &#039;*value* is the instance itself.\n&#039;
          &#039;\n&#039;
          &#039;A traceback object is normally created automatically when an &#039;
          &#039;exception\n&#039;
          &#039;is raised and attached to it as the &quot;__traceback__&quot; attribute, &#039;
          &#039;which\n&#039;
          &#039;is writable. You can create an exception and set your own traceback &#039;
          &#039;in\n&#039;
          &#039;one step using the &quot;with_traceback()&quot; exception method (which &#039;
          &#039;returns\n&#039;
          &#039;the same exception instance, with its traceback set to its &#039;
          &#039;argument),\n&#039;
          &#039;like so:\n&#039;
          &#039;\n&#039;
          &#039;   raise Exception(&quot;foo occurred&quot;).with_traceback(tracebackobj)\n&#039;
          &#039;\n&#039;
          &#039;The &quot;from&quot; clause is used for exception chaining: if given, the &#039;
          &#039;second\n&#039;
          &#039;*expression* must be another exception class or instance, which &#039;
          &#039;will\n&#039;
          &#039;then be attached to the raised exception as the &quot;__cause__&quot; &#039;
          &#039;attribute\n&#039;
          &#039;(which is writable).  If the raised exception is not handled, both\n&#039;
          &#039;exceptions will be printed:\n&#039;
          &#039;\n&#039;
          &#039;   &gt;&gt;&gt; try:\n&#039;
          &#039;   ...     print(1 / 0)\n&#039;
          &#039;   ... except Exception as exc:\n&#039;
          &#039;   ...     raise RuntimeError(&quot;Something bad happened&quot;) from exc\n&#039;
          &#039;   ...\n&#039;
          &#039;   Traceback (most recent call last):\n&#039;
          &#039;     File &quot;&lt;stdin&gt;&quot;, line 2, in &lt;module&gt;\n&#039;
          &#039;   ZeroDivisionError: division by zero\n&#039;
          &#039;\n&#039;
          &#039;   The above exception was the direct cause of the following &#039;
          &#039;exception:\n&#039;
          &#039;\n&#039;
          &#039;   Traceback (most recent call last):\n&#039;
          &#039;     File &quot;&lt;stdin&gt;&quot;, line 4, in &lt;module&gt;\n&#039;
          &#039;   RuntimeError: Something bad happened\n&#039;
          &#039;\n&#039;
          &#039;A similar mechanism works implicitly if an exception is raised &#039;
          &#039;inside\n&#039;
          &#039;an exception handler or a &quot;finally&quot; clause: the previous exception &#039;
          &#039;is\n&#039;
          &#039;then attached as the new exception’s &quot;__context__&quot; attribute:\n&#039;
          &#039;\n&#039;
          &#039;   &gt;&gt;&gt; try:\n&#039;
          &#039;   ...     print(1 / 0)\n&#039;
          &#039;   ... except:\n&#039;
          &#039;   ...     raise RuntimeError(&quot;Something bad happened&quot;)\n&#039;
          &#039;   ...\n&#039;
          &#039;   Traceback (most recent call last):\n&#039;
          &#039;     File &quot;&lt;stdin&gt;&quot;, line 2, in &lt;module&gt;\n&#039;
          &#039;   ZeroDivisionError: division by zero\n&#039;
          &#039;\n&#039;
          &#039;   During handling of the above exception, another exception &#039;
          &#039;occurred:\n&#039;
          &#039;\n&#039;
          &#039;   Traceback (most recent call last):\n&#039;
          &#039;     File &quot;&lt;stdin&gt;&quot;, line 4, in &lt;module&gt;\n&#039;
          &#039;   RuntimeError: Something bad happened\n&#039;
          &#039;\n&#039;
          &#039;Exception chaining can be explicitly suppressed by specifying &#039;
          &#039;&quot;None&quot;\n&#039;
          &#039;in the &quot;from&quot; clause:\n&#039;
          &#039;\n&#039;
          &#039;   &gt;&gt;&gt; try:\n&#039;
          &#039;   ...     print(1 / 0)\n&#039;
          &#039;   ... except:\n&#039;
          &#039;   ...     raise RuntimeError(&quot;Something bad happened&quot;) from None\n&#039;
          &#039;   ...\n&#039;
          &#039;   Traceback (most recent call last):\n&#039;
          &#039;     File &quot;&lt;stdin&gt;&quot;, line 4, in &lt;module&gt;\n&#039;
          &#039;   RuntimeError: Something bad happened\n&#039;
          &#039;\n&#039;
          &#039;Additional information on exceptions can be found in section\n&#039;
          &#039;Exceptions, and information about handling exceptions is in &#039;
          &#039;section\n&#039;
          &#039;The try statement.\n&#039;
          &#039;\n&#039;
          &#039;Changed in version 3.3: &quot;None&quot; is now permitted as &quot;Y&quot; in &quot;raise X\n&#039;
          &#039;from Y&quot;.\n&#039;
          &#039;\n&#039;
          &#039;New in version 3.3: The &quot;__suppress_context__&quot; attribute to &#039;
          &#039;suppress\n&#039;
          &#039;automatic display of the exception context.\n&#039;,
 &#039;return&#039;: &#039;The &quot;return&quot; statement\n&#039;
           &#039;**********************\n&#039;
           &#039;\n&#039;
           &#039;   return_stmt ::= &quot;return&quot; [expression_list]\n&#039;
           &#039;\n&#039;
           &#039;&quot;return&quot; may only occur syntactically nested in a function &#039;
           &#039;definition,\n&#039;
           &#039;not within a nested class definition.\n&#039;
           &#039;\n&#039;
           &#039;If an expression list is present, it is evaluated, else &quot;None&quot; is\n&#039;
           &#039;substituted.\n&#039;
           &#039;\n&#039;
           &#039;&quot;return&quot; leaves the current function call with the expression list &#039;
           &#039;(or\n&#039;
           &#039;&quot;None&quot;) as return value.\n&#039;
           &#039;\n&#039;
           &#039;When &quot;return&quot; passes control out of a &quot;try&quot; statement with a &#039;
           &#039;&quot;finally&quot;\n&#039;
           &#039;clause, that &quot;finally&quot; clause is executed before really leaving &#039;
           &#039;the\n&#039;
           &#039;function.\n&#039;
           &#039;\n&#039;
           &#039;In a generator function, the &quot;return&quot; statement indicates that &#039;
           &#039;the\n&#039;
           &#039;generator is done and will cause &quot;StopIteration&quot; to be raised. &#039;
           &#039;The\n&#039;
           &#039;returned value (if any) is used as an argument to construct\n&#039;
           &#039;&quot;StopIteration&quot; and becomes the &quot;StopIteration.value&quot; attribute.\n&#039;
           &#039;\n&#039;
           &#039;In an asynchronous generator function, an empty &quot;return&quot; &#039;
           &#039;statement\n&#039;
           &#039;indicates that the asynchronous generator is done and will cause\n&#039;
           &#039;&quot;StopAsyncIteration&quot; to be raised.  A non-empty &quot;return&quot; statement &#039;
           &#039;is\n&#039;
           &#039;a syntax error in an asynchronous generator function.\n&#039;,
 &#039;sequence-types&#039;: &#039;Emulating container types\n&#039;
                   &#039;*************************\n&#039;
                   &#039;\n&#039;
                   &#039;The following methods can be defined to implement &#039;
                   &#039;container objects.\n&#039;
                   &#039;Containers usually are sequences (such as lists or tuples) &#039;
                   &#039;or mappings\n&#039;
                   &#039;(like dictionaries), but can represent other containers as &#039;
                   &#039;well.  The\n&#039;
                   &#039;first set of methods is used either to emulate a sequence &#039;
                   &#039;or to\n&#039;
                   &#039;emulate a mapping; the difference is that for a sequence, &#039;
                   &#039;the\n&#039;
                   &#039;allowable keys should be the integers *k* for which &quot;0 &lt;= &#039;
                   &#039;k &lt; N&quot; where\n&#039;
                   &#039;*N* is the length of the sequence, or slice objects, which &#039;
                   &#039;define a\n&#039;
                   &#039;range of items.  It is also recommended that mappings &#039;
                   &#039;provide the\n&#039;
                   &#039;methods &quot;keys()&quot;, &quot;values()&quot;, &quot;items()&quot;, &quot;get()&quot;, &#039;
                   &#039;&quot;clear()&quot;,\n&#039;
                   &#039;&quot;setdefault()&quot;, &quot;pop()&quot;, &quot;popitem()&quot;, &quot;copy()&quot;, and &#039;
                   &#039;&quot;update()&quot;\n&#039;
                   &#039;behaving similar to those for Python’s standard dictionary &#039;
                   &#039;objects.\n&#039;
                   &#039;The &quot;collections&quot; module provides a &quot;MutableMapping&quot; &#039;
                   &#039;abstract base\n&#039;
                   &#039;class to help create those methods from a base set of &#039;
                   &#039;&quot;__getitem__()&quot;,\n&#039;
                   &#039;&quot;__setitem__()&quot;, &quot;__delitem__()&quot;, and &quot;keys()&quot;. Mutable &#039;
                   &#039;sequences\n&#039;
                   &#039;should provide methods &quot;append()&quot;, &quot;count()&quot;, &quot;index()&quot;, &#039;
                   &#039;&quot;extend()&quot;,\n&#039;
                   &#039;&quot;insert()&quot;, &quot;pop()&quot;, &quot;remove()&quot;, &quot;reverse()&quot; and &quot;sort()&quot;, &#039;
                   &#039;like Python\n&#039;
                   &#039;standard list objects.  Finally, sequence types should &#039;
                   &#039;implement\n&#039;
                   &#039;addition (meaning concatenation) and multiplication &#039;
                   &#039;(meaning\n&#039;
                   &#039;repetition) by defining the methods &quot;__add__()&quot;, &#039;
                   &#039;&quot;__radd__()&quot;,\n&#039;
                   &#039;&quot;__iadd__()&quot;, &quot;__mul__()&quot;, &quot;__rmul__()&quot; and &quot;__imul__()&quot; &#039;
                   &#039;described\n&#039;
                   &#039;below; they should not define other numerical operators.  &#039;
                   &#039;It is\n&#039;
                   &#039;recommended that both mappings and sequences implement &#039;
                   &#039;the\n&#039;
                   &#039;&quot;__contains__()&quot; method to allow efficient use of the &quot;in&quot; &#039;
                   &#039;operator;\n&#039;
                   &#039;for mappings, &quot;in&quot; should search the mapping’s keys; for &#039;
                   &#039;sequences, it\n&#039;
                   &#039;should search through the values.  It is further &#039;
                   &#039;recommended that both\n&#039;
                   &#039;mappings and sequences implement the &quot;__iter__()&quot; method &#039;
                   &#039;to allow\n&#039;
                   &#039;efficient iteration through the container; for mappings, &#039;
                   &#039;&quot;__iter__()&quot;\n&#039;
                   &#039;should be the same as &quot;keys()&quot;; for sequences, it should &#039;
                   &#039;iterate\n&#039;
                   &#039;through the values.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__len__(self)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called to implement the built-in function &quot;len()&quot;.  &#039;
                   &#039;Should return\n&#039;
                   &#039;   the length of the object, an integer &quot;&gt;=&quot; 0.  Also, an &#039;
                   &#039;object that\n&#039;
                   &#039;   doesn’t define a &quot;__bool__()&quot; method and whose &#039;
                   &#039;&quot;__len__()&quot; method\n&#039;
                   &#039;   returns zero is considered to be false in a Boolean &#039;
                   &#039;context.\n&#039;
                   &#039;\n&#039;
                   &#039;   **CPython implementation detail:** In CPython, the &#039;
                   &#039;length is\n&#039;
                   &#039;   required to be at most &quot;sys.maxsize&quot;. If the length is &#039;
                   &#039;larger than\n&#039;
                   &#039;   &quot;sys.maxsize&quot; some features (such as &quot;len()&quot;) may &#039;
                   &#039;raise\n&#039;
                   &#039;   &quot;OverflowError&quot;.  To prevent raising &quot;OverflowError&quot; by &#039;
                   &#039;truth value\n&#039;
                   &#039;   testing, an object must define a &quot;__bool__()&quot; method.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__length_hint__(self)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called to implement &quot;operator.length_hint()&quot;. Should &#039;
                   &#039;return an\n&#039;
                   &#039;   estimated length for the object (which may be greater &#039;
                   &#039;or less than\n&#039;
                   &#039;   the actual length). The length must be an integer &quot;&gt;=&quot; &#039;
                   &#039;0. This\n&#039;
                   &#039;   method is purely an optimization and is never required &#039;
                   &#039;for\n&#039;
                   &#039;   correctness.\n&#039;
                   &#039;\n&#039;
                   &#039;   New in version 3.4.\n&#039;
                   &#039;\n&#039;
                   &#039;Note: Slicing is done exclusively with the following three &#039;
                   &#039;methods.\n&#039;
                   &#039;  A call like\n&#039;
                   &#039;\n&#039;
                   &#039;     a[1:2] = b\n&#039;
                   &#039;\n&#039;
                   &#039;  is translated to\n&#039;
                   &#039;\n&#039;
                   &#039;     a[slice(1, 2, None)] = b\n&#039;
                   &#039;\n&#039;
                   &#039;  and so forth.  Missing slice items are always filled in &#039;
                   &#039;with &quot;None&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__getitem__(self, key)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called to implement evaluation of &quot;self[key]&quot;. For &#039;
                   &#039;sequence types,\n&#039;
                   &#039;   the accepted keys should be integers and slice &#039;
                   &#039;objects.  Note that\n&#039;
                   &#039;   the special interpretation of negative indexes (if the &#039;
                   &#039;class wishes\n&#039;
                   &#039;   to emulate a sequence type) is up to the &#039;
                   &#039;&quot;__getitem__()&quot; method. If\n&#039;
                   &#039;   *key* is of an inappropriate type, &quot;TypeError&quot; may be &#039;
                   &#039;raised; if of\n&#039;
                   &#039;   a value outside the set of indexes for the sequence &#039;
                   &#039;(after any\n&#039;
                   &#039;   special interpretation of negative values), &#039;
                   &#039;&quot;IndexError&quot; should be\n&#039;
                   &#039;   raised. For mapping types, if *key* is missing (not in &#039;
                   &#039;the\n&#039;
                   &#039;   container), &quot;KeyError&quot; should be raised.\n&#039;
                   &#039;\n&#039;
                   &#039;   Note: &quot;for&quot; loops expect that an &quot;IndexError&quot; will be &#039;
                   &#039;raised for\n&#039;
                   &#039;     illegal indexes to allow proper detection of the end &#039;
                   &#039;of the\n&#039;
                   &#039;     sequence.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__setitem__(self, key, value)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called to implement assignment to &quot;self[key]&quot;.  Same &#039;
                   &#039;note as for\n&#039;
                   &#039;   &quot;__getitem__()&quot;.  This should only be implemented for &#039;
                   &#039;mappings if\n&#039;
                   &#039;   the objects support changes to the values for keys, or &#039;
                   &#039;if new keys\n&#039;
                   &#039;   can be added, or for sequences if elements can be &#039;
                   &#039;replaced.  The\n&#039;
                   &#039;   same exceptions should be raised for improper *key* &#039;
                   &#039;values as for\n&#039;
                   &#039;   the &quot;__getitem__()&quot; method.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__delitem__(self, key)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called to implement deletion of &quot;self[key]&quot;.  Same note &#039;
                   &#039;as for\n&#039;
                   &#039;   &quot;__getitem__()&quot;.  This should only be implemented for &#039;
                   &#039;mappings if\n&#039;
                   &#039;   the objects support removal of keys, or for sequences &#039;
                   &#039;if elements\n&#039;
                   &#039;   can be removed from the sequence.  The same exceptions &#039;
                   &#039;should be\n&#039;
                   &#039;   raised for improper *key* values as for the &#039;
                   &#039;&quot;__getitem__()&quot; method.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__missing__(self, key)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called by &quot;dict&quot;.&quot;__getitem__()&quot; to implement &#039;
                   &#039;&quot;self[key]&quot; for dict\n&#039;
                   &#039;   subclasses when key is not in the dictionary.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__iter__(self)\n&#039;
                   &#039;\n&#039;
                   &#039;   This method is called when an iterator is required for &#039;
                   &#039;a container.\n&#039;
                   &#039;   This method should return a new iterator object that &#039;
                   &#039;can iterate\n&#039;
                   &#039;   over all the objects in the container.  For mappings, &#039;
                   &#039;it should\n&#039;
                   &#039;   iterate over the keys of the container.\n&#039;
                   &#039;\n&#039;
                   &#039;   Iterator objects also need to implement this method; &#039;
                   &#039;they are\n&#039;
                   &#039;   required to return themselves.  For more information on &#039;
                   &#039;iterator\n&#039;
                   &#039;   objects, see Iterator Types.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__reversed__(self)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called (if present) by the &quot;reversed()&quot; built-in to &#039;
                   &#039;implement\n&#039;
                   &#039;   reverse iteration.  It should return a new iterator &#039;
                   &#039;object that\n&#039;
                   &#039;   iterates over all the objects in the container in &#039;
                   &#039;reverse order.\n&#039;
                   &#039;\n&#039;
                   &#039;   If the &quot;__reversed__()&quot; method is not provided, the &#039;
                   &#039;&quot;reversed()&quot;\n&#039;
                   &#039;   built-in will fall back to using the sequence protocol &#039;
                   &#039;(&quot;__len__()&quot;\n&#039;
                   &#039;   and &quot;__getitem__()&quot;).  Objects that support the &#039;
                   &#039;sequence protocol\n&#039;
                   &#039;   should only provide &quot;__reversed__()&quot; if they can &#039;
                   &#039;provide an\n&#039;
                   &#039;   implementation that is more efficient than the one &#039;
                   &#039;provided by\n&#039;
                   &#039;   &quot;reversed()&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;The membership test operators (&quot;in&quot; and &quot;not in&quot;) are &#039;
                   &#039;normally\n&#039;
                   &#039;implemented as an iteration through a sequence.  However, &#039;
                   &#039;container\n&#039;
                   &#039;objects can supply the following special method with a &#039;
                   &#039;more efficient\n&#039;
                   &#039;implementation, which also does not require the object be &#039;
                   &#039;a sequence.\n&#039;
                   &#039;\n&#039;
                   &#039;object.__contains__(self, item)\n&#039;
                   &#039;\n&#039;
                   &#039;   Called to implement membership test operators.  Should &#039;
                   &#039;return true\n&#039;
                   &#039;   if *item* is in *self*, false otherwise.  For mapping &#039;
                   &#039;objects, this\n&#039;
                   &#039;   should consider the keys of the mapping rather than the &#039;
                   &#039;values or\n&#039;
                   &#039;   the key-item pairs.\n&#039;
                   &#039;\n&#039;
                   &#039;   For objects that don’t define &quot;__contains__()&quot;, the &#039;
                   &#039;membership test\n&#039;
                   &#039;   first tries iteration via &quot;__iter__()&quot;, then the old &#039;
                   &#039;sequence\n&#039;
                   &#039;   iteration protocol via &quot;__getitem__()&quot;, see this &#039;
                   &#039;section in the\n&#039;
                   &#039;   language reference.\n&#039;,
 &#039;shifting&#039;: &#039;Shifting operations\n&#039;
             &#039;*******************\n&#039;
             &#039;\n&#039;
             &#039;The shifting operations have lower priority than the arithmetic\n&#039;
             &#039;operations:\n&#039;
             &#039;\n&#039;
             &#039;   shift_expr ::= a_expr | shift_expr (&quot;&lt;&lt;&quot; | &quot;&gt;&gt;&quot;) a_expr\n&#039;
             &#039;\n&#039;
             &#039;These operators accept integers as arguments.  They shift the &#039;
             &#039;first\n&#039;
             &#039;argument to the left or right by the number of bits given by &#039;
             &#039;the\n&#039;
             &#039;second argument.\n&#039;
             &#039;\n&#039;
             &#039;A right shift by *n* bits is defined as floor division by &#039;
             &#039;&quot;pow(2,n)&quot;.\n&#039;
             &#039;A left shift by *n* bits is defined as multiplication with &#039;
             &#039;&quot;pow(2,n)&quot;.\n&#039;
             &#039;\n&#039;
             &#039;Note: In the current implementation, the right-hand operand is\n&#039;
             &#039;  required to be at most &quot;sys.maxsize&quot;.  If the right-hand &#039;
             &#039;operand is\n&#039;
             &#039;  larger than &quot;sys.maxsize&quot; an &quot;OverflowError&quot; exception is &#039;
             &#039;raised.\n&#039;,
 &#039;slicings&#039;: &#039;Slicings\n&#039;
             &#039;********\n&#039;
             &#039;\n&#039;
             &#039;A slicing selects a range of items in a sequence object (e.g., &#039;
             &#039;a\n&#039;
             &#039;string, tuple or list).  Slicings may be used as expressions or &#039;
             &#039;as\n&#039;
             &#039;targets in assignment or &quot;del&quot; statements.  The syntax for a &#039;
             &#039;slicing:\n&#039;
             &#039;\n&#039;
             &#039;   slicing      ::= primary &quot;[&quot; slice_list &quot;]&quot;\n&#039;
             &#039;   slice_list   ::= slice_item (&quot;,&quot; slice_item)* [&quot;,&quot;]\n&#039;
             &#039;   slice_item   ::= expression | proper_slice\n&#039;
             &#039;   proper_slice ::= [lower_bound] &quot;:&quot; [upper_bound] [ &quot;:&quot; &#039;
             &#039;[stride] ]\n&#039;
             &#039;   lower_bound  ::= expression\n&#039;
             &#039;   upper_bound  ::= expression\n&#039;
             &#039;   stride       ::= expression\n&#039;
             &#039;\n&#039;
             &#039;There is ambiguity in the formal syntax here: anything that &#039;
             &#039;looks like\n&#039;
             &#039;an expression list also looks like a slice list, so any &#039;
             &#039;subscription\n&#039;
             &#039;can be interpreted as a slicing.  Rather than further &#039;
             &#039;complicating the\n&#039;
             &#039;syntax, this is disambiguated by defining that in this case the\n&#039;
             &#039;interpretation as a subscription takes priority over the\n&#039;
             &#039;interpretation as a slicing (this is the case if the slice list\n&#039;
             &#039;contains no proper slice).\n&#039;
             &#039;\n&#039;
             &#039;The semantics for a slicing are as follows.  The primary is &#039;
             &#039;indexed\n&#039;
             &#039;(using the same &quot;__getitem__()&quot; method as normal subscription) &#039;
             &#039;with a\n&#039;
             &#039;key that is constructed from the slice list, as follows.  If the &#039;
             &#039;slice\n&#039;
             &#039;list contains at least one comma, the key is a tuple containing &#039;
             &#039;the\n&#039;
             &#039;conversion of the slice items; otherwise, the conversion of the &#039;
             &#039;lone\n&#039;
             &#039;slice item is the key.  The conversion of a slice item that is &#039;
             &#039;an\n&#039;
             &#039;expression is that expression.  The conversion of a proper slice &#039;
             &#039;is a\n&#039;
             &#039;slice object (see section The standard type hierarchy) whose &#039;
             &#039;&quot;start&quot;,\n&#039;
             &#039;&quot;stop&quot; and &quot;step&quot; attributes are the values of the expressions &#039;
             &#039;given\n&#039;
             &#039;as lower bound, upper bound and stride, respectively, &#039;
             &#039;substituting\n&#039;
             &#039;&quot;None&quot; for missing expressions.\n&#039;,
 &#039;specialattrs&#039;: &#039;Special Attributes\n&#039;
                 &#039;******************\n&#039;
                 &#039;\n&#039;
                 &#039;The implementation adds a few special read-only attributes &#039;
                 &#039;to several\n&#039;
                 &#039;object types, where they are relevant.  Some of these are &#039;
                 &#039;not reported\n&#039;
                 &#039;by the &quot;dir()&quot; built-in function.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__dict__\n&#039;
                 &#039;\n&#039;
                 &#039;   A dictionary or other mapping object used to store an &#039;
                 &#039;object’s\n&#039;
                 &#039;   (writable) attributes.\n&#039;
                 &#039;\n&#039;
                 &#039;instance.__class__\n&#039;
                 &#039;\n&#039;
                 &#039;   The class to which a class instance belongs.\n&#039;
                 &#039;\n&#039;
                 &#039;class.__bases__\n&#039;
                 &#039;\n&#039;
                 &#039;   The tuple of base classes of a class object.\n&#039;
                 &#039;\n&#039;
                 &#039;definition.__name__\n&#039;
                 &#039;\n&#039;
                 &#039;   The name of the class, function, method, descriptor, or &#039;
                 &#039;generator\n&#039;
                 &#039;   instance.\n&#039;
                 &#039;\n&#039;
                 &#039;definition.__qualname__\n&#039;
                 &#039;\n&#039;
                 &#039;   The *qualified name* of the class, function, method, &#039;
                 &#039;descriptor, or\n&#039;
                 &#039;   generator instance.\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 3.3.\n&#039;
                 &#039;\n&#039;
                 &#039;class.__mro__\n&#039;
                 &#039;\n&#039;
                 &#039;   This attribute is a tuple of classes that are considered &#039;
                 &#039;when\n&#039;
                 &#039;   looking for base classes during method resolution.\n&#039;
                 &#039;\n&#039;
                 &#039;class.mro()\n&#039;
                 &#039;\n&#039;
                 &#039;   This method can be overridden by a metaclass to customize &#039;
                 &#039;the\n&#039;
                 &#039;   method resolution order for its instances.  It is called &#039;
                 &#039;at class\n&#039;
                 &#039;   instantiation, and its result is stored in &quot;__mro__&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;class.__subclasses__()\n&#039;
                 &#039;\n&#039;
                 &#039;   Each class keeps a list of weak references to its &#039;
                 &#039;immediate\n&#039;
                 &#039;   subclasses.  This method returns a list of all those &#039;
                 &#039;references\n&#039;
                 &#039;   still alive. Example:\n&#039;
                 &#039;\n&#039;
                 &#039;      &gt;&gt;&gt; int.__subclasses__()\n&#039;
                 &quot;      [&lt;class &#039;bool&#039;&gt;]\n&quot;
                 &#039;\n&#039;
                 &#039;-[ Footnotes ]-\n&#039;
                 &#039;\n&#039;
                 &#039;[1] Additional information on these special methods may be &#039;
                 &#039;found\n&#039;
                 &#039;    in the Python Reference Manual (Basic customization).\n&#039;
                 &#039;\n&#039;
                 &#039;[2] As a consequence, the list &quot;[1, 2]&quot; is considered equal &#039;
                 &#039;to\n&#039;
                 &#039;    &quot;[1.0, 2.0]&quot;, and similarly for tuples.\n&#039;
                 &#039;\n&#039;
                 &#039;[3] They must have since the parser can’t tell the type of &#039;
                 &#039;the\n&#039;
                 &#039;    operands.\n&#039;
                 &#039;\n&#039;
                 &#039;[4] Cased characters are those with general category &#039;
                 &#039;property\n&#039;
                 &#039;    being one of “Lu” (Letter, uppercase), “Ll” (Letter, &#039;
                 &#039;lowercase),\n&#039;
                 &#039;    or “Lt” (Letter, titlecase).\n&#039;
                 &#039;\n&#039;
                 &#039;[5] To format only a tuple you should therefore provide a\n&#039;
                 &#039;    singleton tuple whose only element is the tuple to be &#039;
                 &#039;formatted.\n&#039;,
 &#039;specialnames&#039;: &#039;Special method names\n&#039;
                 &#039;********************\n&#039;
                 &#039;\n&#039;
                 &#039;A class can implement certain operations that are invoked by &#039;
                 &#039;special\n&#039;
                 &#039;syntax (such as arithmetic operations or subscripting and &#039;
                 &#039;slicing) by\n&#039;
                 &#039;defining methods with special names. This is Python’s &#039;
                 &#039;approach to\n&#039;
                 &#039;*operator overloading*, allowing classes to define their own &#039;
                 &#039;behavior\n&#039;
                 &#039;with respect to language operators.  For instance, if a &#039;
                 &#039;class defines\n&#039;
                 &#039;a method named &quot;__getitem__()&quot;, and &quot;x&quot; is an instance of &#039;
                 &#039;this class,\n&#039;
                 &#039;then &quot;x[i]&quot; is roughly equivalent to &quot;type(x).__getitem__(x, &#039;
                 &#039;i)&quot;.\n&#039;
                 &#039;Except where mentioned, attempts to execute an operation &#039;
                 &#039;raise an\n&#039;
                 &#039;exception when no appropriate method is defined (typically\n&#039;
                 &#039;&quot;AttributeError&quot; or &quot;TypeError&quot;).\n&#039;
                 &#039;\n&#039;
                 &#039;Setting a special method to &quot;None&quot; indicates that the &#039;
                 &#039;corresponding\n&#039;
                 &#039;operation is not available.  For example, if a class sets &#039;
                 &#039;&quot;__iter__()&quot;\n&#039;
                 &#039;to &quot;None&quot;, the class is not iterable, so calling &quot;iter()&quot; on &#039;
                 &#039;its\n&#039;
                 &#039;instances will raise a &quot;TypeError&quot; (without falling back to\n&#039;
                 &#039;&quot;__getitem__()&quot;). [2]\n&#039;
                 &#039;\n&#039;
                 &#039;When implementing a class that emulates any built-in type, &#039;
                 &#039;it is\n&#039;
                 &#039;important that the emulation only be implemented to the &#039;
                 &#039;degree that it\n&#039;
                 &#039;makes sense for the object being modelled.  For example, &#039;
                 &#039;some\n&#039;
                 &#039;sequences may work well with retrieval of individual &#039;
                 &#039;elements, but\n&#039;
                 &#039;extracting a slice may not make sense.  (One example of this &#039;
                 &#039;is the\n&#039;
                 &#039;&quot;NodeList&quot; interface in the W3C’s Document Object Model.)\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Basic customization\n&#039;
                 &#039;===================\n&#039;
                 &#039;\n&#039;
                 &#039;object.__new__(cls[, ...])\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to create a new instance of class *cls*.  &#039;
                 &#039;&quot;__new__()&quot; is a\n&#039;
                 &#039;   static method (special-cased so you need not declare it &#039;
                 &#039;as such)\n&#039;
                 &#039;   that takes the class of which an instance was requested &#039;
                 &#039;as its\n&#039;
                 &#039;   first argument.  The remaining arguments are those passed &#039;
                 &#039;to the\n&#039;
                 &#039;   object constructor expression (the call to the class).  &#039;
                 &#039;The return\n&#039;
                 &#039;   value of &quot;__new__()&quot; should be the new object instance &#039;
                 &#039;(usually an\n&#039;
                 &#039;   instance of *cls*).\n&#039;
                 &#039;\n&#039;
                 &#039;   Typical implementations create a new instance of the &#039;
                 &#039;class by\n&#039;
                 &#039;   invoking the superclass’s &quot;__new__()&quot; method using\n&#039;
                 &#039;   &quot;super().__new__(cls[, ...])&quot; with appropriate arguments &#039;
                 &#039;and then\n&#039;
                 &#039;   modifying the newly-created instance as necessary before &#039;
                 &#039;returning\n&#039;
                 &#039;   it.\n&#039;
                 &#039;\n&#039;
                 &#039;   If &quot;__new__()&quot; returns an instance of *cls*, then the &#039;
                 &#039;new\n&#039;
                 &#039;   instance’s &quot;__init__()&quot; method will be invoked like\n&#039;
                 &#039;   &quot;__init__(self[, ...])&quot;, where *self* is the new instance &#039;
                 &#039;and the\n&#039;
                 &#039;   remaining arguments are the same as were passed to &#039;
                 &#039;&quot;__new__()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   If &quot;__new__()&quot; does not return an instance of *cls*, then &#039;
                 &#039;the new\n&#039;
                 &#039;   instance’s &quot;__init__()&quot; method will not be invoked.\n&#039;
                 &#039;\n&#039;
                 &#039;   &quot;__new__()&quot; is intended mainly to allow subclasses of &#039;
                 &#039;immutable\n&#039;
                 &#039;   types (like int, str, or tuple) to customize instance &#039;
                 &#039;creation.  It\n&#039;
                 &#039;   is also commonly overridden in custom metaclasses in &#039;
                 &#039;order to\n&#039;
                 &#039;   customize class creation.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__init__(self[, ...])\n&#039;
                 &#039;\n&#039;
                 &#039;   Called after the instance has been created (by &#039;
                 &#039;&quot;__new__()&quot;), but\n&#039;
                 &#039;   before it is returned to the caller.  The arguments are &#039;
                 &#039;those\n&#039;
                 &#039;   passed to the class constructor expression.  If a base &#039;
                 &#039;class has an\n&#039;
                 &#039;   &quot;__init__()&quot; method, the derived class’s &quot;__init__()&quot; &#039;
                 &#039;method, if\n&#039;
                 &#039;   any, must explicitly call it to ensure proper &#039;
                 &#039;initialization of the\n&#039;
                 &#039;   base class part of the instance; for example:\n&#039;
                 &#039;   &quot;super().__init__([args...])&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   Because &quot;__new__()&quot; and &quot;__init__()&quot; work together in &#039;
                 &#039;constructing\n&#039;
                 &#039;   objects (&quot;__new__()&quot; to create it, and &quot;__init__()&quot; to &#039;
                 &#039;customize\n&#039;
                 &#039;   it), no non-&quot;None&quot; value may be returned by &quot;__init__()&quot;; &#039;
                 &#039;doing so\n&#039;
                 &#039;   will cause a &quot;TypeError&quot; to be raised at runtime.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__del__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called when the instance is about to be destroyed.  This &#039;
                 &#039;is also\n&#039;
                 &#039;   called a finalizer or (improperly) a destructor.  If a &#039;
                 &#039;base class\n&#039;
                 &#039;   has a &quot;__del__()&quot; method, the derived class’s &quot;__del__()&quot; &#039;
                 &#039;method,\n&#039;
                 &#039;   if any, must explicitly call it to ensure proper deletion &#039;
                 &#039;of the\n&#039;
                 &#039;   base class part of the instance.\n&#039;
                 &#039;\n&#039;
                 &#039;   It is possible (though not recommended!) for the &#039;
                 &#039;&quot;__del__()&quot; method\n&#039;
                 &#039;   to postpone destruction of the instance by creating a new &#039;
                 &#039;reference\n&#039;
                 &#039;   to it.  This is called object *resurrection*.  It is\n&#039;
                 &#039;   implementation-dependent whether &quot;__del__()&quot; is called a &#039;
                 &#039;second\n&#039;
                 &#039;   time when a resurrected object is about to be destroyed; &#039;
                 &#039;the\n&#039;
                 &#039;   current *CPython* implementation only calls it once.\n&#039;
                 &#039;\n&#039;
                 &#039;   It is not guaranteed that &quot;__del__()&quot; methods are called &#039;
                 &#039;for\n&#039;
                 &#039;   objects that still exist when the interpreter exits.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: &quot;del x&quot; doesn’t directly call &quot;x.__del__()&quot; — the &#039;
                 &#039;former\n&#039;
                 &#039;     decrements the reference count for &quot;x&quot; by one, and the &#039;
                 &#039;latter is\n&#039;
                 &#039;     only called when &quot;x&quot;’s reference count reaches zero.\n&#039;
                 &#039;\n&#039;
                 &#039;   **CPython implementation detail:** It is possible for a &#039;
                 &#039;reference\n&#039;
                 &#039;   cycle to prevent the reference count of an object from &#039;
                 &#039;going to\n&#039;
                 &#039;   zero.  In this case, the cycle will be later detected and &#039;
                 &#039;deleted\n&#039;
                 &#039;   by the *cyclic garbage collector*.  A common cause of &#039;
                 &#039;reference\n&#039;
                 &#039;   cycles is when an exception has been caught in a local &#039;
                 &#039;variable.\n&#039;
                 &#039;   The frame’s locals then reference the exception, which &#039;
                 &#039;references\n&#039;
                 &#039;   its own traceback, which references the locals of all &#039;
                 &#039;frames caught\n&#039;
                 &#039;   in the traceback.\n&#039;
                 &#039;\n&#039;
                 &#039;   See also: Documentation for the &quot;gc&quot; module.\n&#039;
                 &#039;\n&#039;
                 &#039;   Warning: Due to the precarious circumstances under which\n&#039;
                 &#039;     &quot;__del__()&quot; methods are invoked, exceptions that occur &#039;
                 &#039;during\n&#039;
                 &#039;     their execution are ignored, and a warning is printed &#039;
                 &#039;to\n&#039;
                 &#039;     &quot;sys.stderr&quot; instead. In particular:\n&#039;
                 &#039;\n&#039;
                 &#039;     * &quot;__del__()&quot; can be invoked when arbitrary code is &#039;
                 &#039;being\n&#039;
                 &#039;       executed, including from any arbitrary thread.  If &#039;
                 &#039;&quot;__del__()&quot;\n&#039;
                 &#039;       needs to take a lock or invoke any other blocking &#039;
                 &#039;resource, it\n&#039;
                 &#039;       may deadlock as the resource may already be taken by &#039;
                 &#039;the code\n&#039;
                 &#039;       that gets interrupted to execute &quot;__del__()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;     * &quot;__del__()&quot; can be executed during interpreter &#039;
                 &#039;shutdown.  As\n&#039;
                 &#039;       a consequence, the global variables it needs to &#039;
                 &#039;access\n&#039;
                 &#039;       (including other modules) may already have been &#039;
                 &#039;deleted or set\n&#039;
                 &#039;       to &quot;None&quot;. Python guarantees that globals whose name &#039;
                 &#039;begins\n&#039;
                 &#039;       with a single underscore are deleted from their &#039;
                 &#039;module before\n&#039;
                 &#039;       other globals are deleted; if no other references to &#039;
                 &#039;such\n&#039;
                 &#039;       globals exist, this may help in assuring that &#039;
                 &#039;imported modules\n&#039;
                 &#039;       are still available at the time when the &quot;__del__()&quot; &#039;
                 &#039;method is\n&#039;
                 &#039;       called.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__repr__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by the &quot;repr()&quot; built-in function to compute the &#039;
                 &#039;“official”\n&#039;
                 &#039;   string representation of an object.  If at all possible, &#039;
                 &#039;this\n&#039;
                 &#039;   should look like a valid Python expression that could be &#039;
                 &#039;used to\n&#039;
                 &#039;   recreate an object with the same value (given an &#039;
                 &#039;appropriate\n&#039;
                 &#039;   environment).  If this is not possible, a string of the &#039;
                 &#039;form\n&#039;
                 &#039;   &quot;&lt;...some useful description...&gt;&quot; should be returned. The &#039;
                 &#039;return\n&#039;
                 &#039;   value must be a string object. If a class defines &#039;
                 &#039;&quot;__repr__()&quot; but\n&#039;
                 &#039;   not &quot;__str__()&quot;, then &quot;__repr__()&quot; is also used when an &#039;
                 &#039;“informal”\n&#039;
                 &#039;   string representation of instances of that class is &#039;
                 &#039;required.\n&#039;
                 &#039;\n&#039;
                 &#039;   This is typically used for debugging, so it is important &#039;
                 &#039;that the\n&#039;
                 &#039;   representation is information-rich and unambiguous.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__str__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by &quot;str(object)&quot; and the built-in functions &#039;
                 &#039;&quot;format()&quot; and\n&#039;
                 &#039;   &quot;print()&quot; to compute the “informal” or nicely printable &#039;
                 &#039;string\n&#039;
                 &#039;   representation of an object.  The return value must be a &#039;
                 &#039;string\n&#039;
                 &#039;   object.\n&#039;
                 &#039;\n&#039;
                 &#039;   This method differs from &quot;object.__repr__()&quot; in that &#039;
                 &#039;there is no\n&#039;
                 &#039;   expectation that &quot;__str__()&quot; return a valid Python &#039;
                 &#039;expression: a\n&#039;
                 &#039;   more convenient or concise representation can be used.\n&#039;
                 &#039;\n&#039;
                 &#039;   The default implementation defined by the built-in type &#039;
                 &#039;&quot;object&quot;\n&#039;
                 &#039;   calls &quot;object.__repr__()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__bytes__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by bytes to compute a byte-string representation &#039;
                 &#039;of an\n&#039;
                 &#039;   object. This should return a &quot;bytes&quot; object.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__format__(self, format_spec)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by the &quot;format()&quot; built-in function, and by &#039;
                 &#039;extension,\n&#039;
                 &#039;   evaluation of formatted string literals and the &#039;
                 &#039;&quot;str.format()&quot;\n&#039;
                 &#039;   method, to produce a “formatted” string representation of &#039;
                 &#039;an\n&#039;
                 &#039;   object. The &quot;format_spec&quot; argument is a string that &#039;
                 &#039;contains a\n&#039;
                 &#039;   description of the formatting options desired. The &#039;
                 &#039;interpretation\n&#039;
                 &#039;   of the &quot;format_spec&quot; argument is up to the type &#039;
                 &#039;implementing\n&#039;
                 &#039;   &quot;__format__()&quot;, however most classes will either &#039;
                 &#039;delegate\n&#039;
                 &#039;   formatting to one of the built-in types, or use a &#039;
                 &#039;similar\n&#039;
                 &#039;   formatting option syntax.\n&#039;
                 &#039;\n&#039;
                 &#039;   See Format Specification Mini-Language for a description &#039;
                 &#039;of the\n&#039;
                 &#039;   standard formatting syntax.\n&#039;
                 &#039;\n&#039;
                 &#039;   The return value must be a string object.\n&#039;
                 &#039;\n&#039;
                 &#039;   Changed in version 3.4: The __format__ method of &quot;object&quot; &#039;
                 &#039;itself\n&#039;
                 &#039;   raises a &quot;TypeError&quot; if passed any non-empty string.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__lt__(self, other)\n&#039;
                 &#039;object.__le__(self, other)\n&#039;
                 &#039;object.__eq__(self, other)\n&#039;
                 &#039;object.__ne__(self, other)\n&#039;
                 &#039;object.__gt__(self, other)\n&#039;
                 &#039;object.__ge__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   These are the so-called “rich comparison” methods. The\n&#039;
                 &#039;   correspondence between operator symbols and method names &#039;
                 &#039;is as\n&#039;
                 &#039;   follows: &quot;x&lt;y&quot; calls &quot;x.__lt__(y)&quot;, &quot;x&lt;=y&quot; calls &#039;
                 &#039;&quot;x.__le__(y)&quot;,\n&#039;
                 &#039;   &quot;x==y&quot; calls &quot;x.__eq__(y)&quot;, &quot;x!=y&quot; calls &quot;x.__ne__(y)&quot;, &#039;
                 &#039;&quot;x&gt;y&quot; calls\n&#039;
                 &#039;   &quot;x.__gt__(y)&quot;, and &quot;x&gt;=y&quot; calls &quot;x.__ge__(y)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   A rich comparison method may return the singleton &#039;
                 &#039;&quot;NotImplemented&quot;\n&#039;
                 &#039;   if it does not implement the operation for a given pair &#039;
                 &#039;of\n&#039;
                 &#039;   arguments. By convention, &quot;False&quot; and &quot;True&quot; are returned &#039;
                 &#039;for a\n&#039;
                 &#039;   successful comparison. However, these methods can return &#039;
                 &#039;any value,\n&#039;
                 &#039;   so if the comparison operator is used in a Boolean &#039;
                 &#039;context (e.g.,\n&#039;
                 &#039;   in the condition of an &quot;if&quot; statement), Python will call &#039;
                 &#039;&quot;bool()&quot;\n&#039;
                 &#039;   on the value to determine if the result is true or &#039;
                 &#039;false.\n&#039;
                 &#039;\n&#039;
                 &#039;   By default, &quot;__ne__()&quot; delegates to &quot;__eq__()&quot; and &#039;
                 &#039;inverts the\n&#039;
                 &#039;   result unless it is &quot;NotImplemented&quot;.  There are no other &#039;
                 &#039;implied\n&#039;
                 &#039;   relationships among the comparison operators, for &#039;
                 &#039;example, the\n&#039;
                 &#039;   truth of &quot;(x&lt;y or x==y)&quot; does not imply &quot;x&lt;=y&quot;. To &#039;
                 &#039;automatically\n&#039;
                 &#039;   generate ordering operations from a single root &#039;
                 &#039;operation, see\n&#039;
                 &#039;   &quot;functools.total_ordering()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   See the paragraph on &quot;__hash__()&quot; for some important &#039;
                 &#039;notes on\n&#039;
                 &#039;   creating *hashable* objects which support custom &#039;
                 &#039;comparison\n&#039;
                 &#039;   operations and are usable as dictionary keys.\n&#039;
                 &#039;\n&#039;
                 &#039;   There are no swapped-argument versions of these methods &#039;
                 &#039;(to be used\n&#039;
                 &#039;   when the left argument does not support the operation but &#039;
                 &#039;the right\n&#039;
                 &#039;   argument does); rather, &quot;__lt__()&quot; and &quot;__gt__()&quot; are &#039;
                 &#039;each other’s\n&#039;
                 &#039;   reflection, &quot;__le__()&quot; and &quot;__ge__()&quot; are each other’s &#039;
                 &#039;reflection,\n&#039;
                 &#039;   and &quot;__eq__()&quot; and &quot;__ne__()&quot; are their own reflection. &#039;
                 &#039;If the\n&#039;
                 &#039;   operands are of different types, and right operand’s type &#039;
                 &#039;is a\n&#039;
                 &#039;   direct or indirect subclass of the left operand’s type, &#039;
                 &#039;the\n&#039;
                 &#039;   reflected method of the right operand has priority, &#039;
                 &#039;otherwise the\n&#039;
                 &#039;   left operand’s method has priority.  Virtual subclassing &#039;
                 &#039;is not\n&#039;
                 &#039;   considered.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__hash__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by built-in function &quot;hash()&quot; and for operations &#039;
                 &#039;on members\n&#039;
                 &#039;   of hashed collections including &quot;set&quot;, &quot;frozenset&quot;, and &#039;
                 &#039;&quot;dict&quot;.\n&#039;
                 &#039;   &quot;__hash__()&quot; should return an integer. The only required &#039;
                 &#039;property\n&#039;
                 &#039;   is that objects which compare equal have the same hash &#039;
                 &#039;value; it is\n&#039;
                 &#039;   advised to mix together the hash values of the components &#039;
                 &#039;of the\n&#039;
                 &#039;   object that also play a part in comparison of objects by &#039;
                 &#039;packing\n&#039;
                 &#039;   them into a tuple and hashing the tuple. Example:\n&#039;
                 &#039;\n&#039;
                 &#039;      def __hash__(self):\n&#039;
                 &#039;          return hash((self.name, self.nick, self.color))\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: &quot;hash()&quot; truncates the value returned from an &#039;
                 &#039;object’s\n&#039;
                 &#039;     custom &quot;__hash__()&quot; method to the size of a &#039;
                 &#039;&quot;Py_ssize_t&quot;.  This\n&#039;
                 &#039;     is typically 8 bytes on 64-bit builds and 4 bytes on &#039;
                 &#039;32-bit\n&#039;
                 &#039;     builds. If an object’s   &quot;__hash__()&quot; must interoperate &#039;
                 &#039;on builds\n&#039;
                 &#039;     of different bit sizes, be sure to check the width on &#039;
                 &#039;all\n&#039;
                 &#039;     supported builds.  An easy way to do this is with &#039;
                 &#039;&quot;python -c\n&#039;
                 &#039;     &quot;import sys; print(sys.hash_info.width)&quot;&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   If a class does not define an &quot;__eq__()&quot; method it should &#039;
                 &#039;not\n&#039;
                 &#039;   define a &quot;__hash__()&quot; operation either; if it defines &#039;
                 &#039;&quot;__eq__()&quot;\n&#039;
                 &#039;   but not &quot;__hash__()&quot;, its instances will not be usable as &#039;
                 &#039;items in\n&#039;
                 &#039;   hashable collections.  If a class defines mutable objects &#039;
                 &#039;and\n&#039;
                 &#039;   implements an &quot;__eq__()&quot; method, it should not implement\n&#039;
                 &#039;   &quot;__hash__()&quot;, since the implementation of hashable &#039;
                 &#039;collections\n&#039;
                 &#039;   requires that a key’s hash value is immutable (if the &#039;
                 &#039;object’s hash\n&#039;
                 &#039;   value changes, it will be in the wrong hash bucket).\n&#039;
                 &#039;\n&#039;
                 &#039;   User-defined classes have &quot;__eq__()&quot; and &quot;__hash__()&quot; &#039;
                 &#039;methods by\n&#039;
                 &#039;   default; with them, all objects compare unequal (except &#039;
                 &#039;with\n&#039;
                 &#039;   themselves) and &quot;x.__hash__()&quot; returns an appropriate &#039;
                 &#039;value such\n&#039;
                 &#039;   that &quot;x == y&quot; implies both that &quot;x is y&quot; and &quot;hash(x) == &#039;
                 &#039;hash(y)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   A class that overrides &quot;__eq__()&quot; and does not define &#039;
                 &#039;&quot;__hash__()&quot;\n&#039;
                 &#039;   will have its &quot;__hash__()&quot; implicitly set to &quot;None&quot;.  &#039;
                 &#039;When the\n&#039;
                 &#039;   &quot;__hash__()&quot; method of a class is &quot;None&quot;, instances of &#039;
                 &#039;the class\n&#039;
                 &#039;   will raise an appropriate &quot;TypeError&quot; when a program &#039;
                 &#039;attempts to\n&#039;
                 &#039;   retrieve their hash value, and will also be correctly &#039;
                 &#039;identified as\n&#039;
                 &#039;   unhashable when checking &quot;isinstance(obj, &#039;
                 &#039;collections.Hashable)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   If a class that overrides &quot;__eq__()&quot; needs to retain the\n&#039;
                 &#039;   implementation of &quot;__hash__()&quot; from a parent class, the &#039;
                 &#039;interpreter\n&#039;
                 &#039;   must be told this explicitly by setting &quot;__hash__ =\n&#039;
                 &#039;   &lt;ParentClass&gt;.__hash__&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   If a class that does not override &quot;__eq__()&quot; wishes to &#039;
                 &#039;suppress\n&#039;
                 &#039;   hash support, it should include &quot;__hash__ = None&quot; in the &#039;
                 &#039;class\n&#039;
                 &#039;   definition. A class which defines its own &quot;__hash__()&quot; &#039;
                 &#039;that\n&#039;
                 &#039;   explicitly raises a &quot;TypeError&quot; would be incorrectly &#039;
                 &#039;identified as\n&#039;
                 &#039;   hashable by an &quot;isinstance(obj, collections.Hashable)&quot; &#039;
                 &#039;call.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: By default, the &quot;__hash__()&quot; values of str, bytes &#039;
                 &#039;and\n&#039;
                 &#039;     datetime objects are “salted” with an unpredictable &#039;
                 &#039;random value.\n&#039;
                 &#039;     Although they remain constant within an individual &#039;
                 &#039;Python\n&#039;
                 &#039;     process, they are not predictable between repeated &#039;
                 &#039;invocations of\n&#039;
                 &#039;     Python.This is intended to provide protection against a &#039;
                 &#039;denial-\n&#039;
                 &#039;     of-service caused by carefully-chosen inputs that &#039;
                 &#039;exploit the\n&#039;
                 &#039;     worst case performance of a dict insertion, O(n^2) &#039;
                 &#039;complexity.\n&#039;
                 &#039;     See http://www.ocert.org/advisories/ocert-2011-003.html &#039;
                 &#039;for\n&#039;
                 &#039;     details.Changing hash values affects the iteration &#039;
                 &#039;order of\n&#039;
                 &#039;     dicts, sets and other mappings.  Python has never made &#039;
                 &#039;guarantees\n&#039;
                 &#039;     about this ordering (and it typically varies between &#039;
                 &#039;32-bit and\n&#039;
                 &#039;     64-bit builds).See also &quot;PYTHONHASHSEED&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   Changed in version 3.3: Hash randomization is enabled by &#039;
                 &#039;default.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__bool__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement truth value testing and the built-in &#039;
                 &#039;operation\n&#039;
                 &#039;   &quot;bool()&quot;; should return &quot;False&quot; or &quot;True&quot;.  When this &#039;
                 &#039;method is not\n&#039;
                 &#039;   defined, &quot;__len__()&quot; is called, if it is defined, and the &#039;
                 &#039;object is\n&#039;
                 &#039;   considered true if its result is nonzero.  If a class &#039;
                 &#039;defines\n&#039;
                 &#039;   neither &quot;__len__()&quot; nor &quot;__bool__()&quot;, all its instances &#039;
                 &#039;are\n&#039;
                 &#039;   considered true.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Customizing attribute access\n&#039;
                 &#039;============================\n&#039;
                 &#039;\n&#039;
                 &#039;The following methods can be defined to customize the &#039;
                 &#039;meaning of\n&#039;
                 &#039;attribute access (use of, assignment to, or deletion of &#039;
                 &#039;&quot;x.name&quot;) for\n&#039;
                 &#039;class instances.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__getattr__(self, name)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called when the default attribute access fails with an\n&#039;
                 &#039;   &quot;AttributeError&quot; (either &quot;__getattribute__()&quot; raises an\n&#039;
                 &#039;   &quot;AttributeError&quot; because *name* is not an instance &#039;
                 &#039;attribute or an\n&#039;
                 &#039;   attribute in the class tree for &quot;self&quot;; or &quot;__get__()&quot; of &#039;
                 &#039;a *name*\n&#039;
                 &#039;   property raises &quot;AttributeError&quot;).  This method should &#039;
                 &#039;either\n&#039;
                 &#039;   return the (computed) attribute value or raise an &#039;
                 &#039;&quot;AttributeError&quot;\n&#039;
                 &#039;   exception.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note that if the attribute is found through the normal &#039;
                 &#039;mechanism,\n&#039;
                 &#039;   &quot;__getattr__()&quot; is not called.  (This is an intentional &#039;
                 &#039;asymmetry\n&#039;
                 &#039;   between &quot;__getattr__()&quot; and &quot;__setattr__()&quot;.) This is &#039;
                 &#039;done both for\n&#039;
                 &#039;   efficiency reasons and because otherwise &quot;__getattr__()&quot; &#039;
                 &#039;would have\n&#039;
                 &#039;   no way to access other attributes of the instance.  Note &#039;
                 &#039;that at\n&#039;
                 &#039;   least for instance variables, you can fake total control &#039;
                 &#039;by not\n&#039;
                 &#039;   inserting any values in the instance attribute dictionary &#039;
                 &#039;(but\n&#039;
                 &#039;   instead inserting them in another object).  See the\n&#039;
                 &#039;   &quot;__getattribute__()&quot; method below for a way to actually &#039;
                 &#039;get total\n&#039;
                 &#039;   control over attribute access.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__getattribute__(self, name)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called unconditionally to implement attribute accesses &#039;
                 &#039;for\n&#039;
                 &#039;   instances of the class. If the class also defines &#039;
                 &#039;&quot;__getattr__()&quot;,\n&#039;
                 &#039;   the latter will not be called unless &quot;__getattribute__()&quot; &#039;
                 &#039;either\n&#039;
                 &#039;   calls it explicitly or raises an &quot;AttributeError&quot;. This &#039;
                 &#039;method\n&#039;
                 &#039;   should return the (computed) attribute value or raise an\n&#039;
                 &#039;   &quot;AttributeError&quot; exception. In order to avoid infinite &#039;
                 &#039;recursion in\n&#039;
                 &#039;   this method, its implementation should always call the &#039;
                 &#039;base class\n&#039;
                 &#039;   method with the same name to access any attributes it &#039;
                 &#039;needs, for\n&#039;
                 &#039;   example, &quot;object.__getattribute__(self, name)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: This method may still be bypassed when looking up &#039;
                 &#039;special\n&#039;
                 &#039;     methods as the result of implicit invocation via &#039;
                 &#039;language syntax\n&#039;
                 &#039;     or built-in functions. See Special method lookup.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__setattr__(self, name, value)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called when an attribute assignment is attempted.  This &#039;
                 &#039;is called\n&#039;
                 &#039;   instead of the normal mechanism (i.e. store the value in &#039;
                 &#039;the\n&#039;
                 &#039;   instance dictionary). *name* is the attribute name, &#039;
                 &#039;*value* is the\n&#039;
                 &#039;   value to be assigned to it.\n&#039;
                 &#039;\n&#039;
                 &#039;   If &quot;__setattr__()&quot; wants to assign to an instance &#039;
                 &#039;attribute, it\n&#039;
                 &#039;   should call the base class method with the same name, for &#039;
                 &#039;example,\n&#039;
                 &#039;   &quot;object.__setattr__(self, name, value)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__delattr__(self, name)\n&#039;
                 &#039;\n&#039;
                 &#039;   Like &quot;__setattr__()&quot; but for attribute deletion instead &#039;
                 &#039;of\n&#039;
                 &#039;   assignment.  This should only be implemented if &quot;del &#039;
                 &#039;obj.name&quot; is\n&#039;
                 &#039;   meaningful for the object.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__dir__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called when &quot;dir()&quot; is called on the object. A sequence &#039;
                 &#039;must be\n&#039;
                 &#039;   returned. &quot;dir()&quot; converts the returned sequence to a &#039;
                 &#039;list and\n&#039;
                 &#039;   sorts it.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Customizing module attribute access\n&#039;
                 &#039;-----------------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;For a more fine grained customization of the module behavior &#039;
                 &#039;(setting\n&#039;
                 &#039;attributes, properties, etc.), one can set the &quot;__class__&quot; &#039;
                 &#039;attribute\n&#039;
                 &#039;of a module object to a subclass of &quot;types.ModuleType&quot;. For &#039;
                 &#039;example:\n&#039;
                 &#039;\n&#039;
                 &#039;   import sys\n&#039;
                 &#039;   from types import ModuleType\n&#039;
                 &#039;\n&#039;
                 &#039;   class VerboseModule(ModuleType):\n&#039;
                 &#039;       def __repr__(self):\n&#039;
                 &quot;           return f&#039;Verbose {self.__name__}&#039;\n&quot;
                 &#039;\n&#039;
                 &#039;       def __setattr__(self, attr, value):\n&#039;
                 &quot;           print(f&#039;Setting {attr}...&#039;)\n&quot;
                 &#039;           setattr(self, attr, value)\n&#039;
                 &#039;\n&#039;
                 &#039;   sys.modules[__name__].__class__ = VerboseModule\n&#039;
                 &#039;\n&#039;
                 &#039;Note: Setting module &quot;__class__&quot; only affects lookups made &#039;
                 &#039;using the\n&#039;
                 &#039;  attribute access syntax – directly accessing the module &#039;
                 &#039;globals\n&#039;
                 &#039;  (whether by code within the module, or via a reference to &#039;
                 &#039;the\n&#039;
                 &#039;  module’s globals dictionary) is unaffected.\n&#039;
                 &#039;\n&#039;
                 &#039;Changed in version 3.5: &quot;__class__&quot; module attribute is now &#039;
                 &#039;writable.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Implementing Descriptors\n&#039;
                 &#039;------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;The following methods only apply when an instance of the &#039;
                 &#039;class\n&#039;
                 &#039;containing the method (a so-called *descriptor* class) &#039;
                 &#039;appears in an\n&#039;
                 &#039;*owner* class (the descriptor must be in either the owner’s &#039;
                 &#039;class\n&#039;
                 &#039;dictionary or in the class dictionary for one of its &#039;
                 &#039;parents).  In the\n&#039;
                 &#039;examples below, “the attribute” refers to the attribute &#039;
                 &#039;whose name is\n&#039;
                 &#039;the key of the property in the owner class’ &quot;__dict__&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__get__(self, instance, owner)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to get the attribute of the owner class (class &#039;
                 &#039;attribute\n&#039;
                 &#039;   access) or of an instance of that class (instance &#039;
                 &#039;attribute\n&#039;
                 &#039;   access). *owner* is always the owner class, while &#039;
                 &#039;*instance* is the\n&#039;
                 &#039;   instance that the attribute was accessed through, or &#039;
                 &#039;&quot;None&quot; when\n&#039;
                 &#039;   the attribute is accessed through the *owner*.  This &#039;
                 &#039;method should\n&#039;
                 &#039;   return the (computed) attribute value or raise an &#039;
                 &#039;&quot;AttributeError&quot;\n&#039;
                 &#039;   exception.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__set__(self, instance, value)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to set the attribute on an instance *instance* of &#039;
                 &#039;the owner\n&#039;
                 &#039;   class to a new value, *value*.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__delete__(self, instance)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to delete the attribute on an instance *instance* &#039;
                 &#039;of the\n&#039;
                 &#039;   owner class.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__set_name__(self, owner, name)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called at the time the owning class *owner* is created. &#039;
                 &#039;The\n&#039;
                 &#039;   descriptor has been assigned to *name*.\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 3.6.\n&#039;
                 &#039;\n&#039;
                 &#039;The attribute &quot;__objclass__&quot; is interpreted by the &quot;inspect&quot; &#039;
                 &#039;module as\n&#039;
                 &#039;specifying the class where this object was defined (setting &#039;
                 &#039;this\n&#039;
                 &#039;appropriately can assist in runtime introspection of dynamic &#039;
                 &#039;class\n&#039;
                 &#039;attributes). For callables, it may indicate that an instance &#039;
                 &#039;of the\n&#039;
                 &#039;given type (or a subclass) is expected or required as the &#039;
                 &#039;first\n&#039;
                 &#039;positional argument (for example, CPython sets this &#039;
                 &#039;attribute for\n&#039;
                 &#039;unbound methods that are implemented in C).\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Invoking Descriptors\n&#039;
                 &#039;--------------------\n&#039;
                 &#039;\n&#039;
                 &#039;In general, a descriptor is an object attribute with &#039;
                 &#039;“binding\n&#039;
                 &#039;behavior”, one whose attribute access has been overridden by &#039;
                 &#039;methods\n&#039;
                 &#039;in the descriptor protocol:  &quot;__get__()&quot;, &quot;__set__()&quot;, and\n&#039;
                 &#039;&quot;__delete__()&quot;. If any of those methods are defined for an &#039;
                 &#039;object, it\n&#039;
                 &#039;is said to be a descriptor.\n&#039;
                 &#039;\n&#039;
                 &#039;The default behavior for attribute access is to get, set, or &#039;
                 &#039;delete\n&#039;
                 &#039;the attribute from an object’s dictionary. For instance, &#039;
                 &#039;&quot;a.x&quot; has a\n&#039;
                 &#039;lookup chain starting with &quot;a.__dict__[\&#039;x\&#039;]&quot;, then\n&#039;
                 &#039;&quot;type(a).__dict__[\&#039;x\&#039;]&quot;, and continuing through the base &#039;
                 &#039;classes of\n&#039;
                 &#039;&quot;type(a)&quot; excluding metaclasses.\n&#039;
                 &#039;\n&#039;
                 &#039;However, if the looked-up value is an object defining one of &#039;
                 &#039;the\n&#039;
                 &#039;descriptor methods, then Python may override the default &#039;
                 &#039;behavior and\n&#039;
                 &#039;invoke the descriptor method instead.  Where this occurs in &#039;
                 &#039;the\n&#039;
                 &#039;precedence chain depends on which descriptor methods were &#039;
                 &#039;defined and\n&#039;
                 &#039;how they were called.\n&#039;
                 &#039;\n&#039;
                 &#039;The starting point for descriptor invocation is a binding, &#039;
                 &#039;&quot;a.x&quot;. How\n&#039;
                 &#039;the arguments are assembled depends on &quot;a&quot;:\n&#039;
                 &#039;\n&#039;
                 &#039;Direct Call\n&#039;
                 &#039;   The simplest and least common call is when user code &#039;
                 &#039;directly\n&#039;
                 &#039;   invokes a descriptor method:    &quot;x.__get__(a)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Instance Binding\n&#039;
                 &#039;   If binding to an object instance, &quot;a.x&quot; is transformed &#039;
                 &#039;into the\n&#039;
                 &#039;   call: &quot;type(a).__dict__[\&#039;x\&#039;].__get__(a, type(a))&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Class Binding\n&#039;
                 &#039;   If binding to a class, &quot;A.x&quot; is transformed into the &#039;
                 &#039;call:\n&#039;
                 &#039;   &quot;A.__dict__[\&#039;x\&#039;].__get__(None, A)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Super Binding\n&#039;
                 &#039;   If &quot;a&quot; is an instance of &quot;super&quot;, then the binding &#039;
                 &#039;&quot;super(B,\n&#039;
                 &#039;   obj).m()&quot; searches &quot;obj.__class__.__mro__&quot; for the base &#039;
                 &#039;class &quot;A&quot;\n&#039;
                 &#039;   immediately preceding &quot;B&quot; and then invokes the descriptor &#039;
                 &#039;with the\n&#039;
                 &#039;   call: &quot;A.__dict__[\&#039;m\&#039;].__get__(obj, obj.__class__)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;For instance bindings, the precedence of descriptor &#039;
                 &#039;invocation depends\n&#039;
                 &#039;on the which descriptor methods are defined.  A descriptor &#039;
                 &#039;can define\n&#039;
                 &#039;any combination of &quot;__get__()&quot;, &quot;__set__()&quot; and &#039;
                 &#039;&quot;__delete__()&quot;.  If it\n&#039;
                 &#039;does not define &quot;__get__()&quot;, then accessing the attribute &#039;
                 &#039;will return\n&#039;
                 &#039;the descriptor object itself unless there is a value in the &#039;
                 &#039;object’s\n&#039;
                 &#039;instance dictionary.  If the descriptor defines &quot;__set__()&quot; &#039;
                 &#039;and/or\n&#039;
                 &#039;&quot;__delete__()&quot;, it is a data descriptor; if it defines &#039;
                 &#039;neither, it is\n&#039;
                 &#039;a non-data descriptor.  Normally, data descriptors define &#039;
                 &#039;both\n&#039;
                 &#039;&quot;__get__()&quot; and &quot;__set__()&quot;, while non-data descriptors have &#039;
                 &#039;just the\n&#039;
                 &#039;&quot;__get__()&quot; method.  Data descriptors with &quot;__set__()&quot; and &#039;
                 &#039;&quot;__get__()&quot;\n&#039;
                 &#039;defined always override a redefinition in an instance &#039;
                 &#039;dictionary.  In\n&#039;
                 &#039;contrast, non-data descriptors can be overridden by &#039;
                 &#039;instances.\n&#039;
                 &#039;\n&#039;
                 &#039;Python methods (including &quot;staticmethod()&quot; and &#039;
                 &#039;&quot;classmethod()&quot;) are\n&#039;
                 &#039;implemented as non-data descriptors.  Accordingly, instances &#039;
                 &#039;can\n&#039;
                 &#039;redefine and override methods.  This allows individual &#039;
                 &#039;instances to\n&#039;
                 &#039;acquire behaviors that differ from other instances of the &#039;
                 &#039;same class.\n&#039;
                 &#039;\n&#039;
                 &#039;The &quot;property()&quot; function is implemented as a data &#039;
                 &#039;descriptor.\n&#039;
                 &#039;Accordingly, instances cannot override the behavior of a &#039;
                 &#039;property.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;__slots__\n&#039;
                 &#039;---------\n&#039;
                 &#039;\n&#039;
                 &#039;*__slots__* allow us to explicitly declare data members &#039;
                 &#039;(like\n&#039;
                 &#039;properties) and deny the creation of *__dict__* and &#039;
                 &#039;*__weakref__*\n&#039;
                 &#039;(unless explicitly declared in *__slots__* or available in a &#039;
                 &#039;parent.)\n&#039;
                 &#039;\n&#039;
                 &#039;The space saved over using *__dict__* can be significant.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__slots__\n&#039;
                 &#039;\n&#039;
                 &#039;   This class variable can be assigned a string, iterable, &#039;
                 &#039;or sequence\n&#039;
                 &#039;   of strings with variable names used by instances.  &#039;
                 &#039;*__slots__*\n&#039;
                 &#039;   reserves space for the declared variables and prevents &#039;
                 &#039;the\n&#039;
                 &#039;   automatic creation of *__dict__* and *__weakref__* for &#039;
                 &#039;each\n&#039;
                 &#039;   instance.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Notes on using *__slots__*\n&#039;
                 &#039;~~~~~~~~~~~~~~~~~~~~~~~~~~\n&#039;
                 &#039;\n&#039;
                 &#039;* When inheriting from a class without *__slots__*, the &#039;
                 &#039;*__dict__*\n&#039;
                 &#039;  and *__weakref__* attribute of the instances will always &#039;
                 &#039;be\n&#039;
                 &#039;  accessible.\n&#039;
                 &#039;\n&#039;
                 &#039;* Without a *__dict__* variable, instances cannot be &#039;
                 &#039;assigned new\n&#039;
                 &#039;  variables not listed in the *__slots__* definition.  &#039;
                 &#039;Attempts to\n&#039;
                 &#039;  assign to an unlisted variable name raises &#039;
                 &#039;&quot;AttributeError&quot;. If\n&#039;
                 &#039;  dynamic assignment of new variables is desired, then add\n&#039;
                 &#039;  &quot;\&#039;__dict__\&#039;&quot; to the sequence of strings in the &#039;
                 &#039;*__slots__*\n&#039;
                 &#039;  declaration.\n&#039;
                 &#039;\n&#039;
                 &#039;* Without a *__weakref__* variable for each instance, &#039;
                 &#039;classes\n&#039;
                 &#039;  defining *__slots__* do not support weak references to &#039;
                 &#039;its\n&#039;
                 &#039;  instances. If weak reference support is needed, then add\n&#039;
                 &#039;  &quot;\&#039;__weakref__\&#039;&quot; to the sequence of strings in the &#039;
                 &#039;*__slots__*\n&#039;
                 &#039;  declaration.\n&#039;
                 &#039;\n&#039;
                 &#039;* *__slots__* are implemented at the class level by &#039;
                 &#039;creating\n&#039;
                 &#039;  descriptors (Implementing Descriptors) for each variable &#039;
                 &#039;name.  As a\n&#039;
                 &#039;  result, class attributes cannot be used to set default &#039;
                 &#039;values for\n&#039;
                 &#039;  instance variables defined by *__slots__*; otherwise, the &#039;
                 &#039;class\n&#039;
                 &#039;  attribute would overwrite the descriptor assignment.\n&#039;
                 &#039;\n&#039;
                 &#039;* The action of a *__slots__* declaration is not limited to &#039;
                 &#039;the\n&#039;
                 &#039;  class where it is defined.  *__slots__* declared in &#039;
                 &#039;parents are\n&#039;
                 &#039;  available in child classes. However, child subclasses will &#039;
                 &#039;get a\n&#039;
                 &#039;  *__dict__* and *__weakref__* unless they also define &#039;
                 &#039;*__slots__*\n&#039;
                 &#039;  (which should only contain names of any *additional* &#039;
                 &#039;slots).\n&#039;
                 &#039;\n&#039;
                 &#039;* If a class defines a slot also defined in a base class, &#039;
                 &#039;the\n&#039;
                 &#039;  instance variable defined by the base class slot is &#039;
                 &#039;inaccessible\n&#039;
                 &#039;  (except by retrieving its descriptor directly from the &#039;
                 &#039;base class).\n&#039;
                 &#039;  This renders the meaning of the program undefined.  In the &#039;
                 &#039;future, a\n&#039;
                 &#039;  check may be added to prevent this.\n&#039;
                 &#039;\n&#039;
                 &#039;* Nonempty *__slots__* does not work for classes derived &#039;
                 &#039;from\n&#039;
                 &#039;  “variable-length” built-in types such as &quot;int&quot;, &quot;bytes&quot; &#039;
                 &#039;and &quot;tuple&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;* Any non-string iterable may be assigned to *__slots__*. &#039;
                 &#039;Mappings\n&#039;
                 &#039;  may also be used; however, in the future, special meaning &#039;
                 &#039;may be\n&#039;
                 &#039;  assigned to the values corresponding to each key.\n&#039;
                 &#039;\n&#039;
                 &#039;* *__class__* assignment works only if both classes have the &#039;
                 &#039;same\n&#039;
                 &#039;  *__slots__*.\n&#039;
                 &#039;\n&#039;
                 &#039;* Multiple inheritance with multiple slotted parent classes &#039;
                 &#039;can be\n&#039;
                 &#039;  used, but only one parent is allowed to have attributes &#039;
                 &#039;created by\n&#039;
                 &#039;  slots (the other bases must have empty slot layouts) - &#039;
                 &#039;violations\n&#039;
                 &#039;  raise &quot;TypeError&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Customizing class creation\n&#039;
                 &#039;==========================\n&#039;
                 &#039;\n&#039;
                 &#039;Whenever a class inherits from another class, &#039;
                 &#039;*__init_subclass__* is\n&#039;
                 &#039;called on that class. This way, it is possible to write &#039;
                 &#039;classes which\n&#039;
                 &#039;change the behavior of subclasses. This is closely related &#039;
                 &#039;to class\n&#039;
                 &#039;decorators, but where class decorators only affect the &#039;
                 &#039;specific class\n&#039;
                 &#039;they’re applied to, &quot;__init_subclass__&quot; solely applies to &#039;
                 &#039;future\n&#039;
                 &#039;subclasses of the class defining the method.\n&#039;
                 &#039;\n&#039;
                 &#039;classmethod object.__init_subclass__(cls)\n&#039;
                 &#039;\n&#039;
                 &#039;   This method is called whenever the containing class is &#039;
                 &#039;subclassed.\n&#039;
                 &#039;   *cls* is then the new subclass. If defined as a normal &#039;
                 &#039;instance\n&#039;
                 &#039;   method, this method is implicitly converted to a class &#039;
                 &#039;method.\n&#039;
                 &#039;\n&#039;
                 &#039;   Keyword arguments which are given to a new class are &#039;
                 &#039;passed to the\n&#039;
                 &#039;   parent’s class &quot;__init_subclass__&quot;. For compatibility &#039;
                 &#039;with other\n&#039;
                 &#039;   classes using &quot;__init_subclass__&quot;, one should take out &#039;
                 &#039;the needed\n&#039;
                 &#039;   keyword arguments and pass the others over to the base &#039;
                 &#039;class, as\n&#039;
                 &#039;   in:\n&#039;
                 &#039;\n&#039;
                 &#039;      class Philosopher:\n&#039;
                 &#039;          def __init_subclass__(cls, default_name, &#039;
                 &#039;**kwargs):\n&#039;
                 &#039;              super().__init_subclass__(**kwargs)\n&#039;
                 &#039;              cls.default_name = default_name\n&#039;
                 &#039;\n&#039;
                 &#039;      class AustralianPhilosopher(Philosopher, &#039;
                 &#039;default_name=&quot;Bruce&quot;):\n&#039;
                 &#039;          pass\n&#039;
                 &#039;\n&#039;
                 &#039;   The default implementation &quot;object.__init_subclass__&quot; &#039;
                 &#039;does nothing,\n&#039;
                 &#039;   but raises an error if it is called with any arguments.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: The metaclass hint &quot;metaclass&quot; is consumed by the &#039;
                 &#039;rest of\n&#039;
                 &#039;     the type machinery, and is never passed to &#039;
                 &#039;&quot;__init_subclass__&quot;\n&#039;
                 &#039;     implementations. The actual metaclass (rather than the &#039;
                 &#039;explicit\n&#039;
                 &#039;     hint) can be accessed as &quot;type(cls)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 3.6.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Metaclasses\n&#039;
                 &#039;-----------\n&#039;
                 &#039;\n&#039;
                 &#039;By default, classes are constructed using &quot;type()&quot;. The &#039;
                 &#039;class body is\n&#039;
                 &#039;executed in a new namespace and the class name is bound &#039;
                 &#039;locally to the\n&#039;
                 &#039;result of &quot;type(name, bases, namespace)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;The class creation process can be customized by passing the\n&#039;
                 &#039;&quot;metaclass&quot; keyword argument in the class definition line, &#039;
                 &#039;or by\n&#039;
                 &#039;inheriting from an existing class that included such an &#039;
                 &#039;argument. In\n&#039;
                 &#039;the following example, both &quot;MyClass&quot; and &quot;MySubclass&quot; are &#039;
                 &#039;instances\n&#039;
                 &#039;of &quot;Meta&quot;:\n&#039;
                 &#039;\n&#039;
                 &#039;   class Meta(type):\n&#039;
                 &#039;       pass\n&#039;
                 &#039;\n&#039;
                 &#039;   class MyClass(metaclass=Meta):\n&#039;
                 &#039;       pass\n&#039;
                 &#039;\n&#039;
                 &#039;   class MySubclass(MyClass):\n&#039;
                 &#039;       pass\n&#039;
                 &#039;\n&#039;
                 &#039;Any other keyword arguments that are specified in the class &#039;
                 &#039;definition\n&#039;
                 &#039;are passed through to all metaclass operations described &#039;
                 &#039;below.\n&#039;
                 &#039;\n&#039;
                 &#039;When a class definition is executed, the following steps &#039;
                 &#039;occur:\n&#039;
                 &#039;\n&#039;
                 &#039;* the appropriate metaclass is determined\n&#039;
                 &#039;\n&#039;
                 &#039;* the class namespace is prepared\n&#039;
                 &#039;\n&#039;
                 &#039;* the class body is executed\n&#039;
                 &#039;\n&#039;
                 &#039;* the class object is created\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Determining the appropriate metaclass\n&#039;
                 &#039;-------------------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;The appropriate metaclass for a class definition is &#039;
                 &#039;determined as\n&#039;
                 &#039;follows:\n&#039;
                 &#039;\n&#039;
                 &#039;* if no bases and no explicit metaclass are given, then &#039;
                 &#039;&quot;type()&quot; is\n&#039;
                 &#039;  used\n&#039;
                 &#039;\n&#039;
                 &#039;* if an explicit metaclass is given and it is *not* an &#039;
                 &#039;instance of\n&#039;
                 &#039;  &quot;type()&quot;, then it is used directly as the metaclass\n&#039;
                 &#039;\n&#039;
                 &#039;* if an instance of &quot;type()&quot; is given as the explicit &#039;
                 &#039;metaclass, or\n&#039;
                 &#039;  bases are defined, then the most derived metaclass is &#039;
                 &#039;used\n&#039;
                 &#039;\n&#039;
                 &#039;The most derived metaclass is selected from the explicitly &#039;
                 &#039;specified\n&#039;
                 &#039;metaclass (if any) and the metaclasses (i.e. &quot;type(cls)&quot;) of &#039;
                 &#039;all\n&#039;
                 &#039;specified base classes. The most derived metaclass is one &#039;
                 &#039;which is a\n&#039;
                 &#039;subtype of *all* of these candidate metaclasses. If none of &#039;
                 &#039;the\n&#039;
                 &#039;candidate metaclasses meets that criterion, then the class &#039;
                 &#039;definition\n&#039;
                 &#039;will fail with &quot;TypeError&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Preparing the class namespace\n&#039;
                 &#039;-----------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;Once the appropriate metaclass has been identified, then the &#039;
                 &#039;class\n&#039;
                 &#039;namespace is prepared. If the metaclass has a &quot;__prepare__&quot; &#039;
                 &#039;attribute,\n&#039;
                 &#039;it is called as &quot;namespace = metaclass.__prepare__(name, &#039;
                 &#039;bases,\n&#039;
                 &#039;**kwds)&quot; (where the additional keyword arguments, if any, &#039;
                 &#039;come from\n&#039;
                 &#039;the class definition).\n&#039;
                 &#039;\n&#039;
                 &#039;If the metaclass has no &quot;__prepare__&quot; attribute, then the &#039;
                 &#039;class\n&#039;
                 &#039;namespace is initialised as an empty ordered mapping.\n&#039;
                 &#039;\n&#039;
                 &#039;See also:\n&#039;
                 &#039;\n&#039;
                 &#039;  **PEP 3115** - Metaclasses in Python 3000\n&#039;
                 &#039;     Introduced the &quot;__prepare__&quot; namespace hook\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Executing the class body\n&#039;
                 &#039;------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;The class body is executed (approximately) as &quot;exec(body, &#039;
                 &#039;globals(),\n&#039;
                 &#039;namespace)&quot;. The key difference from a normal call to &#039;
                 &#039;&quot;exec()&quot; is that\n&#039;
                 &#039;lexical scoping allows the class body (including any &#039;
                 &#039;methods) to\n&#039;
                 &#039;reference names from the current and outer scopes when the &#039;
                 &#039;class\n&#039;
                 &#039;definition occurs inside a function.\n&#039;
                 &#039;\n&#039;
                 &#039;However, even when the class definition occurs inside the &#039;
                 &#039;function,\n&#039;
                 &#039;methods defined inside the class still cannot see names &#039;
                 &#039;defined at the\n&#039;
                 &#039;class scope. Class variables must be accessed through the &#039;
                 &#039;first\n&#039;
                 &#039;parameter of instance or class methods, or through the &#039;
                 &#039;implicit\n&#039;
                 &#039;lexically scoped &quot;__class__&quot; reference described in the next &#039;
                 &#039;section.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Creating the class object\n&#039;
                 &#039;-------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;Once the class namespace has been populated by executing the &#039;
                 &#039;class\n&#039;
                 &#039;body, the class object is created by calling &#039;
                 &#039;&quot;metaclass(name, bases,\n&#039;
                 &#039;namespace, **kwds)&quot; (the additional keywords passed here are &#039;
                 &#039;the same\n&#039;
                 &#039;as those passed to &quot;__prepare__&quot;).\n&#039;
                 &#039;\n&#039;
                 &#039;This class object is the one that will be referenced by the &#039;
                 &#039;zero-\n&#039;
                 &#039;argument form of &quot;super()&quot;. &quot;__class__&quot; is an implicit &#039;
                 &#039;closure\n&#039;
                 &#039;reference created by the compiler if any methods in a class &#039;
                 &#039;body refer\n&#039;
                 &#039;to either &quot;__class__&quot; or &quot;super&quot;. This allows the zero &#039;
                 &#039;argument form\n&#039;
                 &#039;of &quot;super()&quot; to correctly identify the class being defined &#039;
                 &#039;based on\n&#039;
                 &#039;lexical scoping, while the class or instance that was used &#039;
                 &#039;to make the\n&#039;
                 &#039;current call is identified based on the first argument &#039;
                 &#039;passed to the\n&#039;
                 &#039;method.\n&#039;
                 &#039;\n&#039;
                 &#039;**CPython implementation detail:** In CPython 3.6 and later, &#039;
                 &#039;the\n&#039;
                 &#039;&quot;__class__&quot; cell is passed to the metaclass as a &#039;
                 &#039;&quot;__classcell__&quot; entry\n&#039;
                 &#039;in the class namespace. If present, this must be propagated &#039;
                 &#039;up to the\n&#039;
                 &#039;&quot;type.__new__&quot; call in order for the class to be &#039;
                 &#039;initialised\n&#039;
                 &#039;correctly. Failing to do so will result in a &#039;
                 &#039;&quot;DeprecationWarning&quot; in\n&#039;
                 &#039;Python 3.6, and a &quot;RuntimeError&quot; in Python 3.8.\n&#039;
                 &#039;\n&#039;
                 &#039;When using the default metaclass &quot;type&quot;, or any metaclass &#039;
                 &#039;that\n&#039;
                 &#039;ultimately calls &quot;type.__new__&quot;, the following additional\n&#039;
                 &#039;customisation steps are invoked after creating the class &#039;
                 &#039;object:\n&#039;
                 &#039;\n&#039;
                 &#039;* first, &quot;type.__new__&quot; collects all of the descriptors in &#039;
                 &#039;the class\n&#039;
                 &#039;  namespace that define a &quot;__set_name__()&quot; method;\n&#039;
                 &#039;\n&#039;
                 &#039;* second, all of these &quot;__set_name__&quot; methods are called &#039;
                 &#039;with the\n&#039;
                 &#039;  class being defined and the assigned name of that &#039;
                 &#039;particular\n&#039;
                 &#039;  descriptor; and\n&#039;
                 &#039;\n&#039;
                 &#039;* finally, the &quot;__init_subclass__()&quot; hook is called on the &#039;
                 &#039;immediate\n&#039;
                 &#039;  parent of the new class in its method resolution order.\n&#039;
                 &#039;\n&#039;
                 &#039;After the class object is created, it is passed to the &#039;
                 &#039;class\n&#039;
                 &#039;decorators included in the class definition (if any) and the &#039;
                 &#039;resulting\n&#039;
                 &#039;object is bound in the local namespace as the defined &#039;
                 &#039;class.\n&#039;
                 &#039;\n&#039;
                 &#039;When a new class is created by &quot;type.__new__&quot;, the object &#039;
                 &#039;provided as\n&#039;
                 &#039;the namespace parameter is copied to a new ordered mapping &#039;
                 &#039;and the\n&#039;
                 &#039;original object is discarded. The new copy is wrapped in a &#039;
                 &#039;read-only\n&#039;
                 &#039;proxy, which becomes the &quot;__dict__&quot; attribute of the class &#039;
                 &#039;object.\n&#039;
                 &#039;\n&#039;
                 &#039;See also:\n&#039;
                 &#039;\n&#039;
                 &#039;  **PEP 3135** - New super\n&#039;
                 &#039;     Describes the implicit &quot;__class__&quot; closure reference\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Uses for metaclasses\n&#039;
                 &#039;--------------------\n&#039;
                 &#039;\n&#039;
                 &#039;The potential uses for metaclasses are boundless. Some ideas &#039;
                 &#039;that have\n&#039;
                 &#039;been explored include enum, logging, interface checking, &#039;
                 &#039;automatic\n&#039;
                 &#039;delegation, automatic property creation, proxies, &#039;
                 &#039;frameworks, and\n&#039;
                 &#039;automatic resource locking/synchronization.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Customizing instance and subclass checks\n&#039;
                 &#039;========================================\n&#039;
                 &#039;\n&#039;
                 &#039;The following methods are used to override the default &#039;
                 &#039;behavior of the\n&#039;
                 &#039;&quot;isinstance()&quot; and &quot;issubclass()&quot; built-in functions.\n&#039;
                 &#039;\n&#039;
                 &#039;In particular, the metaclass &quot;abc.ABCMeta&quot; implements these &#039;
                 &#039;methods in\n&#039;
                 &#039;order to allow the addition of Abstract Base Classes (ABCs) &#039;
                 &#039;as\n&#039;
                 &#039;“virtual base classes” to any class or type (including &#039;
                 &#039;built-in\n&#039;
                 &#039;types), including other ABCs.\n&#039;
                 &#039;\n&#039;
                 &#039;class.__instancecheck__(self, instance)\n&#039;
                 &#039;\n&#039;
                 &#039;   Return true if *instance* should be considered a (direct &#039;
                 &#039;or\n&#039;
                 &#039;   indirect) instance of *class*. If defined, called to &#039;
                 &#039;implement\n&#039;
                 &#039;   &quot;isinstance(instance, class)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;class.__subclasscheck__(self, subclass)\n&#039;
                 &#039;\n&#039;
                 &#039;   Return true if *subclass* should be considered a (direct &#039;
                 &#039;or\n&#039;
                 &#039;   indirect) subclass of *class*.  If defined, called to &#039;
                 &#039;implement\n&#039;
                 &#039;   &quot;issubclass(subclass, class)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Note that these methods are looked up on the type &#039;
                 &#039;(metaclass) of a\n&#039;
                 &#039;class.  They cannot be defined as class methods in the &#039;
                 &#039;actual class.\n&#039;
                 &#039;This is consistent with the lookup of special methods that &#039;
                 &#039;are called\n&#039;
                 &#039;on instances, only in this case the instance is itself a &#039;
                 &#039;class.\n&#039;
                 &#039;\n&#039;
                 &#039;See also:\n&#039;
                 &#039;\n&#039;
                 &#039;  **PEP 3119** - Introducing Abstract Base Classes\n&#039;
                 &#039;     Includes the specification for customizing &#039;
                 &#039;&quot;isinstance()&quot; and\n&#039;
                 &#039;     &quot;issubclass()&quot; behavior through &quot;__instancecheck__()&quot; &#039;
                 &#039;and\n&#039;
                 &#039;     &quot;__subclasscheck__()&quot;, with motivation for this &#039;
                 &#039;functionality in\n&#039;
                 &#039;     the context of adding Abstract Base Classes (see the &#039;
                 &#039;&quot;abc&quot;\n&#039;
                 &#039;     module) to the language.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Emulating callable objects\n&#039;
                 &#039;==========================\n&#039;
                 &#039;\n&#039;
                 &#039;object.__call__(self[, args...])\n&#039;
                 &#039;\n&#039;
                 &#039;   Called when the instance is “called” as a function; if &#039;
                 &#039;this method\n&#039;
                 &#039;   is defined, &quot;x(arg1, arg2, ...)&quot; is a shorthand for\n&#039;
                 &#039;   &quot;x.__call__(arg1, arg2, ...)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Emulating container types\n&#039;
                 &#039;=========================\n&#039;
                 &#039;\n&#039;
                 &#039;The following methods can be defined to implement container &#039;
                 &#039;objects.\n&#039;
                 &#039;Containers usually are sequences (such as lists or tuples) &#039;
                 &#039;or mappings\n&#039;
                 &#039;(like dictionaries), but can represent other containers as &#039;
                 &#039;well.  The\n&#039;
                 &#039;first set of methods is used either to emulate a sequence or &#039;
                 &#039;to\n&#039;
                 &#039;emulate a mapping; the difference is that for a sequence, &#039;
                 &#039;the\n&#039;
                 &#039;allowable keys should be the integers *k* for which &quot;0 &lt;= k &#039;
                 &#039;&lt; N&quot; where\n&#039;
                 &#039;*N* is the length of the sequence, or slice objects, which &#039;
                 &#039;define a\n&#039;
                 &#039;range of items.  It is also recommended that mappings &#039;
                 &#039;provide the\n&#039;
                 &#039;methods &quot;keys()&quot;, &quot;values()&quot;, &quot;items()&quot;, &quot;get()&quot;, &#039;
                 &#039;&quot;clear()&quot;,\n&#039;
                 &#039;&quot;setdefault()&quot;, &quot;pop()&quot;, &quot;popitem()&quot;, &quot;copy()&quot;, and &#039;
                 &#039;&quot;update()&quot;\n&#039;
                 &#039;behaving similar to those for Python’s standard dictionary &#039;
                 &#039;objects.\n&#039;
                 &#039;The &quot;collections&quot; module provides a &quot;MutableMapping&quot; &#039;
                 &#039;abstract base\n&#039;
                 &#039;class to help create those methods from a base set of &#039;
                 &#039;&quot;__getitem__()&quot;,\n&#039;
                 &#039;&quot;__setitem__()&quot;, &quot;__delitem__()&quot;, and &quot;keys()&quot;. Mutable &#039;
                 &#039;sequences\n&#039;
                 &#039;should provide methods &quot;append()&quot;, &quot;count()&quot;, &quot;index()&quot;, &#039;
                 &#039;&quot;extend()&quot;,\n&#039;
                 &#039;&quot;insert()&quot;, &quot;pop()&quot;, &quot;remove()&quot;, &quot;reverse()&quot; and &quot;sort()&quot;, &#039;
                 &#039;like Python\n&#039;
                 &#039;standard list objects.  Finally, sequence types should &#039;
                 &#039;implement\n&#039;
                 &#039;addition (meaning concatenation) and multiplication &#039;
                 &#039;(meaning\n&#039;
                 &#039;repetition) by defining the methods &quot;__add__()&quot;, &#039;
                 &#039;&quot;__radd__()&quot;,\n&#039;
                 &#039;&quot;__iadd__()&quot;, &quot;__mul__()&quot;, &quot;__rmul__()&quot; and &quot;__imul__()&quot; &#039;
                 &#039;described\n&#039;
                 &#039;below; they should not define other numerical operators.  It &#039;
                 &#039;is\n&#039;
                 &#039;recommended that both mappings and sequences implement the\n&#039;
                 &#039;&quot;__contains__()&quot; method to allow efficient use of the &quot;in&quot; &#039;
                 &#039;operator;\n&#039;
                 &#039;for mappings, &quot;in&quot; should search the mapping’s keys; for &#039;
                 &#039;sequences, it\n&#039;
                 &#039;should search through the values.  It is further recommended &#039;
                 &#039;that both\n&#039;
                 &#039;mappings and sequences implement the &quot;__iter__()&quot; method to &#039;
                 &#039;allow\n&#039;
                 &#039;efficient iteration through the container; for mappings, &#039;
                 &#039;&quot;__iter__()&quot;\n&#039;
                 &#039;should be the same as &quot;keys()&quot;; for sequences, it should &#039;
                 &#039;iterate\n&#039;
                 &#039;through the values.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__len__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement the built-in function &quot;len()&quot;.  &#039;
                 &#039;Should return\n&#039;
                 &#039;   the length of the object, an integer &quot;&gt;=&quot; 0.  Also, an &#039;
                 &#039;object that\n&#039;
                 &#039;   doesn’t define a &quot;__bool__()&quot; method and whose &#039;
                 &#039;&quot;__len__()&quot; method\n&#039;
                 &#039;   returns zero is considered to be false in a Boolean &#039;
                 &#039;context.\n&#039;
                 &#039;\n&#039;
                 &#039;   **CPython implementation detail:** In CPython, the length &#039;
                 &#039;is\n&#039;
                 &#039;   required to be at most &quot;sys.maxsize&quot;. If the length is &#039;
                 &#039;larger than\n&#039;
                 &#039;   &quot;sys.maxsize&quot; some features (such as &quot;len()&quot;) may raise\n&#039;
                 &#039;   &quot;OverflowError&quot;.  To prevent raising &quot;OverflowError&quot; by &#039;
                 &#039;truth value\n&#039;
                 &#039;   testing, an object must define a &quot;__bool__()&quot; method.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__length_hint__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement &quot;operator.length_hint()&quot;. Should &#039;
                 &#039;return an\n&#039;
                 &#039;   estimated length for the object (which may be greater or &#039;
                 &#039;less than\n&#039;
                 &#039;   the actual length). The length must be an integer &quot;&gt;=&quot; 0. &#039;
                 &#039;This\n&#039;
                 &#039;   method is purely an optimization and is never required &#039;
                 &#039;for\n&#039;
                 &#039;   correctness.\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 3.4.\n&#039;
                 &#039;\n&#039;
                 &#039;Note: Slicing is done exclusively with the following three &#039;
                 &#039;methods.\n&#039;
                 &#039;  A call like\n&#039;
                 &#039;\n&#039;
                 &#039;     a[1:2] = b\n&#039;
                 &#039;\n&#039;
                 &#039;  is translated to\n&#039;
                 &#039;\n&#039;
                 &#039;     a[slice(1, 2, None)] = b\n&#039;
                 &#039;\n&#039;
                 &#039;  and so forth.  Missing slice items are always filled in &#039;
                 &#039;with &quot;None&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__getitem__(self, key)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement evaluation of &quot;self[key]&quot;. For &#039;
                 &#039;sequence types,\n&#039;
                 &#039;   the accepted keys should be integers and slice objects.  &#039;
                 &#039;Note that\n&#039;
                 &#039;   the special interpretation of negative indexes (if the &#039;
                 &#039;class wishes\n&#039;
                 &#039;   to emulate a sequence type) is up to the &quot;__getitem__()&quot; &#039;
                 &#039;method. If\n&#039;
                 &#039;   *key* is of an inappropriate type, &quot;TypeError&quot; may be &#039;
                 &#039;raised; if of\n&#039;
                 &#039;   a value outside the set of indexes for the sequence &#039;
                 &#039;(after any\n&#039;
                 &#039;   special interpretation of negative values), &quot;IndexError&quot; &#039;
                 &#039;should be\n&#039;
                 &#039;   raised. For mapping types, if *key* is missing (not in &#039;
                 &#039;the\n&#039;
                 &#039;   container), &quot;KeyError&quot; should be raised.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: &quot;for&quot; loops expect that an &quot;IndexError&quot; will be &#039;
                 &#039;raised for\n&#039;
                 &#039;     illegal indexes to allow proper detection of the end of &#039;
                 &#039;the\n&#039;
                 &#039;     sequence.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__setitem__(self, key, value)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement assignment to &quot;self[key]&quot;.  Same note &#039;
                 &#039;as for\n&#039;
                 &#039;   &quot;__getitem__()&quot;.  This should only be implemented for &#039;
                 &#039;mappings if\n&#039;
                 &#039;   the objects support changes to the values for keys, or if &#039;
                 &#039;new keys\n&#039;
                 &#039;   can be added, or for sequences if elements can be &#039;
                 &#039;replaced.  The\n&#039;
                 &#039;   same exceptions should be raised for improper *key* &#039;
                 &#039;values as for\n&#039;
                 &#039;   the &quot;__getitem__()&quot; method.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__delitem__(self, key)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement deletion of &quot;self[key]&quot;.  Same note &#039;
                 &#039;as for\n&#039;
                 &#039;   &quot;__getitem__()&quot;.  This should only be implemented for &#039;
                 &#039;mappings if\n&#039;
                 &#039;   the objects support removal of keys, or for sequences if &#039;
                 &#039;elements\n&#039;
                 &#039;   can be removed from the sequence.  The same exceptions &#039;
                 &#039;should be\n&#039;
                 &#039;   raised for improper *key* values as for the &#039;
                 &#039;&quot;__getitem__()&quot; method.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__missing__(self, key)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by &quot;dict&quot;.&quot;__getitem__()&quot; to implement &quot;self[key]&quot; &#039;
                 &#039;for dict\n&#039;
                 &#039;   subclasses when key is not in the dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__iter__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   This method is called when an iterator is required for a &#039;
                 &#039;container.\n&#039;
                 &#039;   This method should return a new iterator object that can &#039;
                 &#039;iterate\n&#039;
                 &#039;   over all the objects in the container.  For mappings, it &#039;
                 &#039;should\n&#039;
                 &#039;   iterate over the keys of the container.\n&#039;
                 &#039;\n&#039;
                 &#039;   Iterator objects also need to implement this method; they &#039;
                 &#039;are\n&#039;
                 &#039;   required to return themselves.  For more information on &#039;
                 &#039;iterator\n&#039;
                 &#039;   objects, see Iterator Types.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__reversed__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called (if present) by the &quot;reversed()&quot; built-in to &#039;
                 &#039;implement\n&#039;
                 &#039;   reverse iteration.  It should return a new iterator &#039;
                 &#039;object that\n&#039;
                 &#039;   iterates over all the objects in the container in reverse &#039;
                 &#039;order.\n&#039;
                 &#039;\n&#039;
                 &#039;   If the &quot;__reversed__()&quot; method is not provided, the &#039;
                 &#039;&quot;reversed()&quot;\n&#039;
                 &#039;   built-in will fall back to using the sequence protocol &#039;
                 &#039;(&quot;__len__()&quot;\n&#039;
                 &#039;   and &quot;__getitem__()&quot;).  Objects that support the sequence &#039;
                 &#039;protocol\n&#039;
                 &#039;   should only provide &quot;__reversed__()&quot; if they can provide &#039;
                 &#039;an\n&#039;
                 &#039;   implementation that is more efficient than the one &#039;
                 &#039;provided by\n&#039;
                 &#039;   &quot;reversed()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;The membership test operators (&quot;in&quot; and &quot;not in&quot;) are &#039;
                 &#039;normally\n&#039;
                 &#039;implemented as an iteration through a sequence.  However, &#039;
                 &#039;container\n&#039;
                 &#039;objects can supply the following special method with a more &#039;
                 &#039;efficient\n&#039;
                 &#039;implementation, which also does not require the object be a &#039;
                 &#039;sequence.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__contains__(self, item)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement membership test operators.  Should &#039;
                 &#039;return true\n&#039;
                 &#039;   if *item* is in *self*, false otherwise.  For mapping &#039;
                 &#039;objects, this\n&#039;
                 &#039;   should consider the keys of the mapping rather than the &#039;
                 &#039;values or\n&#039;
                 &#039;   the key-item pairs.\n&#039;
                 &#039;\n&#039;
                 &#039;   For objects that don’t define &quot;__contains__()&quot;, the &#039;
                 &#039;membership test\n&#039;
                 &#039;   first tries iteration via &quot;__iter__()&quot;, then the old &#039;
                 &#039;sequence\n&#039;
                 &#039;   iteration protocol via &quot;__getitem__()&quot;, see this section &#039;
                 &#039;in the\n&#039;
                 &#039;   language reference.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Emulating numeric types\n&#039;
                 &#039;=======================\n&#039;
                 &#039;\n&#039;
                 &#039;The following methods can be defined to emulate numeric &#039;
                 &#039;objects.\n&#039;
                 &#039;Methods corresponding to operations that are not supported &#039;
                 &#039;by the\n&#039;
                 &#039;particular kind of number implemented (e.g., bitwise &#039;
                 &#039;operations for\n&#039;
                 &#039;non-integral numbers) should be left undefined.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__add__(self, other)\n&#039;
                 &#039;object.__sub__(self, other)\n&#039;
                 &#039;object.__mul__(self, other)\n&#039;
                 &#039;object.__matmul__(self, other)\n&#039;
                 &#039;object.__truediv__(self, other)\n&#039;
                 &#039;object.__floordiv__(self, other)\n&#039;
                 &#039;object.__mod__(self, other)\n&#039;
                 &#039;object.__divmod__(self, other)\n&#039;
                 &#039;object.__pow__(self, other[, modulo])\n&#039;
                 &#039;object.__lshift__(self, other)\n&#039;
                 &#039;object.__rshift__(self, other)\n&#039;
                 &#039;object.__and__(self, other)\n&#039;
                 &#039;object.__xor__(self, other)\n&#039;
                 &#039;object.__or__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   These methods are called to implement the binary &#039;
                 &#039;arithmetic\n&#039;
                 &#039;   operations (&quot;+&quot;, &quot;-&quot;, &quot;*&quot;, &quot;@&quot;, &quot;/&quot;, &quot;//&quot;, &quot;%&quot;, &#039;
                 &#039;&quot;divmod()&quot;,\n&#039;
                 &#039;   &quot;pow()&quot;, &quot;**&quot;, &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;).  For instance, &#039;
                 &#039;to\n&#039;
                 &#039;   evaluate the expression &quot;x + y&quot;, where *x* is an instance &#039;
                 &#039;of a\n&#039;
                 &#039;   class that has an &quot;__add__()&quot; method, &quot;x.__add__(y)&quot; is &#039;
                 &#039;called.\n&#039;
                 &#039;   The &quot;__divmod__()&quot; method should be the equivalent to &#039;
                 &#039;using\n&#039;
                 &#039;   &quot;__floordiv__()&quot; and &quot;__mod__()&quot;; it should not be &#039;
                 &#039;related to\n&#039;
                 &#039;   &quot;__truediv__()&quot;.  Note that &quot;__pow__()&quot; should be defined &#039;
                 &#039;to accept\n&#039;
                 &#039;   an optional third argument if the ternary version of the &#039;
                 &#039;built-in\n&#039;
                 &#039;   &quot;pow()&quot; function is to be supported.\n&#039;
                 &#039;\n&#039;
                 &#039;   If one of those methods does not support the operation &#039;
                 &#039;with the\n&#039;
                 &#039;   supplied arguments, it should return &quot;NotImplemented&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__radd__(self, other)\n&#039;
                 &#039;object.__rsub__(self, other)\n&#039;
                 &#039;object.__rmul__(self, other)\n&#039;
                 &#039;object.__rmatmul__(self, other)\n&#039;
                 &#039;object.__rtruediv__(self, other)\n&#039;
                 &#039;object.__rfloordiv__(self, other)\n&#039;
                 &#039;object.__rmod__(self, other)\n&#039;
                 &#039;object.__rdivmod__(self, other)\n&#039;
                 &#039;object.__rpow__(self, other)\n&#039;
                 &#039;object.__rlshift__(self, other)\n&#039;
                 &#039;object.__rrshift__(self, other)\n&#039;
                 &#039;object.__rand__(self, other)\n&#039;
                 &#039;object.__rxor__(self, other)\n&#039;
                 &#039;object.__ror__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   These methods are called to implement the binary &#039;
                 &#039;arithmetic\n&#039;
                 &#039;   operations (&quot;+&quot;, &quot;-&quot;, &quot;*&quot;, &quot;@&quot;, &quot;/&quot;, &quot;//&quot;, &quot;%&quot;, &#039;
                 &#039;&quot;divmod()&quot;,\n&#039;
                 &#039;   &quot;pow()&quot;, &quot;**&quot;, &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;) with reflected &#039;
                 &#039;(swapped)\n&#039;
                 &#039;   operands.  These functions are only called if the left &#039;
                 &#039;operand does\n&#039;
                 &#039;   not support the corresponding operation [3] and the &#039;
                 &#039;operands are of\n&#039;
                 &#039;   different types. [4] For instance, to evaluate the &#039;
                 &#039;expression &quot;x -\n&#039;
                 &#039;   y&quot;, where *y* is an instance of a class that has an &#039;
                 &#039;&quot;__rsub__()&quot;\n&#039;
                 &#039;   method, &quot;y.__rsub__(x)&quot; is called if &quot;x.__sub__(y)&quot; &#039;
                 &#039;returns\n&#039;
                 &#039;   *NotImplemented*.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note that ternary &quot;pow()&quot; will not try calling &#039;
                 &#039;&quot;__rpow__()&quot; (the\n&#039;
                 &#039;   coercion rules would become too complicated).\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: If the right operand’s type is a subclass of the &#039;
                 &#039;left\n&#039;
                 &#039;     operand’s type and that subclass provides the reflected &#039;
                 &#039;method\n&#039;
                 &#039;     for the operation, this method will be called before &#039;
                 &#039;the left\n&#039;
                 &#039;     operand’s non-reflected method.  This behavior allows &#039;
                 &#039;subclasses\n&#039;
                 &#039;     to override their ancestors’ operations.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__iadd__(self, other)\n&#039;
                 &#039;object.__isub__(self, other)\n&#039;
                 &#039;object.__imul__(self, other)\n&#039;
                 &#039;object.__imatmul__(self, other)\n&#039;
                 &#039;object.__itruediv__(self, other)\n&#039;
                 &#039;object.__ifloordiv__(self, other)\n&#039;
                 &#039;object.__imod__(self, other)\n&#039;
                 &#039;object.__ipow__(self, other[, modulo])\n&#039;
                 &#039;object.__ilshift__(self, other)\n&#039;
                 &#039;object.__irshift__(self, other)\n&#039;
                 &#039;object.__iand__(self, other)\n&#039;
                 &#039;object.__ixor__(self, other)\n&#039;
                 &#039;object.__ior__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   These methods are called to implement the augmented &#039;
                 &#039;arithmetic\n&#039;
                 &#039;   assignments (&quot;+=&quot;, &quot;-=&quot;, &quot;*=&quot;, &quot;@=&quot;, &quot;/=&quot;, &quot;//=&quot;, &quot;%=&quot;, &#039;
                 &#039;&quot;**=&quot;,\n&#039;
                 &#039;   &quot;&lt;&lt;=&quot;, &quot;&gt;&gt;=&quot;, &quot;&amp;=&quot;, &quot;^=&quot;, &quot;|=&quot;).  These methods should &#039;
                 &#039;attempt to\n&#039;
                 &#039;   do the operation in-place (modifying *self*) and return &#039;
                 &#039;the result\n&#039;
                 &#039;   (which could be, but does not have to be, *self*).  If a &#039;
                 &#039;specific\n&#039;
                 &#039;   method is not defined, the augmented assignment falls &#039;
                 &#039;back to the\n&#039;
                 &#039;   normal methods.  For instance, if *x* is an instance of a &#039;
                 &#039;class\n&#039;
                 &#039;   with an &quot;__iadd__()&quot; method, &quot;x += y&quot; is equivalent to &quot;x &#039;
                 &#039;=\n&#039;
                 &#039;   x.__iadd__(y)&quot; . Otherwise, &quot;x.__add__(y)&quot; and &#039;
                 &#039;&quot;y.__radd__(x)&quot; are\n&#039;
                 &#039;   considered, as with the evaluation of &quot;x + y&quot;. In &#039;
                 &#039;certain\n&#039;
                 &#039;   situations, augmented assignment can result in unexpected &#039;
                 &#039;errors\n&#039;
                 &#039;   (see Why does a_tuple[i] += [‘item’] raise an exception &#039;
                 &#039;when the\n&#039;
                 &#039;   addition works?), but this behavior is in fact part of &#039;
                 &#039;the data\n&#039;
                 &#039;   model.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__neg__(self)\n&#039;
                 &#039;object.__pos__(self)\n&#039;
                 &#039;object.__abs__(self)\n&#039;
                 &#039;object.__invert__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement the unary arithmetic operations (&quot;-&quot;, &#039;
                 &#039;&quot;+&quot;,\n&#039;
                 &#039;   &quot;abs()&quot; and &quot;~&quot;).\n&#039;
                 &#039;\n&#039;
                 &#039;object.__complex__(self)\n&#039;
                 &#039;object.__int__(self)\n&#039;
                 &#039;object.__float__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement the built-in functions &quot;complex()&quot;, &#039;
                 &#039;&quot;int()&quot; and\n&#039;
                 &#039;   &quot;float()&quot;.  Should return a value of the appropriate &#039;
                 &#039;type.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__index__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement &quot;operator.index()&quot;, and whenever &#039;
                 &#039;Python needs\n&#039;
                 &#039;   to losslessly convert the numeric object to an integer &#039;
                 &#039;object (such\n&#039;
                 &#039;   as in slicing, or in the built-in &quot;bin()&quot;, &quot;hex()&quot; and &#039;
                 &#039;&quot;oct()&quot;\n&#039;
                 &#039;   functions). Presence of this method indicates that the &#039;
                 &#039;numeric\n&#039;
                 &#039;   object is an integer type.  Must return an integer.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: In order to have a coherent integer type class, &#039;
                 &#039;when\n&#039;
                 &#039;     &quot;__index__()&quot; is defined &quot;__int__()&quot; should also be &#039;
                 &#039;defined, and\n&#039;
                 &#039;     both should return the same value.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__round__(self[, ndigits])\n&#039;
                 &#039;object.__trunc__(self)\n&#039;
                 &#039;object.__floor__(self)\n&#039;
                 &#039;object.__ceil__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement the built-in function &quot;round()&quot; and &#039;
                 &#039;&quot;math&quot;\n&#039;
                 &#039;   functions &quot;trunc()&quot;, &quot;floor()&quot; and &quot;ceil()&quot;. Unless &#039;
                 &#039;*ndigits* is\n&#039;
                 &#039;   passed to &quot;__round__()&quot; all these methods should return &#039;
                 &#039;the value\n&#039;
                 &#039;   of the object truncated to an &quot;Integral&quot; (typically an &#039;
                 &#039;&quot;int&quot;).\n&#039;
                 &#039;\n&#039;
                 &#039;   If &quot;__int__()&quot; is not defined then the built-in function &#039;
                 &#039;&quot;int()&quot;\n&#039;
                 &#039;   falls back to &quot;__trunc__()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;With Statement Context Managers\n&#039;
                 &#039;===============================\n&#039;
                 &#039;\n&#039;
                 &#039;A *context manager* is an object that defines the runtime &#039;
                 &#039;context to\n&#039;
                 &#039;be established when executing a &quot;with&quot; statement. The &#039;
                 &#039;context manager\n&#039;
                 &#039;handles the entry into, and the exit from, the desired &#039;
                 &#039;runtime context\n&#039;
                 &#039;for the execution of the block of code.  Context managers &#039;
                 &#039;are normally\n&#039;
                 &#039;invoked using the &quot;with&quot; statement (described in section The &#039;
                 &#039;with\n&#039;
                 &#039;statement), but can also be used by directly invoking their &#039;
                 &#039;methods.\n&#039;
                 &#039;\n&#039;
                 &#039;Typical uses of context managers include saving and &#039;
                 &#039;restoring various\n&#039;
                 &#039;kinds of global state, locking and unlocking resources, &#039;
                 &#039;closing opened\n&#039;
                 &#039;files, etc.\n&#039;
                 &#039;\n&#039;
                 &#039;For more information on context managers, see Context &#039;
                 &#039;Manager Types.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__enter__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Enter the runtime context related to this object. The &#039;
                 &#039;&quot;with&quot;\n&#039;
                 &#039;   statement will bind this method’s return value to the &#039;
                 &#039;target(s)\n&#039;
                 &#039;   specified in the &quot;as&quot; clause of the statement, if any.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__exit__(self, exc_type, exc_value, traceback)\n&#039;
                 &#039;\n&#039;
                 &#039;   Exit the runtime context related to this object. The &#039;
                 &#039;parameters\n&#039;
                 &#039;   describe the exception that caused the context to be &#039;
                 &#039;exited. If the\n&#039;
                 &#039;   context was exited without an exception, all three &#039;
                 &#039;arguments will\n&#039;
                 &#039;   be &quot;None&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   If an exception is supplied, and the method wishes to &#039;
                 &#039;suppress the\n&#039;
                 &#039;   exception (i.e., prevent it from being propagated), it &#039;
                 &#039;should\n&#039;
                 &#039;   return a true value. Otherwise, the exception will be &#039;
                 &#039;processed\n&#039;
                 &#039;   normally upon exit from this method.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note that &quot;__exit__()&quot; methods should not reraise the &#039;
                 &#039;passed-in\n&#039;
                 &#039;   exception; this is the caller’s responsibility.\n&#039;
                 &#039;\n&#039;
                 &#039;See also:\n&#039;
                 &#039;\n&#039;
                 &#039;  **PEP 343** - The “with” statement\n&#039;
                 &#039;     The specification, background, and examples for the &#039;
                 &#039;Python &quot;with&quot;\n&#039;
                 &#039;     statement.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Special method lookup\n&#039;
                 &#039;=====================\n&#039;
                 &#039;\n&#039;
                 &#039;For custom classes, implicit invocations of special methods &#039;
                 &#039;are only\n&#039;
                 &#039;guaranteed to work correctly if defined on an object’s type, &#039;
                 &#039;not in\n&#039;
                 &#039;the object’s instance dictionary.  That behaviour is the &#039;
                 &#039;reason why\n&#039;
                 &#039;the following code raises an exception:\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; class C:\n&#039;
                 &#039;   ...     pass\n&#039;
                 &#039;   ...\n&#039;
                 &#039;   &gt;&gt;&gt; c = C()\n&#039;
                 &#039;   &gt;&gt;&gt; c.__len__ = lambda: 5\n&#039;
                 &#039;   &gt;&gt;&gt; len(c)\n&#039;
                 &#039;   Traceback (most recent call last):\n&#039;
                 &#039;     File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;\n&#039;
                 &quot;   TypeError: object of type &#039;C&#039; has no len()\n&quot;
                 &#039;\n&#039;
                 &#039;The rationale behind this behaviour lies with a number of &#039;
                 &#039;special\n&#039;
                 &#039;methods such as &quot;__hash__()&quot; and &quot;__repr__()&quot; that are &#039;
                 &#039;implemented by\n&#039;
                 &#039;all objects, including type objects. If the implicit lookup &#039;
                 &#039;of these\n&#039;
                 &#039;methods used the conventional lookup process, they would &#039;
                 &#039;fail when\n&#039;
                 &#039;invoked on the type object itself:\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; 1 .__hash__() == hash(1)\n&#039;
                 &#039;   True\n&#039;
                 &#039;   &gt;&gt;&gt; int.__hash__() == hash(int)\n&#039;
                 &#039;   Traceback (most recent call last):\n&#039;
                 &#039;     File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;\n&#039;
                 &quot;   TypeError: descriptor &#039;__hash__&#039; of &#039;int&#039; object needs an &quot;
                 &#039;argument\n&#039;
                 &#039;\n&#039;
                 &#039;Incorrectly attempting to invoke an unbound method of a &#039;
                 &#039;class in this\n&#039;
                 &#039;way is sometimes referred to as ‘metaclass confusion’, and &#039;
                 &#039;is avoided\n&#039;
                 &#039;by bypassing the instance when looking up special methods:\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; type(1).__hash__(1) == hash(1)\n&#039;
                 &#039;   True\n&#039;
                 &#039;   &gt;&gt;&gt; type(int).__hash__(int) == hash(int)\n&#039;
                 &#039;   True\n&#039;
                 &#039;\n&#039;
                 &#039;In addition to bypassing any instance attributes in the &#039;
                 &#039;interest of\n&#039;
                 &#039;correctness, implicit special method lookup generally also &#039;
                 &#039;bypasses\n&#039;
                 &#039;the &quot;__getattribute__()&quot; method even of the object’s &#039;
                 &#039;metaclass:\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; class Meta(type):\n&#039;
                 &#039;   ...     def __getattribute__(*args):\n&#039;
                 &#039;   ...         print(&quot;Metaclass getattribute invoked&quot;)\n&#039;
                 &#039;   ...         return type.__getattribute__(*args)\n&#039;
                 &#039;   ...\n&#039;
                 &#039;   &gt;&gt;&gt; class C(object, metaclass=Meta):\n&#039;
                 &#039;   ...     def __len__(self):\n&#039;
                 &#039;   ...         return 10\n&#039;
                 &#039;   ...     def __getattribute__(*args):\n&#039;
                 &#039;   ...         print(&quot;Class getattribute invoked&quot;)\n&#039;
                 &#039;   ...         return object.__getattribute__(*args)\n&#039;
                 &#039;   ...\n&#039;
                 &#039;   &gt;&gt;&gt; c = C()\n&#039;
                 &#039;   &gt;&gt;&gt; c.__len__()                 # Explicit lookup via &#039;
                 &#039;instance\n&#039;
                 &#039;   Class getattribute invoked\n&#039;
                 &#039;   10\n&#039;
                 &#039;   &gt;&gt;&gt; type(c).__len__(c)          # Explicit lookup via &#039;
                 &#039;type\n&#039;
                 &#039;   Metaclass getattribute invoked\n&#039;
                 &#039;   10\n&#039;
                 &#039;   &gt;&gt;&gt; len(c)                      # Implicit lookup\n&#039;
                 &#039;   10\n&#039;
                 &#039;\n&#039;
                 &#039;Bypassing the &quot;__getattribute__()&quot; machinery in this fashion &#039;
                 &#039;provides\n&#039;
                 &#039;significant scope for speed optimisations within the &#039;
                 &#039;interpreter, at\n&#039;
                 &#039;the cost of some flexibility in the handling of special &#039;
                 &#039;methods (the\n&#039;
                 &#039;special method *must* be set on the class object itself in &#039;
                 &#039;order to be\n&#039;
                 &#039;consistently invoked by the interpreter).\n&#039;,
 &#039;string-methods&#039;: &#039;String Methods\n&#039;
                   &#039;**************\n&#039;
                   &#039;\n&#039;
                   &#039;Strings implement all of the common sequence operations, &#039;
                   &#039;along with\n&#039;
                   &#039;the additional methods described below.\n&#039;
                   &#039;\n&#039;
                   &#039;Strings also support two styles of string formatting, one &#039;
                   &#039;providing a\n&#039;
                   &#039;large degree of flexibility and customization (see &#039;
                   &#039;&quot;str.format()&quot;,\n&#039;
                   &#039;Format String Syntax and Custom String Formatting) and the &#039;
                   &#039;other based\n&#039;
                   &#039;on C &quot;printf&quot; style formatting that handles a narrower &#039;
                   &#039;range of types\n&#039;
                   &#039;and is slightly harder to use correctly, but is often &#039;
                   &#039;faster for the\n&#039;
                   &#039;cases it can handle (printf-style String Formatting).\n&#039;
                   &#039;\n&#039;
                   &#039;The Text Processing Services section of the standard &#039;
                   &#039;library covers a\n&#039;
                   &#039;number of other modules that provide various text related &#039;
                   &#039;utilities\n&#039;
                   &#039;(including regular expression support in the &quot;re&quot; &#039;
                   &#039;module).\n&#039;
                   &#039;\n&#039;
                   &#039;str.capitalize()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with its first character &#039;
                   &#039;capitalized\n&#039;
                   &#039;   and the rest lowercased.\n&#039;
                   &#039;\n&#039;
                   &#039;str.casefold()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a casefolded copy of the string. Casefolded &#039;
                   &#039;strings may be\n&#039;
                   &#039;   used for caseless matching.\n&#039;
                   &#039;\n&#039;
                   &#039;   Casefolding is similar to lowercasing but more &#039;
                   &#039;aggressive because\n&#039;
                   &#039;   it is intended to remove all case distinctions in a &#039;
                   &#039;string. For\n&#039;
                   &#039;   example, the German lowercase letter &quot;\&#039;ß\&#039;&quot; is &#039;
                   &#039;equivalent to &quot;&quot;ss&quot;&quot;.\n&#039;
                   &#039;   Since it is already lowercase, &quot;lower()&quot; would do &#039;
                   &#039;nothing to &quot;\&#039;ß\&#039;&quot;;\n&#039;
                   &#039;   &quot;casefold()&quot; converts it to &quot;&quot;ss&quot;&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;   The casefolding algorithm is described in section 3.13 &#039;
                   &#039;of the\n&#039;
                   &#039;   Unicode Standard.\n&#039;
                   &#039;\n&#039;
                   &#039;   New in version 3.3.\n&#039;
                   &#039;\n&#039;
                   &#039;str.center(width[, fillchar])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return centered in a string of length *width*. Padding &#039;
                   &#039;is done\n&#039;
                   &#039;   using the specified *fillchar* (default is an ASCII &#039;
                   &#039;space). The\n&#039;
                   &#039;   original string is returned if *width* is less than or &#039;
                   &#039;equal to\n&#039;
                   &#039;   &quot;len(s)&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;str.count(sub[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return the number of non-overlapping occurrences of &#039;
                   &#039;substring *sub*\n&#039;
                   &#039;   in the range [*start*, *end*].  Optional arguments &#039;
                   &#039;*start* and\n&#039;
                   &#039;   *end* are interpreted as in slice notation.\n&#039;
                   &#039;\n&#039;
                   &#039;str.encode(encoding=&quot;utf-8&quot;, errors=&quot;strict&quot;)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return an encoded version of the string as a bytes &#039;
                   &#039;object. Default\n&#039;
                   &#039;   encoding is &quot;\&#039;utf-8\&#039;&quot;. *errors* may be given to set a &#039;
                   &#039;different\n&#039;
                   &#039;   error handling scheme. The default for *errors* is &#039;
                   &#039;&quot;\&#039;strict\&#039;&quot;,\n&#039;
                   &#039;   meaning that encoding errors raise a &quot;UnicodeError&quot;. &#039;
                   &#039;Other possible\n&#039;
                   &#039;   values are &quot;\&#039;ignore\&#039;&quot;, &quot;\&#039;replace\&#039;&quot;, &#039;
                   &#039;&quot;\&#039;xmlcharrefreplace\&#039;&quot;,\n&#039;
                   &#039;   &quot;\&#039;backslashreplace\&#039;&quot; and any other name registered &#039;
                   &#039;via\n&#039;
                   &#039;   &quot;codecs.register_error()&quot;, see section Error Handlers. &#039;
                   &#039;For a list\n&#039;
                   &#039;   of possible encodings, see section Standard Encodings.\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 3.1: Support for keyword arguments &#039;
                   &#039;added.\n&#039;
                   &#039;\n&#039;
                   &#039;str.endswith(suffix[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return &quot;True&quot; if the string ends with the specified &#039;
                   &#039;*suffix*,\n&#039;
                   &#039;   otherwise return &quot;False&quot;.  *suffix* can also be a tuple &#039;
                   &#039;of suffixes\n&#039;
                   &#039;   to look for.  With optional *start*, test beginning at &#039;
                   &#039;that\n&#039;
                   &#039;   position.  With optional *end*, stop comparing at that &#039;
                   &#039;position.\n&#039;
                   &#039;\n&#039;
                   &#039;str.expandtabs(tabsize=8)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string where all tab characters &#039;
                   &#039;are replaced\n&#039;
                   &#039;   by one or more spaces, depending on the current column &#039;
                   &#039;and the\n&#039;
                   &#039;   given tab size.  Tab positions occur every *tabsize* &#039;
                   &#039;characters\n&#039;
                   &#039;   (default is 8, giving tab positions at columns 0, 8, 16 &#039;
                   &#039;and so on).\n&#039;
                   &#039;   To expand the string, the current column is set to zero &#039;
                   &#039;and the\n&#039;
                   &#039;   string is examined character by character.  If the &#039;
                   &#039;character is a\n&#039;
                   &#039;   tab (&quot;\\t&quot;), one or more space characters are inserted &#039;
                   &#039;in the result\n&#039;
                   &#039;   until the current column is equal to the next tab &#039;
                   &#039;position. (The\n&#039;
                   &#039;   tab character itself is not copied.)  If the character &#039;
                   &#039;is a newline\n&#039;
                   &#039;   (&quot;\\n&quot;) or return (&quot;\\r&quot;), it is copied and the current &#039;
                   &#039;column is\n&#039;
                   &#039;   reset to zero.  Any other character is copied unchanged &#039;
                   &#039;and the\n&#039;
                   &#039;   current column is incremented by one regardless of how &#039;
                   &#039;the\n&#039;
                   &#039;   character is represented when printed.\n&#039;
                   &#039;\n&#039;
                   &quot;   &gt;&gt;&gt; &#039;01\\t012\\t0123\\t01234&#039;.expandtabs()\n&quot;
                   &quot;   &#039;01      012     0123    01234&#039;\n&quot;
                   &quot;   &gt;&gt;&gt; &#039;01\\t012\\t0123\\t01234&#039;.expandtabs(4)\n&quot;
                   &quot;   &#039;01  012 0123    01234&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;str.find(sub[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return the lowest index in the string where substring &#039;
                   &#039;*sub* is\n&#039;
                   &#039;   found within the slice &quot;s[start:end]&quot;.  Optional &#039;
                   &#039;arguments *start*\n&#039;
                   &#039;   and *end* are interpreted as in slice notation.  Return &#039;
                   &#039;&quot;-1&quot; if\n&#039;
                   &#039;   *sub* is not found.\n&#039;
                   &#039;\n&#039;
                   &#039;   Note: The &quot;find()&quot; method should be used only if you &#039;
                   &#039;need to know\n&#039;
                   &#039;     the position of *sub*.  To check if *sub* is a &#039;
                   &#039;substring or not,\n&#039;
                   &#039;     use the &quot;in&quot; operator:\n&#039;
                   &#039;\n&#039;
                   &quot;        &gt;&gt;&gt; &#039;Py&#039; in &#039;Python&#039;\n&quot;
                   &#039;        True\n&#039;
                   &#039;\n&#039;
                   &#039;str.format(*args, **kwargs)\n&#039;
                   &#039;\n&#039;
                   &#039;   Perform a string formatting operation.  The string on &#039;
                   &#039;which this\n&#039;
                   &#039;   method is called can contain literal text or &#039;
                   &#039;replacement fields\n&#039;
                   &#039;   delimited by braces &quot;{}&quot;.  Each replacement field &#039;
                   &#039;contains either\n&#039;
                   &#039;   the numeric index of a positional argument, or the name &#039;
                   &#039;of a\n&#039;
                   &#039;   keyword argument.  Returns a copy of the string where &#039;
                   &#039;each\n&#039;
                   &#039;   replacement field is replaced with the string value of &#039;
                   &#039;the\n&#039;
                   &#039;   corresponding argument.\n&#039;
                   &#039;\n&#039;
                   &#039;   &gt;&gt;&gt; &quot;The sum of 1 + 2 is {0}&quot;.format(1+2)\n&#039;
                   &quot;   &#039;The sum of 1 + 2 is 3&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;   See Format String Syntax for a description of the &#039;
                   &#039;various\n&#039;
                   &#039;   formatting options that can be specified in format &#039;
                   &#039;strings.\n&#039;
                   &#039;\n&#039;
                   &#039;   Note: When formatting a number (&quot;int&quot;, &quot;float&quot;, &#039;
                   &#039;&quot;complex&quot;,\n&#039;
                   &#039;     &quot;decimal.Decimal&quot; and subclasses) with the &quot;n&quot; type &#039;
                   &#039;(ex:\n&#039;
                   &#039;     &quot;\&#039;{:n}\&#039;.format(1234)&quot;), the function temporarily &#039;
                   &#039;sets the\n&#039;
                   &#039;     &quot;LC_CTYPE&quot; locale to the &quot;LC_NUMERIC&quot; locale to &#039;
                   &#039;decode\n&#039;
                   &#039;     &quot;decimal_point&quot; and &quot;thousands_sep&quot; fields of &#039;
                   &#039;&quot;localeconv()&quot; if\n&#039;
                   &#039;     they are non-ASCII or longer than 1 byte, and the &#039;
                   &#039;&quot;LC_NUMERIC&quot;\n&#039;
                   &#039;     locale is different than the &quot;LC_CTYPE&quot; locale.  This &#039;
                   &#039;temporary\n&#039;
                   &#039;     change affects other threads.\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 3.6.5: When formatting a number with &#039;
                   &#039;the &quot;n&quot;\n&#039;
                   &#039;   type, the function sets temporarily the &quot;LC_CTYPE&quot; &#039;
                   &#039;locale to the\n&#039;
                   &#039;   &quot;LC_NUMERIC&quot; locale in some cases.\n&#039;
                   &#039;\n&#039;
                   &#039;str.format_map(mapping)\n&#039;
                   &#039;\n&#039;
                   &#039;   Similar to &quot;str.format(**mapping)&quot;, except that &#039;
                   &#039;&quot;mapping&quot; is used\n&#039;
                   &#039;   directly and not copied to a &quot;dict&quot;.  This is useful if &#039;
                   &#039;for example\n&#039;
                   &#039;   &quot;mapping&quot; is a dict subclass:\n&#039;
                   &#039;\n&#039;
                   &#039;   &gt;&gt;&gt; class Default(dict):\n&#039;
                   &#039;   ...     def __missing__(self, key):\n&#039;
                   &#039;   ...         return key\n&#039;
                   &#039;   ...\n&#039;
                   &quot;   &gt;&gt;&gt; &#039;{name} was born in &quot;
                   &quot;{country}&#039;.format_map(Default(name=&#039;Guido&#039;))\n&quot;
                   &quot;   &#039;Guido was born in country&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;   New in version 3.2.\n&#039;
                   &#039;\n&#039;
                   &#039;str.index(sub[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Like &quot;find()&quot;, but raise &quot;ValueError&quot; when the &#039;
                   &#039;substring is not\n&#039;
                   &#039;   found.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isalnum()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all characters in the string are &#039;
                   &#039;alphanumeric and\n&#039;
                   &#039;   there is at least one character, false otherwise.  A &#039;
                   &#039;character &quot;c&quot;\n&#039;
                   &#039;   is alphanumeric if one of the following returns &#039;
                   &#039;&quot;True&quot;:\n&#039;
                   &#039;   &quot;c.isalpha()&quot;, &quot;c.isdecimal()&quot;, &quot;c.isdigit()&quot;, or &#039;
                   &#039;&quot;c.isnumeric()&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isalpha()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all characters in the string are &#039;
                   &#039;alphabetic and\n&#039;
                   &#039;   there is at least one character, false otherwise.  &#039;
                   &#039;Alphabetic\n&#039;
                   &#039;   characters are those characters defined in the Unicode &#039;
                   &#039;character\n&#039;
                   &#039;   database as “Letter”, i.e., those with general category &#039;
                   &#039;property\n&#039;
                   &#039;   being one of “Lm”, “Lt”, “Lu”, “Ll”, or “Lo”.  Note &#039;
                   &#039;that this is\n&#039;
                   &#039;   different from the “Alphabetic” property defined in the &#039;
                   &#039;Unicode\n&#039;
                   &#039;   Standard.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isdecimal()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all characters in the string are decimal &#039;
                   &#039;characters\n&#039;
                   &#039;   and there is at least one character, false otherwise. &#039;
                   &#039;Decimal\n&#039;
                   &#039;   characters are those that can be used to form numbers &#039;
                   &#039;in base 10,\n&#039;
                   &#039;   e.g. U+0660, ARABIC-INDIC DIGIT ZERO.  Formally a &#039;
                   &#039;decimal character\n&#039;
                   &#039;   is a character in the Unicode General Category “Nd”.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isdigit()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all characters in the string are digits &#039;
                   &#039;and there is\n&#039;
                   &#039;   at least one character, false otherwise.  Digits &#039;
                   &#039;include decimal\n&#039;
                   &#039;   characters and digits that need special handling, such &#039;
                   &#039;as the\n&#039;
                   &#039;   compatibility superscript digits. This covers digits &#039;
                   &#039;which cannot\n&#039;
                   &#039;   be used to form numbers in base 10, like the Kharosthi &#039;
                   &#039;numbers.\n&#039;
                   &#039;   Formally, a digit is a character that has the property &#039;
                   &#039;value\n&#039;
                   &#039;   Numeric_Type=Digit or Numeric_Type=Decimal.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isidentifier()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if the string is a valid identifier &#039;
                   &#039;according to the\n&#039;
                   &#039;   language definition, section Identifiers and keywords.\n&#039;
                   &#039;\n&#039;
                   &#039;   Use &quot;keyword.iskeyword()&quot; to test for reserved &#039;
                   &#039;identifiers such as\n&#039;
                   &#039;   &quot;def&quot; and &quot;class&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;str.islower()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all cased characters [4] in the string &#039;
                   &#039;are lowercase\n&#039;
                   &#039;   and there is at least one cased character, false &#039;
                   &#039;otherwise.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isnumeric()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all characters in the string are numeric &#039;
                   &#039;characters,\n&#039;
                   &#039;   and there is at least one character, false otherwise. &#039;
                   &#039;Numeric\n&#039;
                   &#039;   characters include digit characters, and all characters &#039;
                   &#039;that have\n&#039;
                   &#039;   the Unicode numeric value property, e.g. U+2155, VULGAR &#039;
                   &#039;FRACTION\n&#039;
                   &#039;   ONE FIFTH.  Formally, numeric characters are those with &#039;
                   &#039;the\n&#039;
                   &#039;   property value Numeric_Type=Digit, Numeric_Type=Decimal &#039;
                   &#039;or\n&#039;
                   &#039;   Numeric_Type=Numeric.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isprintable()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all characters in the string are &#039;
                   &#039;printable or the\n&#039;
                   &#039;   string is empty, false otherwise.  Nonprintable &#039;
                   &#039;characters are\n&#039;
                   &#039;   those characters defined in the Unicode character &#039;
                   &#039;database as\n&#039;
                   &#039;   “Other” or “Separator”, excepting the ASCII space &#039;
                   &#039;(0x20) which is\n&#039;
                   &#039;   considered printable.  (Note that printable characters &#039;
                   &#039;in this\n&#039;
                   &#039;   context are those which should not be escaped when &#039;
                   &#039;&quot;repr()&quot; is\n&#039;
                   &#039;   invoked on a string.  It has no bearing on the handling &#039;
                   &#039;of strings\n&#039;
                   &#039;   written to &quot;sys.stdout&quot; or &quot;sys.stderr&quot;.)\n&#039;
                   &#039;\n&#039;
                   &#039;str.isspace()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if there are only whitespace characters in &#039;
                   &#039;the string\n&#039;
                   &#039;   and there is at least one character, false otherwise.  &#039;
                   &#039;Whitespace\n&#039;
                   &#039;   characters  are those characters defined in the Unicode &#039;
                   &#039;character\n&#039;
                   &#039;   database as “Other” or “Separator” and those with &#039;
                   &#039;bidirectional\n&#039;
                   &#039;   property being one of “WS”, “B”, or “S”.\n&#039;
                   &#039;\n&#039;
                   &#039;str.istitle()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if the string is a titlecased string and &#039;
                   &#039;there is at\n&#039;
                   &#039;   least one character, for example uppercase characters &#039;
                   &#039;may only\n&#039;
                   &#039;   follow uncased characters and lowercase characters only &#039;
                   &#039;cased ones.\n&#039;
                   &#039;   Return false otherwise.\n&#039;
                   &#039;\n&#039;
                   &#039;str.isupper()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return true if all cased characters [4] in the string &#039;
                   &#039;are uppercase\n&#039;
                   &#039;   and there is at least one cased character, false &#039;
                   &#039;otherwise.\n&#039;
                   &#039;\n&#039;
                   &#039;str.join(iterable)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a string which is the concatenation of the &#039;
                   &#039;strings in\n&#039;
                   &#039;   *iterable*. A &quot;TypeError&quot; will be raised if there are &#039;
                   &#039;any non-\n&#039;
                   &#039;   string values in *iterable*, including &quot;bytes&quot; &#039;
                   &#039;objects.  The\n&#039;
                   &#039;   separator between elements is the string providing this &#039;
                   &#039;method.\n&#039;
                   &#039;\n&#039;
                   &#039;str.ljust(width[, fillchar])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return the string left justified in a string of length &#039;
                   &#039;*width*.\n&#039;
                   &#039;   Padding is done using the specified *fillchar* (default &#039;
                   &#039;is an ASCII\n&#039;
                   &#039;   space). The original string is returned if *width* is &#039;
                   &#039;less than or\n&#039;
                   &#039;   equal to &quot;len(s)&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;str.lower()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with all the cased &#039;
                   &#039;characters [4]\n&#039;
                   &#039;   converted to lowercase.\n&#039;
                   &#039;\n&#039;
                   &#039;   The lowercasing algorithm used is described in section &#039;
                   &#039;3.13 of the\n&#039;
                   &#039;   Unicode Standard.\n&#039;
                   &#039;\n&#039;
                   &#039;str.lstrip([chars])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with leading characters &#039;
                   &#039;removed.  The\n&#039;
                   &#039;   *chars* argument is a string specifying the set of &#039;
                   &#039;characters to be\n&#039;
                   &#039;   removed.  If omitted or &quot;None&quot;, the *chars* argument &#039;
                   &#039;defaults to\n&#039;
                   &#039;   removing whitespace.  The *chars* argument is not a &#039;
                   &#039;prefix; rather,\n&#039;
                   &#039;   all combinations of its values are stripped:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;   spacious   &#039;.lstrip()\n&quot;
                   &quot;      &#039;spacious   &#039;\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;www.example.com&#039;.lstrip(&#039;cmowz.&#039;)\n&quot;
                   &quot;      &#039;example.com&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;static str.maketrans(x[, y[, z]])\n&#039;
                   &#039;\n&#039;
                   &#039;   This static method returns a translation table usable &#039;
                   &#039;for\n&#039;
                   &#039;   &quot;str.translate()&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;   If there is only one argument, it must be a dictionary &#039;
                   &#039;mapping\n&#039;
                   &#039;   Unicode ordinals (integers) or characters (strings of &#039;
                   &#039;length 1) to\n&#039;
                   &#039;   Unicode ordinals, strings (of arbitrary lengths) or &#039;
                   &#039;&quot;None&quot;.\n&#039;
                   &#039;   Character keys will then be converted to ordinals.\n&#039;
                   &#039;\n&#039;
                   &#039;   If there are two arguments, they must be strings of &#039;
                   &#039;equal length,\n&#039;
                   &#039;   and in the resulting dictionary, each character in x &#039;
                   &#039;will be mapped\n&#039;
                   &#039;   to the character at the same position in y.  If there &#039;
                   &#039;is a third\n&#039;
                   &#039;   argument, it must be a string, whose characters will be &#039;
                   &#039;mapped to\n&#039;
                   &#039;   &quot;None&quot; in the result.\n&#039;
                   &#039;\n&#039;
                   &#039;str.partition(sep)\n&#039;
                   &#039;\n&#039;
                   &#039;   Split the string at the first occurrence of *sep*, and &#039;
                   &#039;return a\n&#039;
                   &#039;   3-tuple containing the part before the separator, the &#039;
                   &#039;separator\n&#039;
                   &#039;   itself, and the part after the separator.  If the &#039;
                   &#039;separator is not\n&#039;
                   &#039;   found, return a 3-tuple containing the string itself, &#039;
                   &#039;followed by\n&#039;
                   &#039;   two empty strings.\n&#039;
                   &#039;\n&#039;
                   &#039;str.replace(old, new[, count])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with all occurrences of &#039;
                   &#039;substring *old*\n&#039;
                   &#039;   replaced by *new*.  If the optional argument *count* is &#039;
                   &#039;given, only\n&#039;
                   &#039;   the first *count* occurrences are replaced.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rfind(sub[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return the highest index in the string where substring &#039;
                   &#039;*sub* is\n&#039;
                   &#039;   found, such that *sub* is contained within &#039;
                   &#039;&quot;s[start:end]&quot;.\n&#039;
                   &#039;   Optional arguments *start* and *end* are interpreted as &#039;
                   &#039;in slice\n&#039;
                   &#039;   notation.  Return &quot;-1&quot; on failure.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rindex(sub[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Like &quot;rfind()&quot; but raises &quot;ValueError&quot; when the &#039;
                   &#039;substring *sub* is\n&#039;
                   &#039;   not found.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rjust(width[, fillchar])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return the string right justified in a string of length &#039;
                   &#039;*width*.\n&#039;
                   &#039;   Padding is done using the specified *fillchar* (default &#039;
                   &#039;is an ASCII\n&#039;
                   &#039;   space). The original string is returned if *width* is &#039;
                   &#039;less than or\n&#039;
                   &#039;   equal to &quot;len(s)&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rpartition(sep)\n&#039;
                   &#039;\n&#039;
                   &#039;   Split the string at the last occurrence of *sep*, and &#039;
                   &#039;return a\n&#039;
                   &#039;   3-tuple containing the part before the separator, the &#039;
                   &#039;separator\n&#039;
                   &#039;   itself, and the part after the separator.  If the &#039;
                   &#039;separator is not\n&#039;
                   &#039;   found, return a 3-tuple containing two empty strings, &#039;
                   &#039;followed by\n&#039;
                   &#039;   the string itself.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rsplit(sep=None, maxsplit=-1)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a list of the words in the string, using *sep* &#039;
                   &#039;as the\n&#039;
                   &#039;   delimiter string. If *maxsplit* is given, at most &#039;
                   &#039;*maxsplit* splits\n&#039;
                   &#039;   are done, the *rightmost* ones.  If *sep* is not &#039;
                   &#039;specified or\n&#039;
                   &#039;   &quot;None&quot;, any whitespace string is a separator.  Except &#039;
                   &#039;for splitting\n&#039;
                   &#039;   from the right, &quot;rsplit()&quot; behaves like &quot;split()&quot; which &#039;
                   &#039;is\n&#039;
                   &#039;   described in detail below.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rstrip([chars])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with trailing characters &#039;
                   &#039;removed.  The\n&#039;
                   &#039;   *chars* argument is a string specifying the set of &#039;
                   &#039;characters to be\n&#039;
                   &#039;   removed.  If omitted or &quot;None&quot;, the *chars* argument &#039;
                   &#039;defaults to\n&#039;
                   &#039;   removing whitespace.  The *chars* argument is not a &#039;
                   &#039;suffix; rather,\n&#039;
                   &#039;   all combinations of its values are stripped:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;   spacious   &#039;.rstrip()\n&quot;
                   &quot;      &#039;   spacious&#039;\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;mississippi&#039;.rstrip(&#039;ipz&#039;)\n&quot;
                   &quot;      &#039;mississ&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;str.split(sep=None, maxsplit=-1)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a list of the words in the string, using *sep* &#039;
                   &#039;as the\n&#039;
                   &#039;   delimiter string.  If *maxsplit* is given, at most &#039;
                   &#039;*maxsplit*\n&#039;
                   &#039;   splits are done (thus, the list will have at most &#039;
                   &#039;&quot;maxsplit+1&quot;\n&#039;
                   &#039;   elements).  If *maxsplit* is not specified or &quot;-1&quot;, &#039;
                   &#039;then there is\n&#039;
                   &#039;   no limit on the number of splits (all possible splits &#039;
                   &#039;are made).\n&#039;
                   &#039;\n&#039;
                   &#039;   If *sep* is given, consecutive delimiters are not &#039;
                   &#039;grouped together\n&#039;
                   &#039;   and are deemed to delimit empty strings (for example,\n&#039;
                   &#039;   &quot;\&#039;1,,2\&#039;.split(\&#039;,\&#039;)&quot; returns &quot;[\&#039;1\&#039;, \&#039;\&#039;, &#039;
                   &#039;\&#039;2\&#039;]&quot;).  The *sep* argument\n&#039;
                   &#039;   may consist of multiple characters (for example,\n&#039;
                   &#039;   &quot;\&#039;1&lt;&gt;2&lt;&gt;3\&#039;.split(\&#039;&lt;&gt;\&#039;)&quot; returns &quot;[\&#039;1\&#039;, \&#039;2\&#039;, &#039;
                   &#039;\&#039;3\&#039;]&quot;). Splitting an\n&#039;
                   &#039;   empty string with a specified separator returns &#039;
                   &#039;&quot;[\&#039;\&#039;]&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;   For example:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;1,2,3&#039;.split(&#039;,&#039;)\n&quot;
                   &quot;      [&#039;1&#039;, &#039;2&#039;, &#039;3&#039;]\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;1,2,3&#039;.split(&#039;,&#039;, maxsplit=1)\n&quot;
                   &quot;      [&#039;1&#039;, &#039;2,3&#039;]\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;1,2,,3,&#039;.split(&#039;,&#039;)\n&quot;
                   &quot;      [&#039;1&#039;, &#039;2&#039;, &#039;&#039;, &#039;3&#039;, &#039;&#039;]\n&quot;
                   &#039;\n&#039;
                   &#039;   If *sep* is not specified or is &quot;None&quot;, a different &#039;
                   &#039;splitting\n&#039;
                   &#039;   algorithm is applied: runs of consecutive whitespace &#039;
                   &#039;are regarded\n&#039;
                   &#039;   as a single separator, and the result will contain no &#039;
                   &#039;empty strings\n&#039;
                   &#039;   at the start or end if the string has leading or &#039;
                   &#039;trailing\n&#039;
                   &#039;   whitespace.  Consequently, splitting an empty string or &#039;
                   &#039;a string\n&#039;
                   &#039;   consisting of just whitespace with a &quot;None&quot; separator &#039;
                   &#039;returns &quot;[]&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;   For example:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;1 2 3&#039;.split()\n&quot;
                   &quot;      [&#039;1&#039;, &#039;2&#039;, &#039;3&#039;]\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;1 2 3&#039;.split(maxsplit=1)\n&quot;
                   &quot;      [&#039;1&#039;, &#039;2 3&#039;]\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;   1   2   3   &#039;.split()\n&quot;
                   &quot;      [&#039;1&#039;, &#039;2&#039;, &#039;3&#039;]\n&quot;
                   &#039;\n&#039;
                   &#039;str.splitlines([keepends])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a list of the lines in the string, breaking at &#039;
                   &#039;line\n&#039;
                   &#039;   boundaries.  Line breaks are not included in the &#039;
                   &#039;resulting list\n&#039;
                   &#039;   unless *keepends* is given and true.\n&#039;
                   &#039;\n&#039;
                   &#039;   This method splits on the following line boundaries.  &#039;
                   &#039;In\n&#039;
                   &#039;   particular, the boundaries are a superset of *universal &#039;
                   &#039;newlines*.\n&#039;
                   &#039;\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | Representation          | &#039;
                   &#039;Description                   |\n&#039;
                   &#039;   &#039;
                   &#039;+=========================+===============================+\n&#039;
                   &#039;   | &quot;\\n&quot;                    | Line &#039;
                   &#039;Feed                     |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\r&quot;                    | Carriage &#039;
                   &#039;Return               |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\r\\n&quot;                  | Carriage Return + Line &#039;
                   &#039;Feed   |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\v&quot; or &quot;\\x0b&quot;          | Line &#039;
                   &#039;Tabulation               |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\f&quot; or &quot;\\x0c&quot;          | Form &#039;
                   &#039;Feed                     |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\x1c&quot;                  | File &#039;
                   &#039;Separator                |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\x1d&quot;                  | Group &#039;
                   &#039;Separator               |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\x1e&quot;                  | Record &#039;
                   &#039;Separator              |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\x85&quot;                  | Next Line (C1 Control &#039;
                   &#039;Code)   |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\u2028&quot;                | Line &#039;
                   &#039;Separator                |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;   | &quot;\\u2029&quot;                | Paragraph &#039;
                   &#039;Separator           |\n&#039;
                   &#039;   &#039;
                   &#039;+-------------------------+-------------------------------+\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 3.2: &quot;\\v&quot; and &quot;\\f&quot; added to list &#039;
                   &#039;of line\n&#039;
                   &#039;   boundaries.\n&#039;
                   &#039;\n&#039;
                   &#039;   For example:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;ab c\\n\\nde fg\\rkl\\r\\n&#039;.splitlines()\n&quot;
                   &quot;      [&#039;ab c&#039;, &#039;&#039;, &#039;de fg&#039;, &#039;kl&#039;]\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;ab c\\n\\nde &quot;
                   &quot;fg\\rkl\\r\\n&#039;.splitlines(keepends=True)\n&quot;
                   &quot;      [&#039;ab c\\n&#039;, &#039;\\n&#039;, &#039;de fg\\r&#039;, &#039;kl\\r\\n&#039;]\n&quot;
                   &#039;\n&#039;
                   &#039;   Unlike &quot;split()&quot; when a delimiter string *sep* is &#039;
                   &#039;given, this\n&#039;
                   &#039;   method returns an empty list for the empty string, and &#039;
                   &#039;a terminal\n&#039;
                   &#039;   line break does not result in an extra line:\n&#039;
                   &#039;\n&#039;
                   &#039;      &gt;&gt;&gt; &quot;&quot;.splitlines()\n&#039;
                   &#039;      []\n&#039;
                   &#039;      &gt;&gt;&gt; &quot;One line\\n&quot;.splitlines()\n&#039;
                   &quot;      [&#039;One line&#039;]\n&quot;
                   &#039;\n&#039;
                   &#039;   For comparison, &quot;split(\&#039;\\n\&#039;)&quot; gives:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;&#039;.split(&#039;\\n&#039;)\n&quot;
                   &quot;      [&#039;&#039;]\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;Two lines\\n&#039;.split(&#039;\\n&#039;)\n&quot;
                   &quot;      [&#039;Two lines&#039;, &#039;&#039;]\n&quot;
                   &#039;\n&#039;
                   &#039;str.startswith(prefix[, start[, end]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return &quot;True&quot; if string starts with the *prefix*, &#039;
                   &#039;otherwise return\n&#039;
                   &#039;   &quot;False&quot;. *prefix* can also be a tuple of prefixes to &#039;
                   &#039;look for.\n&#039;
                   &#039;   With optional *start*, test string beginning at that &#039;
                   &#039;position.\n&#039;
                   &#039;   With optional *end*, stop comparing string at that &#039;
                   &#039;position.\n&#039;
                   &#039;\n&#039;
                   &#039;str.strip([chars])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with the leading and &#039;
                   &#039;trailing\n&#039;
                   &#039;   characters removed. The *chars* argument is a string &#039;
                   &#039;specifying the\n&#039;
                   &#039;   set of characters to be removed. If omitted or &quot;None&quot;, &#039;
                   &#039;the *chars*\n&#039;
                   &#039;   argument defaults to removing whitespace. The *chars* &#039;
                   &#039;argument is\n&#039;
                   &#039;   not a prefix or suffix; rather, all combinations of its &#039;
                   &#039;values are\n&#039;
                   &#039;   stripped:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;   spacious   &#039;.strip()\n&quot;
                   &quot;      &#039;spacious&#039;\n&quot;
                   &quot;      &gt;&gt;&gt; &#039;www.example.com&#039;.strip(&#039;cmowz.&#039;)\n&quot;
                   &quot;      &#039;example&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;   The outermost leading and trailing *chars* argument &#039;
                   &#039;values are\n&#039;
                   &#039;   stripped from the string. Characters are removed from &#039;
                   &#039;the leading\n&#039;
                   &#039;   end until reaching a string character that is not &#039;
                   &#039;contained in the\n&#039;
                   &#039;   set of characters in *chars*. A similar action takes &#039;
                   &#039;place on the\n&#039;
                   &#039;   trailing end. For example:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; comment_string = &#039;#....... Section 3.2.1 Issue &quot;
                   &quot;#32 .......&#039;\n&quot;
                   &quot;      &gt;&gt;&gt; comment_string.strip(&#039;.#! &#039;)\n&quot;
                   &quot;      &#039;Section 3.2.1 Issue #32&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;str.swapcase()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with uppercase characters &#039;
                   &#039;converted to\n&#039;
                   &#039;   lowercase and vice versa. Note that it is not &#039;
                   &#039;necessarily true that\n&#039;
                   &#039;   &quot;s.swapcase().swapcase() == s&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;str.title()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a titlecased version of the string where words &#039;
                   &#039;start with an\n&#039;
                   &#039;   uppercase character and the remaining characters are &#039;
                   &#039;lowercase.\n&#039;
                   &#039;\n&#039;
                   &#039;   For example:\n&#039;
                   &#039;\n&#039;
                   &quot;      &gt;&gt;&gt; &#039;Hello world&#039;.title()\n&quot;
                   &quot;      &#039;Hello World&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;   The algorithm uses a simple language-independent &#039;
                   &#039;definition of a\n&#039;
                   &#039;   word as groups of consecutive letters.  The definition &#039;
                   &#039;works in\n&#039;
                   &#039;   many contexts but it means that apostrophes in &#039;
                   &#039;contractions and\n&#039;
                   &#039;   possessives form word boundaries, which may not be the &#039;
                   &#039;desired\n&#039;
                   &#039;   result:\n&#039;
                   &#039;\n&#039;
                   &#039;      &gt;&gt;&gt; &quot;they\&#039;re bill\&#039;s friends from the UK&quot;.title()\n&#039;
                   &#039;      &quot;They\&#039;Re Bill\&#039;S Friends From The Uk&quot;\n&#039;
                   &#039;\n&#039;
                   &#039;   A workaround for apostrophes can be constructed using &#039;
                   &#039;regular\n&#039;
                   &#039;   expressions:\n&#039;
                   &#039;\n&#039;
                   &#039;      &gt;&gt;&gt; import re\n&#039;
                   &#039;      &gt;&gt;&gt; def titlecase(s):\n&#039;
                   &#039;      ...     return re.sub(r&quot;[A-Za-z]+(\&#039;[A-Za-z]+)?&quot;,\n&#039;
                   &#039;      ...                   lambda mo: &#039;
                   &#039;mo.group(0)[0].upper() +\n&#039;
                   &#039;      ...                              &#039;
                   &#039;mo.group(0)[1:].lower(),\n&#039;
                   &#039;      ...                   s)\n&#039;
                   &#039;      ...\n&#039;
                   &#039;      &gt;&gt;&gt; titlecase(&quot;they\&#039;re bill\&#039;s friends.&quot;)\n&#039;
                   &#039;      &quot;They\&#039;re Bill\&#039;s Friends.&quot;\n&#039;
                   &#039;\n&#039;
                   &#039;str.translate(table)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string in which each character has &#039;
                   &#039;been mapped\n&#039;
                   &#039;   through the given translation table.  The table must be &#039;
                   &#039;an object\n&#039;
                   &#039;   that implements indexing via &quot;__getitem__()&quot;, typically &#039;
                   &#039;a *mapping*\n&#039;
                   &#039;   or *sequence*.  When indexed by a Unicode ordinal (an &#039;
                   &#039;integer), the\n&#039;
                   &#039;   table object can do any of the following: return a &#039;
                   &#039;Unicode ordinal\n&#039;
                   &#039;   or a string, to map the character to one or more other &#039;
                   &#039;characters;\n&#039;
                   &#039;   return &quot;None&quot;, to delete the character from the return &#039;
                   &#039;string; or\n&#039;
                   &#039;   raise a &quot;LookupError&quot; exception, to map the character &#039;
                   &#039;to itself.\n&#039;
                   &#039;\n&#039;
                   &#039;   You can use &quot;str.maketrans()&quot; to create a translation &#039;
                   &#039;map from\n&#039;
                   &#039;   character-to-character mappings in different formats.\n&#039;
                   &#039;\n&#039;
                   &#039;   See also the &quot;codecs&quot; module for a more flexible &#039;
                   &#039;approach to custom\n&#039;
                   &#039;   character mappings.\n&#039;
                   &#039;\n&#039;
                   &#039;str.upper()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string with all the cased &#039;
                   &#039;characters [4]\n&#039;
                   &#039;   converted to uppercase.  Note that &#039;
                   &#039;&quot;s.upper().isupper()&quot; might be\n&#039;
                   &#039;   &quot;False&quot; if &quot;s&quot; contains uncased characters or if the &#039;
                   &#039;Unicode\n&#039;
                   &#039;   category of the resulting character(s) is not “Lu” &#039;
                   &#039;(Letter,\n&#039;
                   &#039;   uppercase), but e.g. “Lt” (Letter, titlecase).\n&#039;
                   &#039;\n&#039;
                   &#039;   The uppercasing algorithm used is described in section &#039;
                   &#039;3.13 of the\n&#039;
                   &#039;   Unicode Standard.\n&#039;
                   &#039;\n&#039;
                   &#039;str.zfill(width)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string left filled with ASCII &#039;
                   &#039;&quot;\&#039;0\&#039;&quot; digits to\n&#039;
                   &#039;   make a string of length *width*. A leading sign prefix\n&#039;
                   &#039;   (&quot;\&#039;+\&#039;&quot;/&quot;\&#039;-\&#039;&quot;) is handled by inserting the padding &#039;
                   &#039;*after* the sign\n&#039;
                   &#039;   character rather than before. The original string is &#039;
                   &#039;returned if\n&#039;
                   &#039;   *width* is less than or equal to &quot;len(s)&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;   For example:\n&#039;
                   &#039;\n&#039;
                   &#039;      &gt;&gt;&gt; &quot;42&quot;.zfill(5)\n&#039;
                   &quot;      &#039;00042&#039;\n&quot;
                   &#039;      &gt;&gt;&gt; &quot;-42&quot;.zfill(5)\n&#039;
                   &quot;      &#039;-0042&#039;\n&quot;,
 &#039;strings&#039;: &#039;String and Bytes literals\n&#039;
            &#039;*************************\n&#039;
            &#039;\n&#039;
            &#039;String literals are described by the following lexical &#039;
            &#039;definitions:\n&#039;
            &#039;\n&#039;
            &#039;   stringliteral   ::= [stringprefix](shortstring | longstring)\n&#039;
            &#039;   stringprefix    ::= &quot;r&quot; | &quot;u&quot; | &quot;R&quot; | &quot;U&quot; | &quot;f&quot; | &quot;F&quot;\n&#039;
            &#039;                    | &quot;fr&quot; | &quot;Fr&quot; | &quot;fR&quot; | &quot;FR&quot; | &quot;rf&quot; | &quot;rF&quot; | &#039;
            &#039;&quot;Rf&quot; | &quot;RF&quot;\n&#039;
            &#039;   shortstring     ::= &quot;\&#039;&quot; shortstringitem* &quot;\&#039;&quot; | \&#039;&quot;\&#039; &#039;
            &#039;shortstringitem* \&#039;&quot;\&#039;\n&#039;
            &#039;   longstring      ::= &quot;\&#039;\&#039;\&#039;&quot; longstringitem* &quot;\&#039;\&#039;\&#039;&quot; | &#039;
            &#039;\&#039;&quot;&quot;&quot;\&#039; longstringitem* \&#039;&quot;&quot;&quot;\&#039;\n&#039;
            &#039;   shortstringitem ::= shortstringchar | stringescapeseq\n&#039;
            &#039;   longstringitem  ::= longstringchar | stringescapeseq\n&#039;
            &#039;   shortstringchar ::= &lt;any source character except &quot;\\&quot; or &#039;
            &#039;newline or the quote&gt;\n&#039;
            &#039;   longstringchar  ::= &lt;any source character except &quot;\\&quot;&gt;\n&#039;
            &#039;   stringescapeseq ::= &quot;\\&quot; &lt;any source character&gt;\n&#039;
            &#039;\n&#039;
            &#039;   bytesliteral   ::= bytesprefix(shortbytes | longbytes)\n&#039;
            &#039;   bytesprefix    ::= &quot;b&quot; | &quot;B&quot; | &quot;br&quot; | &quot;Br&quot; | &quot;bR&quot; | &quot;BR&quot; | &#039;
            &#039;&quot;rb&quot; | &quot;rB&quot; | &quot;Rb&quot; | &quot;RB&quot;\n&#039;
            &#039;   shortbytes     ::= &quot;\&#039;&quot; shortbytesitem* &quot;\&#039;&quot; | \&#039;&quot;\&#039; &#039;
            &#039;shortbytesitem* \&#039;&quot;\&#039;\n&#039;
            &#039;   longbytes      ::= &quot;\&#039;\&#039;\&#039;&quot; longbytesitem* &quot;\&#039;\&#039;\&#039;&quot; | \&#039;&quot;&quot;&quot;\&#039; &#039;
            &#039;longbytesitem* \&#039;&quot;&quot;&quot;\&#039;\n&#039;
            &#039;   shortbytesitem ::= shortbyteschar | bytesescapeseq\n&#039;
            &#039;   longbytesitem  ::= longbyteschar | bytesescapeseq\n&#039;
            &#039;   shortbyteschar ::= &lt;any ASCII character except &quot;\\&quot; or newline &#039;
            &#039;or the quote&gt;\n&#039;
            &#039;   longbyteschar  ::= &lt;any ASCII character except &quot;\\&quot;&gt;\n&#039;
            &#039;   bytesescapeseq ::= &quot;\\&quot; &lt;any ASCII character&gt;\n&#039;
            &#039;\n&#039;
            &#039;One syntactic restriction not indicated by these productions is &#039;
            &#039;that\n&#039;
            &#039;whitespace is not allowed between the &quot;stringprefix&quot; or &#039;
            &#039;&quot;bytesprefix&quot;\n&#039;
            &#039;and the rest of the literal. The source character set is defined &#039;
            &#039;by\n&#039;
            &#039;the encoding declaration; it is UTF-8 if no encoding declaration &#039;
            &#039;is\n&#039;
            &#039;given in the source file; see section Encoding declarations.\n&#039;
            &#039;\n&#039;
            &#039;In plain English: Both types of literals can be enclosed in &#039;
            &#039;matching\n&#039;
            &#039;single quotes (&quot;\&#039;&quot;) or double quotes (&quot;&quot;&quot;).  They can also be &#039;
            &#039;enclosed\n&#039;
            &#039;in matching groups of three single or double quotes (these are\n&#039;
            &#039;generally referred to as *triple-quoted strings*).  The &#039;
            &#039;backslash\n&#039;
            &#039;(&quot;\\&quot;) character is used to escape characters that otherwise have &#039;
            &#039;a\n&#039;
            &#039;special meaning, such as newline, backslash itself, or the quote\n&#039;
            &#039;character.\n&#039;
            &#039;\n&#039;
            &#039;Bytes literals are always prefixed with &quot;\&#039;b\&#039;&quot; or &quot;\&#039;B\&#039;&quot;; they &#039;
            &#039;produce\n&#039;
            &#039;an instance of the &quot;bytes&quot; type instead of the &quot;str&quot; type.  They &#039;
            &#039;may\n&#039;
            &#039;only contain ASCII characters; bytes with a numeric value of 128 &#039;
            &#039;or\n&#039;
            &#039;greater must be expressed with escapes.\n&#039;
            &#039;\n&#039;
            &#039;Both string and bytes literals may optionally be prefixed with a\n&#039;
            &#039;letter &quot;\&#039;r\&#039;&quot; or &quot;\&#039;R\&#039;&quot;; such strings are called *raw strings* &#039;
            &#039;and treat\n&#039;
            &#039;backslashes as literal characters.  As a result, in string &#039;
            &#039;literals,\n&#039;
            &#039;&quot;\&#039;\\U\&#039;&quot; and &quot;\&#039;\\u\&#039;&quot; escapes in raw strings are not treated &#039;
            &#039;specially.\n&#039;
            &#039;Given that Python 2.x’s raw unicode literals behave differently &#039;
            &#039;than\n&#039;
            &#039;Python 3.x’s the &quot;\&#039;ur\&#039;&quot; syntax is not supported.\n&#039;
            &#039;\n&#039;
            &#039;New in version 3.3: The &quot;\&#039;rb\&#039;&quot; prefix of raw bytes literals has &#039;
            &#039;been\n&#039;
            &#039;added as a synonym of &quot;\&#039;br\&#039;&quot;.\n&#039;
            &#039;\n&#039;
            &#039;New in version 3.3: Support for the unicode legacy literal\n&#039;
            &#039;(&quot;u\&#039;value\&#039;&quot;) was reintroduced to simplify the maintenance of &#039;
            &#039;dual\n&#039;
            &#039;Python 2.x and 3.x codebases. See **PEP 414** for more &#039;
            &#039;information.\n&#039;
            &#039;\n&#039;
            &#039;A string literal with &quot;\&#039;f\&#039;&quot; or &quot;\&#039;F\&#039;&quot; in its prefix is a &#039;
            &#039;*formatted\n&#039;
            &#039;string literal*; see Formatted string literals.  The &quot;\&#039;f\&#039;&quot; may &#039;
            &#039;be\n&#039;
            &#039;combined with &quot;\&#039;r\&#039;&quot;, but not with &quot;\&#039;b\&#039;&quot; or &quot;\&#039;u\&#039;&quot;, therefore &#039;
            &#039;raw\n&#039;
            &#039;formatted strings are possible, but formatted bytes literals are &#039;
            &#039;not.\n&#039;
            &#039;\n&#039;
            &#039;In triple-quoted literals, unescaped newlines and quotes are &#039;
            &#039;allowed\n&#039;
            &#039;(and are retained), except that three unescaped quotes in a row\n&#039;
            &#039;terminate the literal.  (A “quote” is the character used to open &#039;
            &#039;the\n&#039;
            &#039;literal, i.e. either &quot;\&#039;&quot; or &quot;&quot;&quot;.)\n&#039;
            &#039;\n&#039;
            &#039;Unless an &quot;\&#039;r\&#039;&quot; or &quot;\&#039;R\&#039;&quot; prefix is present, escape sequences &#039;
            &#039;in string\n&#039;
            &#039;and bytes literals are interpreted according to rules similar to &#039;
            &#039;those\n&#039;
            &#039;used by Standard C.  The recognized escape sequences are:\n&#039;
            &#039;\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| Escape Sequence   | Meaning                           | Notes   &#039;
            &#039;|\n&#039;
            &#039;+===================+===================================+=========+\n&#039;
            &#039;| &quot;\\newline&quot;        | Backslash and newline ignored     &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\\\&quot;              | Backslash (&quot;\\&quot;)                   &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\\&#039;&quot;              | Single quote (&quot;\&#039;&quot;)                &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\&quot;&quot;              | Double quote (&quot;&quot;&quot;)                &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\a&quot;              | ASCII Bell (BEL)                  &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\b&quot;              | ASCII Backspace (BS)              &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\f&quot;              | ASCII Formfeed (FF)               &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\n&quot;              | ASCII Linefeed (LF)               &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\r&quot;              | ASCII Carriage Return (CR)        &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\t&quot;              | ASCII Horizontal Tab (TAB)        &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\v&quot;              | ASCII Vertical Tab (VT)           &#039;
            &#039;|         |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\ooo&quot;            | Character with octal value *ooo*  | &#039;
            &#039;(1,3)   |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\xhh&quot;            | Character with hex value *hh*     | &#039;
            &#039;(2,3)   |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;\n&#039;
            &#039;Escape sequences only recognized in string literals are:\n&#039;
            &#039;\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| Escape Sequence   | Meaning                           | Notes   &#039;
            &#039;|\n&#039;
            &#039;+===================+===================================+=========+\n&#039;
            &#039;| &quot;\\N{name}&quot;        | Character named *name* in the     | &#039;
            &#039;(4)     |\n&#039;
            &#039;|                   | Unicode database                  |         &#039;
            &#039;|\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\uxxxx&quot;          | Character with 16-bit hex value   | &#039;
            &#039;(5)     |\n&#039;
            &#039;|                   | *xxxx*                            |         &#039;
            &#039;|\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\Uxxxxxxxx&quot;      | Character with 32-bit hex value   | &#039;
            &#039;(6)     |\n&#039;
            &#039;|                   | *xxxxxxxx*                        |         &#039;
            &#039;|\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;\n&#039;
            &#039;Notes:\n&#039;
            &#039;\n&#039;
            &#039;1. As in Standard C, up to three octal digits are accepted.\n&#039;
            &#039;\n&#039;
            &#039;2. Unlike in Standard C, exactly two hex digits are required.\n&#039;
            &#039;\n&#039;
            &#039;3. In a bytes literal, hexadecimal and octal escapes denote the\n&#039;
            &#039;   byte with the given value. In a string literal, these escapes\n&#039;
            &#039;   denote a Unicode character with the given value.\n&#039;
            &#039;\n&#039;
            &#039;4. Changed in version 3.3: Support for name aliases [1] has been\n&#039;
            &#039;   added.\n&#039;
            &#039;\n&#039;
            &#039;5. Exactly four hex digits are required.\n&#039;
            &#039;\n&#039;
            &#039;6. Any Unicode character can be encoded this way.  Exactly eight\n&#039;
            &#039;   hex digits are required.\n&#039;
            &#039;\n&#039;
            &#039;Unlike Standard C, all unrecognized escape sequences are left in &#039;
            &#039;the\n&#039;
            &#039;string unchanged, i.e., *the backslash is left in the result*.  &#039;
            &#039;(This\n&#039;
            &#039;behavior is useful when debugging: if an escape sequence is &#039;
            &#039;mistyped,\n&#039;
            &#039;the resulting output is more easily recognized as broken.)  It is &#039;
            &#039;also\n&#039;
            &#039;important to note that the escape sequences only recognized in &#039;
            &#039;string\n&#039;
            &#039;literals fall into the category of unrecognized escapes for &#039;
            &#039;bytes\n&#039;
            &#039;literals.\n&#039;
            &#039;\n&#039;
            &#039;   Changed in version 3.6: Unrecognized escape sequences produce &#039;
            &#039;a\n&#039;
            &#039;   DeprecationWarning.  In some future version of Python they &#039;
            &#039;will be\n&#039;
            &#039;   a SyntaxError.\n&#039;
            &#039;\n&#039;
            &#039;Even in a raw literal, quotes can be escaped with a backslash, &#039;
            &#039;but the\n&#039;
            &#039;backslash remains in the result; for example, &quot;r&quot;\\&quot;&quot;&quot; is a &#039;
            &#039;valid\n&#039;
            &#039;string literal consisting of two characters: a backslash and a &#039;
            &#039;double\n&#039;
            &#039;quote; &quot;r&quot;\\&quot;&quot; is not a valid string literal (even a raw string &#039;
            &#039;cannot\n&#039;
            &#039;end in an odd number of backslashes).  Specifically, *a raw &#039;
            &#039;literal\n&#039;
            &#039;cannot end in a single backslash* (since the backslash would &#039;
            &#039;escape\n&#039;
            &#039;the following quote character).  Note also that a single &#039;
            &#039;backslash\n&#039;
            &#039;followed by a newline is interpreted as those two characters as &#039;
            &#039;part\n&#039;
            &#039;of the literal, *not* as a line continuation.\n&#039;,
 &#039;subscriptions&#039;: &#039;Subscriptions\n&#039;
                  &#039;*************\n&#039;
                  &#039;\n&#039;
                  &#039;A subscription selects an item of a sequence (string, tuple &#039;
                  &#039;or list)\n&#039;
                  &#039;or mapping (dictionary) object:\n&#039;
                  &#039;\n&#039;
                  &#039;   subscription ::= primary &quot;[&quot; expression_list &quot;]&quot;\n&#039;
                  &#039;\n&#039;
                  &#039;The primary must evaluate to an object that supports &#039;
                  &#039;subscription\n&#039;
                  &#039;(lists or dictionaries for example).  User-defined objects &#039;
                  &#039;can support\n&#039;
                  &#039;subscription by defining a &quot;__getitem__()&quot; method.\n&#039;
                  &#039;\n&#039;
                  &#039;For built-in objects, there are two types of objects that &#039;
                  &#039;support\n&#039;
                  &#039;subscription:\n&#039;
                  &#039;\n&#039;
                  &#039;If the primary is a mapping, the expression list must &#039;
                  &#039;evaluate to an\n&#039;
                  &#039;object whose value is one of the keys of the mapping, and &#039;
                  &#039;the\n&#039;
                  &#039;subscription selects the value in the mapping that &#039;
                  &#039;corresponds to that\n&#039;
                  &#039;key.  (The expression list is a tuple except if it has &#039;
                  &#039;exactly one\n&#039;
                  &#039;item.)\n&#039;
                  &#039;\n&#039;
                  &#039;If the primary is a sequence, the expression list must &#039;
                  &#039;evaluate to an\n&#039;
                  &#039;integer or a slice (as discussed in the following &#039;
                  &#039;section).\n&#039;
                  &#039;\n&#039;
                  &#039;The formal syntax makes no special provision for negative &#039;
                  &#039;indices in\n&#039;
                  &#039;sequences; however, built-in sequences all provide a &#039;
                  &#039;&quot;__getitem__()&quot;\n&#039;
                  &#039;method that interprets negative indices by adding the &#039;
                  &#039;length of the\n&#039;
                  &#039;sequence to the index (so that &quot;x[-1]&quot; selects the last &#039;
                  &#039;item of &quot;x&quot;).\n&#039;
                  &#039;The resulting value must be a nonnegative integer less than &#039;
                  &#039;the number\n&#039;
                  &#039;of items in the sequence, and the subscription selects the &#039;
                  &#039;item whose\n&#039;
                  &#039;index is that value (counting from zero). Since the support &#039;
                  &#039;for\n&#039;
                  &#039;negative indices and slicing occurs in the object’s &#039;
                  &#039;&quot;__getitem__()&quot;\n&#039;
                  &#039;method, subclasses overriding this method will need to &#039;
                  &#039;explicitly add\n&#039;
                  &#039;that support.\n&#039;
                  &#039;\n&#039;
                  &#039;A string’s items are characters.  A character is not a &#039;
                  &#039;separate data\n&#039;
                  &#039;type but a string of exactly one character.\n&#039;,
 &#039;truth&#039;: &#039;Truth Value Testing\n&#039;
          &#039;*******************\n&#039;
          &#039;\n&#039;
          &#039;Any object can be tested for truth value, for use in an &quot;if&quot; or\n&#039;
          &#039;&quot;while&quot; condition or as operand of the Boolean operations below.\n&#039;
          &#039;\n&#039;
          &#039;By default, an object is considered true unless its class defines\n&#039;
          &#039;either a &quot;__bool__()&quot; method that returns &quot;False&quot; or a &quot;__len__()&quot;\n&#039;
          &#039;method that returns zero, when called with the object. [1]  Here &#039;
          &#039;are\n&#039;
          &#039;most of the built-in objects considered false:\n&#039;
          &#039;\n&#039;
          &#039;* constants defined to be false: &quot;None&quot; and &quot;False&quot;.\n&#039;
          &#039;\n&#039;
          &#039;* zero of any numeric type: &quot;0&quot;, &quot;0.0&quot;, &quot;0j&quot;, &quot;Decimal(0)&quot;,\n&#039;
          &#039;  &quot;Fraction(0, 1)&quot;\n&#039;
          &#039;\n&#039;
          &#039;* empty sequences and collections: &quot;\&#039;\&#039;&quot;, &quot;()&quot;, &quot;[]&quot;, &quot;{}&quot;, &#039;
          &#039;&quot;set()&quot;,\n&#039;
          &#039;  &quot;range(0)&quot;\n&#039;
          &#039;\n&#039;
          &#039;Operations and built-in functions that have a Boolean result &#039;
          &#039;always\n&#039;
          &#039;return &quot;0&quot; or &quot;False&quot; for false and &quot;1&quot; or &quot;True&quot; for true, unless\n&#039;
          &#039;otherwise stated. (Important exception: the Boolean operations &#039;
          &#039;&quot;or&quot;\n&#039;
          &#039;and &quot;and&quot; always return one of their operands.)\n&#039;,
 &#039;try&#039;: &#039;The &quot;try&quot; statement\n&#039;
        &#039;*******************\n&#039;
        &#039;\n&#039;
        &#039;The &quot;try&quot; statement specifies exception handlers and/or cleanup code\n&#039;
        &#039;for a group of statements:\n&#039;
        &#039;\n&#039;
        &#039;   try_stmt  ::= try1_stmt | try2_stmt\n&#039;
        &#039;   try1_stmt ::= &quot;try&quot; &quot;:&quot; suite\n&#039;
        &#039;                 (&quot;except&quot; [expression [&quot;as&quot; identifier]] &quot;:&quot; &#039;
        &#039;suite)+\n&#039;
        &#039;                 [&quot;else&quot; &quot;:&quot; suite]\n&#039;
        &#039;                 [&quot;finally&quot; &quot;:&quot; suite]\n&#039;
        &#039;   try2_stmt ::= &quot;try&quot; &quot;:&quot; suite\n&#039;
        &#039;                 &quot;finally&quot; &quot;:&quot; suite\n&#039;
        &#039;\n&#039;
        &#039;The &quot;except&quot; clause(s) specify one or more exception handlers. When &#039;
        &#039;no\n&#039;
        &#039;exception occurs in the &quot;try&quot; clause, no exception handler is\n&#039;
        &#039;executed. When an exception occurs in the &quot;try&quot; suite, a search for &#039;
        &#039;an\n&#039;
        &#039;exception handler is started.  This search inspects the except &#039;
        &#039;clauses\n&#039;
        &#039;in turn until one is found that matches the exception.  An &#039;
        &#039;expression-\n&#039;
        &#039;less except clause, if present, must be last; it matches any\n&#039;
        &#039;exception.  For an except clause with an expression, that expression\n&#039;
        &#039;is evaluated, and the clause matches the exception if the resulting\n&#039;
        &#039;object is “compatible” with the exception.  An object is compatible\n&#039;
        &#039;with an exception if it is the class or a base class of the &#039;
        &#039;exception\n&#039;
        &#039;object or a tuple containing an item compatible with the exception.\n&#039;
        &#039;\n&#039;
        &#039;If no except clause matches the exception, the search for an &#039;
        &#039;exception\n&#039;
        &#039;handler continues in the surrounding code and on the invocation &#039;
        &#039;stack.\n&#039;
        &#039;[1]\n&#039;
        &#039;\n&#039;
        &#039;If the evaluation of an expression in the header of an except clause\n&#039;
        &#039;raises an exception, the original search for a handler is canceled &#039;
        &#039;and\n&#039;
        &#039;a search starts for the new exception in the surrounding code and on\n&#039;
        &#039;the call stack (it is treated as if the entire &quot;try&quot; statement &#039;
        &#039;raised\n&#039;
        &#039;the exception).\n&#039;
        &#039;\n&#039;
        &#039;When a matching except clause is found, the exception is assigned to\n&#039;
        &#039;the target specified after the &quot;as&quot; keyword in that except clause, &#039;
        &#039;if\n&#039;
        &#039;present, and the except clause’s suite is executed.  All except\n&#039;
        &#039;clauses must have an executable block.  When the end of this block &#039;
        &#039;is\n&#039;
        &#039;reached, execution continues normally after the entire try &#039;
        &#039;statement.\n&#039;
        &#039;(This means that if two nested handlers exist for the same &#039;
        &#039;exception,\n&#039;
        &#039;and the exception occurs in the try clause of the inner handler, the\n&#039;
        &#039;outer handler will not handle the exception.)\n&#039;
        &#039;\n&#039;
        &#039;When an exception has been assigned using &quot;as target&quot;, it is cleared\n&#039;
        &#039;at the end of the except clause.  This is as if\n&#039;
        &#039;\n&#039;
        &#039;   except E as N:\n&#039;
        &#039;       foo\n&#039;
        &#039;\n&#039;
        &#039;was translated to\n&#039;
        &#039;\n&#039;
        &#039;   except E as N:\n&#039;
        &#039;       try:\n&#039;
        &#039;           foo\n&#039;
        &#039;       finally:\n&#039;
        &#039;           del N\n&#039;
        &#039;\n&#039;
        &#039;This means the exception must be assigned to a different name to be\n&#039;
        &#039;able to refer to it after the except clause.  Exceptions are cleared\n&#039;
        &#039;because with the traceback attached to them, they form a reference\n&#039;
        &#039;cycle with the stack frame, keeping all locals in that frame alive\n&#039;
        &#039;until the next garbage collection occurs.\n&#039;
        &#039;\n&#039;
        &#039;Before an except clause’s suite is executed, details about the\n&#039;
        &#039;exception are stored in the &quot;sys&quot; module and can be accessed via\n&#039;
        &#039;&quot;sys.exc_info()&quot;. &quot;sys.exc_info()&quot; returns a 3-tuple consisting of &#039;
        &#039;the\n&#039;
        &#039;exception class, the exception instance and a traceback object (see\n&#039;
        &#039;section The standard type hierarchy) identifying the point in the\n&#039;
        &#039;program where the exception occurred.  &quot;sys.exc_info()&quot; values are\n&#039;
        &#039;restored to their previous values (before the call) when returning\n&#039;
        &#039;from a function that handled an exception.\n&#039;
        &#039;\n&#039;
        &#039;The optional &quot;else&quot; clause is executed if the control flow leaves &#039;
        &#039;the\n&#039;
        &#039;&quot;try&quot; suite, no exception was raised, and no &quot;return&quot;, &quot;continue&quot;, &#039;
        &#039;or\n&#039;
        &#039;&quot;break&quot; statement was executed.  Exceptions in the &quot;else&quot; clause are\n&#039;
        &#039;not handled by the preceding &quot;except&quot; clauses.\n&#039;
        &#039;\n&#039;
        &#039;If &quot;finally&quot; is present, it specifies a ‘cleanup’ handler.  The &#039;
        &#039;&quot;try&quot;\n&#039;
        &#039;clause is executed, including any &quot;except&quot; and &quot;else&quot; clauses.  If &#039;
        &#039;an\n&#039;
        &#039;exception occurs in any of the clauses and is not handled, the\n&#039;
        &#039;exception is temporarily saved. The &quot;finally&quot; clause is executed.  &#039;
        &#039;If\n&#039;
        &#039;there is a saved exception it is re-raised at the end of the &#039;
        &#039;&quot;finally&quot;\n&#039;
        &#039;clause.  If the &quot;finally&quot; clause raises another exception, the saved\n&#039;
        &#039;exception is set as the context of the new exception. If the &#039;
        &#039;&quot;finally&quot;\n&#039;
        &#039;clause executes a &quot;return&quot; or &quot;break&quot; statement, the saved exception\n&#039;
        &#039;is discarded:\n&#039;
        &#039;\n&#039;
        &#039;   &gt;&gt;&gt; def f():\n&#039;
        &#039;   ...     try:\n&#039;
        &#039;   ...         1/0\n&#039;
        &#039;   ...     finally:\n&#039;
        &#039;   ...         return 42\n&#039;
        &#039;   ...\n&#039;
        &#039;   &gt;&gt;&gt; f()\n&#039;
        &#039;   42\n&#039;
        &#039;\n&#039;
        &#039;The exception information is not available to the program during\n&#039;
        &#039;execution of the &quot;finally&quot; clause.\n&#039;
        &#039;\n&#039;
        &#039;When a &quot;return&quot;, &quot;break&quot; or &quot;continue&quot; statement is executed in the\n&#039;
        &#039;&quot;try&quot; suite of a &quot;try&quot;…&quot;finally&quot; statement, the &quot;finally&quot; clause is\n&#039;
        &#039;also executed ‘on the way out.’ A &quot;continue&quot; statement is illegal in\n&#039;
        &#039;the &quot;finally&quot; clause. (The reason is a problem with the current\n&#039;
        &#039;implementation — this restriction may be lifted in the future).\n&#039;
        &#039;\n&#039;
        &#039;The return value of a function is determined by the last &quot;return&quot;\n&#039;
        &#039;statement executed.  Since the &quot;finally&quot; clause always executes, a\n&#039;
        &#039;&quot;return&quot; statement executed in the &quot;finally&quot; clause will always be &#039;
        &#039;the\n&#039;
        &#039;last one executed:\n&#039;
        &#039;\n&#039;
        &#039;   &gt;&gt;&gt; def foo():\n&#039;
        &#039;   ...     try:\n&#039;
        &quot;   ...         return &#039;try&#039;\n&quot;
        &#039;   ...     finally:\n&#039;
        &quot;   ...         return &#039;finally&#039;\n&quot;
        &#039;   ...\n&#039;
        &#039;   &gt;&gt;&gt; foo()\n&#039;
        &quot;   &#039;finally&#039;\n&quot;
        &#039;\n&#039;
        &#039;Additional information on exceptions can be found in section\n&#039;
        &#039;Exceptions, and information on using the &quot;raise&quot; statement to &#039;
        &#039;generate\n&#039;
        &#039;exceptions may be found in section The raise statement.\n&#039;,
 &#039;types&#039;: &#039;The standard type hierarchy\n&#039;
          &#039;***************************\n&#039;
          &#039;\n&#039;
          &#039;Below is a list of the types that are built into Python.  &#039;
          &#039;Extension\n&#039;
          &#039;modules (written in C, Java, or other languages, depending on the\n&#039;
          &#039;implementation) can define additional types.  Future versions of\n&#039;
          &#039;Python may add types to the type hierarchy (e.g., rational &#039;
          &#039;numbers,\n&#039;
          &#039;efficiently stored arrays of integers, etc.), although such &#039;
          &#039;additions\n&#039;
          &#039;will often be provided via the standard library instead.\n&#039;
          &#039;\n&#039;
          &#039;Some of the type descriptions below contain a paragraph listing\n&#039;
          &#039;‘special attributes.’  These are attributes that provide access to &#039;
          &#039;the\n&#039;
          &#039;implementation and are not intended for general use.  Their &#039;
          &#039;definition\n&#039;
          &#039;may change in the future.\n&#039;
          &#039;\n&#039;
          &#039;None\n&#039;
          &#039;   This type has a single value.  There is a single object with &#039;
          &#039;this\n&#039;
          &#039;   value. This object is accessed through the built-in name &quot;None&quot;. &#039;
          &#039;It\n&#039;
          &#039;   is used to signify the absence of a value in many situations, &#039;
          &#039;e.g.,\n&#039;
          &#039;   it is returned from functions that don’t explicitly return\n&#039;
          &#039;   anything. Its truth value is false.\n&#039;
          &#039;\n&#039;
          &#039;NotImplemented\n&#039;
          &#039;   This type has a single value.  There is a single object with &#039;
          &#039;this\n&#039;
          &#039;   value. This object is accessed through the built-in name\n&#039;
          &#039;   &quot;NotImplemented&quot;. Numeric methods and rich comparison methods\n&#039;
          &#039;   should return this value if they do not implement the operation &#039;
          &#039;for\n&#039;
          &#039;   the operands provided.  (The interpreter will then try the\n&#039;
          &#039;   reflected operation, or some other fallback, depending on the\n&#039;
          &#039;   operator.)  Its truth value is true.\n&#039;
          &#039;\n&#039;
          &#039;   See Implementing the arithmetic operations for more details.\n&#039;
          &#039;\n&#039;
          &#039;Ellipsis\n&#039;
          &#039;   This type has a single value.  There is a single object with &#039;
          &#039;this\n&#039;
          &#039;   value. This object is accessed through the literal &quot;...&quot; or the\n&#039;
          &#039;   built-in name &quot;Ellipsis&quot;.  Its truth value is true.\n&#039;
          &#039;\n&#039;
          &#039;&quot;numbers.Number&quot;\n&#039;
          &#039;   These are created by numeric literals and returned as results &#039;
          &#039;by\n&#039;
          &#039;   arithmetic operators and arithmetic built-in functions.  &#039;
          &#039;Numeric\n&#039;
          &#039;   objects are immutable; once created their value never changes.\n&#039;
          &#039;   Python numbers are of course strongly related to mathematical\n&#039;
          &#039;   numbers, but subject to the limitations of numerical &#039;
          &#039;representation\n&#039;
          &#039;   in computers.\n&#039;
          &#039;\n&#039;
          &#039;   Python distinguishes between integers, floating point numbers, &#039;
          &#039;and\n&#039;
          &#039;   complex numbers:\n&#039;
          &#039;\n&#039;
          &#039;   &quot;numbers.Integral&quot;\n&#039;
          &#039;      These represent elements from the mathematical set of &#039;
          &#039;integers\n&#039;
          &#039;      (positive and negative).\n&#039;
          &#039;\n&#039;
          &#039;      There are two types of integers:\n&#039;
          &#039;\n&#039;
          &#039;      Integers (&quot;int&quot;)\n&#039;
          &#039;\n&#039;
          &#039;         These represent numbers in an unlimited range, subject to\n&#039;
          &#039;         available (virtual) memory only.  For the purpose of &#039;
          &#039;shift\n&#039;
          &#039;         and mask operations, a binary representation is assumed, &#039;
          &#039;and\n&#039;
          &#039;         negative numbers are represented in a variant of 2’s\n&#039;
          &#039;         complement which gives the illusion of an infinite string &#039;
          &#039;of\n&#039;
          &#039;         sign bits extending to the left.\n&#039;
          &#039;\n&#039;
          &#039;      Booleans (&quot;bool&quot;)\n&#039;
          &#039;         These represent the truth values False and True.  The two\n&#039;
          &#039;         objects representing the values &quot;False&quot; and &quot;True&quot; are &#039;
          &#039;the\n&#039;
          &#039;         only Boolean objects. The Boolean type is a subtype of &#039;
          &#039;the\n&#039;
          &#039;         integer type, and Boolean values behave like the values 0 &#039;
          &#039;and\n&#039;
          &#039;         1, respectively, in almost all contexts, the exception &#039;
          &#039;being\n&#039;
          &#039;         that when converted to a string, the strings &quot;&quot;False&quot;&quot; or\n&#039;
          &#039;         &quot;&quot;True&quot;&quot; are returned, respectively.\n&#039;
          &#039;\n&#039;
          &#039;      The rules for integer representation are intended to give &#039;
          &#039;the\n&#039;
          &#039;      most meaningful interpretation of shift and mask operations\n&#039;
          &#039;      involving negative integers.\n&#039;
          &#039;\n&#039;
          &#039;   &quot;numbers.Real&quot; (&quot;float&quot;)\n&#039;
          &#039;      These represent machine-level double precision floating &#039;
          &#039;point\n&#039;
          &#039;      numbers. You are at the mercy of the underlying machine\n&#039;
          &#039;      architecture (and C or Java implementation) for the accepted\n&#039;
          &#039;      range and handling of overflow. Python does not support &#039;
          &#039;single-\n&#039;
          &#039;      precision floating point numbers; the savings in processor &#039;
          &#039;and\n&#039;
          &#039;      memory usage that are usually the reason for using these are\n&#039;
          &#039;      dwarfed by the overhead of using objects in Python, so there &#039;
          &#039;is\n&#039;
          &#039;      no reason to complicate the language with two kinds of &#039;
          &#039;floating\n&#039;
          &#039;      point numbers.\n&#039;
          &#039;\n&#039;
          &#039;   &quot;numbers.Complex&quot; (&quot;complex&quot;)\n&#039;
          &#039;      These represent complex numbers as a pair of machine-level\n&#039;
          &#039;      double precision floating point numbers.  The same caveats &#039;
          &#039;apply\n&#039;
          &#039;      as for floating point numbers. The real and imaginary parts &#039;
          &#039;of a\n&#039;
          &#039;      complex number &quot;z&quot; can be retrieved through the read-only\n&#039;
          &#039;      attributes &quot;z.real&quot; and &quot;z.imag&quot;.\n&#039;
          &#039;\n&#039;
          &#039;Sequences\n&#039;
          &#039;   These represent finite ordered sets indexed by non-negative\n&#039;
          &#039;   numbers. The built-in function &quot;len()&quot; returns the number of &#039;
          &#039;items\n&#039;
          &#039;   of a sequence. When the length of a sequence is *n*, the index &#039;
          &#039;set\n&#039;
          &#039;   contains the numbers 0, 1, …, *n*-1.  Item *i* of sequence *a* &#039;
          &#039;is\n&#039;
          &#039;   selected by &quot;a[i]&quot;.\n&#039;
          &#039;\n&#039;
          &#039;   Sequences also support slicing: &quot;a[i:j]&quot; selects all items with\n&#039;
          &#039;   index *k* such that *i* &quot;&lt;=&quot; *k* &quot;&lt;&quot; *j*.  When used as an\n&#039;
          &#039;   expression, a slice is a sequence of the same type.  This &#039;
          &#039;implies\n&#039;
          &#039;   that the index set is renumbered so that it starts at 0.\n&#039;
          &#039;\n&#039;
          &#039;   Some sequences also support “extended slicing” with a third &#039;
          &#039;“step”\n&#039;
          &#039;   parameter: &quot;a[i:j:k]&quot; selects all items of *a* with index *x* &#039;
          &#039;where\n&#039;
          &#039;   &quot;x = i + n*k&quot;, *n* &quot;&gt;=&quot; &quot;0&quot; and *i* &quot;&lt;=&quot; *x* &quot;&lt;&quot; *j*.\n&#039;
          &#039;\n&#039;
          &#039;   Sequences are distinguished according to their mutability:\n&#039;
          &#039;\n&#039;
          &#039;   Immutable sequences\n&#039;
          &#039;      An object of an immutable sequence type cannot change once it &#039;
          &#039;is\n&#039;
          &#039;      created.  (If the object contains references to other &#039;
          &#039;objects,\n&#039;
          &#039;      these other objects may be mutable and may be changed; &#039;
          &#039;however,\n&#039;
          &#039;      the collection of objects directly referenced by an &#039;
          &#039;immutable\n&#039;
          &#039;      object cannot change.)\n&#039;
          &#039;\n&#039;
          &#039;      The following types are immutable sequences:\n&#039;
          &#039;\n&#039;
          &#039;      Strings\n&#039;
          &#039;         A string is a sequence of values that represent Unicode &#039;
          &#039;code\n&#039;
          &#039;         points. All the code points in the range &quot;U+0000 - &#039;
          &#039;U+10FFFF&quot;\n&#039;
          &#039;         can be represented in a string.  Python doesn’t have a &#039;
          &#039;&quot;char&quot;\n&#039;
          &#039;         type; instead, every code point in the string is &#039;
          &#039;represented\n&#039;
          &#039;         as a string object with length &quot;1&quot;.  The built-in &#039;
          &#039;function\n&#039;
          &#039;         &quot;ord()&quot; converts a code point from its string form to an\n&#039;
          &#039;         integer in the range &quot;0 - 10FFFF&quot;; &quot;chr()&quot; converts an\n&#039;
          &#039;         integer in the range &quot;0 - 10FFFF&quot; to the corresponding &#039;
          &#039;length\n&#039;
          &#039;         &quot;1&quot; string object. &quot;str.encode()&quot; can be used to convert &#039;
          &#039;a\n&#039;
          &#039;         &quot;str&quot; to &quot;bytes&quot; using the given text encoding, and\n&#039;
          &#039;         &quot;bytes.decode()&quot; can be used to achieve the opposite.\n&#039;
          &#039;\n&#039;
          &#039;      Tuples\n&#039;
          &#039;         The items of a tuple are arbitrary Python objects. Tuples &#039;
          &#039;of\n&#039;
          &#039;         two or more items are formed by comma-separated lists of\n&#039;
          &#039;         expressions.  A tuple of one item (a ‘singleton’) can be\n&#039;
          &#039;         formed by affixing a comma to an expression (an expression &#039;
          &#039;by\n&#039;
          &#039;         itself does not create a tuple, since parentheses must be\n&#039;
          &#039;         usable for grouping of expressions).  An empty tuple can &#039;
          &#039;be\n&#039;
          &#039;         formed by an empty pair of parentheses.\n&#039;
          &#039;\n&#039;
          &#039;      Bytes\n&#039;
          &#039;         A bytes object is an immutable array.  The items are &#039;
          &#039;8-bit\n&#039;
          &#039;         bytes, represented by integers in the range 0 &lt;= x &lt; 256.\n&#039;
          &#039;         Bytes literals (like &quot;b\&#039;abc\&#039;&quot;) and the built-in &#039;
          &#039;&quot;bytes()&quot;\n&#039;
          &#039;         constructor can be used to create bytes objects.  Also, &#039;
          &#039;bytes\n&#039;
          &#039;         objects can be decoded to strings via the &quot;decode()&quot; &#039;
          &#039;method.\n&#039;
          &#039;\n&#039;
          &#039;   Mutable sequences\n&#039;
          &#039;      Mutable sequences can be changed after they are created.  &#039;
          &#039;The\n&#039;
          &#039;      subscription and slicing notations can be used as the target &#039;
          &#039;of\n&#039;
          &#039;      assignment and &quot;del&quot; (delete) statements.\n&#039;
          &#039;\n&#039;
          &#039;      There are currently two intrinsic mutable sequence types:\n&#039;
          &#039;\n&#039;
          &#039;      Lists\n&#039;
          &#039;         The items of a list are arbitrary Python objects.  Lists &#039;
          &#039;are\n&#039;
          &#039;         formed by placing a comma-separated list of expressions &#039;
          &#039;in\n&#039;
          &#039;         square brackets. (Note that there are no special cases &#039;
          &#039;needed\n&#039;
          &#039;         to form lists of length 0 or 1.)\n&#039;
          &#039;\n&#039;
          &#039;      Byte Arrays\n&#039;
          &#039;         A bytearray object is a mutable array. They are created &#039;
          &#039;by\n&#039;
          &#039;         the built-in &quot;bytearray()&quot; constructor.  Aside from being\n&#039;
          &#039;         mutable (and hence unhashable), byte arrays otherwise &#039;
          &#039;provide\n&#039;
          &#039;         the same interface and functionality as immutable &quot;bytes&quot;\n&#039;
          &#039;         objects.\n&#039;
          &#039;\n&#039;
          &#039;      The extension module &quot;array&quot; provides an additional example &#039;
          &#039;of a\n&#039;
          &#039;      mutable sequence type, as does the &quot;collections&quot; module.\n&#039;
          &#039;\n&#039;
          &#039;Set types\n&#039;
          &#039;   These represent unordered, finite sets of unique, immutable\n&#039;
          &#039;   objects. As such, they cannot be indexed by any subscript. &#039;
          &#039;However,\n&#039;
          &#039;   they can be iterated over, and the built-in function &quot;len()&quot;\n&#039;
          &#039;   returns the number of items in a set. Common uses for sets are &#039;
          &#039;fast\n&#039;
          &#039;   membership testing, removing duplicates from a sequence, and\n&#039;
          &#039;   computing mathematical operations such as intersection, union,\n&#039;
          &#039;   difference, and symmetric difference.\n&#039;
          &#039;\n&#039;
          &#039;   For set elements, the same immutability rules apply as for\n&#039;
          &#039;   dictionary keys. Note that numeric types obey the normal rules &#039;
          &#039;for\n&#039;
          &#039;   numeric comparison: if two numbers compare equal (e.g., &quot;1&quot; and\n&#039;
          &#039;   &quot;1.0&quot;), only one of them can be contained in a set.\n&#039;
          &#039;\n&#039;
          &#039;   There are currently two intrinsic set types:\n&#039;
          &#039;\n&#039;
          &#039;   Sets\n&#039;
          &#039;      These represent a mutable set. They are created by the &#039;
          &#039;built-in\n&#039;
          &#039;      &quot;set()&quot; constructor and can be modified afterwards by &#039;
          &#039;several\n&#039;
          &#039;      methods, such as &quot;add()&quot;.\n&#039;
          &#039;\n&#039;
          &#039;   Frozen sets\n&#039;
          &#039;      These represent an immutable set.  They are created by the\n&#039;
          &#039;      built-in &quot;frozenset()&quot; constructor.  As a frozenset is &#039;
          &#039;immutable\n&#039;
          &#039;      and *hashable*, it can be used again as an element of &#039;
          &#039;another\n&#039;
          &#039;      set, or as a dictionary key.\n&#039;
          &#039;\n&#039;
          &#039;Mappings\n&#039;
          &#039;   These represent finite sets of objects indexed by arbitrary &#039;
          &#039;index\n&#039;
          &#039;   sets. The subscript notation &quot;a[k]&quot; selects the item indexed by &#039;
          &#039;&quot;k&quot;\n&#039;
          &#039;   from the mapping &quot;a&quot;; this can be used in expressions and as &#039;
          &#039;the\n&#039;
          &#039;   target of assignments or &quot;del&quot; statements. The built-in &#039;
          &#039;function\n&#039;
          &#039;   &quot;len()&quot; returns the number of items in a mapping.\n&#039;
          &#039;\n&#039;
          &#039;   There is currently a single intrinsic mapping type:\n&#039;
          &#039;\n&#039;
          &#039;   Dictionaries\n&#039;
          &#039;      These represent finite sets of objects indexed by nearly\n&#039;
          &#039;      arbitrary values.  The only types of values not acceptable &#039;
          &#039;as\n&#039;
          &#039;      keys are values containing lists or dictionaries or other\n&#039;
          &#039;      mutable types that are compared by value rather than by &#039;
          &#039;object\n&#039;
          &#039;      identity, the reason being that the efficient implementation &#039;
          &#039;of\n&#039;
          &#039;      dictionaries requires a key’s hash value to remain constant.\n&#039;
          &#039;      Numeric types used for keys obey the normal rules for &#039;
          &#039;numeric\n&#039;
          &#039;      comparison: if two numbers compare equal (e.g., &quot;1&quot; and &#039;
          &#039;&quot;1.0&quot;)\n&#039;
          &#039;      then they can be used interchangeably to index the same\n&#039;
          &#039;      dictionary entry.\n&#039;
          &#039;\n&#039;
          &#039;      Dictionaries are mutable; they can be created by the &quot;{...}&quot;\n&#039;
          &#039;      notation (see section Dictionary displays).\n&#039;
          &#039;\n&#039;
          &#039;      The extension modules &quot;dbm.ndbm&quot; and &quot;dbm.gnu&quot; provide\n&#039;
          &#039;      additional examples of mapping types, as does the &#039;
          &#039;&quot;collections&quot;\n&#039;
          &#039;      module.\n&#039;
          &#039;\n&#039;
          &#039;Callable types\n&#039;
          &#039;   These are the types to which the function call operation (see\n&#039;
          &#039;   section Calls) can be applied:\n&#039;
          &#039;\n&#039;
          &#039;   User-defined functions\n&#039;
          &#039;      A user-defined function object is created by a function\n&#039;
          &#039;      definition (see section Function definitions).  It should be\n&#039;
          &#039;      called with an argument list containing the same number of &#039;
          &#039;items\n&#039;
          &#039;      as the function’s formal parameter list.\n&#039;
          &#039;\n&#039;
          &#039;      Special attributes:\n&#039;
          &#039;\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | Attribute                 | Meaning                         &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+===========================+=================================+=============+\n&#039;
          &#039;      | &quot;__doc__&quot;                 | The function’s documentation    &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | string, or &quot;None&quot; if            &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | unavailable; not inherited by   &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | subclasses                      &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__name__&quot;                | The function’s name             &#039;
          &#039;| Writable    |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__qualname__&quot;            | The function’s *qualified name* &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | New in version 3.3.             &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__module__&quot;              | The name of the module the      &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | function was defined in, or     &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | &quot;None&quot; if unavailable.          &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__defaults__&quot;            | A tuple containing default      &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | argument values for those       &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | arguments that have defaults,   &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | or &quot;None&quot; if no arguments have  &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | a default value                 &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__code__&quot;                | The code object representing    &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | the compiled function body.     &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__globals__&quot;             | A reference to the dictionary   &#039;
          &#039;| Read-only   |\n&#039;
          &#039;      |                           | that holds the function’s       &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | global variables — the global   &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | namespace of the module in      &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | which the function was defined. &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__dict__&quot;                | The namespace supporting        &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | arbitrary function attributes.  &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__closure__&quot;             | &quot;None&quot; or a tuple of cells that &#039;
          &#039;| Read-only   |\n&#039;
          &#039;      |                           | contain bindings for the        &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | function’s free variables.      &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__annotations__&quot;         | A dict containing annotations   &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | of parameters.  The keys of the &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | dict are the parameter names,   &#039;
          &#039;|             |\n&#039;
          &#039;      |                           | and &quot;\&#039;return\&#039;&quot; for the &#039;
          &#039;return   |             |\n&#039;
          &#039;      |                           | annotation, if provided.        &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__kwdefaults__&quot;          | A dict containing defaults for  &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                           | keyword-only parameters.        &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+---------------------------+---------------------------------+-------------+\n&#039;
          &#039;\n&#039;
          &#039;      Most of the attributes labelled “Writable” check the type of &#039;
          &#039;the\n&#039;
          &#039;      assigned value.\n&#039;
          &#039;\n&#039;
          &#039;      Function objects also support getting and setting arbitrary\n&#039;
          &#039;      attributes, which can be used, for example, to attach &#039;
          &#039;metadata\n&#039;
          &#039;      to functions.  Regular attribute dot-notation is used to get &#039;
          &#039;and\n&#039;
          &#039;      set such attributes. *Note that the current implementation &#039;
          &#039;only\n&#039;
          &#039;      supports function attributes on user-defined functions. &#039;
          &#039;Function\n&#039;
          &#039;      attributes on built-in functions may be supported in the\n&#039;
          &#039;      future.*\n&#039;
          &#039;\n&#039;
          &#039;      Additional information about a function’s definition can be\n&#039;
          &#039;      retrieved from its code object; see the description of &#039;
          &#039;internal\n&#039;
          &#039;      types below.\n&#039;
          &#039;\n&#039;
          &#039;   Instance methods\n&#039;
          &#039;      An instance method object combines a class, a class instance &#039;
          &#039;and\n&#039;
          &#039;      any callable object (normally a user-defined function).\n&#039;
          &#039;\n&#039;
          &#039;      Special read-only attributes: &quot;__self__&quot; is the class &#039;
          &#039;instance\n&#039;
          &#039;      object, &quot;__func__&quot; is the function object; &quot;__doc__&quot; is the\n&#039;
          &#039;      method’s documentation (same as &quot;__func__.__doc__&quot;); &#039;
          &#039;&quot;__name__&quot;\n&#039;
          &#039;      is the method name (same as &quot;__func__.__name__&quot;); &#039;
          &#039;&quot;__module__&quot;\n&#039;
          &#039;      is the name of the module the method was defined in, or &#039;
          &#039;&quot;None&quot;\n&#039;
          &#039;      if unavailable.\n&#039;
          &#039;\n&#039;
          &#039;      Methods also support accessing (but not setting) the &#039;
          &#039;arbitrary\n&#039;
          &#039;      function attributes on the underlying function object.\n&#039;
          &#039;\n&#039;
          &#039;      User-defined method objects may be created when getting an\n&#039;
          &#039;      attribute of a class (perhaps via an instance of that class), &#039;
          &#039;if\n&#039;
          &#039;      that attribute is a user-defined function object or a class\n&#039;
          &#039;      method object.\n&#039;
          &#039;\n&#039;
          &#039;      When an instance method object is created by retrieving a &#039;
          &#039;user-\n&#039;
          &#039;      defined function object from a class via one of its &#039;
          &#039;instances,\n&#039;
          &#039;      its &quot;__self__&quot; attribute is the instance, and the method &#039;
          &#039;object\n&#039;
          &#039;      is said to be bound.  The new method’s &quot;__func__&quot; attribute &#039;
          &#039;is\n&#039;
          &#039;      the original function object.\n&#039;
          &#039;\n&#039;
          &#039;      When a user-defined method object is created by retrieving\n&#039;
          &#039;      another method object from a class or instance, the behaviour &#039;
          &#039;is\n&#039;
          &#039;      the same as for a function object, except that the &#039;
          &#039;&quot;__func__&quot;\n&#039;
          &#039;      attribute of the new instance is not the original method &#039;
          &#039;object\n&#039;
          &#039;      but its &quot;__func__&quot; attribute.\n&#039;
          &#039;\n&#039;
          &#039;      When an instance method object is created by retrieving a &#039;
          &#039;class\n&#039;
          &#039;      method object from a class or instance, its &quot;__self__&quot; &#039;
          &#039;attribute\n&#039;
          &#039;      is the class itself, and its &quot;__func__&quot; attribute is the\n&#039;
          &#039;      function object underlying the class method.\n&#039;
          &#039;\n&#039;
          &#039;      When an instance method object is called, the underlying\n&#039;
          &#039;      function (&quot;__func__&quot;) is called, inserting the class &#039;
          &#039;instance\n&#039;
          &#039;      (&quot;__self__&quot;) in front of the argument list.  For instance, &#039;
          &#039;when\n&#039;
          &#039;      &quot;C&quot; is a class which contains a definition for a function &#039;
          &#039;&quot;f()&quot;,\n&#039;
          &#039;      and &quot;x&quot; is an instance of &quot;C&quot;, calling &quot;x.f(1)&quot; is equivalent &#039;
          &#039;to\n&#039;
          &#039;      calling &quot;C.f(x, 1)&quot;.\n&#039;
          &#039;\n&#039;
          &#039;      When an instance method object is derived from a class &#039;
          &#039;method\n&#039;
          &#039;      object, the “class instance” stored in &quot;__self__&quot; will &#039;
          &#039;actually\n&#039;
          &#039;      be the class itself, so that calling either &quot;x.f(1)&quot; or &#039;
          &#039;&quot;C.f(1)&quot;\n&#039;
          &#039;      is equivalent to calling &quot;f(C,1)&quot; where &quot;f&quot; is the &#039;
          &#039;underlying\n&#039;
          &#039;      function.\n&#039;
          &#039;\n&#039;
          &#039;      Note that the transformation from function object to &#039;
          &#039;instance\n&#039;
          &#039;      method object happens each time the attribute is retrieved &#039;
          &#039;from\n&#039;
          &#039;      the instance.  In some cases, a fruitful optimization is to\n&#039;
          &#039;      assign the attribute to a local variable and call that local\n&#039;
          &#039;      variable. Also notice that this transformation only happens &#039;
          &#039;for\n&#039;
          &#039;      user-defined functions; other callable objects (and all non-\n&#039;
          &#039;      callable objects) are retrieved without transformation.  It &#039;
          &#039;is\n&#039;
          &#039;      also important to note that user-defined functions which are\n&#039;
          &#039;      attributes of a class instance are not converted to bound\n&#039;
          &#039;      methods; this *only* happens when the function is an &#039;
          &#039;attribute\n&#039;
          &#039;      of the class.\n&#039;
          &#039;\n&#039;
          &#039;   Generator functions\n&#039;
          &#039;      A function or method which uses the &quot;yield&quot; statement (see\n&#039;
          &#039;      section The yield statement) is called a *generator &#039;
          &#039;function*.\n&#039;
          &#039;      Such a function, when called, always returns an iterator &#039;
          &#039;object\n&#039;
          &#039;      which can be used to execute the body of the function:  &#039;
          &#039;calling\n&#039;
          &#039;      the iterator’s &quot;iterator.__next__()&quot; method will cause the\n&#039;
          &#039;      function to execute until it provides a value using the &#039;
          &#039;&quot;yield&quot;\n&#039;
          &#039;      statement.  When the function executes a &quot;return&quot; statement &#039;
          &#039;or\n&#039;
          &#039;      falls off the end, a &quot;StopIteration&quot; exception is raised and &#039;
          &#039;the\n&#039;
          &#039;      iterator will have reached the end of the set of values to &#039;
          &#039;be\n&#039;
          &#039;      returned.\n&#039;
          &#039;\n&#039;
          &#039;   Coroutine functions\n&#039;
          &#039;      A function or method which is defined using &quot;async def&quot; is\n&#039;
          &#039;      called a *coroutine function*.  Such a function, when &#039;
          &#039;called,\n&#039;
          &#039;      returns a *coroutine* object.  It may contain &quot;await&quot;\n&#039;
          &#039;      expressions, as well as &quot;async with&quot; and &quot;async for&quot; &#039;
          &#039;statements.\n&#039;
          &#039;      See also the Coroutine Objects section.\n&#039;
          &#039;\n&#039;
          &#039;   Asynchronous generator functions\n&#039;
          &#039;      A function or method which is defined using &quot;async def&quot; and\n&#039;
          &#039;      which uses the &quot;yield&quot; statement is called a *asynchronous\n&#039;
          &#039;      generator function*.  Such a function, when called, returns &#039;
          &#039;an\n&#039;
          &#039;      asynchronous iterator object which can be used in an &quot;async &#039;
          &#039;for&quot;\n&#039;
          &#039;      statement to execute the body of the function.\n&#039;
          &#039;\n&#039;
          &#039;      Calling the asynchronous iterator’s &quot;aiterator.__anext__()&quot;\n&#039;
          &#039;      method will return an *awaitable* which when awaited will\n&#039;
          &#039;      execute until it provides a value using the &quot;yield&quot; &#039;
          &#039;expression.\n&#039;
          &#039;      When the function executes an empty &quot;return&quot; statement or &#039;
          &#039;falls\n&#039;
          &#039;      off the end, a &quot;StopAsyncIteration&quot; exception is raised and &#039;
          &#039;the\n&#039;
          &#039;      asynchronous iterator will have reached the end of the set &#039;
          &#039;of\n&#039;
          &#039;      values to be yielded.\n&#039;
          &#039;\n&#039;
          &#039;   Built-in functions\n&#039;
          &#039;      A built-in function object is a wrapper around a C function.\n&#039;
          &#039;      Examples of built-in functions are &quot;len()&quot; and &quot;math.sin()&quot;\n&#039;
          &#039;      (&quot;math&quot; is a standard built-in module). The number and type &#039;
          &#039;of\n&#039;
          &#039;      the arguments are determined by the C function. Special &#039;
          &#039;read-\n&#039;
          &#039;      only attributes: &quot;__doc__&quot; is the function’s documentation\n&#039;
          &#039;      string, or &quot;None&quot; if unavailable; &quot;__name__&quot; is the &#039;
          &#039;function’s\n&#039;
          &#039;      name; &quot;__self__&quot; is set to &quot;None&quot; (but see the next item);\n&#039;
          &#039;      &quot;__module__&quot; is the name of the module the function was &#039;
          &#039;defined\n&#039;
          &#039;      in or &quot;None&quot; if unavailable.\n&#039;
          &#039;\n&#039;
          &#039;   Built-in methods\n&#039;
          &#039;      This is really a different disguise of a built-in function, &#039;
          &#039;this\n&#039;
          &#039;      time containing an object passed to the C function as an\n&#039;
          &#039;      implicit extra argument.  An example of a built-in method is\n&#039;
          &#039;      &quot;alist.append()&quot;, assuming *alist* is a list object. In this\n&#039;
          &#039;      case, the special read-only attribute &quot;__self__&quot; is set to &#039;
          &#039;the\n&#039;
          &#039;      object denoted by *alist*.\n&#039;
          &#039;\n&#039;
          &#039;   Classes\n&#039;
          &#039;      Classes are callable.  These objects normally act as &#039;
          &#039;factories\n&#039;
          &#039;      for new instances of themselves, but variations are possible &#039;
          &#039;for\n&#039;
          &#039;      class types that override &quot;__new__()&quot;.  The arguments of the\n&#039;
          &#039;      call are passed to &quot;__new__()&quot; and, in the typical case, to\n&#039;
          &#039;      &quot;__init__()&quot; to initialize the new instance.\n&#039;
          &#039;\n&#039;
          &#039;   Class Instances\n&#039;
          &#039;      Instances of arbitrary classes can be made callable by &#039;
          &#039;defining\n&#039;
          &#039;      a &quot;__call__()&quot; method in their class.\n&#039;
          &#039;\n&#039;
          &#039;Modules\n&#039;
          &#039;   Modules are a basic organizational unit of Python code, and are\n&#039;
          &#039;   created by the import system as invoked either by the &quot;import&quot;\n&#039;
          &#039;   statement (see &quot;import&quot;), or by calling functions such as\n&#039;
          &#039;   &quot;importlib.import_module()&quot; and built-in &quot;__import__()&quot;.  A &#039;
          &#039;module\n&#039;
          &#039;   object has a namespace implemented by a dictionary object (this &#039;
          &#039;is\n&#039;
          &#039;   the dictionary referenced by the &quot;__globals__&quot; attribute of\n&#039;
          &#039;   functions defined in the module).  Attribute references are\n&#039;
          &#039;   translated to lookups in this dictionary, e.g., &quot;m.x&quot; is &#039;
          &#039;equivalent\n&#039;
          &#039;   to &quot;m.__dict__[&quot;x&quot;]&quot;. A module object does not contain the code\n&#039;
          &#039;   object used to initialize the module (since it isn’t needed &#039;
          &#039;once\n&#039;
          &#039;   the initialization is done).\n&#039;
          &#039;\n&#039;
          &#039;   Attribute assignment updates the module’s namespace dictionary,\n&#039;
          &#039;   e.g., &quot;m.x = 1&quot; is equivalent to &quot;m.__dict__[&quot;x&quot;] = 1&quot;.\n&#039;
          &#039;\n&#039;
          &#039;   Predefined (writable) attributes: &quot;__name__&quot; is the module’s &#039;
          &#039;name;\n&#039;
          &#039;   &quot;__doc__&quot; is the module’s documentation string, or &quot;None&quot; if\n&#039;
          &#039;   unavailable; &quot;__annotations__&quot; (optional) is a dictionary\n&#039;
          &#039;   containing *variable annotations* collected during module body\n&#039;
          &#039;   execution; &quot;__file__&quot; is the pathname of the file from which &#039;
          &#039;the\n&#039;
          &#039;   module was loaded, if it was loaded from a file. The &quot;__file__&quot;\n&#039;
          &#039;   attribute may be missing for certain types of modules, such as &#039;
          &#039;C\n&#039;
          &#039;   modules that are statically linked into the interpreter; for\n&#039;
          &#039;   extension modules loaded dynamically from a shared library, it &#039;
          &#039;is\n&#039;
          &#039;   the pathname of the shared library file.\n&#039;
          &#039;\n&#039;
          &#039;   Special read-only attribute: &quot;__dict__&quot; is the module’s &#039;
          &#039;namespace\n&#039;
          &#039;   as a dictionary object.\n&#039;
          &#039;\n&#039;
          &#039;   **CPython implementation detail:** Because of the way CPython\n&#039;
          &#039;   clears module dictionaries, the module dictionary will be &#039;
          &#039;cleared\n&#039;
          &#039;   when the module falls out of scope even if the dictionary still &#039;
          &#039;has\n&#039;
          &#039;   live references.  To avoid this, copy the dictionary or keep &#039;
          &#039;the\n&#039;
          &#039;   module around while using its dictionary directly.\n&#039;
          &#039;\n&#039;
          &#039;Custom classes\n&#039;
          &#039;   Custom class types are typically created by class definitions &#039;
          &#039;(see\n&#039;
          &#039;   section Class definitions).  A class has a namespace implemented &#039;
          &#039;by\n&#039;
          &#039;   a dictionary object. Class attribute references are translated &#039;
          &#039;to\n&#039;
          &#039;   lookups in this dictionary, e.g., &quot;C.x&quot; is translated to\n&#039;
          &#039;   &quot;C.__dict__[&quot;x&quot;]&quot; (although there are a number of hooks which &#039;
          &#039;allow\n&#039;
          &#039;   for other means of locating attributes). When the attribute name &#039;
          &#039;is\n&#039;
          &#039;   not found there, the attribute search continues in the base\n&#039;
          &#039;   classes. This search of the base classes uses the C3 method\n&#039;
          &#039;   resolution order which behaves correctly even in the presence &#039;
          &#039;of\n&#039;
          &#039;   ‘diamond’ inheritance structures where there are multiple\n&#039;
          &#039;   inheritance paths leading back to a common ancestor. Additional\n&#039;
          &#039;   details on the C3 MRO used by Python can be found in the\n&#039;
          &#039;   documentation accompanying the 2.3 release at\n&#039;
          &#039;   https://www.python.org/download/releases/2.3/mro/.\n&#039;
          &#039;\n&#039;
          &#039;   When a class attribute reference (for class &quot;C&quot;, say) would &#039;
          &#039;yield a\n&#039;
          &#039;   class method object, it is transformed into an instance method\n&#039;
          &#039;   object whose &quot;__self__&quot; attribute is &quot;C&quot;.  When it would yield &#039;
          &#039;a\n&#039;
          &#039;   static method object, it is transformed into the object wrapped &#039;
          &#039;by\n&#039;
          &#039;   the static method object. See section Implementing Descriptors &#039;
          &#039;for\n&#039;
          &#039;   another way in which attributes retrieved from a class may &#039;
          &#039;differ\n&#039;
          &#039;   from those actually contained in its &quot;__dict__&quot;.\n&#039;
          &#039;\n&#039;
          &#039;   Class attribute assignments update the class’s dictionary, &#039;
          &#039;never\n&#039;
          &#039;   the dictionary of a base class.\n&#039;
          &#039;\n&#039;
          &#039;   A class object can be called (see above) to yield a class &#039;
          &#039;instance\n&#039;
          &#039;   (see below).\n&#039;
          &#039;\n&#039;
          &#039;   Special attributes: &quot;__name__&quot; is the class name; &quot;__module__&quot; &#039;
          &#039;is\n&#039;
          &#039;   the module name in which the class was defined; &quot;__dict__&quot; is &#039;
          &#039;the\n&#039;
          &#039;   dictionary containing the class’s namespace; &quot;__bases__&quot; is a &#039;
          &#039;tuple\n&#039;
          &#039;   containing the base classes, in the order of their occurrence &#039;
          &#039;in\n&#039;
          &#039;   the base class list; &quot;__doc__&quot; is the class’s documentation &#039;
          &#039;string,\n&#039;
          &#039;   or &quot;None&quot; if undefined; &quot;__annotations__&quot; (optional) is a\n&#039;
          &#039;   dictionary containing *variable annotations* collected during &#039;
          &#039;class\n&#039;
          &#039;   body execution.\n&#039;
          &#039;\n&#039;
          &#039;Class instances\n&#039;
          &#039;   A class instance is created by calling a class object (see &#039;
          &#039;above).\n&#039;
          &#039;   A class instance has a namespace implemented as a dictionary &#039;
          &#039;which\n&#039;
          &#039;   is the first place in which attribute references are searched.\n&#039;
          &#039;   When an attribute is not found there, and the instance’s class &#039;
          &#039;has\n&#039;
          &#039;   an attribute by that name, the search continues with the class\n&#039;
          &#039;   attributes.  If a class attribute is found that is a &#039;
          &#039;user-defined\n&#039;
          &#039;   function object, it is transformed into an instance method &#039;
          &#039;object\n&#039;
          &#039;   whose &quot;__self__&quot; attribute is the instance.  Static method and\n&#039;
          &#039;   class method objects are also transformed; see above under\n&#039;
          &#039;   “Classes”.  See section Implementing Descriptors for another way &#039;
          &#039;in\n&#039;
          &#039;   which attributes of a class retrieved via its instances may &#039;
          &#039;differ\n&#039;
          &#039;   from the objects actually stored in the class’s &quot;__dict__&quot;.  If &#039;
          &#039;no\n&#039;
          &#039;   class attribute is found, and the object’s class has a\n&#039;
          &#039;   &quot;__getattr__()&quot; method, that is called to satisfy the lookup.\n&#039;
          &#039;\n&#039;
          &#039;   Attribute assignments and deletions update the instance’s\n&#039;
          &#039;   dictionary, never a class’s dictionary.  If the class has a\n&#039;
          &#039;   &quot;__setattr__()&quot; or &quot;__delattr__()&quot; method, this is called &#039;
          &#039;instead\n&#039;
          &#039;   of updating the instance dictionary directly.\n&#039;
          &#039;\n&#039;
          &#039;   Class instances can pretend to be numbers, sequences, or &#039;
          &#039;mappings\n&#039;
          &#039;   if they have methods with certain special names.  See section\n&#039;
          &#039;   Special method names.\n&#039;
          &#039;\n&#039;
          &#039;   Special attributes: &quot;__dict__&quot; is the attribute dictionary;\n&#039;
          &#039;   &quot;__class__&quot; is the instance’s class.\n&#039;
          &#039;\n&#039;
          &#039;I/O objects (also known as file objects)\n&#039;
          &#039;   A *file object* represents an open file.  Various shortcuts are\n&#039;
          &#039;   available to create file objects: the &quot;open()&quot; built-in &#039;
          &#039;function,\n&#039;
          &#039;   and also &quot;os.popen()&quot;, &quot;os.fdopen()&quot;, and the &quot;makefile()&quot; &#039;
          &#039;method\n&#039;
          &#039;   of socket objects (and perhaps by other functions or methods\n&#039;
          &#039;   provided by extension modules).\n&#039;
          &#039;\n&#039;
          &#039;   The objects &quot;sys.stdin&quot;, &quot;sys.stdout&quot; and &quot;sys.stderr&quot; are\n&#039;
          &#039;   initialized to file objects corresponding to the interpreter’s\n&#039;
          &#039;   standard input, output and error streams; they are all open in &#039;
          &#039;text\n&#039;
          &#039;   mode and therefore follow the interface defined by the\n&#039;
          &#039;   &quot;io.TextIOBase&quot; abstract class.\n&#039;
          &#039;\n&#039;
          &#039;Internal types\n&#039;
          &#039;   A few types used internally by the interpreter are exposed to &#039;
          &#039;the\n&#039;
          &#039;   user. Their definitions may change with future versions of the\n&#039;
          &#039;   interpreter, but they are mentioned here for completeness.\n&#039;
          &#039;\n&#039;
          &#039;   Code objects\n&#039;
          &#039;      Code objects represent *byte-compiled* executable Python &#039;
          &#039;code,\n&#039;
          &#039;      or *bytecode*. The difference between a code object and a\n&#039;
          &#039;      function object is that the function object contains an &#039;
          &#039;explicit\n&#039;
          &#039;      reference to the function’s globals (the module in which it &#039;
          &#039;was\n&#039;
          &#039;      defined), while a code object contains no context; also the\n&#039;
          &#039;      default argument values are stored in the function object, &#039;
          &#039;not\n&#039;
          &#039;      in the code object (because they represent values calculated &#039;
          &#039;at\n&#039;
          &#039;      run-time).  Unlike function objects, code objects are &#039;
          &#039;immutable\n&#039;
          &#039;      and contain no references (directly or indirectly) to &#039;
          &#039;mutable\n&#039;
          &#039;      objects.\n&#039;
          &#039;\n&#039;
          &#039;      Special read-only attributes: &quot;co_name&quot; gives the function &#039;
          &#039;name;\n&#039;
          &#039;      &quot;co_argcount&quot; is the number of positional arguments &#039;
          &#039;(including\n&#039;
          &#039;      arguments with default values); &quot;co_nlocals&quot; is the number &#039;
          &#039;of\n&#039;
          &#039;      local variables used by the function (including arguments);\n&#039;
          &#039;      &quot;co_varnames&quot; is a tuple containing the names of the local\n&#039;
          &#039;      variables (starting with the argument names); &quot;co_cellvars&quot; &#039;
          &#039;is a\n&#039;
          &#039;      tuple containing the names of local variables that are\n&#039;
          &#039;      referenced by nested functions; &quot;co_freevars&quot; is a tuple\n&#039;
          &#039;      containing the names of free variables; &quot;co_code&quot; is a &#039;
          &#039;string\n&#039;
          &#039;      representing the sequence of bytecode instructions; &#039;
          &#039;&quot;co_consts&quot;\n&#039;
          &#039;      is a tuple containing the literals used by the bytecode;\n&#039;
          &#039;      &quot;co_names&quot; is a tuple containing the names used by the &#039;
          &#039;bytecode;\n&#039;
          &#039;      &quot;co_filename&quot; is the filename from which the code was &#039;
          &#039;compiled;\n&#039;
          &#039;      &quot;co_firstlineno&quot; is the first line number of the function;\n&#039;
          &#039;      &quot;co_lnotab&quot; is a string encoding the mapping from bytecode\n&#039;
          &#039;      offsets to line numbers (for details see the source code of &#039;
          &#039;the\n&#039;
          &#039;      interpreter); &quot;co_stacksize&quot; is the required stack size\n&#039;
          &#039;      (including local variables); &quot;co_flags&quot; is an integer &#039;
          &#039;encoding a\n&#039;
          &#039;      number of flags for the interpreter.\n&#039;
          &#039;\n&#039;
          &#039;      The following flag bits are defined for &quot;co_flags&quot;: bit &#039;
          &#039;&quot;0x04&quot;\n&#039;
          &#039;      is set if the function uses the &quot;*arguments&quot; syntax to accept &#039;
          &#039;an\n&#039;
          &#039;      arbitrary number of positional arguments; bit &quot;0x08&quot; is set &#039;
          &#039;if\n&#039;
          &#039;      the function uses the &quot;**keywords&quot; syntax to accept &#039;
          &#039;arbitrary\n&#039;
          &#039;      keyword arguments; bit &quot;0x20&quot; is set if the function is a\n&#039;
          &#039;      generator.\n&#039;
          &#039;\n&#039;
          &#039;      Future feature declarations (&quot;from __future__ import &#039;
          &#039;division&quot;)\n&#039;
          &#039;      also use bits in &quot;co_flags&quot; to indicate whether a code &#039;
          &#039;object\n&#039;
          &#039;      was compiled with a particular feature enabled: bit &quot;0x2000&quot; &#039;
          &#039;is\n&#039;
          &#039;      set if the function was compiled with future division &#039;
          &#039;enabled;\n&#039;
          &#039;      bits &quot;0x10&quot; and &quot;0x1000&quot; were used in earlier versions of\n&#039;
          &#039;      Python.\n&#039;
          &#039;\n&#039;
          &#039;      Other bits in &quot;co_flags&quot; are reserved for internal use.\n&#039;
          &#039;\n&#039;
          &#039;      If a code object represents a function, the first item in\n&#039;
          &#039;      &quot;co_consts&quot; is the documentation string of the function, or\n&#039;
          &#039;      &quot;None&quot; if undefined.\n&#039;
          &#039;\n&#039;
          &#039;   Frame objects\n&#039;
          &#039;      Frame objects represent execution frames.  They may occur in\n&#039;
          &#039;      traceback objects (see below).\n&#039;
          &#039;\n&#039;
          &#039;      Special read-only attributes: &quot;f_back&quot; is to the previous &#039;
          &#039;stack\n&#039;
          &#039;      frame (towards the caller), or &quot;None&quot; if this is the bottom\n&#039;
          &#039;      stack frame; &quot;f_code&quot; is the code object being executed in &#039;
          &#039;this\n&#039;
          &#039;      frame; &quot;f_locals&quot; is the dictionary used to look up local\n&#039;
          &#039;      variables; &quot;f_globals&quot; is used for global variables;\n&#039;
          &#039;      &quot;f_builtins&quot; is used for built-in (intrinsic) names; &#039;
          &#039;&quot;f_lasti&quot;\n&#039;
          &#039;      gives the precise instruction (this is an index into the\n&#039;
          &#039;      bytecode string of the code object).\n&#039;
          &#039;\n&#039;
          &#039;      Special writable attributes: &quot;f_trace&quot;, if not &quot;None&quot;, is a\n&#039;
          &#039;      function called at the start of each source code line (this &#039;
          &#039;is\n&#039;
          &#039;      used by the debugger); &quot;f_lineno&quot; is the current line number &#039;
          &#039;of\n&#039;
          &#039;      the frame — writing to this from within a trace function &#039;
          &#039;jumps\n&#039;
          &#039;      to the given line (only for the bottom-most frame).  A &#039;
          &#039;debugger\n&#039;
          &#039;      can implement a Jump command (aka Set Next Statement) by &#039;
          &#039;writing\n&#039;
          &#039;      to f_lineno.\n&#039;
          &#039;\n&#039;
          &#039;      Frame objects support one method:\n&#039;
          &#039;\n&#039;
          &#039;      frame.clear()\n&#039;
          &#039;\n&#039;
          &#039;         This method clears all references to local variables held &#039;
          &#039;by\n&#039;
          &#039;         the frame.  Also, if the frame belonged to a generator, &#039;
          &#039;the\n&#039;
          &#039;         generator is finalized.  This helps break reference &#039;
          &#039;cycles\n&#039;
          &#039;         involving frame objects (for example when catching an\n&#039;
          &#039;         exception and storing its traceback for later use).\n&#039;
          &#039;\n&#039;
          &#039;         &quot;RuntimeError&quot; is raised if the frame is currently &#039;
          &#039;executing.\n&#039;
          &#039;\n&#039;
          &#039;         New in version 3.4.\n&#039;
          &#039;\n&#039;
          &#039;   Traceback objects\n&#039;
          &#039;      Traceback objects represent a stack trace of an exception.  &#039;
          &#039;A\n&#039;
          &#039;      traceback object is created when an exception occurs.  When &#039;
          &#039;the\n&#039;
          &#039;      search for an exception handler unwinds the execution stack, &#039;
          &#039;at\n&#039;
          &#039;      each unwound level a traceback object is inserted in front &#039;
          &#039;of\n&#039;
          &#039;      the current traceback.  When an exception handler is &#039;
          &#039;entered,\n&#039;
          &#039;      the stack trace is made available to the program. (See &#039;
          &#039;section\n&#039;
          &#039;      The try statement.) It is accessible as the third item of &#039;
          &#039;the\n&#039;
          &#039;      tuple returned by &quot;sys.exc_info()&quot;. When the program contains &#039;
          &#039;no\n&#039;
          &#039;      suitable handler, the stack trace is written (nicely &#039;
          &#039;formatted)\n&#039;
          &#039;      to the standard error stream; if the interpreter is &#039;
          &#039;interactive,\n&#039;
          &#039;      it is also made available to the user as &#039;
          &#039;&quot;sys.last_traceback&quot;.\n&#039;
          &#039;\n&#039;
          &#039;      Special read-only attributes: &quot;tb_next&quot; is the next level in &#039;
          &#039;the\n&#039;
          &#039;      stack trace (towards the frame where the exception occurred), &#039;
          &#039;or\n&#039;
          &#039;      &quot;None&quot; if there is no next level; &quot;tb_frame&quot; points to the\n&#039;
          &#039;      execution frame of the current level; &quot;tb_lineno&quot; gives the &#039;
          &#039;line\n&#039;
          &#039;      number where the exception occurred; &quot;tb_lasti&quot; indicates &#039;
          &#039;the\n&#039;
          &#039;      precise instruction.  The line number and last instruction &#039;
          &#039;in\n&#039;
          &#039;      the traceback may differ from the line number of its frame\n&#039;
          &#039;      object if the exception occurred in a &quot;try&quot; statement with &#039;
          &#039;no\n&#039;
          &#039;      matching except clause or with a finally clause.\n&#039;
          &#039;\n&#039;
          &#039;   Slice objects\n&#039;
          &#039;      Slice objects are used to represent slices for &#039;
          &#039;&quot;__getitem__()&quot;\n&#039;
          &#039;      methods.  They are also created by the built-in &quot;slice()&quot;\n&#039;
          &#039;      function.\n&#039;
          &#039;\n&#039;
          &#039;      Special read-only attributes: &quot;start&quot; is the lower bound; &#039;
          &#039;&quot;stop&quot;\n&#039;
          &#039;      is the upper bound; &quot;step&quot; is the step value; each is &quot;None&quot; &#039;
          &#039;if\n&#039;
          &#039;      omitted.  These attributes can have any type.\n&#039;
          &#039;\n&#039;
          &#039;      Slice objects support one method:\n&#039;
          &#039;\n&#039;
          &#039;      slice.indices(self, length)\n&#039;
          &#039;\n&#039;
          &#039;         This method takes a single integer argument *length* and\n&#039;
          &#039;         computes information about the slice that the slice &#039;
          &#039;object\n&#039;
          &#039;         would describe if applied to a sequence of *length* &#039;
          &#039;items.\n&#039;
          &#039;         It returns a tuple of three integers; respectively these &#039;
          &#039;are\n&#039;
          &#039;         the *start* and *stop* indices and the *step* or stride\n&#039;
          &#039;         length of the slice. Missing or out-of-bounds indices are\n&#039;
          &#039;         handled in a manner consistent with regular slices.\n&#039;
          &#039;\n&#039;
          &#039;   Static method objects\n&#039;
          &#039;      Static method objects provide a way of defeating the\n&#039;
          &#039;      transformation of function objects to method objects &#039;
          &#039;described\n&#039;
          &#039;      above. A static method object is a wrapper around any other\n&#039;
          &#039;      object, usually a user-defined method object. When a static\n&#039;
          &#039;      method object is retrieved from a class or a class instance, &#039;
          &#039;the\n&#039;
          &#039;      object actually returned is the wrapped object, which is not\n&#039;
          &#039;      subject to any further transformation. Static method objects &#039;
          &#039;are\n&#039;
          &#039;      not themselves callable, although the objects they wrap &#039;
          &#039;usually\n&#039;
          &#039;      are. Static method objects are created by the built-in\n&#039;
          &#039;      &quot;staticmethod()&quot; constructor.\n&#039;
          &#039;\n&#039;
          &#039;   Class method objects\n&#039;
          &#039;      A class method object, like a static method object, is a &#039;
          &#039;wrapper\n&#039;
          &#039;      around another object that alters the way in which that &#039;
          &#039;object\n&#039;
          &#039;      is retrieved from classes and class instances. The behaviour &#039;
          &#039;of\n&#039;
          &#039;      class method objects upon such retrieval is described above,\n&#039;
          &#039;      under “User-defined methods”. Class method objects are &#039;
          &#039;created\n&#039;
          &#039;      by the built-in &quot;classmethod()&quot; constructor.\n&#039;,
 &#039;typesfunctions&#039;: &#039;Functions\n&#039;
                   &#039;*********\n&#039;
                   &#039;\n&#039;
                   &#039;Function objects are created by function definitions.  The &#039;
                   &#039;only\n&#039;
                   &#039;operation on a function object is to call it: &#039;
                   &#039;&quot;func(argument-list)&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;There are really two flavors of function objects: built-in &#039;
                   &#039;functions\n&#039;
                   &#039;and user-defined functions.  Both support the same &#039;
                   &#039;operation (to call\n&#039;
                   &#039;the function), but the implementation is different, hence &#039;
                   &#039;the\n&#039;
                   &#039;different object types.\n&#039;
                   &#039;\n&#039;
                   &#039;See Function definitions for more information.\n&#039;,
 &#039;typesmapping&#039;: &#039;Mapping Types — &quot;dict&quot;\n&#039;
                 &#039;**********************\n&#039;
                 &#039;\n&#039;
                 &#039;A *mapping* object maps *hashable* values to arbitrary &#039;
                 &#039;objects.\n&#039;
                 &#039;Mappings are mutable objects.  There is currently only one &#039;
                 &#039;standard\n&#039;
                 &#039;mapping type, the *dictionary*.  (For other containers see &#039;
                 &#039;the built-\n&#039;
                 &#039;in &quot;list&quot;, &quot;set&quot;, and &quot;tuple&quot; classes, and the &quot;collections&quot; &#039;
                 &#039;module.)\n&#039;
                 &#039;\n&#039;
                 &#039;A dictionary’s keys are *almost* arbitrary values.  Values &#039;
                 &#039;that are\n&#039;
                 &#039;not *hashable*, that is, values containing lists, &#039;
                 &#039;dictionaries or\n&#039;
                 &#039;other mutable types (that are compared by value rather than &#039;
                 &#039;by object\n&#039;
                 &#039;identity) may not be used as keys.  Numeric types used for &#039;
                 &#039;keys obey\n&#039;
                 &#039;the normal rules for numeric comparison: if two numbers &#039;
                 &#039;compare equal\n&#039;
                 &#039;(such as &quot;1&quot; and &quot;1.0&quot;) then they can be used &#039;
                 &#039;interchangeably to index\n&#039;
                 &#039;the same dictionary entry.  (Note however, that since &#039;
                 &#039;computers store\n&#039;
                 &#039;floating-point numbers as approximations it is usually &#039;
                 &#039;unwise to use\n&#039;
                 &#039;them as dictionary keys.)\n&#039;
                 &#039;\n&#039;
                 &#039;Dictionaries can be created by placing a comma-separated &#039;
                 &#039;list of &quot;key:\n&#039;
                 &#039;value&quot; pairs within braces, for example: &quot;{\&#039;jack\&#039;: 4098, &#039;
                 &quot;&#039;sjoerd&#039;:\n&quot;
                 &#039;4127}&quot; or &quot;{4098: \&#039;jack\&#039;, 4127: \&#039;sjoerd\&#039;}&quot;, or by the &#039;
                 &#039;&quot;dict&quot;\n&#039;
                 &#039;constructor.\n&#039;
                 &#039;\n&#039;
                 &#039;class dict(**kwarg)\n&#039;
                 &#039;class dict(mapping, **kwarg)\n&#039;
                 &#039;class dict(iterable, **kwarg)\n&#039;
                 &#039;\n&#039;
                 &#039;   Return a new dictionary initialized from an optional &#039;
                 &#039;positional\n&#039;
                 &#039;   argument and a possibly empty set of keyword arguments.\n&#039;
                 &#039;\n&#039;
                 &#039;   If no positional argument is given, an empty dictionary &#039;
                 &#039;is created.\n&#039;
                 &#039;   If a positional argument is given and it is a mapping &#039;
                 &#039;object, a\n&#039;
                 &#039;   dictionary is created with the same key-value pairs as &#039;
                 &#039;the mapping\n&#039;
                 &#039;   object.  Otherwise, the positional argument must be an &#039;
                 &#039;*iterable*\n&#039;
                 &#039;   object.  Each item in the iterable must itself be an &#039;
                 &#039;iterable with\n&#039;
                 &#039;   exactly two objects.  The first object of each item &#039;
                 &#039;becomes a key\n&#039;
                 &#039;   in the new dictionary, and the second object the &#039;
                 &#039;corresponding\n&#039;
                 &#039;   value.  If a key occurs more than once, the last value &#039;
                 &#039;for that key\n&#039;
                 &#039;   becomes the corresponding value in the new dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;   If keyword arguments are given, the keyword arguments and &#039;
                 &#039;their\n&#039;
                 &#039;   values are added to the dictionary created from the &#039;
                 &#039;positional\n&#039;
                 &#039;   argument.  If a key being added is already present, the &#039;
                 &#039;value from\n&#039;
                 &#039;   the keyword argument replaces the value from the &#039;
                 &#039;positional\n&#039;
                 &#039;   argument.\n&#039;
                 &#039;\n&#039;
                 &#039;   To illustrate, the following examples all return a &#039;
                 &#039;dictionary equal\n&#039;
                 &#039;   to &quot;{&quot;one&quot;: 1, &quot;two&quot;: 2, &quot;three&quot;: 3}&quot;:\n&#039;
                 &#039;\n&#039;
                 &#039;      &gt;&gt;&gt; a = dict(one=1, two=2, three=3)\n&#039;
                 &quot;      &gt;&gt;&gt; b = {&#039;one&#039;: 1, &#039;two&#039;: 2, &#039;three&#039;: 3}\n&quot;
                 &quot;      &gt;&gt;&gt; c = dict(zip([&#039;one&#039;, &#039;two&#039;, &#039;three&#039;], [1, 2, 3]))\n&quot;
                 &quot;      &gt;&gt;&gt; d = dict([(&#039;two&#039;, 2), (&#039;one&#039;, 1), (&#039;three&#039;, 3)])\n&quot;
                 &quot;      &gt;&gt;&gt; e = dict({&#039;three&#039;: 3, &#039;one&#039;: 1, &#039;two&#039;: 2})\n&quot;
                 &#039;      &gt;&gt;&gt; a == b == c == d == e\n&#039;
                 &#039;      True\n&#039;
                 &#039;\n&#039;
                 &#039;   Providing keyword arguments as in the first example only &#039;
                 &#039;works for\n&#039;
                 &#039;   keys that are valid Python identifiers.  Otherwise, any &#039;
                 &#039;valid keys\n&#039;
                 &#039;   can be used.\n&#039;
                 &#039;\n&#039;
                 &#039;   These are the operations that dictionaries support (and &#039;
                 &#039;therefore,\n&#039;
                 &#039;   custom mapping types should support too):\n&#039;
                 &#039;\n&#039;
                 &#039;   len(d)\n&#039;
                 &#039;\n&#039;
                 &#039;      Return the number of items in the dictionary *d*.\n&#039;
                 &#039;\n&#039;
                 &#039;   d[key]\n&#039;
                 &#039;\n&#039;
                 &#039;      Return the item of *d* with key *key*.  Raises a &#039;
                 &#039;&quot;KeyError&quot; if\n&#039;
                 &#039;      *key* is not in the map.\n&#039;
                 &#039;\n&#039;
                 &#039;      If a subclass of dict defines a method &quot;__missing__()&quot; &#039;
                 &#039;and *key*\n&#039;
                 &#039;      is not present, the &quot;d[key]&quot; operation calls that &#039;
                 &#039;method with\n&#039;
                 &#039;      the key *key* as argument.  The &quot;d[key]&quot; operation &#039;
                 &#039;then returns\n&#039;
                 &#039;      or raises whatever is returned or raised by the\n&#039;
                 &#039;      &quot;__missing__(key)&quot; call. No other operations or &#039;
                 &#039;methods invoke\n&#039;
                 &#039;      &quot;__missing__()&quot;. If &quot;__missing__()&quot; is not defined, &#039;
                 &#039;&quot;KeyError&quot;\n&#039;
                 &#039;      is raised. &quot;__missing__()&quot; must be a method; it cannot &#039;
                 &#039;be an\n&#039;
                 &#039;      instance variable:\n&#039;
                 &#039;\n&#039;
                 &#039;         &gt;&gt;&gt; class Counter(dict):\n&#039;
                 &#039;         ...     def __missing__(self, key):\n&#039;
                 &#039;         ...         return 0\n&#039;
                 &#039;         &gt;&gt;&gt; c = Counter()\n&#039;
                 &quot;         &gt;&gt;&gt; c[&#039;red&#039;]\n&quot;
                 &#039;         0\n&#039;
                 &quot;         &gt;&gt;&gt; c[&#039;red&#039;] += 1\n&quot;
                 &quot;         &gt;&gt;&gt; c[&#039;red&#039;]\n&quot;
                 &#039;         1\n&#039;
                 &#039;\n&#039;
                 &#039;      The example above shows part of the implementation of\n&#039;
                 &#039;      &quot;collections.Counter&quot;.  A different &quot;__missing__&quot; &#039;
                 &#039;method is used\n&#039;
                 &#039;      by &quot;collections.defaultdict&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   d[key] = value\n&#039;
                 &#039;\n&#039;
                 &#039;      Set &quot;d[key]&quot; to *value*.\n&#039;
                 &#039;\n&#039;
                 &#039;   del d[key]\n&#039;
                 &#039;\n&#039;
                 &#039;      Remove &quot;d[key]&quot; from *d*.  Raises a &quot;KeyError&quot; if &#039;
                 &#039;*key* is not\n&#039;
                 &#039;      in the map.\n&#039;
                 &#039;\n&#039;
                 &#039;   key in d\n&#039;
                 &#039;\n&#039;
                 &#039;      Return &quot;True&quot; if *d* has a key *key*, else &quot;False&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   key not in d\n&#039;
                 &#039;\n&#039;
                 &#039;      Equivalent to &quot;not key in d&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   iter(d)\n&#039;
                 &#039;\n&#039;
                 &#039;      Return an iterator over the keys of the dictionary.  &#039;
                 &#039;This is a\n&#039;
                 &#039;      shortcut for &quot;iter(d.keys())&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   clear()\n&#039;
                 &#039;\n&#039;
                 &#039;      Remove all items from the dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;   copy()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return a shallow copy of the dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;   classmethod fromkeys(seq[, value])\n&#039;
                 &#039;\n&#039;
                 &#039;      Create a new dictionary with keys from *seq* and &#039;
                 &#039;values set to\n&#039;
                 &#039;      *value*.\n&#039;
                 &#039;\n&#039;
                 &#039;      &quot;fromkeys()&quot; is a class method that returns a new &#039;
                 &#039;dictionary.\n&#039;
                 &#039;      *value* defaults to &quot;None&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   get(key[, default])\n&#039;
                 &#039;\n&#039;
                 &#039;      Return the value for *key* if *key* is in the &#039;
                 &#039;dictionary, else\n&#039;
                 &#039;      *default*. If *default* is not given, it defaults to &#039;
                 &#039;&quot;None&quot;, so\n&#039;
                 &#039;      that this method never raises a &quot;KeyError&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   items()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return a new view of the dictionary’s items (&quot;(key, &#039;
                 &#039;value)&quot;\n&#039;
                 &#039;      pairs). See the documentation of view objects.\n&#039;
                 &#039;\n&#039;
                 &#039;   keys()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return a new view of the dictionary’s keys.  See the\n&#039;
                 &#039;      documentation of view objects.\n&#039;
                 &#039;\n&#039;
                 &#039;   pop(key[, default])\n&#039;
                 &#039;\n&#039;
                 &#039;      If *key* is in the dictionary, remove it and return &#039;
                 &#039;its value,\n&#039;
                 &#039;      else return *default*.  If *default* is not given and &#039;
                 &#039;*key* is\n&#039;
                 &#039;      not in the dictionary, a &quot;KeyError&quot; is raised.\n&#039;
                 &#039;\n&#039;
                 &#039;   popitem()\n&#039;
                 &#039;\n&#039;
                 &#039;      Remove and return an arbitrary &quot;(key, value)&quot; pair &#039;
                 &#039;from the\n&#039;
                 &#039;      dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;      &quot;popitem()&quot; is useful to destructively iterate over a\n&#039;
                 &#039;      dictionary, as often used in set algorithms.  If the &#039;
                 &#039;dictionary\n&#039;
                 &#039;      is empty, calling &quot;popitem()&quot; raises a &quot;KeyError&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   setdefault(key[, default])\n&#039;
                 &#039;\n&#039;
                 &#039;      If *key* is in the dictionary, return its value.  If &#039;
                 &#039;not, insert\n&#039;
                 &#039;      *key* with a value of *default* and return *default*.  &#039;
                 &#039;*default*\n&#039;
                 &#039;      defaults to &quot;None&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   update([other])\n&#039;
                 &#039;\n&#039;
                 &#039;      Update the dictionary with the key/value pairs from &#039;
                 &#039;*other*,\n&#039;
                 &#039;      overwriting existing keys.  Return &quot;None&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;      &quot;update()&quot; accepts either another dictionary object or &#039;
                 &#039;an\n&#039;
                 &#039;      iterable of key/value pairs (as tuples or other &#039;
                 &#039;iterables of\n&#039;
                 &#039;      length two).  If keyword arguments are specified, the &#039;
                 &#039;dictionary\n&#039;
                 &#039;      is then updated with those key/value pairs: &#039;
                 &#039;&quot;d.update(red=1,\n&#039;
                 &#039;      blue=2)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   values()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return a new view of the dictionary’s values.  See &#039;
                 &#039;the\n&#039;
                 &#039;      documentation of view objects.\n&#039;
                 &#039;\n&#039;
                 &#039;   Dictionaries compare equal if and only if they have the &#039;
                 &#039;same &quot;(key,\n&#039;
                 &#039;   value)&quot; pairs. Order comparisons (‘&lt;’, ‘&lt;=’, ‘&gt;=’, ‘&gt;’) &#039;
                 &#039;raise\n&#039;
                 &#039;   &quot;TypeError&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;See also: &quot;types.MappingProxyType&quot; can be used to create a &#039;
                 &#039;read-only\n&#039;
                 &#039;  view of a &quot;dict&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Dictionary view objects\n&#039;
                 &#039;=======================\n&#039;
                 &#039;\n&#039;
                 &#039;The objects returned by &quot;dict.keys()&quot;, &quot;dict.values()&quot; and\n&#039;
                 &#039;&quot;dict.items()&quot; are *view objects*.  They provide a dynamic &#039;
                 &#039;view on the\n&#039;
                 &#039;dictionary’s entries, which means that when the dictionary &#039;
                 &#039;changes,\n&#039;
                 &#039;the view reflects these changes.\n&#039;
                 &#039;\n&#039;
                 &#039;Dictionary views can be iterated over to yield their &#039;
                 &#039;respective data,\n&#039;
                 &#039;and support membership tests:\n&#039;
                 &#039;\n&#039;
                 &#039;len(dictview)\n&#039;
                 &#039;\n&#039;
                 &#039;   Return the number of entries in the dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;iter(dictview)\n&#039;
                 &#039;\n&#039;
                 &#039;   Return an iterator over the keys, values or items &#039;
                 &#039;(represented as\n&#039;
                 &#039;   tuples of &quot;(key, value)&quot;) in the dictionary.\n&#039;
                 &#039;\n&#039;
                 &#039;   Keys and values are iterated over in an arbitrary order &#039;
                 &#039;which is\n&#039;
                 &#039;   non-random, varies across Python implementations, and &#039;
                 &#039;depends on\n&#039;
                 &#039;   the dictionary’s history of insertions and deletions. If &#039;
                 &#039;keys,\n&#039;
                 &#039;   values and items views are iterated over with no &#039;
                 &#039;intervening\n&#039;
                 &#039;   modifications to the dictionary, the order of items will &#039;
                 &#039;directly\n&#039;
                 &#039;   correspond.  This allows the creation of &quot;(value, key)&quot; &#039;
                 &#039;pairs using\n&#039;
                 &#039;   &quot;zip()&quot;: &quot;pairs = zip(d.values(), d.keys())&quot;.  Another &#039;
                 &#039;way to\n&#039;
                 &#039;   create the same list is &quot;pairs = [(v, k) for (k, v) in &#039;
                 &#039;d.items()]&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   Iterating views while adding or deleting entries in the &#039;
                 &#039;dictionary\n&#039;
                 &#039;   may raise a &quot;RuntimeError&quot; or fail to iterate over all &#039;
                 &#039;entries.\n&#039;
                 &#039;\n&#039;
                 &#039;x in dictview\n&#039;
                 &#039;\n&#039;
                 &#039;   Return &quot;True&quot; if *x* is in the underlying dictionary’s &#039;
                 &#039;keys, values\n&#039;
                 &#039;   or items (in the latter case, *x* should be a &quot;(key, &#039;
                 &#039;value)&quot;\n&#039;
                 &#039;   tuple).\n&#039;
                 &#039;\n&#039;
                 &#039;Keys views are set-like since their entries are unique and &#039;
                 &#039;hashable.\n&#039;
                 &#039;If all values are hashable, so that &quot;(key, value)&quot; pairs are &#039;
                 &#039;unique\n&#039;
                 &#039;and hashable, then the items view is also set-like.  (Values &#039;
                 &#039;views are\n&#039;
                 &#039;not treated as set-like since the entries are generally not &#039;
                 &#039;unique.)\n&#039;
                 &#039;For set-like views, all of the operations defined for the &#039;
                 &#039;abstract\n&#039;
                 &#039;base class &quot;collections.abc.Set&quot; are available (for example, &#039;
                 &#039;&quot;==&quot;,\n&#039;
                 &#039;&quot;&lt;&quot;, or &quot;^&quot;).\n&#039;
                 &#039;\n&#039;
                 &#039;An example of dictionary view usage:\n&#039;
                 &#039;\n&#039;
                 &quot;   &gt;&gt;&gt; dishes = {&#039;eggs&#039;: 2, &#039;sausage&#039;: 1, &#039;bacon&#039;: 1, &quot;
                 &quot;&#039;spam&#039;: 500}\n&quot;
                 &#039;   &gt;&gt;&gt; keys = dishes.keys()\n&#039;
                 &#039;   &gt;&gt;&gt; values = dishes.values()\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; # iteration\n&#039;
                 &#039;   &gt;&gt;&gt; n = 0\n&#039;
                 &#039;   &gt;&gt;&gt; for val in values:\n&#039;
                 &#039;   ...     n += val\n&#039;
                 &#039;   &gt;&gt;&gt; print(n)\n&#039;
                 &#039;   504\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; # keys and values are iterated over in the same &#039;
                 &#039;order\n&#039;
                 &#039;   &gt;&gt;&gt; list(keys)\n&#039;
                 &quot;   [&#039;eggs&#039;, &#039;bacon&#039;, &#039;sausage&#039;, &#039;spam&#039;]\n&quot;
                 &#039;   &gt;&gt;&gt; list(values)\n&#039;
                 &#039;   [2, 1, 1, 500]\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; # view objects are dynamic and reflect dict changes\n&#039;
                 &quot;   &gt;&gt;&gt; del dishes[&#039;eggs&#039;]\n&quot;
                 &quot;   &gt;&gt;&gt; del dishes[&#039;sausage&#039;]\n&quot;
                 &#039;   &gt;&gt;&gt; list(keys)\n&#039;
                 &quot;   [&#039;spam&#039;, &#039;bacon&#039;]\n&quot;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; # set operations\n&#039;
                 &quot;   &gt;&gt;&gt; keys &amp; {&#039;eggs&#039;, &#039;bacon&#039;, &#039;salad&#039;}\n&quot;
                 &quot;   {&#039;bacon&#039;}\n&quot;
                 &quot;   &gt;&gt;&gt; keys ^ {&#039;sausage&#039;, &#039;juice&#039;}\n&quot;
                 &quot;   {&#039;juice&#039;, &#039;sausage&#039;, &#039;bacon&#039;, &#039;spam&#039;}\n&quot;,
 &#039;typesmethods&#039;: &#039;Methods\n&#039;
                 &#039;*******\n&#039;
                 &#039;\n&#039;
                 &#039;Methods are functions that are called using the attribute &#039;
                 &#039;notation.\n&#039;
                 &#039;There are two flavors: built-in methods (such as &quot;append()&quot; &#039;
                 &#039;on lists)\n&#039;
                 &#039;and class instance methods.  Built-in methods are described &#039;
                 &#039;with the\n&#039;
                 &#039;types that support them.\n&#039;
                 &#039;\n&#039;
                 &#039;If you access a method (a function defined in a class &#039;
                 &#039;namespace)\n&#039;
                 &#039;through an instance, you get a special object: a *bound &#039;
                 &#039;method* (also\n&#039;
                 &#039;called *instance method*) object. When called, it will add &#039;
                 &#039;the &quot;self&quot;\n&#039;
                 &#039;argument to the argument list.  Bound methods have two &#039;
                 &#039;special read-\n&#039;
                 &#039;only attributes: &quot;m.__self__&quot; is the object on which the &#039;
                 &#039;method\n&#039;
                 &#039;operates, and &quot;m.__func__&quot; is the function implementing the &#039;
                 &#039;method.\n&#039;
                 &#039;Calling &quot;m(arg-1, arg-2, ..., arg-n)&quot; is completely &#039;
                 &#039;equivalent to\n&#039;
                 &#039;calling &quot;m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Like function objects, bound method objects support getting &#039;
                 &#039;arbitrary\n&#039;
                 &#039;attributes.  However, since method attributes are actually &#039;
                 &#039;stored on\n&#039;
                 &#039;the underlying function object (&quot;meth.__func__&quot;), setting &#039;
                 &#039;method\n&#039;
                 &#039;attributes on bound methods is disallowed.  Attempting to &#039;
                 &#039;set an\n&#039;
                 &#039;attribute on a method results in an &quot;AttributeError&quot; being &#039;
                 &#039;raised.  In\n&#039;
                 &#039;order to set a method attribute, you need to explicitly set &#039;
                 &#039;it on the\n&#039;
                 &#039;underlying function object:\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; class C:\n&#039;
                 &#039;   ...     def method(self):\n&#039;
                 &#039;   ...         pass\n&#039;
                 &#039;   ...\n&#039;
                 &#039;   &gt;&gt;&gt; c = C()\n&#039;
                 &quot;   &gt;&gt;&gt; c.method.whoami = &#039;my name is method&#039;  # can&#039;t set on &quot;
                 &#039;the method\n&#039;
                 &#039;   Traceback (most recent call last):\n&#039;
                 &#039;     File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;\n&#039;
                 &quot;   AttributeError: &#039;method&#039; object has no attribute &quot;
                 &quot;&#039;whoami&#039;\n&quot;
                 &quot;   &gt;&gt;&gt; c.method.__func__.whoami = &#039;my name is method&#039;\n&quot;
                 &#039;   &gt;&gt;&gt; c.method.whoami\n&#039;
                 &quot;   &#039;my name is method&#039;\n&quot;
                 &#039;\n&#039;
                 &#039;See The standard type hierarchy for more information.\n&#039;,
 &#039;typesmodules&#039;: &#039;Modules\n&#039;
                 &#039;*******\n&#039;
                 &#039;\n&#039;
                 &#039;The only special operation on a module is attribute access: &#039;
                 &#039;&quot;m.name&quot;,\n&#039;
                 &#039;where *m* is a module and *name* accesses a name defined in &#039;
                 &#039;*m*’s\n&#039;
                 &#039;symbol table. Module attributes can be assigned to.  (Note &#039;
                 &#039;that the\n&#039;
                 &#039;&quot;import&quot; statement is not, strictly speaking, an operation &#039;
                 &#039;on a module\n&#039;
                 &#039;object; &quot;import foo&quot; does not require a module object named &#039;
                 &#039;*foo* to\n&#039;
                 &#039;exist, rather it requires an (external) *definition* for a &#039;
                 &#039;module\n&#039;
                 &#039;named *foo* somewhere.)\n&#039;
                 &#039;\n&#039;
                 &#039;A special attribute of every module is &quot;__dict__&quot;. This is &#039;
                 &#039;the\n&#039;
                 &#039;dictionary containing the module’s symbol table. Modifying &#039;
                 &#039;this\n&#039;
                 &#039;dictionary will actually change the module’s symbol table, &#039;
                 &#039;but direct\n&#039;
                 &#039;assignment to the &quot;__dict__&quot; attribute is not possible (you &#039;
                 &#039;can write\n&#039;
                 &#039;&quot;m.__dict__[\&#039;a\&#039;] = 1&quot;, which defines &quot;m.a&quot; to be &quot;1&quot;, but &#039;
                 &#039;you can’t\n&#039;
                 &#039;write &quot;m.__dict__ = {}&quot;).  Modifying &quot;__dict__&quot; directly is &#039;
                 &#039;not\n&#039;
                 &#039;recommended.\n&#039;
                 &#039;\n&#039;
                 &#039;Modules built into the interpreter are written like this: &#039;
                 &#039;&quot;&lt;module\n&#039;
                 &#039;\&#039;sys\&#039; (built-in)&gt;&quot;.  If loaded from a file, they are &#039;
                 &#039;written as\n&#039;
                 &#039;&quot;&lt;module \&#039;os\&#039; from &#039;
                 &#039;\&#039;/usr/local/lib/pythonX.Y/os.pyc\&#039;&gt;&quot;.\n&#039;,
 &#039;typesseq&#039;: &#039;Sequence Types — &quot;list&quot;, &quot;tuple&quot;, &quot;range&quot;\n&#039;
             &#039;*****************************************\n&#039;
             &#039;\n&#039;
             &#039;There are three basic sequence types: lists, tuples, and range\n&#039;
             &#039;objects. Additional sequence types tailored for processing of &#039;
             &#039;binary\n&#039;
             &#039;data and text strings are described in dedicated sections.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Common Sequence Operations\n&#039;
             &#039;==========================\n&#039;
             &#039;\n&#039;
             &#039;The operations in the following table are supported by most &#039;
             &#039;sequence\n&#039;
             &#039;types, both mutable and immutable. The &#039;
             &#039;&quot;collections.abc.Sequence&quot; ABC\n&#039;
             &#039;is provided to make it easier to correctly implement these &#039;
             &#039;operations\n&#039;
             &#039;on custom sequence types.\n&#039;
             &#039;\n&#039;
             &#039;This table lists the sequence operations sorted in ascending &#039;
             &#039;priority.\n&#039;
             &#039;In the table, *s* and *t* are sequences of the same type, *n*, &#039;
             &#039;*i*,\n&#039;
             &#039;*j* and *k* are integers and *x* is an arbitrary object that &#039;
             &#039;meets any\n&#039;
             &#039;type and value restrictions imposed by *s*.\n&#039;
             &#039;\n&#039;
             &#039;The &quot;in&quot; and &quot;not in&quot; operations have the same priorities as &#039;
             &#039;the\n&#039;
             &#039;comparison operations. The &quot;+&quot; (concatenation) and &quot;*&quot; &#039;
             &#039;(repetition)\n&#039;
             &#039;operations have the same priority as the corresponding numeric\n&#039;
             &#039;operations. [3]\n&#039;
             &#039;\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| Operation                  | Result                           &#039;
             &#039;| Notes      |\n&#039;
             &#039;+============================+==================================+============+\n&#039;
             &#039;| &quot;x in s&quot;                   | &quot;True&quot; if an item of *s* is      &#039;
             &#039;| (1)        |\n&#039;
             &#039;|                            | equal to *x*, else &quot;False&quot;       &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;x not in s&quot;               | &quot;False&quot; if an item of *s* is     &#039;
             &#039;| (1)        |\n&#039;
             &#039;|                            | equal to *x*, else &quot;True&quot;        &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s + t&quot;                    | the concatenation of *s* and *t* &#039;
             &#039;| (6)(7)     |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s * n&quot; or &quot;n * s&quot;         | equivalent to adding *s* to      &#039;
             &#039;| (2)(7)     |\n&#039;
             &#039;|                            | itself *n* times                 &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s[i]&quot;                     | *i*th item of *s*, origin 0      &#039;
             &#039;| (3)        |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s[i:j]&quot;                   | slice of *s* from *i* to *j*     &#039;
             &#039;| (3)(4)     |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s[i:j:k]&quot;                 | slice of *s* from *i* to *j*     &#039;
             &#039;| (3)(5)     |\n&#039;
             &#039;|                            | with step *k*                    &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;len(s)&quot;                   | length of *s*                    &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;min(s)&quot;                   | smallest item of *s*             &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;max(s)&quot;                   | largest item of *s*              &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s.index(x[, i[, j]])&quot;     | index of the first occurrence of &#039;
             &#039;| (8)        |\n&#039;
             &#039;|                            | *x* in *s* (at or after index    &#039;
             &#039;|            |\n&#039;
             &#039;|                            | *i* and before index *j*)        &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s.count(x)&quot;               | total number of occurrences of   &#039;
             &#039;|            |\n&#039;
             &#039;|                            | *x* in *s*                       &#039;
             &#039;|            |\n&#039;
             &#039;+----------------------------+----------------------------------+------------+\n&#039;
             &#039;\n&#039;
             &#039;Sequences of the same type also support comparisons.  In &#039;
             &#039;particular,\n&#039;
             &#039;tuples and lists are compared lexicographically by comparing\n&#039;
             &#039;corresponding elements. This means that to compare equal, every\n&#039;
             &#039;element must compare equal and the two sequences must be of the &#039;
             &#039;same\n&#039;
             &#039;type and have the same length.  (For full details see &#039;
             &#039;Comparisons in\n&#039;
             &#039;the language reference.)\n&#039;
             &#039;\n&#039;
             &#039;Notes:\n&#039;
             &#039;\n&#039;
             &#039;1. While the &quot;in&quot; and &quot;not in&quot; operations are used only for &#039;
             &#039;simple\n&#039;
             &#039;   containment testing in the general case, some specialised &#039;
             &#039;sequences\n&#039;
             &#039;   (such as &quot;str&quot;, &quot;bytes&quot; and &quot;bytearray&quot;) also use them for\n&#039;
             &#039;   subsequence testing:\n&#039;
             &#039;\n&#039;
             &#039;      &gt;&gt;&gt; &quot;gg&quot; in &quot;eggs&quot;\n&#039;
             &#039;      True\n&#039;
             &#039;\n&#039;
             &#039;2. Values of *n* less than &quot;0&quot; are treated as &quot;0&quot; (which yields &#039;
             &#039;an\n&#039;
             &#039;   empty sequence of the same type as *s*).  Note that items in &#039;
             &#039;the\n&#039;
             &#039;   sequence *s* are not copied; they are referenced multiple &#039;
             &#039;times.\n&#039;
             &#039;   This often haunts new Python programmers; consider:\n&#039;
             &#039;\n&#039;
             &#039;      &gt;&gt;&gt; lists = [[]] * 3\n&#039;
             &#039;      &gt;&gt;&gt; lists\n&#039;
             &#039;      [[], [], []]\n&#039;
             &#039;      &gt;&gt;&gt; lists[0].append(3)\n&#039;
             &#039;      &gt;&gt;&gt; lists\n&#039;
             &#039;      [[3], [3], [3]]\n&#039;
             &#039;\n&#039;
             &#039;   What has happened is that &quot;[[]]&quot; is a one-element list &#039;
             &#039;containing\n&#039;
             &#039;   an empty list, so all three elements of &quot;[[]] * 3&quot; are &#039;
             &#039;references\n&#039;
             &#039;   to this single empty list.  Modifying any of the elements of\n&#039;
             &#039;   &quot;lists&quot; modifies this single list. You can create a list of\n&#039;
             &#039;   different lists this way:\n&#039;
             &#039;\n&#039;
             &#039;      &gt;&gt;&gt; lists = [[] for i in range(3)]\n&#039;
             &#039;      &gt;&gt;&gt; lists[0].append(3)\n&#039;
             &#039;      &gt;&gt;&gt; lists[1].append(5)\n&#039;
             &#039;      &gt;&gt;&gt; lists[2].append(7)\n&#039;
             &#039;      &gt;&gt;&gt; lists\n&#039;
             &#039;      [[3], [5], [7]]\n&#039;
             &#039;\n&#039;
             &#039;   Further explanation is available in the FAQ entry How do I &#039;
             &#039;create a\n&#039;
             &#039;   multidimensional list?.\n&#039;
             &#039;\n&#039;
             &#039;3. If *i* or *j* is negative, the index is relative to the end &#039;
             &#039;of\n&#039;
             &#039;   sequence *s*: &quot;len(s) + i&quot; or &quot;len(s) + j&quot; is substituted.  &#039;
             &#039;But\n&#039;
             &#039;   note that &quot;-0&quot; is still &quot;0&quot;.\n&#039;
             &#039;\n&#039;
             &#039;4. The slice of *s* from *i* to *j* is defined as the sequence &#039;
             &#039;of\n&#039;
             &#039;   items with index *k* such that &quot;i &lt;= k &lt; j&quot;.  If *i* or *j* &#039;
             &#039;is\n&#039;
             &#039;   greater than &quot;len(s)&quot;, use &quot;len(s)&quot;.  If *i* is omitted or &#039;
             &#039;&quot;None&quot;,\n&#039;
             &#039;   use &quot;0&quot;.  If *j* is omitted or &quot;None&quot;, use &quot;len(s)&quot;.  If *i* &#039;
             &#039;is\n&#039;
             &#039;   greater than or equal to *j*, the slice is empty.\n&#039;
             &#039;\n&#039;
             &#039;5. The slice of *s* from *i* to *j* with step *k* is defined as &#039;
             &#039;the\n&#039;
             &#039;   sequence of items with index  &quot;x = i + n*k&quot; such that &quot;0 &lt;= n &#039;
             &#039;&lt;\n&#039;
             &#039;   (j-i)/k&quot;.  In other words, the indices are &quot;i&quot;, &quot;i+k&quot;, &#039;
             &#039;&quot;i+2*k&quot;,\n&#039;
             &#039;   &quot;i+3*k&quot; and so on, stopping when *j* is reached (but never\n&#039;
             &#039;   including *j*).  When *k* is positive, *i* and *j* are &#039;
             &#039;reduced to\n&#039;
             &#039;   &quot;len(s)&quot; if they are greater. When *k* is negative, *i* and &#039;
             &#039;*j* are\n&#039;
             &#039;   reduced to &quot;len(s) - 1&quot; if they are greater.  If *i* or *j* &#039;
             &#039;are\n&#039;
             &#039;   omitted or &quot;None&quot;, they become “end” values (which end &#039;
             &#039;depends on\n&#039;
             &#039;   the sign of *k*).  Note, *k* cannot be zero. If *k* is &#039;
             &#039;&quot;None&quot;, it\n&#039;
             &#039;   is treated like &quot;1&quot;.\n&#039;
             &#039;\n&#039;
             &#039;6. Concatenating immutable sequences always results in a new\n&#039;
             &#039;   object. This means that building up a sequence by repeated\n&#039;
             &#039;   concatenation will have a quadratic runtime cost in the &#039;
             &#039;total\n&#039;
             &#039;   sequence length. To get a linear runtime cost, you must &#039;
             &#039;switch to\n&#039;
             &#039;   one of the alternatives below:\n&#039;
             &#039;\n&#039;
             &#039;   * if concatenating &quot;str&quot; objects, you can build a list and &#039;
             &#039;use\n&#039;
             &#039;     &quot;str.join()&quot; at the end or else write to an &quot;io.StringIO&quot;\n&#039;
             &#039;     instance and retrieve its value when complete\n&#039;
             &#039;\n&#039;
             &#039;   * if concatenating &quot;bytes&quot; objects, you can similarly use\n&#039;
             &#039;     &quot;bytes.join()&quot; or &quot;io.BytesIO&quot;, or you can do in-place\n&#039;
             &#039;     concatenation with a &quot;bytearray&quot; object.  &quot;bytearray&quot; &#039;
             &#039;objects are\n&#039;
             &#039;     mutable and have an efficient overallocation mechanism\n&#039;
             &#039;\n&#039;
             &#039;   * if concatenating &quot;tuple&quot; objects, extend a &quot;list&quot; instead\n&#039;
             &#039;\n&#039;
             &#039;   * for other types, investigate the relevant class &#039;
             &#039;documentation\n&#039;
             &#039;\n&#039;
             &#039;7. Some sequence types (such as &quot;range&quot;) only support item\n&#039;
             &#039;   sequences that follow specific patterns, and hence don’t &#039;
             &#039;support\n&#039;
             &#039;   sequence concatenation or repetition.\n&#039;
             &#039;\n&#039;
             &#039;8. &quot;index&quot; raises &quot;ValueError&quot; when *x* is not found in *s*. &#039;
             &#039;Not\n&#039;
             &#039;   all implementations support passing the additional arguments &#039;
             &#039;*i*\n&#039;
             &#039;   and *j*. These arguments allow efficient searching of &#039;
             &#039;subsections\n&#039;
             &#039;   of the sequence. Passing the extra arguments is roughly &#039;
             &#039;equivalent\n&#039;
             &#039;   to using &quot;s[i:j].index(x)&quot;, only without copying any data and &#039;
             &#039;with\n&#039;
             &#039;   the returned index being relative to the start of the &#039;
             &#039;sequence\n&#039;
             &#039;   rather than the start of the slice.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Immutable Sequence Types\n&#039;
             &#039;========================\n&#039;
             &#039;\n&#039;
             &#039;The only operation that immutable sequence types generally &#039;
             &#039;implement\n&#039;
             &#039;that is not also implemented by mutable sequence types is &#039;
             &#039;support for\n&#039;
             &#039;the &quot;hash()&quot; built-in.\n&#039;
             &#039;\n&#039;
             &#039;This support allows immutable sequences, such as &quot;tuple&quot; &#039;
             &#039;instances, to\n&#039;
             &#039;be used as &quot;dict&quot; keys and stored in &quot;set&quot; and &quot;frozenset&quot; &#039;
             &#039;instances.\n&#039;
             &#039;\n&#039;
             &#039;Attempting to hash an immutable sequence that contains &#039;
             &#039;unhashable\n&#039;
             &#039;values will result in &quot;TypeError&quot;.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Mutable Sequence Types\n&#039;
             &#039;======================\n&#039;
             &#039;\n&#039;
             &#039;The operations in the following table are defined on mutable &#039;
             &#039;sequence\n&#039;
             &#039;types. The &quot;collections.abc.MutableSequence&quot; ABC is provided to &#039;
             &#039;make\n&#039;
             &#039;it easier to correctly implement these operations on custom &#039;
             &#039;sequence\n&#039;
             &#039;types.\n&#039;
             &#039;\n&#039;
             &#039;In the table *s* is an instance of a mutable sequence type, *t* &#039;
             &#039;is any\n&#039;
             &#039;iterable object and *x* is an arbitrary object that meets any &#039;
             &#039;type and\n&#039;
             &#039;value restrictions imposed by *s* (for example, &quot;bytearray&quot; &#039;
             &#039;only\n&#039;
             &#039;accepts integers that meet the value restriction &quot;0 &lt;= x &lt;= &#039;
             &#039;255&quot;).\n&#039;
             &#039;\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| Operation                      | &#039;
             &#039;Result                           | Notes                 |\n&#039;
             &#039;+================================+==================================+=======================+\n&#039;
             &#039;| &quot;s[i] = x&quot;                     | item *i* of *s* is replaced &#039;
             &#039;by   |                       |\n&#039;
             &#039;|                                | &#039;
             &#039;*x*                              |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s[i:j] = t&quot;                   | slice of *s* from *i* to *j* &#039;
             &#039;is  |                       |\n&#039;
             &#039;|                                | replaced by the contents of &#039;
             &#039;the  |                       |\n&#039;
             &#039;|                                | iterable &#039;
             &#039;*t*                     |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;del s[i:j]&quot;                   | same as &quot;s[i:j] = &#039;
             &#039;[]&quot;            |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s[i:j:k] = t&quot;                 | the elements of &quot;s[i:j:k]&quot; &#039;
             &#039;are   | (1)                   |\n&#039;
             &#039;|                                | replaced by those of &#039;
             &#039;*t*         |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;del s[i:j:k]&quot;                 | removes the elements &#039;
             &#039;of          |                       |\n&#039;
             &#039;|                                | &quot;s[i:j:k]&quot; from the &#039;
             &#039;list         |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.append(x)&quot;                  | appends *x* to the end of &#039;
             &#039;the    |                       |\n&#039;
             &#039;|                                | sequence (same &#039;
             &#039;as                |                       |\n&#039;
             &#039;|                                | &quot;s[len(s):len(s)] = &#039;
             &#039;[x]&quot;)        |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.clear()&quot;                    | removes all items from *s* &#039;
             &#039;(same | (5)                   |\n&#039;
             &#039;|                                | as &quot;del &#039;
             &#039;s[:]&quot;)                   |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.copy()&quot;                     | creates a shallow copy of &#039;
             &#039;*s*    | (5)                   |\n&#039;
             &#039;|                                | (same as &#039;
             &#039;&quot;s[:]&quot;)                 |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.extend(t)&quot; or &quot;s += t&quot;      | extends *s* with the contents &#039;
             &#039;of |                       |\n&#039;
             &#039;|                                | *t* (for the most part the &#039;
             &#039;same  |                       |\n&#039;
             &#039;|                                | as &quot;s[len(s):len(s)] = &#039;
             &#039;t&quot;)       |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s *= n&quot;                       | updates *s* with its &#039;
             &#039;contents    | (6)                   |\n&#039;
             &#039;|                                | repeated *n* &#039;
             &#039;times               |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.insert(i, x)&quot;               | inserts *x* into *s* at &#039;
             &#039;the      |                       |\n&#039;
             &#039;|                                | index given by *i* (same &#039;
             &#039;as      |                       |\n&#039;
             &#039;|                                | &quot;s[i:i] = &#039;
             &#039;[x]&quot;)                  |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.pop([i])&quot;                   | retrieves the item at *i* &#039;
             &#039;and    | (2)                   |\n&#039;
             &#039;|                                | also removes it from &#039;
             &#039;*s*         |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.remove(x)&quot;                  | remove the first item from &#039;
             &#039;*s*   | (3)                   |\n&#039;
             &#039;|                                | where &quot;s[i] == &#039;
             &#039;x&quot;                |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.reverse()&quot;                  | reverses the items of *s* &#039;
             &#039;in     | (4)                   |\n&#039;
             &#039;|                                | &#039;
             &#039;place                            |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;\n&#039;
             &#039;Notes:\n&#039;
             &#039;\n&#039;
             &#039;1. *t* must have the same length as the slice it is replacing.\n&#039;
             &#039;\n&#039;
             &#039;2. The optional argument *i* defaults to &quot;-1&quot;, so that by &#039;
             &#039;default\n&#039;
             &#039;   the last item is removed and returned.\n&#039;
             &#039;\n&#039;
             &#039;3. &quot;remove&quot; raises &quot;ValueError&quot; when *x* is not found in *s*.\n&#039;
             &#039;\n&#039;
             &#039;4. The &quot;reverse()&quot; method modifies the sequence in place for\n&#039;
             &#039;   economy of space when reversing a large sequence.  To remind &#039;
             &#039;users\n&#039;
             &#039;   that it operates by side effect, it does not return the &#039;
             &#039;reversed\n&#039;
             &#039;   sequence.\n&#039;
             &#039;\n&#039;
             &#039;5. &quot;clear()&quot; and &quot;copy()&quot; are included for consistency with the\n&#039;
             &#039;   interfaces of mutable containers that don’t support slicing\n&#039;
             &#039;   operations (such as &quot;dict&quot; and &quot;set&quot;)\n&#039;
             &#039;\n&#039;
             &#039;   New in version 3.3: &quot;clear()&quot; and &quot;copy()&quot; methods.\n&#039;
             &#039;\n&#039;
             &#039;6. The value *n* is an integer, or an object implementing\n&#039;
             &#039;   &quot;__index__()&quot;.  Zero and negative values of *n* clear the &#039;
             &#039;sequence.\n&#039;
             &#039;   Items in the sequence are not copied; they are referenced &#039;
             &#039;multiple\n&#039;
             &#039;   times, as explained for &quot;s * n&quot; under Common Sequence &#039;
             &#039;Operations.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Lists\n&#039;
             &#039;=====\n&#039;
             &#039;\n&#039;
             &#039;Lists are mutable sequences, typically used to store collections &#039;
             &#039;of\n&#039;
             &#039;homogeneous items (where the precise degree of similarity will &#039;
             &#039;vary by\n&#039;
             &#039;application).\n&#039;
             &#039;\n&#039;
             &#039;class list([iterable])\n&#039;
             &#039;\n&#039;
             &#039;   Lists may be constructed in several ways:\n&#039;
             &#039;\n&#039;
             &#039;   * Using a pair of square brackets to denote the empty list: &#039;
             &#039;&quot;[]&quot;\n&#039;
             &#039;\n&#039;
             &#039;   * Using square brackets, separating items with commas: &#039;
             &#039;&quot;[a]&quot;,\n&#039;
             &#039;     &quot;[a, b, c]&quot;\n&#039;
             &#039;\n&#039;
             &#039;   * Using a list comprehension: &quot;[x for x in iterable]&quot;\n&#039;
             &#039;\n&#039;
             &#039;   * Using the type constructor: &quot;list()&quot; or &quot;list(iterable)&quot;\n&#039;
             &#039;\n&#039;
             &#039;   The constructor builds a list whose items are the same and in &#039;
             &#039;the\n&#039;
             &#039;   same order as *iterable*’s items.  *iterable* may be either &#039;
             &#039;a\n&#039;
             &#039;   sequence, a container that supports iteration, or an &#039;
             &#039;iterator\n&#039;
             &#039;   object.  If *iterable* is already a list, a copy is made and\n&#039;
             &#039;   returned, similar to &quot;iterable[:]&quot;. For example, &#039;
             &#039;&quot;list(\&#039;abc\&#039;)&quot;\n&#039;
             &#039;   returns &quot;[\&#039;a\&#039;, \&#039;b\&#039;, \&#039;c\&#039;]&quot; and &quot;list( (1, 2, 3) )&quot; &#039;
             &#039;returns &quot;[1, 2,\n&#039;
             &#039;   3]&quot;. If no argument is given, the constructor creates a new &#039;
             &#039;empty\n&#039;
             &#039;   list, &quot;[]&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   Many other operations also produce lists, including the &#039;
             &#039;&quot;sorted()&quot;\n&#039;
             &#039;   built-in.\n&#039;
             &#039;\n&#039;
             &#039;   Lists implement all of the common and mutable sequence &#039;
             &#039;operations.\n&#039;
             &#039;   Lists also provide the following additional method:\n&#039;
             &#039;\n&#039;
             &#039;   sort(*, key=None, reverse=False)\n&#039;
             &#039;\n&#039;
             &#039;      This method sorts the list in place, using only &quot;&lt;&quot; &#039;
             &#039;comparisons\n&#039;
             &#039;      between items. Exceptions are not suppressed - if any &#039;
             &#039;comparison\n&#039;
             &#039;      operations fail, the entire sort operation will fail (and &#039;
             &#039;the\n&#039;
             &#039;      list will likely be left in a partially modified state).\n&#039;
             &#039;\n&#039;
             &#039;      &quot;sort()&quot; accepts two arguments that can only be passed by\n&#039;
             &#039;      keyword (keyword-only arguments):\n&#039;
             &#039;\n&#039;
             &#039;      *key* specifies a function of one argument that is used &#039;
             &#039;to\n&#039;
             &#039;      extract a comparison key from each list element (for &#039;
             &#039;example,\n&#039;
             &#039;      &quot;key=str.lower&quot;). The key corresponding to each item in &#039;
             &#039;the list\n&#039;
             &#039;      is calculated once and then used for the entire sorting &#039;
             &#039;process.\n&#039;
             &#039;      The default value of &quot;None&quot; means that list items are &#039;
             &#039;sorted\n&#039;
             &#039;      directly without calculating a separate key value.\n&#039;
             &#039;\n&#039;
             &#039;      The &quot;functools.cmp_to_key()&quot; utility is available to &#039;
             &#039;convert a\n&#039;
             &#039;      2.x style *cmp* function to a *key* function.\n&#039;
             &#039;\n&#039;
             &#039;      *reverse* is a boolean value.  If set to &quot;True&quot;, then the &#039;
             &#039;list\n&#039;
             &#039;      elements are sorted as if each comparison were reversed.\n&#039;
             &#039;\n&#039;
             &#039;      This method modifies the sequence in place for economy of &#039;
             &#039;space\n&#039;
             &#039;      when sorting a large sequence.  To remind users that it &#039;
             &#039;operates\n&#039;
             &#039;      by side effect, it does not return the sorted sequence &#039;
             &#039;(use\n&#039;
             &#039;      &quot;sorted()&quot; to explicitly request a new sorted list &#039;
             &#039;instance).\n&#039;
             &#039;\n&#039;
             &#039;      The &quot;sort()&quot; method is guaranteed to be stable.  A sort &#039;
             &#039;is\n&#039;
             &#039;      stable if it guarantees not to change the relative order &#039;
             &#039;of\n&#039;
             &#039;      elements that compare equal — this is helpful for sorting &#039;
             &#039;in\n&#039;
             &#039;      multiple passes (for example, sort by department, then by &#039;
             &#039;salary\n&#039;
             &#039;      grade).\n&#039;
             &#039;\n&#039;
             &#039;      **CPython implementation detail:** While a list is being &#039;
             &#039;sorted,\n&#039;
             &#039;      the effect of attempting to mutate, or even inspect, the &#039;
             &#039;list is\n&#039;
             &#039;      undefined.  The C implementation of Python makes the list &#039;
             &#039;appear\n&#039;
             &#039;      empty for the duration, and raises &quot;ValueError&quot; if it can &#039;
             &#039;detect\n&#039;
             &#039;      that the list has been mutated during a sort.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Tuples\n&#039;
             &#039;======\n&#039;
             &#039;\n&#039;
             &#039;Tuples are immutable sequences, typically used to store &#039;
             &#039;collections of\n&#039;
             &#039;heterogeneous data (such as the 2-tuples produced by the &#039;
             &#039;&quot;enumerate()&quot;\n&#039;
             &#039;built-in). Tuples are also used for cases where an immutable &#039;
             &#039;sequence\n&#039;
             &#039;of homogeneous data is needed (such as allowing storage in a &#039;
             &#039;&quot;set&quot; or\n&#039;
             &#039;&quot;dict&quot; instance).\n&#039;
             &#039;\n&#039;
             &#039;class tuple([iterable])\n&#039;
             &#039;\n&#039;
             &#039;   Tuples may be constructed in a number of ways:\n&#039;
             &#039;\n&#039;
             &#039;   * Using a pair of parentheses to denote the empty tuple: &#039;
             &#039;&quot;()&quot;\n&#039;
             &#039;\n&#039;
             &#039;   * Using a trailing comma for a singleton tuple: &quot;a,&quot; or &#039;
             &#039;&quot;(a,)&quot;\n&#039;
             &#039;\n&#039;
             &#039;   * Separating items with commas: &quot;a, b, c&quot; or &quot;(a, b, c)&quot;\n&#039;
             &#039;\n&#039;
             &#039;   * Using the &quot;tuple()&quot; built-in: &quot;tuple()&quot; or &#039;
             &#039;&quot;tuple(iterable)&quot;\n&#039;
             &#039;\n&#039;
             &#039;   The constructor builds a tuple whose items are the same and &#039;
             &#039;in the\n&#039;
             &#039;   same order as *iterable*’s items.  *iterable* may be either &#039;
             &#039;a\n&#039;
             &#039;   sequence, a container that supports iteration, or an &#039;
             &#039;iterator\n&#039;
             &#039;   object.  If *iterable* is already a tuple, it is returned\n&#039;
             &#039;   unchanged. For example, &quot;tuple(\&#039;abc\&#039;)&quot; returns &quot;(\&#039;a\&#039;, &#039;
             &#039;\&#039;b\&#039;, \&#039;c\&#039;)&quot;\n&#039;
             &#039;   and &quot;tuple( [1, 2, 3] )&quot; returns &quot;(1, 2, 3)&quot;. If no argument &#039;
             &#039;is\n&#039;
             &#039;   given, the constructor creates a new empty tuple, &quot;()&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   Note that it is actually the comma which makes a tuple, not &#039;
             &#039;the\n&#039;
             &#039;   parentheses. The parentheses are optional, except in the &#039;
             &#039;empty\n&#039;
             &#039;   tuple case, or when they are needed to avoid syntactic &#039;
             &#039;ambiguity.\n&#039;
             &#039;   For example, &quot;f(a, b, c)&quot; is a function call with three &#039;
             &#039;arguments,\n&#039;
             &#039;   while &quot;f((a, b, c))&quot; is a function call with a 3-tuple as the &#039;
             &#039;sole\n&#039;
             &#039;   argument.\n&#039;
             &#039;\n&#039;
             &#039;   Tuples implement all of the common sequence operations.\n&#039;
             &#039;\n&#039;
             &#039;For heterogeneous collections of data where access by name is &#039;
             &#039;clearer\n&#039;
             &#039;than access by index, &quot;collections.namedtuple()&quot; may be a more\n&#039;
             &#039;appropriate choice than a simple tuple object.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Ranges\n&#039;
             &#039;======\n&#039;
             &#039;\n&#039;
             &#039;The &quot;range&quot; type represents an immutable sequence of numbers and &#039;
             &#039;is\n&#039;
             &#039;commonly used for looping a specific number of times in &quot;for&quot; &#039;
             &#039;loops.\n&#039;
             &#039;\n&#039;
             &#039;class range(stop)\n&#039;
             &#039;class range(start, stop[, step])\n&#039;
             &#039;\n&#039;
             &#039;   The arguments to the range constructor must be integers &#039;
             &#039;(either\n&#039;
             &#039;   built-in &quot;int&quot; or any object that implements the &quot;__index__&quot;\n&#039;
             &#039;   special method).  If the *step* argument is omitted, it &#039;
             &#039;defaults to\n&#039;
             &#039;   &quot;1&quot;. If the *start* argument is omitted, it defaults to &quot;0&quot;. &#039;
             &#039;If\n&#039;
             &#039;   *step* is zero, &quot;ValueError&quot; is raised.\n&#039;
             &#039;\n&#039;
             &#039;   For a positive *step*, the contents of a range &quot;r&quot; are &#039;
             &#039;determined\n&#039;
             &#039;   by the formula &quot;r[i] = start + step*i&quot; where &quot;i &gt;= 0&quot; and &#039;
             &#039;&quot;r[i] &lt;\n&#039;
             &#039;   stop&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   For a negative *step*, the contents of the range are still\n&#039;
             &#039;   determined by the formula &quot;r[i] = start + step*i&quot;, but the\n&#039;
             &#039;   constraints are &quot;i &gt;= 0&quot; and &quot;r[i] &gt; stop&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   A range object will be empty if &quot;r[0]&quot; does not meet the &#039;
             &#039;value\n&#039;
             &#039;   constraint. Ranges do support negative indices, but these &#039;
             &#039;are\n&#039;
             &#039;   interpreted as indexing from the end of the sequence &#039;
             &#039;determined by\n&#039;
             &#039;   the positive indices.\n&#039;
             &#039;\n&#039;
             &#039;   Ranges containing absolute values larger than &quot;sys.maxsize&quot; &#039;
             &#039;are\n&#039;
             &#039;   permitted but some features (such as &quot;len()&quot;) may raise\n&#039;
             &#039;   &quot;OverflowError&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   Range examples:\n&#039;
             &#039;\n&#039;
             &#039;      &gt;&gt;&gt; list(range(10))\n&#039;
             &#039;      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n&#039;
             &#039;      &gt;&gt;&gt; list(range(1, 11))\n&#039;
             &#039;      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n&#039;
             &#039;      &gt;&gt;&gt; list(range(0, 30, 5))\n&#039;
             &#039;      [0, 5, 10, 15, 20, 25]\n&#039;
             &#039;      &gt;&gt;&gt; list(range(0, 10, 3))\n&#039;
             &#039;      [0, 3, 6, 9]\n&#039;
             &#039;      &gt;&gt;&gt; list(range(0, -10, -1))\n&#039;
             &#039;      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n&#039;
             &#039;      &gt;&gt;&gt; list(range(0))\n&#039;
             &#039;      []\n&#039;
             &#039;      &gt;&gt;&gt; list(range(1, 0))\n&#039;
             &#039;      []\n&#039;
             &#039;\n&#039;
             &#039;   Ranges implement all of the common sequence operations &#039;
             &#039;except\n&#039;
             &#039;   concatenation and repetition (due to the fact that range &#039;
             &#039;objects\n&#039;
             &#039;   can only represent sequences that follow a strict pattern &#039;
             &#039;and\n&#039;
             &#039;   repetition and concatenation will usually violate that &#039;
             &#039;pattern).\n&#039;
             &#039;\n&#039;
             &#039;   start\n&#039;
             &#039;\n&#039;
             &#039;      The value of the *start* parameter (or &quot;0&quot; if the &#039;
             &#039;parameter was\n&#039;
             &#039;      not supplied)\n&#039;
             &#039;\n&#039;
             &#039;   stop\n&#039;
             &#039;\n&#039;
             &#039;      The value of the *stop* parameter\n&#039;
             &#039;\n&#039;
             &#039;   step\n&#039;
             &#039;\n&#039;
             &#039;      The value of the *step* parameter (or &quot;1&quot; if the parameter &#039;
             &#039;was\n&#039;
             &#039;      not supplied)\n&#039;
             &#039;\n&#039;
             &#039;The advantage of the &quot;range&quot; type over a regular &quot;list&quot; or &#039;
             &#039;&quot;tuple&quot; is\n&#039;
             &#039;that a &quot;range&quot; object will always take the same (small) amount &#039;
             &#039;of\n&#039;
             &#039;memory, no matter the size of the range it represents (as it &#039;
             &#039;only\n&#039;
             &#039;stores the &quot;start&quot;, &quot;stop&quot; and &quot;step&quot; values, calculating &#039;
             &#039;individual\n&#039;
             &#039;items and subranges as needed).\n&#039;
             &#039;\n&#039;
             &#039;Range objects implement the &quot;collections.abc.Sequence&quot; ABC, and\n&#039;
             &#039;provide features such as containment tests, element index &#039;
             &#039;lookup,\n&#039;
             &#039;slicing and support for negative indices (see Sequence Types — &#039;
             &#039;list,\n&#039;
             &#039;tuple, range):\n&#039;
             &#039;\n&#039;
             &#039;&gt;&gt;&gt; r = range(0, 20, 2)\n&#039;
             &#039;&gt;&gt;&gt; r\n&#039;
             &#039;range(0, 20, 2)\n&#039;
             &#039;&gt;&gt;&gt; 11 in r\n&#039;
             &#039;False\n&#039;
             &#039;&gt;&gt;&gt; 10 in r\n&#039;
             &#039;True\n&#039;
             &#039;&gt;&gt;&gt; r.index(10)\n&#039;
             &#039;5\n&#039;
             &#039;&gt;&gt;&gt; r[5]\n&#039;
             &#039;10\n&#039;
             &#039;&gt;&gt;&gt; r[:5]\n&#039;
             &#039;range(0, 10, 2)\n&#039;
             &#039;&gt;&gt;&gt; r[-1]\n&#039;
             &#039;18\n&#039;
             &#039;\n&#039;
             &#039;Testing range objects for equality with &quot;==&quot; and &quot;!=&quot; compares &#039;
             &#039;them as\n&#039;
             &#039;sequences.  That is, two range objects are considered equal if &#039;
             &#039;they\n&#039;
             &#039;represent the same sequence of values.  (Note that two range &#039;
             &#039;objects\n&#039;
             &#039;that compare equal might have different &quot;start&quot;, &quot;stop&quot; and &#039;
             &#039;&quot;step&quot;\n&#039;
             &#039;attributes, for example &quot;range(0) == range(2, 1, 3)&quot; or &#039;
             &#039;&quot;range(0, 3,\n&#039;
             &#039;2) == range(0, 4, 2)&quot;.)\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.2: Implement the Sequence ABC. Support &#039;
             &#039;slicing\n&#039;
             &#039;and negative indices. Test &quot;int&quot; objects for membership in &#039;
             &#039;constant\n&#039;
             &#039;time instead of iterating through all items.\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 3.3: Define ‘==’ and ‘!=’ to compare range &#039;
             &#039;objects\n&#039;
             &#039;based on the sequence of values they define (instead of &#039;
             &#039;comparing\n&#039;
             &#039;based on object identity).\n&#039;
             &#039;\n&#039;
             &#039;New in version 3.3: The &quot;start&quot;, &quot;stop&quot; and &quot;step&quot; attributes.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  * The linspace recipe shows how to implement a lazy version &#039;
             &#039;of\n&#039;
             &#039;    range suitable for floating point applications.\n&#039;,
 &#039;typesseq-mutable&#039;: &#039;Mutable Sequence Types\n&#039;
                     &#039;**********************\n&#039;
                     &#039;\n&#039;
                     &#039;The operations in the following table are defined on &#039;
                     &#039;mutable sequence\n&#039;
                     &#039;types. The &quot;collections.abc.MutableSequence&quot; ABC is &#039;
                     &#039;provided to make\n&#039;
                     &#039;it easier to correctly implement these operations on &#039;
                     &#039;custom sequence\n&#039;
                     &#039;types.\n&#039;
                     &#039;\n&#039;
                     &#039;In the table *s* is an instance of a mutable sequence &#039;
                     &#039;type, *t* is any\n&#039;
                     &#039;iterable object and *x* is an arbitrary object that &#039;
                     &#039;meets any type and\n&#039;
                     &#039;value restrictions imposed by *s* (for example, &#039;
                     &#039;&quot;bytearray&quot; only\n&#039;
                     &#039;accepts integers that meet the value restriction &quot;0 &lt;= x &#039;
                     &#039;&lt;= 255&quot;).\n&#039;
                     &#039;\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| Operation                      | &#039;
                     &#039;Result                           | Notes                 &#039;
                     &#039;|\n&#039;
                     &#039;+================================+==================================+=======================+\n&#039;
                     &#039;| &quot;s[i] = x&quot;                     | item *i* of *s* is &#039;
                     &#039;replaced by   |                       |\n&#039;
                     &#039;|                                | &#039;
                     &#039;*x*                              |                       &#039;
                     &#039;|\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s[i:j] = t&quot;                   | slice of *s* from *i* &#039;
                     &#039;to *j* is  |                       |\n&#039;
                     &#039;|                                | replaced by the &#039;
                     &#039;contents of the  |                       |\n&#039;
                     &#039;|                                | iterable &#039;
                     &#039;*t*                     |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;del s[i:j]&quot;                   | same as &quot;s[i:j] = &#039;
                     &#039;[]&quot;            |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s[i:j:k] = t&quot;                 | the elements of &#039;
                     &#039;&quot;s[i:j:k]&quot; are   | (1)                   |\n&#039;
                     &#039;|                                | replaced by those of &#039;
                     &#039;*t*         |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;del s[i:j:k]&quot;                 | removes the elements &#039;
                     &#039;of          |                       |\n&#039;
                     &#039;|                                | &quot;s[i:j:k]&quot; from the &#039;
                     &#039;list         |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.append(x)&quot;                  | appends *x* to the &#039;
                     &#039;end of the    |                       |\n&#039;
                     &#039;|                                | sequence (same &#039;
                     &#039;as                |                       |\n&#039;
                     &#039;|                                | &quot;s[len(s):len(s)] = &#039;
                     &#039;[x]&quot;)        |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.clear()&quot;                    | removes all items &#039;
                     &#039;from *s* (same | (5)                   |\n&#039;
                     &#039;|                                | as &quot;del &#039;
                     &#039;s[:]&quot;)                   |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.copy()&quot;                     | creates a shallow &#039;
                     &#039;copy of *s*    | (5)                   |\n&#039;
                     &#039;|                                | (same as &#039;
                     &#039;&quot;s[:]&quot;)                 |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.extend(t)&quot; or &quot;s += t&quot;      | extends *s* with the &#039;
                     &#039;contents of |                       |\n&#039;
                     &#039;|                                | *t* (for the most &#039;
                     &#039;part the same  |                       |\n&#039;
                     &#039;|                                | as &quot;s[len(s):len(s)] &#039;
                     &#039;= t&quot;)       |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s *= n&quot;                       | updates *s* with its &#039;
                     &#039;contents    | (6)                   |\n&#039;
                     &#039;|                                | repeated *n* &#039;
                     &#039;times               |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.insert(i, x)&quot;               | inserts *x* into *s* &#039;
                     &#039;at the      |                       |\n&#039;
                     &#039;|                                | index given by *i* &#039;
                     &#039;(same as      |                       |\n&#039;
                     &#039;|                                | &quot;s[i:i] = &#039;
                     &#039;[x]&quot;)                  |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.pop([i])&quot;                   | retrieves the item at &#039;
                     &#039;*i* and    | (2)                   |\n&#039;
                     &#039;|                                | also removes it from &#039;
                     &#039;*s*         |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.remove(x)&quot;                  | remove the first item &#039;
                     &#039;from *s*   | (3)                   |\n&#039;
                     &#039;|                                | where &quot;s[i] == &#039;
                     &#039;x&quot;                |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.reverse()&quot;                  | reverses the items of &#039;
                     &#039;*s* in     | (4)                   |\n&#039;
                     &#039;|                                | &#039;
                     &#039;place                            |                       &#039;
                     &#039;|\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;\n&#039;
                     &#039;Notes:\n&#039;
                     &#039;\n&#039;
                     &#039;1. *t* must have the same length as the slice it is &#039;
                     &#039;replacing.\n&#039;
                     &#039;\n&#039;
                     &#039;2. The optional argument *i* defaults to &quot;-1&quot;, so that &#039;
                     &#039;by default\n&#039;
                     &#039;   the last item is removed and returned.\n&#039;
                     &#039;\n&#039;
                     &#039;3. &quot;remove&quot; raises &quot;ValueError&quot; when *x* is not found in &#039;
                     &#039;*s*.\n&#039;
                     &#039;\n&#039;
                     &#039;4. The &quot;reverse()&quot; method modifies the sequence in place &#039;
                     &#039;for\n&#039;
                     &#039;   economy of space when reversing a large sequence.  To &#039;
                     &#039;remind users\n&#039;
                     &#039;   that it operates by side effect, it does not return &#039;
                     &#039;the reversed\n&#039;
                     &#039;   sequence.\n&#039;
                     &#039;\n&#039;
                     &#039;5. &quot;clear()&quot; and &quot;copy()&quot; are included for consistency &#039;
                     &#039;with the\n&#039;
                     &#039;   interfaces of mutable containers that don’t support &#039;
                     &#039;slicing\n&#039;
                     &#039;   operations (such as &quot;dict&quot; and &quot;set&quot;)\n&#039;
                     &#039;\n&#039;
                     &#039;   New in version 3.3: &quot;clear()&quot; and &quot;copy()&quot; methods.\n&#039;
                     &#039;\n&#039;
                     &#039;6. The value *n* is an integer, or an object &#039;
                     &#039;implementing\n&#039;
                     &#039;   &quot;__index__()&quot;.  Zero and negative values of *n* clear &#039;
                     &#039;the sequence.\n&#039;
                     &#039;   Items in the sequence are not copied; they are &#039;
                     &#039;referenced multiple\n&#039;
                     &#039;   times, as explained for &quot;s * n&quot; under Common Sequence &#039;
                     &#039;Operations.\n&#039;,
 &#039;unary&#039;: &#039;Unary arithmetic and bitwise operations\n&#039;
          &#039;***************************************\n&#039;
          &#039;\n&#039;
          &#039;All unary arithmetic and bitwise operations have the same &#039;
          &#039;priority:\n&#039;
          &#039;\n&#039;
          &#039;   u_expr ::= power | &quot;-&quot; u_expr | &quot;+&quot; u_expr | &quot;~&quot; u_expr\n&#039;
          &#039;\n&#039;
          &#039;The unary &quot;-&quot; (minus) operator yields the negation of its numeric\n&#039;
          &#039;argument.\n&#039;
          &#039;\n&#039;
          &#039;The unary &quot;+&quot; (plus) operator yields its numeric argument &#039;
          &#039;unchanged.\n&#039;
          &#039;\n&#039;
          &#039;The unary &quot;~&quot; (invert) operator yields the bitwise inversion of &#039;
          &#039;its\n&#039;
          &#039;integer argument.  The bitwise inversion of &quot;x&quot; is defined as\n&#039;
          &#039;&quot;-(x+1)&quot;.  It only applies to integral numbers.\n&#039;
          &#039;\n&#039;
          &#039;In all three cases, if the argument does not have the proper type, &#039;
          &#039;a\n&#039;
          &#039;&quot;TypeError&quot; exception is raised.\n&#039;,
 &#039;while&#039;: &#039;The &quot;while&quot; statement\n&#039;
          &#039;*********************\n&#039;
          &#039;\n&#039;
          &#039;The &quot;while&quot; statement is used for repeated execution as long as an\n&#039;
          &#039;expression is true:\n&#039;
          &#039;\n&#039;
          &#039;   while_stmt ::= &quot;while&quot; expression &quot;:&quot; suite\n&#039;
          &#039;                  [&quot;else&quot; &quot;:&quot; suite]\n&#039;
          &#039;\n&#039;
          &#039;This repeatedly tests the expression and, if it is true, executes &#039;
          &#039;the\n&#039;
          &#039;first suite; if the expression is false (which may be the first &#039;
          &#039;time\n&#039;
          &#039;it is tested) the suite of the &quot;else&quot; clause, if present, is &#039;
          &#039;executed\n&#039;
          &#039;and the loop terminates.\n&#039;
          &#039;\n&#039;
          &#039;A &quot;break&quot; statement executed in the first suite terminates the &#039;
          &#039;loop\n&#039;
          &#039;without executing the &quot;else&quot; clause’s suite.  A &quot;continue&quot; &#039;
          &#039;statement\n&#039;
          &#039;executed in the first suite skips the rest of the suite and goes &#039;
          &#039;back\n&#039;
          &#039;to testing the expression.\n&#039;,
 &#039;with&#039;: &#039;The &quot;with&quot; statement\n&#039;
         &#039;********************\n&#039;
         &#039;\n&#039;
         &#039;The &quot;with&quot; statement is used to wrap the execution of a block with\n&#039;
         &#039;methods defined by a context manager (see section With Statement\n&#039;
         &#039;Context Managers). This allows common &quot;try&quot;…&quot;except&quot;…&quot;finally&quot; &#039;
         &#039;usage\n&#039;
         &#039;patterns to be encapsulated for convenient reuse.\n&#039;
         &#039;\n&#039;
         &#039;   with_stmt ::= &quot;with&quot; with_item (&quot;,&quot; with_item)* &quot;:&quot; suite\n&#039;
         &#039;   with_item ::= expression [&quot;as&quot; target]\n&#039;
         &#039;\n&#039;
         &#039;The execution of the &quot;with&quot; statement with one “item” proceeds as\n&#039;
         &#039;follows:\n&#039;
         &#039;\n&#039;
         &#039;1. The context expression (the expression given in the &quot;with_item&quot;)\n&#039;
         &#039;   is evaluated to obtain a context manager.\n&#039;
         &#039;\n&#039;
         &#039;2. The context manager’s &quot;__exit__()&quot; is loaded for later use.\n&#039;
         &#039;\n&#039;
         &#039;3. The context manager’s &quot;__enter__()&quot; method is invoked.\n&#039;
         &#039;\n&#039;
         &#039;4. If a target was included in the &quot;with&quot; statement, the return\n&#039;
         &#039;   value from &quot;__enter__()&quot; is assigned to it.\n&#039;
         &#039;\n&#039;
         &#039;   Note: The &quot;with&quot; statement guarantees that if the &quot;__enter__()&quot;\n&#039;
         &#039;     method returns without an error, then &quot;__exit__()&quot; will always &#039;
         &#039;be\n&#039;
         &#039;     called. Thus, if an error occurs during the assignment to the\n&#039;
         &#039;     target list, it will be treated the same as an error occurring\n&#039;
         &#039;     within the suite would be. See step 6 below.\n&#039;
         &#039;\n&#039;
         &#039;5. The suite is executed.\n&#039;
         &#039;\n&#039;
         &#039;6. The context manager’s &quot;__exit__()&quot; method is invoked.  If an\n&#039;
         &#039;   exception caused the suite to be exited, its type, value, and\n&#039;
         &#039;   traceback are passed as arguments to &quot;__exit__()&quot;. Otherwise, &#039;
         &#039;three\n&#039;
         &#039;   &quot;None&quot; arguments are supplied.\n&#039;
         &#039;\n&#039;
         &#039;   If the suite was exited due to an exception, and the return &#039;
         &#039;value\n&#039;
         &#039;   from the &quot;__exit__()&quot; method was false, the exception is &#039;
         &#039;reraised.\n&#039;
         &#039;   If the return value was true, the exception is suppressed, and\n&#039;
         &#039;   execution continues with the statement following the &quot;with&quot;\n&#039;
         &#039;   statement.\n&#039;
         &#039;\n&#039;
         &#039;   If the suite was exited for any reason other than an exception, &#039;
         &#039;the\n&#039;
         &#039;   return value from &quot;__exit__()&quot; is ignored, and execution &#039;
         &#039;proceeds\n&#039;
         &#039;   at the normal location for the kind of exit that was taken.\n&#039;
         &#039;\n&#039;
         &#039;With more than one item, the context managers are processed as if\n&#039;
         &#039;multiple &quot;with&quot; statements were nested:\n&#039;
         &#039;\n&#039;
         &#039;   with A() as a, B() as b:\n&#039;
         &#039;       suite\n&#039;
         &#039;\n&#039;
         &#039;is equivalent to\n&#039;
         &#039;\n&#039;
         &#039;   with A() as a:\n&#039;
         &#039;       with B() as b:\n&#039;
         &#039;           suite\n&#039;
         &#039;\n&#039;
         &#039;Changed in version 3.1: Support for multiple context expressions.\n&#039;
         &#039;\n&#039;
         &#039;See also:\n&#039;
         &#039;\n&#039;
         &#039;  **PEP 343** - The “with” statement\n&#039;
         &#039;     The specification, background, and examples for the Python &#039;
         &#039;&quot;with&quot;\n&#039;
         &#039;     statement.\n&#039;,
 &#039;yield&#039;: &#039;The &quot;yield&quot; statement\n&#039;
          &#039;*********************\n&#039;
          &#039;\n&#039;
          &#039;   yield_stmt ::= yield_expression\n&#039;
          &#039;\n&#039;
          &#039;A &quot;yield&quot; statement is semantically equivalent to a yield &#039;
          &#039;expression.\n&#039;
          &#039;The yield statement can be used to omit the parentheses that would\n&#039;
          &#039;otherwise be required in the equivalent yield expression &#039;
          &#039;statement.\n&#039;
          &#039;For example, the yield statements\n&#039;
          &#039;\n&#039;
          &#039;   yield &lt;expr&gt;\n&#039;
          &#039;   yield from &lt;expr&gt;\n&#039;
          &#039;\n&#039;
          &#039;are equivalent to the yield expression statements\n&#039;
          &#039;\n&#039;
          &#039;   (yield &lt;expr&gt;)\n&#039;
          &#039;   (yield from &lt;expr&gt;)\n&#039;
          &#039;\n&#039;
          &#039;Yield expressions and statements are only used when defining a\n&#039;
          &#039;*generator* function, and are only used in the body of the &#039;
          &#039;generator\n&#039;
          &#039;function.  Using yield in a function definition is sufficient to &#039;
          &#039;cause\n&#039;
          &#039;that definition to create a generator function instead of a normal\n&#039;
          &#039;function.\n&#039;
          &#039;\n&#039;
          &#039;For full details of &quot;yield&quot; semantics, refer to the Yield &#039;
          &#039;expressions\n&#039;
          &#039;section.\n&#039;}
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>