

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: topics.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># -*- coding: utf-8 -*-
# Autogenerated by Sphinx on Sat Aug 26 11:16:28 2017
topics = {&#039;assert&#039;: &#039;\n&#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 -O).  The current code generator emits no code for 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;\n&#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;)+ (expression_list | &#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;\n&#039;
               &#039;(See section Primaries for the syntax definitions for the last &#039;
               &#039;three\n&#039;
               &#039;symbols.)\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 is recursively &#039;
               &#039;defined as\n&#039;
               &#039;follows.\n&#039;
               &#039;\n&#039;
               &#039;* If the target list is a single target: The object is &#039;
               &#039;assigned to\n&#039;
               &#039;  that target.\n&#039;
               &#039;\n&#039;
               &#039;* If the target list is a comma-separated list of targets: &#039;
               &#039;The\n&#039;
               &#039;  object must be an iterable with the same number of items as &#039;
               &#039;there\n&#039;
               &#039;  are targets in the target list, and the items are assigned, &#039;
               &#039;from\n&#039;
               &#039;  left to right, to the corresponding 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; statement in the\n&#039;
               &#039;    current code block: the name is bound to the object in the &#039;
               &#039;current\n&#039;
               &#039;    local namespace.\n&#039;
               &#039;\n&#039;
               &#039;  * Otherwise: the name is bound to the object in the current &#039;
               &#039;global\n&#039;
               &#039;    namespace.\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 a target list enclosed in parentheses or &#039;
               &#039;in\n&#039;
               &#039;  square brackets: The object must be an iterable with the &#039;
               &#039;same number\n&#039;
               &#039;  of items as there are targets in the target list, and its &#039;
               &#039;items are\n&#039;
               &#039;  assigned, from left to right, to the corresponding targets.\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 a plain integer.  If it is negative, &#039;
               &#039;the\n&#039;
               &quot;  sequence&#039;s length is added to it. The resulting value must &quot;
               &#039;be a\n&#039;
               &quot;  nonnegative integer less than the sequence&#039;s length, and &quot;
               &#039;the\n&#039;
               &#039;  sequence is asked to assign the assigned object to its item &#039;
               &#039;with\n&#039;
               &#039;  that index.  If the index is out of range, &quot;IndexError&quot; is &#039;
               &#039;raised\n&#039;
               &#039;  (assignment to a subscripted sequence cannot add new items &#039;
               &#039;to a\n&#039;
               &#039;  list).\n&#039;
               &#039;\n&#039;
               &#039;  If the primary is a mapping object (such as a dictionary), &#039;
               &#039;the\n&#039;
               &quot;  subscript must have a type compatible with the mapping&#039;s key &quot;
               &#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;* 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;
               &quot;  sequence&#039;s length.  The bounds should evaluate to (small) &quot;
               &#039;integers.\n&#039;
               &quot;  If either bound is negative, the sequence&#039;s length is added &quot;
               &#039;to it.\n&#039;
               &#039;  The resulting bounds are clipped to lie between zero and &#039;
               &#039;the\n&#039;
               &quot;  sequence&#039;s length, inclusive.  Finally, the sequence object &quot;
               &#039;is asked\n&#039;
               &#039;  to replace the slice with the items of the assigned &#039;
               &#039;sequence.  The\n&#039;
               &#039;  length of the slice may be different from the length of the &#039;
               &#039;assigned\n&#039;
               &#039;  sequence, thus changing the length of the target sequence, &#039;
               &#039;if the\n&#039;
               &#039;  object 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;WARNING: Although the definition of assignment implies that &#039;
               &#039;overlaps\n&#039;
               &quot;between the left-hand side and the right-hand side are &#039;safe&#039; &quot;
               &#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 are not safe!  For &#039;
               &#039;instance, the\n&#039;
               &#039;following program prints &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\n&#039;
               &#039;   print x\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;\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 for 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;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;atom-identifiers&#039;: &#039;\n&#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;\n&#039;
                  &#039;Literals\n&#039;
                  &#039;********\n&#039;
                  &#039;\n&#039;
                  &#039;Python supports string literals and various numeric &#039;
                  &#039;literals:\n&#039;
                  &#039;\n&#039;
                  &#039;   literal ::= stringliteral | integer | longinteger\n&#039;
                  &#039;               | 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;integer, long integer, floating point number, complex &#039;
                  &#039;number) with the\n&#039;
                  &#039;given value.  The value may be approximated in the case of &#039;
                  &#039;floating\n&#039;
                  &#039;point and imaginary (complex) literals.  See section &#039;
                  &#039;Literals for\n&#039;
                  &#039;details.\n&#039;
                  &#039;\n&#039;
                  &#039;All literals correspond to immutable data types, and hence &#039;
                  &#039;the\n&#039;
                  &quot;object&#039;s identity is less important than its value.  &quot;
                  &#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;\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 an attribute lookup has not found the &#039;
                     &#039;attribute in the\n&#039;
                     &#039;   usual places (i.e. it is not an instance attribute &#039;
                     &#039;nor is it found\n&#039;
                     &#039;   in the class tree for &quot;self&quot;).  &quot;name&quot; is the &#039;
                     &#039;attribute name. This\n&#039;
                     &#039;   method should return the (computed) attribute value &#039;
                     &#039;or raise an\n&#039;
                     &#039;   &quot;AttributeError&quot; 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 in new-style classes.\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 not simply execute &quot;self.name = value&quot; --- &#039;
                     &#039;this would cause\n&#039;
                     &#039;   a recursive call to itself.  Instead, it should &#039;
                     &#039;insert the value in\n&#039;
                     &#039;   the dictionary of instance attributes, e.g., &#039;
                     &#039;&quot;self.__dict__[name] =\n&#039;
                     &#039;   value&quot;.  For new-style classes, rather than accessing &#039;
                     &#039;the instance\n&#039;
                     &#039;   dictionary, it should call the base class method with &#039;
                     &#039;the same\n&#039;
                     &#039;   name, for example, &quot;object.__setattr__(self, name, &#039;
                     &#039;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;\n&#039;
                     &#039;More attribute access for new-style classes\n&#039;
                     &#039;===========================================\n&#039;
                     &#039;\n&#039;
                     &#039;The following methods only apply to new-style classes.\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 &#039;
                     &#039;for new-style\n&#039;
                     &#039;     classes.\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;
                     &quot;owner&#039;s class\n&quot;
                     &#039;dictionary or in the class dictionary for one of its &#039;
                     &#039;parents).  In the\n&#039;
                     &#039;examples below, &quot;the attribute&quot; refers to the attribute &#039;
                     &#039;whose name is\n&#039;
                     &quot;the key of the property in the owner class&#039; &quot;
                     &#039;&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;\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;&quot;binding\n&#039;
                     &#039;behavior&quot;, 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;
                     &quot;the attribute from an object&#039;s dictionary. For instance, &quot;
                     &#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.  Note that descriptors are only &#039;
                     &#039;invoked for new\n&#039;
                     &#039;style objects or classes (ones that subclass &quot;object()&quot; &#039;
                     &#039;or &quot;type()&quot;).\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 a new-style object instance, &quot;a.x&quot; is &#039;
                     &#039;transformed\n&#039;
                     &#039;   into the call: &quot;type(a).__dict__[\&#039;x\&#039;].__get__(a, &#039;
                     &#039;type(a))&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;Class Binding\n&#039;
                     &#039;   If binding to a new-style class, &quot;A.x&quot; is transformed &#039;
                     &#039;into the\n&#039;
                     &#039;   call: &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;
                     &quot;the object&#039;s\n&quot;
                     &#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;By default, instances of both old and new-style classes &#039;
                     &#039;have a\n&#039;
                     &#039;dictionary for attribute storage.  This wastes space for &#039;
                     &#039;objects\n&#039;
                     &#039;having very few instance variables.  The space &#039;
                     &#039;consumption can become\n&#039;
                     &#039;acute when creating large numbers of instances.\n&#039;
                     &#039;\n&#039;
                     &#039;The default can be overridden by defining *__slots__* in &#039;
                     &#039;a new-style\n&#039;
                     &#039;class definition.  The *__slots__* declaration takes a &#039;
                     &#039;sequence of\n&#039;
                     &#039;instance variables and reserves just enough space in &#039;
                     &#039;each instance to\n&#039;
                     &#039;hold a value for each variable.  Space is saved because &#039;
                     &#039;*__dict__* is\n&#039;
                     &#039;not created for each instance.\n&#039;
                     &#039;\n&#039;
                     &#039;__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.  If &#039;
                     &#039;defined in a\n&#039;
                     &#039;   new-style class, *__slots__* reserves space for the &#039;
                     &#039;declared\n&#039;
                     &#039;   variables and prevents the automatic creation of &#039;
                     &#039;*__dict__* and\n&#039;
                     &#039;   *__weakref__* for each instance.\n&#039;
                     &#039;\n&#039;
                     &#039;   New in version 2.2.\n&#039;
                     &#039;\n&#039;
                     &#039;Notes on using *__slots__*\n&#039;
                     &#039;\n&#039;
                     &#039;* When inheriting from a class without *__slots__*, the &#039;
                     &#039;*__dict__*\n&#039;
                     &#039;  attribute of that class will always be accessible, so &#039;
                     &#039;a *__slots__*\n&#039;
                     &#039;  definition in the subclass is meaningless.\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;  Changed in version 2.3: Previously, adding &#039;
                     &#039;&quot;\&#039;__dict__\&#039;&quot; to the\n&#039;
                     &#039;  *__slots__* declaration would not enable the &#039;
                     &#039;assignment of new\n&#039;
                     &#039;  attributes not specifically listed in the sequence of &#039;
                     &#039;instance\n&#039;
                     &#039;  variable names.\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;  Changed in version 2.3: Previously, adding &#039;
                     &#039;&quot;\&#039;__weakref__\&#039;&quot; to the\n&#039;
                     &#039;  *__slots__* declaration would not enable support for &#039;
                     &#039;weak\n&#039;
                     &#039;  references.\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 limited to &#039;
                     &#039;the class\n&#039;
                     &#039;  where it is defined.  As a result, subclasses will &#039;
                     &#039;have a *__dict__*\n&#039;
                     &#039;  unless they also define *__slots__* (which must only &#039;
                     &#039;contain names\n&#039;
                     &#039;  of any *additional* 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;  &quot;variable-length&quot; built-in types such as &quot;long&quot;, &quot;str&quot; &#039;
                     &#039;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;  Changed in version 2.6: Previously, *__class__* &#039;
                     &#039;assignment raised an\n&#039;
                     &#039;  error if either new or old class had *__slots__*.\n&#039;,
 &#039;attribute-references&#039;: &#039;\n&#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, e.g., a module, list, or an &#039;
                         &#039;instance.  This\n&#039;
                         &#039;object is then asked to produce the attribute whose &#039;
                         &#039;name is the\n&#039;
                         &#039;identifier.  If this attribute is not available, the &#039;
                         &#039;exception\n&#039;
                         &#039;&quot;AttributeError&quot; is raised. Otherwise, the type and &#039;
                         &#039;value of the\n&#039;
                         &#039;object produced is determined by the object.  &#039;
                         &#039;Multiple evaluations of\n&#039;
                         &#039;the same attribute reference may yield different &#039;
                         &#039;objects.\n&#039;,
 &#039;augassign&#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 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;\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 for 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;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;\n&#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; u_expr | &#039;
           &#039;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 (plain or long) and the other must be a sequence. In the\n&#039;
           &#039;former case, the numbers are converted to a common type and then\n&#039;
           &#039;multiplied together.  In the latter case, sequence repetition is\n&#039;
           &#039;performed; a negative repetition factor yields an empty sequence.\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. Plain or long integer division yields &#039;
           &#039;an\n&#039;
           &#039;integer of the same type; the result is that of mathematical &#039;
           &#039;division\n&#039;
           &quot;with the &#039;floor&#039; function applied to the result. Division by zero\n&quot;
           &#039;raises the &quot;ZeroDivisionError&quot; 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;[2].\n&#039;
           &#039;\n&#039;
           &#039;The integer division and modulo operators are connected by the\n&#039;
           &#039;following identity: &quot;x == (x/y)*y + (x%y)&quot;.  Integer division and\n&#039;
           &#039;modulo are also connected with the built-in function &quot;divmod()&quot;:\n&#039;
           &#039;&quot;divmod(x, y) == (x/y, x%y)&quot;.  These identities don\&#039;t hold for\n&#039;
           &#039;floating point numbers; there similar identities hold &#039;
           &#039;approximately\n&#039;
           &#039;where &quot;x/y&quot; is replaced by &quot;floor(x/y)&quot; or &quot;floor(x/y) - 1&quot; [3].\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 and unicode objects to &#039;
           &#039;perform\n&#039;
           &#039;string formatting (also known as interpolation). The syntax for &#039;
           &#039;string\n&#039;
           &#039;formatting is described in the Python Library Reference, section\n&#039;
           &#039;String Formatting Operations.\n&#039;
           &#039;\n&#039;
           &#039;Deprecated since version 2.3: The floor division operator, the &#039;
           &#039;modulo\n&#039;
           &#039;operator, and the &quot;divmod()&quot; function are no longer defined for\n&#039;
           &#039;complex numbers.  Instead, convert to a floating point number &#039;
           &#039;using\n&#039;
           &#039;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 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;\n&#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 plain or long integers.  The arguments are converted to a &#039;
            &#039;common\n&#039;
            &#039;type.\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 plain or long integers.  The arguments &#039;
            &#039;are\n&#039;
            &#039;converted to a common type.\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 plain or long integers.  The arguments are &#039;
            &#039;converted to\n&#039;
            &#039;a common type.\n&#039;,
 &#039;bltin-code-objects&#039;: &#039;\n&#039;
                       &#039;Code Objects\n&#039;
                       &#039;************\n&#039;
                       &#039;\n&#039;
                       &#039;Code objects are used by the implementation to &#039;
                       &#039;represent &quot;pseudo-\n&#039;
                       &#039;compiled&quot; executable Python code such as a function &#039;
                       &#039;body. They differ\n&#039;
                       &quot;from function objects because they don&#039;t contain a &quot;
                       &#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;func_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; statement or the built-in &#039;
                       &#039;&quot;eval()&quot;\n&#039;
                       &#039;function.\n&#039;
                       &#039;\n&#039;
                       &#039;See The standard type hierarchy for more &#039;
                       &#039;information.\n&#039;,
 &#039;bltin-ellipsis-object&#039;: &#039;\n&#039;
                          &#039;The Ellipsis Object\n&#039;
                          &#039;*******************\n&#039;
                          &#039;\n&#039;
                          &#039;This object is used by extended slice notation (see &#039;
                          &#039;Slicings).  It\n&#039;
                          &#039;supports no special operations.  There is exactly &#039;
                          &#039;one ellipsis object,\n&#039;
                          &#039;named &quot;Ellipsis&quot; (a built-in name).\n&#039;
                          &#039;\n&#039;
                          &#039;It is written as &quot;Ellipsis&quot;.  When in a subscript, &#039;
                          &#039;it can also be\n&#039;
                          &#039;written as &quot;...&quot;, for example &quot;seq[...]&quot;.\n&#039;,
 &#039;bltin-file-objects&#039;: &#039;\n&#039;
                       &#039;File Objects\n&#039;
                       &#039;************\n&#039;
                       &#039;\n&#039;
                       &#039;File objects are implemented using C\&#039;s &quot;stdio&quot; &#039;
                       &#039;package and can be\n&#039;
                       &#039;created with the built-in &quot;open()&quot; function.  File &#039;
                       &#039;objects are also\n&#039;
                       &#039;returned by some other built-in functions and methods, &#039;
                       &#039;such as\n&#039;
                       &#039;&quot;os.popen()&quot; and &quot;os.fdopen()&quot; and the &quot;makefile()&quot; &#039;
                       &#039;method of socket\n&#039;
                       &#039;objects. Temporary files can be created using the &#039;
                       &#039;&quot;tempfile&quot; module,\n&#039;
                       &#039;and high-level file operations such as copying, &#039;
                       &#039;moving, and deleting\n&#039;
                       &#039;files and directories can be achieved with the &#039;
                       &#039;&quot;shutil&quot; module.\n&#039;
                       &#039;\n&#039;
                       &#039;When a file operation fails for an I/O-related reason, &#039;
                       &#039;the exception\n&#039;
                       &#039;&quot;IOError&quot; is raised.  This includes situations where &#039;
                       &#039;the operation is\n&#039;
                       &#039;not defined for some reason, like &quot;seek()&quot; on a tty &#039;
                       &#039;device or writing\n&#039;
                       &#039;a file opened for reading.\n&#039;
                       &#039;\n&#039;
                       &#039;Files have the following methods:\n&#039;
                       &#039;\n&#039;
                       &#039;file.close()\n&#039;
                       &#039;\n&#039;
                       &#039;   Close the file.  A closed file cannot be read or &#039;
                       &#039;written any more.\n&#039;
                       &#039;   Any operation which requires that the file be open &#039;
                       &#039;will raise a\n&#039;
                       &#039;   &quot;ValueError&quot; after the file has been closed.  &#039;
                       &#039;Calling &quot;close()&quot;\n&#039;
                       &#039;   more than once is allowed.\n&#039;
                       &#039;\n&#039;
                       &#039;   As of Python 2.5, you can avoid having to call this &#039;
                       &#039;method\n&#039;
                       &#039;   explicitly if you use the &quot;with&quot; statement.  For &#039;
                       &#039;example, the\n&#039;
                       &#039;   following code will automatically close *f* when &#039;
                       &#039;the &quot;with&quot; block\n&#039;
                       &#039;   is exited:\n&#039;
                       &#039;\n&#039;
                       &#039;      from __future__ import with_statement # This &#039;
                       &quot;isn&#039;t required in Python 2.6\n&quot;
                       &#039;\n&#039;
                       &#039;      with open(&quot;hello.txt&quot;) as f:\n&#039;
                       &#039;          for line in f:\n&#039;
                       &#039;              print line,\n&#039;
                       &#039;\n&#039;
                       &#039;   In older versions of Python, you would have needed &#039;
                       &#039;to do this to\n&#039;
                       &#039;   get the same effect:\n&#039;
                       &#039;\n&#039;
                       &#039;      f = open(&quot;hello.txt&quot;)\n&#039;
                       &#039;      try:\n&#039;
                       &#039;          for line in f:\n&#039;
                       &#039;              print line,\n&#039;
                       &#039;      finally:\n&#039;
                       &#039;          f.close()\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: Not all &quot;file-like&quot; types in Python support &#039;
                       &#039;use as a\n&#039;
                       &#039;     context manager for the &quot;with&quot; statement.  If &#039;
                       &#039;your code is\n&#039;
                       &#039;     intended to work with any file-like object, you &#039;
                       &#039;can use the\n&#039;
                       &#039;     function &quot;contextlib.closing()&quot; instead of using &#039;
                       &#039;the object\n&#039;
                       &#039;     directly.\n&#039;
                       &#039;\n&#039;
                       &#039;file.flush()\n&#039;
                       &#039;\n&#039;
                       &#039;   Flush the internal buffer, like &quot;stdio&quot;\&#039;s &#039;
                       &#039;&quot;fflush()&quot;.  This may be\n&#039;
                       &#039;   a no-op on some file-like objects.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: &quot;flush()&quot; does not necessarily write the &#039;
                       &quot;file&#039;s data to\n&quot;
                       &#039;     disk. Use &quot;flush()&quot; followed by &quot;os.fsync()&quot; to &#039;
                       &#039;ensure this\n&#039;
                       &#039;     behavior.\n&#039;
                       &#039;\n&#039;
                       &#039;file.fileno()\n&#039;
                       &#039;\n&#039;
                       &#039;   Return the integer &quot;file descriptor&quot; that is used &#039;
                       &#039;by the underlying\n&#039;
                       &#039;   implementation to request I/O operations from the &#039;
                       &#039;operating system.\n&#039;
                       &#039;   This can be useful for other, lower level &#039;
                       &#039;interfaces that use file\n&#039;
                       &#039;   descriptors, such as the &quot;fcntl&quot; module or &#039;
                       &#039;&quot;os.read()&quot; and friends.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: File-like objects which do not have a real &#039;
                       &#039;file descriptor\n&#039;
                       &#039;     should *not* provide this method!\n&#039;
                       &#039;\n&#039;
                       &#039;file.isatty()\n&#039;
                       &#039;\n&#039;
                       &#039;   Return &quot;True&quot; if the file is connected to a &#039;
                       &#039;tty(-like) device, else\n&#039;
                       &#039;   &quot;False&quot;.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: If a file-like object is not associated with &#039;
                       &#039;a real file,\n&#039;
                       &#039;     this method should *not* be implemented.\n&#039;
                       &#039;\n&#039;
                       &#039;file.next()\n&#039;
                       &#039;\n&#039;
                       &#039;   A file object is its own iterator, for example &#039;
                       &#039;&quot;iter(f)&quot; returns\n&#039;
                       &#039;   *f* (unless *f* is closed).  When a file is used as &#039;
                       &#039;an iterator,\n&#039;
                       &#039;   typically in a &quot;for&quot; loop (for example, &quot;for line &#039;
                       &#039;in f: print\n&#039;
                       &#039;   line.strip()&quot;), the &quot;next()&quot; method is called &#039;
                       &#039;repeatedly.  This\n&#039;
                       &#039;   method returns the next input line, or raises &#039;
                       &#039;&quot;StopIteration&quot; when\n&#039;
                       &#039;   EOF is hit when the file is open for reading &#039;
                       &#039;(behavior is undefined\n&#039;
                       &#039;   when the file is open for writing).  In order to &#039;
                       &#039;make a &quot;for&quot; loop\n&#039;
                       &#039;   the most efficient way of looping over the lines of &#039;
                       &#039;a file (a very\n&#039;
                       &#039;   common operation), the &quot;next()&quot; method uses a &#039;
                       &#039;hidden read-ahead\n&#039;
                       &#039;   buffer.  As a consequence of using a read-ahead &#039;
                       &#039;buffer, combining\n&#039;
                       &#039;   &quot;next()&quot; with other file methods (like &#039;
                       &#039;&quot;readline()&quot;) does not work\n&#039;
                       &#039;   right.  However, using &quot;seek()&quot; to reposition the &#039;
                       &#039;file to an\n&#039;
                       &#039;   absolute position will flush the read-ahead &#039;
                       &#039;buffer.\n&#039;
                       &#039;\n&#039;
                       &#039;   New in version 2.3.\n&#039;
                       &#039;\n&#039;
                       &#039;file.read([size])\n&#039;
                       &#039;\n&#039;
                       &#039;   Read at most *size* bytes from the file (less if &#039;
                       &#039;the read hits EOF\n&#039;
                       &#039;   before obtaining *size* bytes).  If the *size* &#039;
                       &#039;argument is negative\n&#039;
                       &#039;   or omitted, read all data until EOF is reached.  &#039;
                       &#039;The bytes are\n&#039;
                       &#039;   returned as a string object.  An empty string is &#039;
                       &#039;returned when EOF\n&#039;
                       &#039;   is encountered immediately.  (For certain files, &#039;
                       &#039;like ttys, it\n&#039;
                       &#039;   makes sense to continue reading after an EOF is &#039;
                       &#039;hit.)  Note that\n&#039;
                       &#039;   this method may call the underlying C function &#039;
                       &#039;&quot;fread()&quot; more than\n&#039;
                       &#039;   once in an effort to acquire as close to *size* &#039;
                       &#039;bytes as possible.\n&#039;
                       &#039;   Also note that when in non-blocking mode, less data &#039;
                       &#039;than was\n&#039;
                       &#039;   requested may be returned, even if no *size* &#039;
                       &#039;parameter was given.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: This function is simply a wrapper for the &#039;
                       &#039;underlying\n&#039;
                       &#039;     &quot;fread()&quot; C function, and will behave the same in &#039;
                       &#039;corner cases,\n&#039;
                       &#039;     such as whether the EOF value is cached.\n&#039;
                       &#039;\n&#039;
                       &#039;file.readline([size])\n&#039;
                       &#039;\n&#039;
                       &#039;   Read one entire line from the file.  A trailing &#039;
                       &#039;newline character\n&#039;
                       &#039;   is kept in the string (but may be absent when a &#039;
                       &#039;file ends with an\n&#039;
                       &#039;   incomplete line). [6] If the *size* argument is &#039;
                       &#039;present and non-\n&#039;
                       &#039;   negative, it is a maximum byte count (including the &#039;
                       &#039;trailing\n&#039;
                       &#039;   newline) and an incomplete line may be returned. &#039;
                       &#039;When *size* is not\n&#039;
                       &#039;   0, an empty string is returned *only* when EOF is &#039;
                       &#039;encountered\n&#039;
                       &#039;   immediately.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: Unlike &quot;stdio&quot;\&#039;s &quot;fgets()&quot;, the returned &#039;
                       &#039;string contains\n&#039;
                       &#039;     null characters (&quot;\&#039;\\0\&#039;&quot;) if they occurred in &#039;
                       &#039;the input.\n&#039;
                       &#039;\n&#039;
                       &#039;file.readlines([sizehint])\n&#039;
                       &#039;\n&#039;
                       &#039;   Read until EOF using &quot;readline()&quot; and return a list &#039;
                       &#039;containing the\n&#039;
                       &#039;   lines thus read.  If the optional *sizehint* &#039;
                       &#039;argument is present,\n&#039;
                       &#039;   instead of reading up to EOF, whole lines totalling &#039;
                       &#039;approximately\n&#039;
                       &#039;   *sizehint* bytes (possibly after rounding up to an &#039;
                       &#039;internal buffer\n&#039;
                       &#039;   size) are read.  Objects implementing a file-like &#039;
                       &#039;interface may\n&#039;
                       &#039;   choose to ignore *sizehint* if it cannot be &#039;
                       &#039;implemented, or cannot\n&#039;
                       &#039;   be implemented efficiently.\n&#039;
                       &#039;\n&#039;
                       &#039;file.xreadlines()\n&#039;
                       &#039;\n&#039;
                       &#039;   This method returns the same thing as &quot;iter(f)&quot;.\n&#039;
                       &#039;\n&#039;
                       &#039;   New in version 2.1.\n&#039;
                       &#039;\n&#039;
                       &#039;   Deprecated since version 2.3: Use &quot;for line in &#039;
                       &#039;file&quot; instead.\n&#039;
                       &#039;\n&#039;
                       &#039;file.seek(offset[, whence])\n&#039;
                       &#039;\n&#039;
                       &#039;   Set the file\&#039;s current position, like &quot;stdio&quot;\&#039;s &#039;
                       &#039;&quot;fseek()&quot;. The\n&#039;
                       &#039;   *whence* argument is optional and defaults to  &#039;
                       &#039;&quot;os.SEEK_SET&quot; or &quot;0&quot;\n&#039;
                       &#039;   (absolute file positioning); other values are &#039;
                       &#039;&quot;os.SEEK_CUR&quot; or &quot;1&quot;\n&#039;
                       &#039;   (seek relative to the current position) and &#039;
                       &#039;&quot;os.SEEK_END&quot; or &quot;2&quot;\n&#039;
                       &quot;   (seek relative to the file&#039;s end).  There is no &quot;
                       &#039;return value.\n&#039;
                       &#039;\n&#039;
                       &#039;   For example, &quot;f.seek(2, os.SEEK_CUR)&quot; advances the &#039;
                       &#039;position by two\n&#039;
                       &#039;   and &quot;f.seek(-3, os.SEEK_END)&quot; sets the position to &#039;
                       &#039;the third to\n&#039;
                       &#039;   last.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note that if the file is opened for appending (mode &#039;
                       &#039;&quot;\&#039;a\&#039;&quot; or\n&#039;
                       &#039;   &quot;\&#039;a+\&#039;&quot;), any &quot;seek()&quot; operations will be undone &#039;
                       &#039;at the next write.\n&#039;
                       &#039;   If the file is only opened for writing in append &#039;
                       &#039;mode (mode &quot;\&#039;a\&#039;&quot;),\n&#039;
                       &#039;   this method is essentially a no-op, but it remains &#039;
                       &#039;useful for files\n&#039;
                       &#039;   opened in append mode with reading enabled (mode &#039;
                       &#039;&quot;\&#039;a+\&#039;&quot;).  If the\n&#039;
                       &#039;   file is opened in text mode (without &quot;\&#039;b\&#039;&quot;), only &#039;
                       &#039;offsets returned\n&#039;
                       &#039;   by &quot;tell()&quot; are legal.  Use of other offsets causes &#039;
                       &#039;undefined\n&#039;
                       &#039;   behavior.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note that not all file objects are seekable.\n&#039;
                       &#039;\n&#039;
                       &#039;   Changed in version 2.6: Passing float values as &#039;
                       &#039;offset has been\n&#039;
                       &#039;   deprecated.\n&#039;
                       &#039;\n&#039;
                       &#039;file.tell()\n&#039;
                       &#039;\n&#039;
                       &quot;   Return the file&#039;s current position, like &quot;
                       &#039;&quot;stdio&quot;\&#039;s &quot;ftell()&quot;.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: On Windows, &quot;tell()&quot; can return illegal &#039;
                       &#039;values (after an\n&#039;
                       &#039;     &quot;fgets()&quot;) when reading files with Unix-style &#039;
                       &#039;line-endings. Use\n&#039;
                       &#039;     binary mode (&quot;\&#039;rb\&#039;&quot;) to circumvent this &#039;
                       &#039;problem.\n&#039;
                       &#039;\n&#039;
                       &#039;file.truncate([size])\n&#039;
                       &#039;\n&#039;
                       &quot;   Truncate the file&#039;s size.  If the optional *size* &quot;
                       &#039;argument is\n&#039;
                       &#039;   present, the file is truncated to (at most) that &#039;
                       &#039;size.  The size\n&#039;
                       &#039;   defaults to the current position. The current file &#039;
                       &#039;position is not\n&#039;
                       &#039;   changed.  Note that if a specified size exceeds the &#039;
                       &quot;file&#039;s current\n&quot;
                       &#039;   size, the result is platform-dependent:  &#039;
                       &#039;possibilities include that\n&#039;
                       &#039;   the file may remain unchanged, increase to the &#039;
                       &#039;specified size as if\n&#039;
                       &#039;   zero-filled, or increase to the specified size with &#039;
                       &#039;undefined new\n&#039;
                       &#039;   content. Availability:  Windows, many Unix &#039;
                       &#039;variants.\n&#039;
                       &#039;\n&#039;
                       &#039;file.write(str)\n&#039;
                       &#039;\n&#039;
                       &#039;   Write a string to the file.  There is no return &#039;
                       &#039;value.  Due to\n&#039;
                       &#039;   buffering, the string may not actually show up in &#039;
                       &#039;the file until\n&#039;
                       &#039;   the &quot;flush()&quot; or &quot;close()&quot; method is called.\n&#039;
                       &#039;\n&#039;
                       &#039;file.writelines(sequence)\n&#039;
                       &#039;\n&#039;
                       &#039;   Write a sequence of strings to the file.  The &#039;
                       &#039;sequence can be any\n&#039;
                       &#039;   iterable object producing strings, typically a list &#039;
                       &#039;of strings.\n&#039;
                       &#039;   There is no return value. (The name is intended to &#039;
                       &#039;match\n&#039;
                       &#039;   &quot;readlines()&quot;; &quot;writelines()&quot; does not add line &#039;
                       &#039;separators.)\n&#039;
                       &#039;\n&#039;
                       &#039;Files support the iterator protocol.  Each iteration &#039;
                       &#039;returns the same\n&#039;
                       &#039;result as &quot;readline()&quot;, and iteration ends when the &#039;
                       &#039;&quot;readline()&quot;\n&#039;
                       &#039;method returns an empty string.\n&#039;
                       &#039;\n&#039;
                       &#039;File objects also offer a number of other interesting &#039;
                       &#039;attributes.\n&#039;
                       &#039;These are not required for file-like objects, but &#039;
                       &#039;should be\n&#039;
                       &#039;implemented if they make sense for the particular &#039;
                       &#039;object.\n&#039;
                       &#039;\n&#039;
                       &#039;file.closed\n&#039;
                       &#039;\n&#039;
                       &#039;   bool indicating the current state of the file &#039;
                       &#039;object.  This is a\n&#039;
                       &#039;   read-only attribute; the &quot;close()&quot; method changes &#039;
                       &#039;the value. It may\n&#039;
                       &#039;   not be available on all file-like objects.\n&#039;
                       &#039;\n&#039;
                       &#039;file.encoding\n&#039;
                       &#039;\n&#039;
                       &#039;   The encoding that this file uses. When Unicode &#039;
                       &#039;strings are written\n&#039;
                       &#039;   to a file, they will be converted to byte strings &#039;
                       &#039;using this\n&#039;
                       &#039;   encoding. In addition, when the file is connected &#039;
                       &#039;to a terminal,\n&#039;
                       &#039;   the attribute gives the encoding that the terminal &#039;
                       &#039;is likely to use\n&#039;
                       &#039;   (that  information might be incorrect if the user &#039;
                       &#039;has misconfigured\n&#039;
                       &#039;   the  terminal). The attribute is read-only and may &#039;
                       &#039;not be present\n&#039;
                       &#039;   on all file-like objects. It may also be &quot;None&quot;, in &#039;
                       &#039;which case the\n&#039;
                       &#039;   file uses the system default encoding for &#039;
                       &#039;converting Unicode\n&#039;
                       &#039;   strings.\n&#039;
                       &#039;\n&#039;
                       &#039;   New in version 2.3.\n&#039;
                       &#039;\n&#039;
                       &#039;file.errors\n&#039;
                       &#039;\n&#039;
                       &#039;   The Unicode error handler used along with the &#039;
                       &#039;encoding.\n&#039;
                       &#039;\n&#039;
                       &#039;   New in version 2.6.\n&#039;
                       &#039;\n&#039;
                       &#039;file.mode\n&#039;
                       &#039;\n&#039;
                       &#039;   The I/O mode for the file.  If the file was created &#039;
                       &#039;using the\n&#039;
                       &#039;   &quot;open()&quot; built-in function, this will be the value &#039;
                       &#039;of the *mode*\n&#039;
                       &#039;   parameter.  This is a read-only attribute and may &#039;
                       &#039;not be present on\n&#039;
                       &#039;   all file-like objects.\n&#039;
                       &#039;\n&#039;
                       &#039;file.name\n&#039;
                       &#039;\n&#039;
                       &#039;   If the file object was created using &quot;open()&quot;, the &#039;
                       &#039;name of the\n&#039;
                       &#039;   file. Otherwise, some string that indicates the &#039;
                       &#039;source of the file\n&#039;
                       &#039;   object, of the form &quot;&lt;...&gt;&quot;.  This is a read-only &#039;
                       &#039;attribute and may\n&#039;
                       &#039;   not be present on all file-like objects.\n&#039;
                       &#039;\n&#039;
                       &#039;file.newlines\n&#039;
                       &#039;\n&#039;
                       &#039;   If Python was built with *universal newlines* &#039;
                       &#039;enabled (the default)\n&#039;
                       &#039;   this read-only attribute exists, and for files &#039;
                       &#039;opened in universal\n&#039;
                       &#039;   newline read mode it keeps track of the types of &#039;
                       &#039;newlines\n&#039;
                       &#039;   encountered while reading the file. The values it &#039;
                       &#039;can take are\n&#039;
                       &#039;   &quot;\&#039;\\r\&#039;&quot;, &quot;\&#039;\\n\&#039;&quot;, &quot;\&#039;\\r\\n\&#039;&quot;, &quot;None&quot; &#039;
                       &#039;(unknown, no newlines read yet) or\n&#039;
                       &#039;   a tuple containing all the newline types seen, to &#039;
                       &#039;indicate that\n&#039;
                       &#039;   multiple newline conventions were encountered. For &#039;
                       &#039;files not opened\n&#039;
                       &#039;   in universal newlines read mode the value of this &#039;
                       &#039;attribute will be\n&#039;
                       &#039;   &quot;None&quot;.\n&#039;
                       &#039;\n&#039;
                       &#039;file.softspace\n&#039;
                       &#039;\n&#039;
                       &#039;   Boolean that indicates whether a space character &#039;
                       &#039;needs to be\n&#039;
                       &#039;   printed before another value when using the &quot;print&quot; &#039;
                       &#039;statement.\n&#039;
                       &#039;   Classes that are trying to simulate a file object &#039;
                       &#039;should also have\n&#039;
                       &#039;   a writable &quot;softspace&quot; attribute, which should be &#039;
                       &#039;initialized to\n&#039;
                       &#039;   zero.  This will be automatic for most classes &#039;
                       &#039;implemented in\n&#039;
                       &#039;   Python (care may be needed for objects that &#039;
                       &#039;override attribute\n&#039;
                       &#039;   access); types implemented in C will have to &#039;
                       &#039;provide a writable\n&#039;
                       &#039;   &quot;softspace&quot; attribute.\n&#039;
                       &#039;\n&#039;
                       &#039;   Note: This attribute is not used to control the &#039;
                       &#039;&quot;print&quot;\n&#039;
                       &#039;     statement, but to allow the implementation of &#039;
                       &#039;&quot;print&quot; to keep\n&#039;
                       &#039;     track of its internal state.\n&#039;,
 &#039;bltin-null-object&#039;: &#039;\n&#039;
                      &#039;The Null Object\n&#039;
                      &#039;***************\n&#039;
                      &#039;\n&#039;
                      &quot;This object is returned by functions that don&#039;t &quot;
                      &#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).\n&#039;
                      &#039;\n&#039;
                      &#039;It is written as &quot;None&quot;.\n&#039;,
 &#039;bltin-type-objects&#039;: &#039;\n&#039;
                       &#039;Type Objects\n&#039;
                       &#039;************\n&#039;
                       &#039;\n&#039;
                       &#039;Type objects represent the various object types.  An &#039;
                       &quot;object&#039;s type is\n&quot;
                       &#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;type \&#039;int\&#039;&gt;&quot;.\n&#039;,
 &#039;booleans&#039;: &#039;\n&#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.  (See the &quot;__nonzero__()&quot; special method for a way to &#039;
             &#039;change\n&#039;
             &#039;this.)\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;invent a\n&#039;
             &#039;value anyway, it does not bother to return a value of the same &#039;
             &#039;type as\n&#039;
             &#039;its argument, so e.g., &quot;not \&#039;foo\&#039;&quot; yields &quot;False&quot;, not &#039;
             &#039;&quot;\&#039;\&#039;&quot;.)\n&#039;,
 &#039;break&#039;: &#039;\n&#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;\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 &quot;called&quot; 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;\n&#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;]\n&#039;
          &#039;            | expression genexpr_for] &quot;)&quot;\n&#039;
          &#039;   argument_list        ::= positional_arguments [&quot;,&quot; &#039;
          &#039;keyword_arguments]\n&#039;
          &#039;                       [&quot;,&quot; &quot;*&quot; expression] [&quot;,&quot; &#039;
          &#039;keyword_arguments]\n&#039;
          &#039;                       [&quot;,&quot; &quot;**&quot; expression]\n&#039;
          &#039;                     | keyword_arguments [&quot;,&quot; &quot;*&quot; expression]\n&#039;
          &#039;                       [&quot;,&quot; &quot;**&quot; expression]\n&#039;
          &#039;                     | &quot;*&quot; expression [&quot;,&quot; keyword_arguments] [&quot;,&quot; &#039;
          &#039;&quot;**&quot; expression]\n&#039;
          &#039;                     | &quot;**&quot; expression\n&#039;
          &#039;   positional_arguments ::= expression (&quot;,&quot; expression)*\n&#039;
          &#039;   keyword_arguments    ::= keyword_item (&quot;,&quot; keyword_item)*\n&#039;
          &#039;   keyword_item         ::= identifier &quot;=&quot; expression\n&#039;
          &#039;\n&#039;
          &#039;A trailing comma may be present after the positional and keyword\n&#039;
          &#039;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 certain class instances\n&#039;
          &#039;themselves are callable; extensions may define additional callable\n&#039;
          &#039;object types).  All argument expressions are evaluated before the &#039;
          &#039;call\n&#039;
          &#039;is attempted.  Please refer to section Function definitions for &#039;
          &#039;the\n&#039;
          &#039;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;
          &quot;be shared by all calls that don&#039;t specify an argument value for &quot;
          &#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;
          &quot;if they are &#039;named&#039; for the purpose of documentation, and which\n&quot;
          &#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 this iterable are &#039;
          &#039;treated\n&#039;
          &#039;as if they were additional positional arguments; if there are\n&#039;
          &#039;positional arguments *x1*, ..., *xN*, and &quot;expression&quot; evaluates to &#039;
          &#039;a\n&#039;
          &#039;sequence *y1*, ..., *yM*, this is equivalent to a call with M+N\n&#039;
          &#039;positional arguments *x1*, ..., *xN*, *y1*, ..., *yM*.\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* some keyword arguments, it is processed *before* &#039;
          &#039;the\n&#039;
          &#039;keyword arguments (and the &quot;**expression&quot; argument, if any -- see\n&#039;
          &#039;below).  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 are\n&#039;
          &#039;treated as additional keyword arguments.  In the case of a keyword\n&#039;
          &#039;appearing in both &quot;expression&quot; and as an explicit keyword argument, &#039;
          &#039;a\n&#039;
          &#039;&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.  Formal parameters using the syntax &quot;(sublist)&quot; cannot be &#039;
          &#039;used\n&#039;
          &#039;as keyword argument names; the outermost sublist corresponds to a\n&#039;
          &#039;single unnamed argument slot, and the argument value is assigned &#039;
          &#039;to\n&#039;
          &#039;the sublist using the usual tuple assignment rules after all other\n&#039;
          &#039;parameter processing is done.\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;\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    ::= &quot;class&quot; classname [inheritance] &quot;:&quot; suite\n&#039;
          &#039;   inheritance ::= &quot;(&quot; [expression_list] &quot;)&quot;\n&#039;
          &#039;   classname   ::= identifier\n&#039;
          &#039;\n&#039;
          &#039;A class definition is an executable statement.  It first evaluates &#039;
          &#039;the\n&#039;
          &#039;inheritance list, if present.  Each item in the inheritance list\n&#039;
          &#039;should evaluate to a class object or class type which allows\n&#039;
          &quot;subclassing.  The class&#039;s suite is then executed in a new &quot;
          &#039;execution\n&#039;
          &#039;frame (see section Naming and binding), using a newly created &#039;
          &#039;local\n&#039;
          &#039;namespace and the original global namespace. (Usually, the suite\n&#039;
          &quot;contains only function definitions.)  When the class&#039;s suite &quot;
          &#039;finishes\n&#039;
          &#039;execution, its execution frame is discarded but its local namespace &#039;
          &#039;is\n&#039;
          &#039;saved. [4] A class object is then created using the inheritance &#039;
          &#039;list\n&#039;
          &#039;for the base classes and the saved local namespace for the &#039;
          &#039;attribute\n&#039;
          &#039;dictionary.  The class name is bound to this class object in the\n&#039;
          &#039;original local namespace.\n&#039;
          &#039;\n&#039;
          &quot;**Programmer&#039;s note:** Variables defined in the class definition &quot;
          &#039;are\n&#039;
          &#039;class variables; they are shared by all instances.  To create &#039;
          &#039;instance\n&#039;
          &#039;variables, they can be set in a method with &quot;self.name = value&quot;.  &#039;
          &#039;Both\n&#039;
          &#039;class and instance variables are accessible through the notation\n&#039;
          &#039;&quot;&quot;self.name&quot;&quot;, and an instance variable hides a class variable &#039;
          &#039;with\n&#039;
          &#039;the same name when accessed in this way. Class variables can be &#039;
          &#039;used\n&#039;
          &#039;as defaults for instance variables, but using mutable values there &#039;
          &#039;can\n&#039;
          &#039;lead to unexpected results.  For *new-style class*es, descriptors &#039;
          &#039;can\n&#039;
          &#039;be used to create instance variables with different implementation\n&#039;
          &#039;details.\n&#039;
          &#039;\n&#039;
          &#039;Class definitions, like function definitions, may be wrapped by one &#039;
          &#039;or\n&#039;
          &#039;more *decorator* expressions.  The evaluation rules for the &#039;
          &#039;decorator\n&#039;
          &#039;expressions are the same as for functions.  The result must be a &#039;
          &#039;class\n&#039;
          &#039;object, which is then bound to the class name.\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 lost.\n&#039;
          &#039;\n&#039;
          &#039;[2] Currently, control &quot;flows off the end&quot; except in the case of\n&#039;
          &#039;    an exception or the execution of a &quot;return&quot;, &quot;continue&quot;, or\n&#039;
          &#039;    &quot;break&quot; statement.\n&#039;
          &#039;\n&#039;
          &#039;[3] A string literal appearing as the first statement in the\n&#039;
          &#039;    function body is transformed into the function\&#039;s &quot;__doc__&quot;\n&#039;
          &quot;    attribute and therefore the function&#039;s *docstring*.\n&quot;
          &#039;\n&#039;
          &#039;[4] A string literal appearing as the first statement in the class\n&#039;
          &#039;    body is transformed into the namespace\&#039;s &quot;__doc__&quot; item and\n&#039;
          &quot;    therefore the class&#039;s *docstring*.\n&quot;,
 &#039;comparisons&#039;: &#039;\n&#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;&lt;&gt;&quot; | &#039;
                &#039;&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 &#039;
                &#039;c ... 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\&#039;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;The forms &quot;&lt;&gt;&quot; and &quot;!=&quot; are equivalent; for consistency with &#039;
                &#039;C, &quot;!=&quot;\n&#039;
                &#039;is preferred; where &quot;!=&quot; is mentioned below &quot;&lt;&gt;&quot; is also &#039;
                &#039;accepted.\n&#039;
                &#039;The &quot;&lt;&gt;&quot; spelling is considered obsolescent.\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;
                &quot;method for an object&#039;s value.  Also, there is no requirement &quot;
                &#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;Types can customize their comparison behavior by implementing &#039;
                &#039;a\n&#039;
                &#039;&quot;__cmp__()&quot; method or *rich comparison methods* like &#039;
                &#039;&quot;__lt__()&quot;,\n&#039;
                &#039;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;The default order comparison (&quot;&lt;&quot;, &quot;&gt;&quot;, &quot;&lt;=&quot;, and &quot;&gt;=&quot;) gives &#039;
                &#039;a\n&#039;
                &#039;consistent but arbitrary order.\n&#039;
                &#039;\n&#039;
                &#039;(This unusual definition of comparison was used to simplify &#039;
                &#039;the\n&#039;
                &#039;definition of operations like sorting and the &quot;in&quot; and &quot;not &#039;
                &#039;in&quot;\n&#039;
                &#039;operators. In the future, the comparison rules for objects &#039;
                &#039;of\n&#039;
                &#039;different types are likely to change.)\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;  long, complex) and of the standard library types\n&#039;
                &#039;  &quot;fractions.Fraction&quot; and &quot;decimal.Decimal&quot; can be compared &#039;
                &#039;within\n&#039;
                &#039;  and across their types, with the restriction that complex &#039;
                &#039;numbers do\n&#039;
                &#039;  not support order comparison.  Within the limits of the &#039;
                &#039;types\n&#039;
                &#039;  involved, they compare mathematically (algorithmically) &#039;
                &#039;correct\n&#039;
                &#039;  without loss of precision.\n&#039;
                &#039;\n&#039;
                &#039;* Strings (instances of &quot;str&quot; or &quot;unicode&quot;) compare\n&#039;
                &#039;  lexicographically using the numeric equivalents (the result &#039;
                &#039;of the\n&#039;
                &#039;  built-in function &quot;ord()&quot;) of their characters. [4] When &#039;
                &#039;comparing\n&#039;
                &#039;  an 8-bit string and a Unicode string, the 8-bit string is &#039;
                &#039;converted\n&#039;
                &#039;  to Unicode.  If the conversion fails, the strings are &#039;
                &#039;considered\n&#039;
                &#039;  unequal.\n&#039;
                &#039;\n&#039;
                &#039;* Instances of &quot;tuple&quot; or &quot;list&quot; can be compared only within &#039;
                &#039;each of\n&#039;
                &#039;  their types.  Equality comparison across these types &#039;
                &#039;results in\n&#039;
                &#039;  unequality, and ordering comparison across these types &#039;
                &#039;gives an\n&#039;
                &#039;  arbitrary order.\n&#039;
                &#039;\n&#039;
                &#039;  These sequences compare lexicographically using comparison &#039;
                &#039;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.\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 are ordered the same as their first unequal &#039;
                &#039;elements\n&#039;
                &#039;    (for example, &quot;cmp([1,2,x], [1,2,y])&quot; returns the same &#039;
                &#039;as\n&#039;
                &#039;    &quot;cmp(x,y)&quot;).  If a corresponding element does not exist, &#039;
                &#039;the\n&#039;
                &#039;    shorter collection is ordered first (for example, &quot;[1,2] &#039;
                &#039;&lt;\n&#039;
                &#039;    [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;  Outcomes other than equality are resolved consistently, but &#039;
                &#039;are not\n&#039;
                &#039;  otherwise defined. [5]\n&#039;
                &#039;\n&#039;
                &#039;* Most other objects of built-in types compare unequal unless &#039;
                &#039;they\n&#039;
                &#039;  are the same object; the choice whether one object is &#039;
                &#039;considered\n&#039;
                &#039;  smaller or larger than another one is made arbitrarily but\n&#039;
                &#039;  consistently within one execution of a program.\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.\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.  &quot;x is &#039;
                &#039;not y&quot;\n&#039;
                &#039;yields the inverse truth value. [6]\n&#039;,
 &#039;compound&#039;: &#039;\n&#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.  Function and class definitions &#039;
             &#039;are\n&#039;
             &#039;also syntactically compound statements.\n&#039;
             &#039;\n&#039;
             &quot;Compound statements consist of one or more &#039;clauses.&#039;  A clause\n&quot;
             &quot;consists of a header and a &#039;suite.&#039;  The clause headers of a\n&quot;
             &#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;
             &quot;header&#039;s\n&quot;
             &#039;colon, or it can be one or more indented statements on &#039;
             &#039;subsequent\n&#039;
             &#039;lines.  Only the latter form of suite can contain nested &#039;
             &#039;compound\n&#039;
             &quot;statements; the following is illegal, mostly because it wouldn&#039;t &quot;
             &#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; statements 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;                     | decorated\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 \&#039;dangling &quot;else&quot;\&#039; 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\&#039;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 of ascending indices.  &#039;
             &#039;Each\n&#039;
             &#039;item in turn is assigned to the target list using the standard &#039;
             &#039;rules\n&#039;
             &#039;for assignments, and then the suite is executed.  When the items &#039;
             &#039;are\n&#039;
             &#039;exhausted (which is immediately when the sequence is empty), the &#039;
             &#039;suite\n&#039;
             &#039;in the &quot;else&quot; clause, if present, is executed, and the 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\&#039;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 was no &#039;
             &#039;next\n&#039;
             &#039;item.\n&#039;
             &#039;\n&#039;
             &#039;The suite may assign to the variable(s) in the target list; this &#039;
             &#039;does\n&#039;
             &#039;not affect the next item assigned to it.\n&#039;
             &#039;\n&#039;
             &#039;The target list is not deleted when the loop is finished, but if &#039;
             &#039;the\n&#039;
             &#039;sequence is empty, it will not have been assigned to at all by &#039;
             &#039;the\n&#039;
             &#039;loop.  Hint: the built-in function &quot;range()&quot; returns a sequence &#039;
             &#039;of\n&#039;
             &#039;integers suitable to emulate the effect of Pascal\&#039;s &quot;for i := a &#039;
             &#039;to b\n&#039;
             &#039;do&quot;; e.g., &quot;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 &#039;
             &#039;the\n&#039;
             &#039;  loop (this can only occur for mutable sequences, i.e. 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; | &quot;,&quot;) &#039;
             &#039;identifier]] &quot;:&quot; 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;Changed in version 2.5: In previous versions of Python,\n&#039;
             &#039;&quot;try&quot;...&quot;except&quot;...&quot;finally&quot; did not work. &quot;try&quot;...&quot;except&quot; had &#039;
             &#039;to be\n&#039;
             &#039;nested in &quot;try&quot;...&quot;finally&quot;.\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 &quot;compatible&quot; 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 in that except clause, if present, and the &#039;
             &#039;except\n&#039;
             &quot;clause&#039;s suite is executed.  All except clauses must have an\n&quot;
             &#039;executable block.  When the end of this block is reached, &#039;
             &#039;execution\n&#039;
             &#039;continues normally after the entire try statement.  (This means &#039;
             &#039;that\n&#039;
             &#039;if two nested handlers exist for the same exception, and the &#039;
             &#039;exception\n&#039;
             &#039;occurs in the try clause of the inner handler, the outer handler &#039;
             &#039;will\n&#039;
             &#039;not handle the exception.)\n&#039;
             &#039;\n&#039;
             &quot;Before an except clause&#039;s suite is executed, details about the\n&quot;
             &#039;exception are assigned to three variables in the &quot;sys&quot; module:\n&#039;
             &#039;&quot;sys.exc_type&quot; receives the object identifying the exception;\n&#039;
             &#039;&quot;sys.exc_value&quot; receives the exception\&#039;s parameter;\n&#039;
             &#039;&quot;sys.exc_traceback&quot; receives a traceback object (see section &#039;
             &#039;The\n&#039;
             &#039;standard type hierarchy) identifying the point in the program &#039;
             &#039;where\n&#039;
             &#039;the exception occurred. These details are also available through &#039;
             &#039;the\n&#039;
             &#039;&quot;sys.exc_info()&quot; function, which returns a tuple &quot;(exc_type,\n&#039;
             &#039;exc_value, exc_traceback)&quot;.  Use of the corresponding variables &#039;
             &#039;is\n&#039;
             &#039;deprecated in favor of this function, since their use is unsafe &#039;
             &#039;in a\n&#039;
             &#039;threaded program.  As of Python 1.5, the variables are restored &#039;
             &#039;to\n&#039;
             &#039;their previous values (before the call) when returning from a &#039;
             &#039;function\n&#039;
             &#039;that handled an exception.\n&#039;
             &#039;\n&#039;
             &#039;The optional &quot;else&quot; clause is executed if and when control flows &#039;
             &#039;off\n&#039;
             &#039;the end of the &quot;try&quot; clause. [2] 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 \&#039;cleanup\&#039; handler.  &#039;
             &#039;The &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\n&#039;
             &#039;&quot;finally&quot; clause. If the &quot;finally&quot; clause raises another &#039;
             &#039;exception or\n&#039;
             &#039;executes a &quot;return&quot; or &quot;break&quot; statement, the saved exception &#039;
             &#039;is\n&#039;
             &#039;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; &#039;
             &#039;clause is\n&#039;
             &#039;also executed \&#039;on the way out.\&#039; 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 &#039;
             &#039;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;New in version 2.5.\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 &#039;
             &#039;&quot;try&quot;...&quot;except&quot;...&quot;finally&quot;\n&#039;
             &#039;usage 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 &quot;item&quot; 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\&#039;s &quot;__exit__()&quot; is loaded for later use.\n&#039;
             &#039;\n&#039;
             &#039;3. The context manager\&#039;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\&#039;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;Note: In Python 2.5, the &quot;with&quot; statement is only allowed when &#039;
             &#039;the\n&#039;
             &#039;  &quot;with_statement&quot; feature has been enabled.  It is always &#039;
             &#039;enabled in\n&#039;
             &#039;  Python 2.6.\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 2.7: Support for multiple context &#039;
             &#039;expressions.\n&#039;
             &#039;\n&#039;
             &#039;See also:\n&#039;
             &#039;\n&#039;
             &#039;  **PEP 343** - The &quot;with&quot; 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;   decorated      ::= decorators (classdef | funcdef)\n&#039;
             &#039;   decorators     ::= decorator+\n&#039;
             &#039;   decorator      ::= &quot;@&quot; dotted_name [&quot;(&quot; [argument_list [&quot;,&quot;]] &#039;
             &#039;&quot;)&quot;] NEWLINE\n&#039;
             &#039;   funcdef        ::= &quot;def&quot; funcname &quot;(&quot; [parameter_list] &quot;)&quot; &#039;
             &#039;&quot;:&quot; suite\n&#039;
             &#039;   dotted_name    ::= identifier (&quot;.&quot; identifier)*\n&#039;
             &#039;   parameter_list ::= (defparameter &quot;,&quot;)*\n&#039;
             &#039;                      (  &quot;*&quot; identifier [&quot;,&quot; &quot;**&quot; identifier]\n&#039;
             &#039;                      | &quot;**&quot; identifier\n&#039;
             &#039;                      | defparameter [&quot;,&quot;] )\n&#039;
             &#039;   defparameter   ::= parameter [&quot;=&quot; expression]\n&#039;
             &#039;   sublist        ::= parameter (&quot;,&quot; parameter)* [&quot;,&quot;]\n&#039;
             &#039;   parameter      ::= identifier | &quot;(&quot; sublist &quot;)&quot;\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. [3]\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 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;When one or more top-level *parameters* have the form &#039;
             &#039;*parameter* &quot;=&quot;\n&#039;
             &#039;*expression*, the function is said to have &quot;default parameter &#039;
             &#039;values.&quot;\n&#039;
             &#039;For a parameter with a default value, the corresponding &#039;
             &#039;*argument* may\n&#039;
             &quot;be omitted from a call, in which case the parameter&#039;s default &quot;
             &#039;value is\n&#039;
             &#039;substituted.  If a parameter has a default value, all following\n&#039;
             &#039;parameters must also have a default value --- this is a &#039;
             &#039;syntactic\n&#039;
             &#039;restriction that is not expressed by the grammar.\n&#039;
             &#039;\n&#039;
             &#039;**Default parameter values are evaluated when the function &#039;
             &#039;definition\n&#039;
             &#039;is executed.**  This means that the expression is evaluated &#039;
             &#039;once, when\n&#039;
             &#039;the function is defined, and that the same &quot;pre-computed&quot; value &#039;
             &#039;is\n&#039;
             &#039;used for each call.  This is especially important to understand &#039;
             &#039;when a\n&#039;
             &#039;default parameter is a mutable object, such as a list or a &#039;
             &#039;dictionary:\n&#039;
             &#039;if the function modifies the object (e.g. by appending an item &#039;
             &#039;to a\n&#039;
             &#039;list), the default value is in effect modified. This is &#039;
             &#039;generally not\n&#039;
             &#039;what was intended.  A way around this  is to use &quot;None&quot; as the\n&#039;
             &#039;default, and explicitly test for it in the body of the function, &#039;
             &#039;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;&quot;*identifier&quot;&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;&quot;**identifier&quot;&quot; is present, it is initialized to a new &#039;
             &#039;dictionary\n&#039;
             &#039;receiving any excess keyword arguments, defaulting to a new &#039;
             &#039;empty\n&#039;
             &#039;dictionary.\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;&quot;def&quot;&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;&quot;def&quot;&quot; form is actually more powerful since &#039;
             &#039;it\n&#039;
             &#039;allows the execution of multiple statements.\n&#039;
             &#039;\n&#039;
             &quot;**Programmer&#039;s note:** Functions are first-class objects.  A &quot;
             &#039;&quot;&quot;def&quot;&quot;\n&#039;
             &#039;form executed inside a function definition defines a local &#039;
             &#039;function\n&#039;
             &#039;that can be returned or passed around.  Free variables used in &#039;
             &#039;the\n&#039;
             &#039;nested function can access the local variables of the function\n&#039;
             &#039;containing the def.  See section Naming and binding for &#039;
             &#039;details.\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    ::= &quot;class&quot; classname [inheritance] &quot;:&quot; suite\n&#039;
             &#039;   inheritance ::= &quot;(&quot; [expression_list] &quot;)&quot;\n&#039;
             &#039;   classname   ::= identifier\n&#039;
             &#039;\n&#039;
             &#039;A class definition is an executable statement.  It first &#039;
             &#039;evaluates the\n&#039;
             &#039;inheritance list, if present.  Each item in the inheritance &#039;
             &#039;list\n&#039;
             &#039;should evaluate to a class object or class type which allows\n&#039;
             &quot;subclassing.  The class&#039;s suite is then executed in a new &quot;
             &#039;execution\n&#039;
             &#039;frame (see section Naming and binding), using a newly created &#039;
             &#039;local\n&#039;
             &#039;namespace and the original global namespace. (Usually, the &#039;
             &#039;suite\n&#039;
             &quot;contains only function definitions.)  When the class&#039;s suite &quot;
             &#039;finishes\n&#039;
             &#039;execution, its execution frame is discarded but its local &#039;
             &#039;namespace is\n&#039;
             &#039;saved. [4] A class object is then created using the inheritance &#039;
             &#039;list\n&#039;
             &#039;for the base classes and the saved local namespace for the &#039;
             &#039;attribute\n&#039;
             &#039;dictionary.  The class name is bound to this class object in &#039;
             &#039;the\n&#039;
             &#039;original local namespace.\n&#039;
             &#039;\n&#039;
             &quot;**Programmer&#039;s note:** Variables defined in the class definition &quot;
             &#039;are\n&#039;
             &#039;class variables; they are shared by all instances.  To create &#039;
             &#039;instance\n&#039;
             &#039;variables, they can be set in a method with &quot;self.name = &#039;
             &#039;value&quot;.  Both\n&#039;
             &#039;class and instance variables are accessible through the &#039;
             &#039;notation\n&#039;
             &#039;&quot;&quot;self.name&quot;&quot;, and an instance variable hides a class variable &#039;
             &#039;with\n&#039;
             &#039;the same name when accessed in this way. Class variables can be &#039;
             &#039;used\n&#039;
             &#039;as defaults for instance variables, but using mutable values &#039;
             &#039;there can\n&#039;
             &#039;lead to unexpected results.  For *new-style class*es, &#039;
             &#039;descriptors can\n&#039;
             &#039;be used to create instance variables with different &#039;
             &#039;implementation\n&#039;
             &#039;details.\n&#039;
             &#039;\n&#039;
             &#039;Class definitions, like function definitions, may be wrapped by &#039;
             &#039;one or\n&#039;
             &#039;more *decorator* expressions.  The evaluation rules for the &#039;
             &#039;decorator\n&#039;
             &#039;expressions are the same as for functions.  The result must be a &#039;
             &#039;class\n&#039;
             &#039;object, which is then bound to the class name.\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] Currently, control &quot;flows off the end&quot; except in the case &#039;
             &#039;of\n&#039;
             &#039;    an exception or the execution of a &quot;return&quot;, &quot;continue&quot;, or\n&#039;
             &#039;    &quot;break&quot; statement.\n&#039;
             &#039;\n&#039;
             &#039;[3] A string literal appearing as the first statement in the\n&#039;
             &#039;    function body is transformed into the function\&#039;s &quot;__doc__&quot;\n&#039;
             &quot;    attribute and therefore the function&#039;s *docstring*.\n&quot;
             &#039;\n&#039;
             &#039;[4] A string literal appearing as the first statement in the &#039;
             &#039;class\n&#039;
             &#039;    body is transformed into the namespace\&#039;s &quot;__doc__&quot; item &#039;
             &#039;and\n&#039;
             &quot;    therefore the class&#039;s *docstring*.\n&quot;,
 &#039;context-managers&#039;: &#039;\n&#039;
                     &#039;With Statement Context Managers\n&#039;
                     &#039;*******************************\n&#039;
                     &#039;\n&#039;
                     &#039;New in version 2.5.\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;
                     &quot;   statement will bind this method&#039;s return value to the &quot;
                     &#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;
                     &quot;   exception; this is the caller&#039;s responsibility.\n&quot;
                     &#039;\n&#039;
                     &#039;See also:\n&#039;
                     &#039;\n&#039;
                     &#039;  **PEP 343** - The &quot;with&quot; 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;\n&#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;\n&#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;&quot;the numeric arguments are converted to a common type,&quot; the &#039;
                &#039;arguments\n&#039;
                &#039;are coerced using the coercion rules listed at  Coercion &#039;
                &#039;rules.  If\n&#039;
                &#039;both arguments are standard numeric types, the following &#039;
                &#039;coercions are\n&#039;
                &#039;applied:\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, if either argument is a long integer, the other &#039;
                &#039;is\n&#039;
                &#039;  converted to long integer;\n&#039;
                &#039;\n&#039;
                &#039;* otherwise, both must be plain integers and no conversion &#039;
                &#039;is\n&#039;
                &#039;  necessary.\n&#039;
                &#039;\n&#039;
                &#039;Some additional rules apply for certain operators (e.g., a &#039;
                &#039;string left\n&#039;
                &quot;argument to the &#039;%&#039; operator). Extensions can define their &quot;
                &#039;own\n&#039;
                &#039;coercions.\n&#039;,
 &#039;customization&#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 &#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\&#039;s &quot;__new__()&quot; method using\n&#039;
                  &#039;   &quot;super(currentclass, cls).__new__(cls[, ...])&quot; with &#039;
                  &#039;appropriate\n&#039;
                  &#039;   arguments and then modifying the newly-created instance &#039;
                  &#039;as\n&#039;
                  &#039;   necessary before returning 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\&#039;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\&#039;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\&#039;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;BaseClass.__init__(self, [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;customise\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 destructor.  If a base class has a &quot;__del__()&quot; &#039;
                  &#039;method, the\n&#039;
                  &#039;   derived class\&#039;s &quot;__del__()&quot; method, if any, must &#039;
                  &#039;explicitly call it\n&#039;
                  &#039;   to ensure proper deletion of the base class part of the &#039;
                  &#039;instance.\n&#039;
                  &#039;   Note that it is possible (though not recommended!) for &#039;
                  &#039;the\n&#039;
                  &#039;   &quot;__del__()&quot; method to postpone destruction of the &#039;
                  &#039;instance by\n&#039;
                  &#039;   creating a new reference to it.  It may then be called &#039;
                  &#039;at a later\n&#039;
                  &#039;   time when this new reference is deleted.  It is not &#039;
                  &#039;guaranteed that\n&#039;
                  &#039;   &quot;__del__()&quot; methods are called for objects that still &#039;
                  &#039;exist when\n&#039;
                  &#039;   the interpreter exits.\n&#039;
                  &#039;\n&#039;
                  &#039;   Note: &quot;del x&quot; doesn\&#039;t directly call &quot;x.__del__()&quot; --- &#039;
                  &#039;the 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;\&#039;s reference count reaches zero.  &#039;
                  &#039;Some common\n&#039;
                  &#039;     situations that may prevent the reference count of an &#039;
                  &#039;object from\n&#039;
                  &#039;     going to zero include: circular references between &#039;
                  &#039;objects (e.g.,\n&#039;
                  &#039;     a doubly-linked list or a tree data structure with &#039;
                  &#039;parent and\n&#039;
                  &#039;     child pointers); a reference to the object on the &#039;
                  &#039;stack frame of\n&#039;
                  &#039;     a function that caught an exception (the traceback &#039;
                  &#039;stored in\n&#039;
                  &#039;     &quot;sys.exc_traceback&quot; keeps the stack frame alive); or a &#039;
                  &#039;reference\n&#039;
                  &#039;     to the object on the stack frame that raised an &#039;
                  &#039;unhandled\n&#039;
                  &#039;     exception in interactive mode (the traceback stored &#039;
                  &#039;in\n&#039;
                  &#039;     &quot;sys.last_traceback&quot; keeps the stack frame alive).  &#039;
                  &#039;The first\n&#039;
                  &#039;     situation can only be remedied by explicitly breaking &#039;
                  &#039;the cycles;\n&#039;
                  &#039;     the latter two situations can be resolved by storing &#039;
                  &#039;&quot;None&quot; in\n&#039;
                  &#039;     &quot;sys.exc_traceback&quot; or &quot;sys.last_traceback&quot;.  Circular &#039;
                  &#039;references\n&#039;
                  &#039;     which are garbage are detected when the option cycle &#039;
                  &#039;detector is\n&#039;
                  &quot;     enabled (it&#039;s on by default), but can only be cleaned &quot;
                  &#039;up if there\n&#039;
                  &#039;     are no Python-level &quot;__del__()&quot; methods involved. &#039;
                  &#039;Refer to the\n&#039;
                  &#039;     documentation for the &quot;gc&quot; module for more information &#039;
                  &#039;about how\n&#039;
                  &#039;     &quot;__del__()&quot; methods are handled by the cycle &#039;
                  &#039;detector,\n&#039;
                  &#039;     particularly the description of the &quot;garbage&quot; value.\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. Also, when &quot;__del__()&quot; is &#039;
                  &#039;invoked in\n&#039;
                  &#039;     response to a module being deleted (e.g., when &#039;
                  &#039;execution of the\n&#039;
                  &#039;     program is done), other globals referenced by the &#039;
                  &#039;&quot;__del__()&quot;\n&#039;
                  &#039;     method may already have been deleted or in the process &#039;
                  &#039;of being\n&#039;
                  &#039;     torn down (e.g. the import machinery shutting down).  &#039;
                  &#039;For this\n&#039;
                  &#039;     reason, &quot;__del__()&quot; methods should do the absolute &#039;
                  &#039;minimum needed\n&#039;
                  &#039;     to maintain external invariants.  Starting with &#039;
                  &#039;version 1.5,\n&#039;
                  &#039;     Python guarantees that globals whose name begins with &#039;
                  &#039;a single\n&#039;
                  &#039;     underscore are deleted from their module before other &#039;
                  &#039;globals are\n&#039;
                  &#039;     deleted; if no other references to such globals exist, &#039;
                  &#039;this may\n&#039;
                  &#039;     help in assuring that imported modules are still &#039;
                  &#039;available at the\n&#039;
                  &#039;     time when the &quot;__del__()&quot; method is called.\n&#039;
                  &#039;\n&#039;
                  &#039;   See also the &quot;-R&quot; command-line option.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__repr__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by the &quot;repr()&quot; built-in function and by string &#039;
                  &#039;conversions\n&#039;
                  &#039;   (reverse quotes) to compute the &quot;official&quot; string &#039;
                  &#039;representation of\n&#039;
                  &#039;   an object.  If at all possible, this should look like a &#039;
                  &#039;valid\n&#039;
                  &#039;   Python expression that could be used to recreate an &#039;
                  &#039;object with the\n&#039;
                  &#039;   same value (given an appropriate environment).  If this &#039;
                  &#039;is not\n&#039;
                  &#039;   possible, a string of the form &quot;&lt;...some useful &#039;
                  &#039;description...&gt;&quot;\n&#039;
                  &#039;   should be returned.  The return value must be a string &#039;
                  &#039;object. If a\n&#039;
                  &#039;   class defines &quot;__repr__()&quot; but not &quot;__str__()&quot;, then &#039;
                  &#039;&quot;__repr__()&quot;\n&#039;
                  &#039;   is also used when an &quot;informal&quot; string representation of &#039;
                  &#039;instances\n&#039;
                  &#039;   of that class is 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 the &quot;str()&quot; built-in function and by the &#039;
                  &#039;&quot;print&quot;\n&#039;
                  &#039;   statement to compute the &quot;informal&quot; string &#039;
                  &#039;representation of an\n&#039;
                  &#039;   object.  This differs from &quot;__repr__()&quot; in that it does &#039;
                  &#039;not have to\n&#039;
                  &#039;   be a valid Python expression: a more convenient or &#039;
                  &#039;concise\n&#039;
                  &#039;   representation may be used instead. The return value &#039;
                  &#039;must be a\n&#039;
                  &#039;   string object.\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;   New in version 2.1.\n&#039;
                  &#039;\n&#039;
                  &#039;   These are the so-called &quot;rich comparison&quot; methods, and &#039;
                  &#039;are called\n&#039;
                  &#039;   for comparison operators in preference to &quot;__cmp__()&quot; &#039;
                  &#039;below. 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; and &quot;x&lt;&gt;y&quot; call &#039;
                  &#039;&quot;x.__ne__(y)&quot;,\n&#039;
                  &#039;   &quot;x&gt;y&quot; calls &quot;x.__gt__(y)&quot;, and &quot;x&gt;=y&quot; calls &#039;
                  &#039;&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;   There are no implied relationships among the comparison &#039;
                  &#039;operators.\n&#039;
                  &#039;   The truth of &quot;x==y&quot; does not imply that &quot;x!=y&quot; is &#039;
                  &#039;false.\n&#039;
                  &#039;   Accordingly, when defining &quot;__eq__()&quot;, one should also &#039;
                  &#039;define\n&#039;
                  &#039;   &quot;__ne__()&quot; so that the operators will behave as &#039;
                  &#039;expected.  See the\n&#039;
                  &#039;   paragraph on &quot;__hash__()&quot; for some important notes on &#039;
                  &#039;creating\n&#039;
                  &#039;   *hashable* objects which support custom comparison &#039;
                  &#039;operations and\n&#039;
                  &#039;   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;
                  &quot;each other&#039;s\n&quot;
                  &#039;   reflection, &quot;__le__()&quot; and &quot;__ge__()&quot; are each other\&#039;s &#039;
                  &#039;reflection,\n&#039;
                  &#039;   and &quot;__eq__()&quot; and &quot;__ne__()&quot; are their own reflection.\n&#039;
                  &#039;\n&#039;
                  &#039;   Arguments to rich comparison methods are never coerced.\n&#039;
                  &#039;\n&#039;
                  &#039;   To automatically generate ordering operations from a &#039;
                  &#039;single root\n&#039;
                  &#039;   operation, see &quot;functools.total_ordering()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__cmp__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called by comparison operations if rich comparison (see &#039;
                  &#039;above) is\n&#039;
                  &#039;   not defined.  Should return a negative integer if &quot;self &#039;
                  &#039;&lt; other&quot;,\n&#039;
                  &#039;   zero if &quot;self == other&quot;, a positive integer if &quot;self &gt; &#039;
                  &#039;other&quot;.  If\n&#039;
                  &#039;   no &quot;__cmp__()&quot;, &quot;__eq__()&quot; or &quot;__ne__()&quot; operation is &#039;
                  &#039;defined,\n&#039;
                  &#039;   class instances are compared by object identity &#039;
                  &#039;(&quot;address&quot;).  See\n&#039;
                  &#039;   also the description of &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. (Note: &#039;
                  &#039;the\n&#039;
                  &#039;   restriction that exceptions are not propagated by &#039;
                  &#039;&quot;__cmp__()&quot; has\n&#039;
                  &#039;   been removed since Python 1.5.)\n&#039;
                  &#039;\n&#039;
                  &#039;object.__rcmp__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   Changed in version 2.1: No longer supported.\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 &#039;
                  &#039;required 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;   If a class does not define a &quot;__cmp__()&quot; or &quot;__eq__()&quot; &#039;
                  &#039;method it\n&#039;
                  &#039;   should not define a &quot;__hash__()&quot; operation either; if it &#039;
                  &#039;defines\n&#039;
                  &#039;   &quot;__cmp__()&quot; or &quot;__eq__()&quot; but not &quot;__hash__()&quot;, its &#039;
                  &#039;instances will\n&#039;
                  &#039;   not be usable in hashed collections.  If a class defines &#039;
                  &#039;mutable\n&#039;
                  &#039;   objects and implements a &quot;__cmp__()&quot; or &quot;__eq__()&quot; &#039;
                  &#039;method, it\n&#039;
                  &#039;   should not implement &quot;__hash__()&quot;, since hashable &#039;
                  &#039;collection\n&#039;
                  &quot;   implementations require that an object&#039;s hash value is &quot;
                  &#039;immutable\n&#039;
                  &quot;   (if the object&#039;s hash value changes, it will be in the &quot;
                  &#039;wrong hash\n&#039;
                  &#039;   bucket).\n&#039;
                  &#039;\n&#039;
                  &#039;   User-defined classes have &quot;__cmp__()&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 a result derived &#039;
                  &#039;from\n&#039;
                  &#039;   &quot;id(x)&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;   Classes which inherit a &quot;__hash__()&quot; method from a &#039;
                  &#039;parent class but\n&#039;
                  &#039;   change the meaning of &quot;__cmp__()&quot; or &quot;__eq__()&quot; such &#039;
                  &#039;that the hash\n&#039;
                  &#039;   value returned is no longer appropriate (e.g. by &#039;
                  &#039;switching to a\n&#039;
                  &#039;   value-based concept of equality instead of the default &#039;
                  &#039;identity\n&#039;
                  &#039;   based equality) can explicitly flag themselves as being &#039;
                  &#039;unhashable\n&#039;
                  &#039;   by setting &quot;__hash__ = None&quot; in the class definition. &#039;
                  &#039;Doing so\n&#039;
                  &#039;   means that not only will instances of the class raise &#039;
                  &#039;an\n&#039;
                  &#039;   appropriate &quot;TypeError&quot; when a program attempts to &#039;
                  &#039;retrieve their\n&#039;
                  &#039;   hash value, but they will also be correctly identified &#039;
                  &#039;as\n&#039;
                  &#039;   unhashable when checking &quot;isinstance(obj, &#039;
                  &#039;collections.Hashable)&quot;\n&#039;
                  &#039;   (unlike classes which define their own &quot;__hash__()&quot; to &#039;
                  &#039;explicitly\n&#039;
                  &#039;   raise &quot;TypeError&quot;).\n&#039;
                  &#039;\n&#039;
                  &#039;   Changed in version 2.5: &quot;__hash__()&quot; may now also return &#039;
                  &#039;a long\n&#039;
                  &#039;   integer object; the 32-bit integer is then derived from &#039;
                  &#039;the hash of\n&#039;
                  &#039;   that object.\n&#039;
                  &#039;\n&#039;
                  &#039;   Changed in version 2.6: &quot;__hash__&quot; may now be set to &#039;
                  &#039;&quot;None&quot; to\n&#039;
                  &#039;   explicitly flag instances of a class as unhashable.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__nonzero__(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;, or their &#039;
                  &#039;integer\n&#039;
                  &#039;   equivalents &quot;0&quot; or &quot;1&quot;.  When this method is not &#039;
                  &#039;defined,\n&#039;
                  &#039;   &quot;__len__()&quot; is called, if it is defined, and the object &#039;
                  &#039;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;__nonzero__()&quot;, all its &#039;
                  &#039;instances are\n&#039;
                  &#039;   considered true.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__unicode__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement &quot;unicode()&quot; built-in; should return &#039;
                  &#039;a Unicode\n&#039;
                  &#039;   object. When this method is not defined, string &#039;
                  &#039;conversion is\n&#039;
                  &#039;   attempted, and the result of string conversion is &#039;
                  &#039;converted to\n&#039;
                  &#039;   Unicode using the system default encoding.\n&#039;,
 &#039;debugger&#039;: &#039;\n&#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\&#039;s prompt is &quot;(Pdb)&quot;. Typical usage to run a &#039;
             &#039;program 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;&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;   python -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;
             &quot;restart the program. Automatic restarting preserves pdb&#039;s state &quot;
             &#039;(such\n&#039;
             &#039;as breakpoints) and in most cases is more useful than quitting &#039;
             &#039;the\n&#039;
             &quot;debugger upon program&#039;s exit.\n&quot;
             &#039;\n&#039;
             &#039;New in version 2.4: Restarting post-mortem behavior added.\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;c&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[, locals]])\n&#039;
             &#039;\n&#039;
             &#039;   Execute the *statement* (given as a string) under debugger &#039;
             &#039;control.\n&#039;
             &#039;   The debugger prompt appears before any code is executed; you &#039;
             &#039;can\n&#039;
             &#039;   set breakpoints and type &quot;continue&quot;, or you can step through &#039;
             &#039;the\n&#039;
             &#039;   statement using &quot;step&quot; or &quot;next&quot; (all these commands are &#039;
             &#039;explained\n&#039;
             &#039;   below).  The optional *globals* and *locals* arguments &#039;
             &#039;specify the\n&#039;
             &#039;   environment in which the code is executed; by default the\n&#039;
             &#039;   dictionary of the module &quot;__main__&quot; is used.  (See the &#039;
             &#039;explanation\n&#039;
             &#039;   of the &quot;exec&quot; statement or the &quot;eval()&quot; built-in function.)\n&#039;
             &#039;\n&#039;
             &#039;pdb.runeval(expression[, globals[, locals]])\n&#039;
             &#039;\n&#039;
             &#039;   Evaluate the *expression* (given as a string) under debugger\n&#039;
             &#039;   control.  When &quot;runeval()&quot; returns, it returns the value of &#039;
             &#039;the\n&#039;
             &#039;   expression.  Otherwise this function is similar to &quot;run()&quot;.\n&#039;
             &#039;\n&#039;
             &#039;pdb.runcall(function[, argument, ...])\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])\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)\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;   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 2.7: The *skip* argument.\n&#039;
             &#039;\n&#039;
             &#039;   run(statement[, globals[, locals]])\n&#039;
             &#039;   runeval(expression[, globals[, locals]])\n&#039;
             &#039;   runcall(function[, argument, ...])\n&#039;
             &#039;   set_trace()\n&#039;
             &#039;\n&#039;
             &#039;      See the documentation for the functions explained above.\n&#039;,
 &#039;del&#039;: &#039;\n&#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;It is illegal to delete a name from the local namespace if it occurs\n&#039;
        &#039;as a free variable in a nested block.\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;dict&#039;: &#039;\n&#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\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;
         &quot;multiple times in the key/datum list, and the final dictionary&#039;s &quot;
         &#039;value\n&#039;
         &#039;for that key will be the last one given.\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;&quot;for&quot; and &quot;if&quot; 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;\n&#039;
                     &#039;Interaction with dynamic features\n&#039;
                     &#039;*********************************\n&#039;
                     &#039;\n&#039;
                     &#039;There are several cases where Python statements are &#039;
                     &#039;illegal when used\n&#039;
                     &#039;in conjunction with nested scopes that contain free &#039;
                     &#039;variables.\n&#039;
                     &#039;\n&#039;
                     &#039;If a variable is referenced in an enclosing scope, it is &#039;
                     &#039;illegal to\n&#039;
                     &#039;delete the name.  An error will be reported at compile &#039;
                     &#039;time.\n&#039;
                     &#039;\n&#039;
                     &#039;If the wild card form of import --- &quot;import *&quot; --- is &#039;
                     &#039;used in a\n&#039;
                     &#039;function and the function contains or is a nested block &#039;
                     &#039;with free\n&#039;
                     &#039;variables, the compiler will raise a &quot;SyntaxError&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;If &quot;exec&quot; is used in a function and the function &#039;
                     &#039;contains or is a\n&#039;
                     &#039;nested block with free variables, the compiler will &#039;
                     &#039;raise a\n&#039;
                     &#039;&quot;SyntaxError&quot; unless the exec explicitly specifies the &#039;
                     &#039;local namespace\n&#039;
                     &#039;for the &quot;exec&quot;.  (In other words, &quot;exec obj&quot; would be &#039;
                     &#039;illegal, but\n&#039;
                     &#039;&quot;exec obj in ns&quot; would be legal.)\n&#039;
                     &#039;\n&#039;
                     &#039;The &quot;eval()&quot;, &quot;execfile()&quot;, and &quot;input()&quot; functions and &#039;
                     &#039;the &quot;exec&quot;\n&#039;
                     &#039;statement do not have access to the full environment for &#039;
                     &#039;resolving\n&#039;
                     &#039;names.  Names may be resolved in the local and global &#039;
                     &#039;namespaces of\n&#039;
                     &#039;the caller.  Free variables are not resolved in the &#039;
                     &#039;nearest enclosing\n&#039;
                     &#039;namespace, but in the global namespace. [1] The &quot;exec&quot; &#039;
                     &#039;statement and\n&#039;
                     &#039;the &quot;eval()&quot; and &quot;execfile()&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;\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 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;\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 &#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 &quot;termination&quot; 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;Exceptions can also be identified by strings, in which case &#039;
               &#039;the\n&#039;
               &#039;&quot;except&quot; clause is selected by object identity.  An arbitrary &#039;
               &#039;value\n&#039;
               &#039;can be raised along with the identifying string which can be &#039;
               &#039;passed to\n&#039;
               &#039;the handler.\n&#039;
               &#039;\n&#039;
               &#039;Note: Messages to exceptions 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;exec&#039;: &#039;\n&#039;
         &#039;The &quot;exec&quot; statement\n&#039;
         &#039;********************\n&#039;
         &#039;\n&#039;
         &#039;   exec_stmt ::= &quot;exec&quot; or_expr [&quot;in&quot; expression [&quot;,&quot; expression]]\n&#039;
         &#039;\n&#039;
         &#039;This statement supports dynamic execution of Python code.  The &#039;
         &#039;first\n&#039;
         &#039;expression should evaluate to either a Unicode string, a *Latin-1*\n&#039;
         &#039;encoded string, an open file object, a code object, or a tuple.  If &#039;
         &#039;it\n&#039;
         &#039;is a string, the string is parsed as a suite of Python statements\n&#039;
         &#039;which is then executed (unless a syntax error occurs). [1] If it is &#039;
         &#039;an\n&#039;
         &#039;open file, the file is parsed until EOF and executed. If it is a &#039;
         &#039;code\n&#039;
         &#039;object, it is simply executed.  For the interpretation of a tuple, &#039;
         &#039;see\n&#039;
         &quot;below.  In all cases, the code that&#039;s executed is expected to be &quot;
         &#039;valid\n&#039;
         &#039;as file input (see section File input).  Be aware that the &quot;return&quot;\n&#039;
         &#039;and &quot;yield&quot; statements may not be used outside of function &#039;
         &#039;definitions\n&#039;
         &#039;even within the context of code passed to the &quot;exec&quot; statement.\n&#039;
         &#039;\n&#039;
         &#039;In all cases, if the optional parts are omitted, the code is &#039;
         &#039;executed\n&#039;
         &#039;in the current scope.  If only the first expression after &quot;in&quot; is\n&#039;
         &#039;specified, it should be a dictionary, which will be used for both &#039;
         &#039;the\n&#039;
         &#039;global and the local variables.  If two expressions are given, they\n&#039;
         &#039;are used for the global and local variables, respectively. If\n&#039;
         &#039;provided, *locals* can be any mapping object. Remember that at &#039;
         &#039;module\n&#039;
         &#039;level, globals and locals are the same dictionary. If two separate\n&#039;
         &#039;objects are given as *globals* and *locals*, the code will be &#039;
         &#039;executed\n&#039;
         &#039;as if it were embedded in a class definition.\n&#039;
         &#039;\n&#039;
         &#039;The first expression may also be a tuple of length 2 or 3.  In this\n&#039;
         &#039;case, the optional parts must be omitted.  The form &quot;exec(expr,\n&#039;
         &#039;globals)&quot; is equivalent to &quot;exec expr in globals&quot;, while the form\n&#039;
         &#039;&quot;exec(expr, globals, locals)&quot; is equivalent to &quot;exec expr in &#039;
         &#039;globals,\n&#039;
         &#039;locals&quot;.  The tuple form of &quot;exec&quot; provides compatibility with &#039;
         &#039;Python\n&#039;
         &#039;3, where &quot;exec&quot; is a function rather than a statement.\n&#039;
         &#039;\n&#039;
         &#039;Changed in version 2.4: Formerly, *locals* was required to be a\n&#039;
         &#039;dictionary.\n&#039;
         &#039;\n&#039;
         &#039;As a side effect, an implementation may insert additional keys into\n&#039;
         &#039;the dictionaries given besides those corresponding to variable &#039;
         &#039;names\n&#039;
         &#039;set by the executed code.  For example, the current implementation &#039;
         &#039;may\n&#039;
         &#039;add a reference to the dictionary of the built-in module &#039;
         &#039;&quot;__builtin__&quot;\n&#039;
         &#039;under the key &quot;__builtins__&quot; (!).\n&#039;
         &#039;\n&#039;
         &quot;**Programmer&#039;s hints:** dynamic evaluation of expressions is &quot;
         &#039;supported\n&#039;
         &#039;by the built-in function &quot;eval()&quot;.  The built-in functions &#039;
         &#039;&quot;globals()&quot;\n&#039;
         &#039;and &quot;locals()&quot; return the current global and local dictionary,\n&#039;
         &#039;respectively, which may be useful to pass around for use by &quot;exec&quot;.\n&#039;
         &#039;\n&#039;
         &#039;-[ Footnotes ]-\n&#039;
         &#039;\n&#039;
         &#039;[1] Note that the parser only accepts the Unix-style end of line\n&#039;
         &#039;    convention. If you are reading the code from a file, make sure &#039;
         &#039;to\n&#039;
         &#039;    use *universal newlines* mode to convert Windows or Mac-style\n&#039;
         &#039;    newlines.\n&#039;,
 &#039;execmodel&#039;: &#039;\n&#039;
              &#039;Execution model\n&#039;
              &#039;***************\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Naming and binding\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. Each occurrence of a name in the program text &#039;
              &#039;refers to\n&#039;
              &#039;the *binding* of that name established in the innermost &#039;
              &#039;function block\n&#039;
              &#039;containing the use.\n&#039;
              &#039;\n&#039;
              &#039;A *block* is a piece of Python program text that is executed as &#039;
              &#039;a\n&#039;
              &#039;unit. The following are blocks: a module, a function body, and &#039;
              &#039;a class\n&#039;
              &#039;definition. Each command typed interactively is a block.  A &#039;
              &#039;script\n&#039;
              &#039;file (a file given as standard input to the interpreter or &#039;
              &#039;specified\n&#039;
              &#039;on the interpreter command line the first argument) is a code &#039;
              &#039;block.\n&#039;
              &#039;A script command (a command specified on the interpreter &#039;
              &#039;command line\n&#039;
              &quot;with the &#039;**-c**&#039; option) is a code block.  The file read by &quot;
              &#039;the\n&#039;
              &#039;built-in function &quot;execfile()&quot; is a code block.  The string &#039;
              &#039;argument\n&#039;
              &#039;passed to the built-in function &quot;eval()&quot; and to the &quot;exec&quot; &#039;
              &#039;statement\n&#039;
              &#039;is a code block. The expression read and evaluated by the &#039;
              &#039;built-in\n&#039;
              &#039;function &quot;input()&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;
              &quot;where and how execution continues after the code block&#039;s &quot;
              &#039;execution has\n&#039;
              &#039;completed.\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.  The scope of names defined &#039;
              &#039;in a\n&#039;
              &#039;class block is limited to the class block; it does not extend &#039;
              &#039;to the\n&#039;
              &#039;code blocks of methods -- this includes generator expressions &#039;
              &#039;since\n&#039;
              &#039;they are implemented using a function scope.  This means that &#039;
              &#039;the\n&#039;
              &#039;following 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;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;
              &quot;is called the block&#039;s *environment*.\n&quot;
              &#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;If a name is bound at the module level, it is a global &#039;
              &#039;variable.  (The\n&#039;
              &#039;variables of the module code block are local and global.)  If &#039;
              &#039;a\n&#039;
              &#039;variable is used in a code block but not defined there, it is a &#039;
              &#039;*free\n&#039;
              &#039;variable*.\n&#039;
              &#039;\n&#039;
              &#039;When a name is not found at all, a &quot;NameError&quot; exception is &#039;
              &#039;raised.\n&#039;
              &#039;If the name refers to a local variable that has not been bound, &#039;
              &#039;a\n&#039;
              &#039;&quot;UnboundLocalError&quot; exception is raised.  &quot;UnboundLocalError&quot; &#039;
              &#039;is a\n&#039;
              &#039;subclass of &quot;NameError&quot;.\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;in the\n&#039;
              &#039;second position of an &quot;except&quot; clause header or after &quot;as&quot; in a &#039;
              &#039;&quot;with&quot;\n&#039;
              &#039;statement.  The &quot;import&quot; statement of the form &quot;from ... import &#039;
              &#039;*&quot;\n&#039;
              &#039;binds all names defined in the imported module, except those &#039;
              &#039;beginning\n&#039;
              &#039;with an underscore.  This form may only be used at the module &#039;
              &#039;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).  It\n&#039;
              &#039;is illegal to unbind a name that is referenced by an enclosing &#039;
              &#039;scope;\n&#039;
              &#039;the compiler will report a &quot;SyntaxError&quot;.\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 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 global 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 &#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;__builtin__&quot;.  The global namespace is searched &#039;
              &#039;first.\n&#039;
              &#039;If the name is not found there, the builtins namespace is &#039;
              &#039;searched.\n&#039;
              &#039;The global statement must precede all uses of the name.\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;
              &quot;the module&#039;s dictionary is used).  By default, when in the &quot;
              &#039;&quot;__main__&quot;\n&#039;
              &#039;module, &quot;__builtins__&quot; is the built-in module &quot;__builtin__&quot; &#039;
              &#039;(note: no\n&#039;
              &#039;\&#039;s\&#039;); when in any other module, &quot;__builtins__&quot; is an alias &#039;
              &#039;for the\n&#039;
              &#039;dictionary of the &quot;__builtin__&quot; module itself.  &quot;__builtins__&quot; &#039;
              &#039;can be\n&#039;
              &#039;set to a user-created dictionary to create a weak form of &#039;
              &#039;restricted\n&#039;
              &#039;execution.\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;__builtin__&quot; (no \&#039;s\&#039;) module and modify its attributes\n&#039;
              &#039;appropriately.\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;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;A class definition is an executable statement that may use and &#039;
              &#039;define\n&#039;
              &#039;names. These references follow the normal rules for name &#039;
              &#039;resolution.\n&#039;
              &#039;The namespace of the class definition becomes the attribute &#039;
              &#039;dictionary\n&#039;
              &#039;of the class.  Names defined at the class scope are not visible &#039;
              &#039;in\n&#039;
              &#039;methods.\n&#039;
              &#039;\n&#039;
              &#039;\n&#039;
              &#039;Interaction with dynamic features\n&#039;
              &#039;---------------------------------\n&#039;
              &#039;\n&#039;
              &#039;There are several cases where Python statements are illegal &#039;
              &#039;when used\n&#039;
              &#039;in conjunction with nested scopes that contain free variables.\n&#039;
              &#039;\n&#039;
              &#039;If a variable is referenced in an enclosing scope, it is &#039;
              &#039;illegal to\n&#039;
              &#039;delete the name.  An error will be reported at compile time.\n&#039;
              &#039;\n&#039;
              &#039;If the wild card form of import --- &quot;import *&quot; --- is used in &#039;
              &#039;a\n&#039;
              &#039;function and the function contains or is a nested block with &#039;
              &#039;free\n&#039;
              &#039;variables, the compiler will raise a &quot;SyntaxError&quot;.\n&#039;
              &#039;\n&#039;
              &#039;If &quot;exec&quot; is used in a function and the function contains or is &#039;
              &#039;a\n&#039;
              &#039;nested block with free variables, the compiler will raise a\n&#039;
              &#039;&quot;SyntaxError&quot; unless the exec explicitly specifies the local &#039;
              &#039;namespace\n&#039;
              &#039;for the &quot;exec&quot;.  (In other words, &quot;exec obj&quot; would be illegal, &#039;
              &#039;but\n&#039;
              &#039;&quot;exec obj in ns&quot; would be legal.)\n&#039;
              &#039;\n&#039;
              &#039;The &quot;eval()&quot;, &quot;execfile()&quot;, and &quot;input()&quot; functions and the &#039;
              &#039;&quot;exec&quot;\n&#039;
              &#039;statement do not have access to the full environment for &#039;
              &#039;resolving\n&#039;
              &#039;names.  Names may be resolved in the local and global &#039;
              &#039;namespaces of\n&#039;
              &#039;the caller.  Free variables are not resolved in the nearest &#039;
              &#039;enclosing\n&#039;
              &#039;namespace, but in the global namespace. [1] The &quot;exec&quot; &#039;
              &#039;statement and\n&#039;
              &#039;the &quot;eval()&quot; and &quot;execfile()&quot; functions have optional arguments &#039;
              &#039;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 &quot;termination&quot; 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;Exceptions can also be identified by strings, in which case &#039;
              &#039;the\n&#039;
              &#039;&quot;except&quot; clause is selected by object identity.  An arbitrary &#039;
              &#039;value\n&#039;
              &#039;can be raised along with the identifying string which can be &#039;
              &#039;passed to\n&#039;
              &#039;the handler.\n&#039;
              &#039;\n&#039;
              &#039;Note: Messages to exceptions 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;\n&#039;
              &#039;Expression lists\n&#039;
              &#039;****************\n&#039;
              &#039;\n&#039;
              &#039;   expression_list ::= expression ( &quot;,&quot; expression )* [&quot;,&quot;]\n&#039;
              &#039;\n&#039;
              &#039;An expression list containing at least one comma yields a &#039;
              &#039;tuple.  The\n&#039;
              &#039;length of the tuple is the number of expressions in the list.  &#039;
              &#039;The\n&#039;
              &#039;expressions are evaluated from left to right.\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;
              &quot;without a trailing comma doesn&#039;t create a tuple, but rather &quot;
              &#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;\n&#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    ::= [intpart] fraction | intpart &quot;.&quot;\n&#039;
             &#039;   exponentfloat ::= (intpart | pointfloat) exponent\n&#039;
             &#039;   intpart       ::= digit+\n&#039;
             &#039;   fraction      ::= &quot;.&quot; digit+\n&#039;
             &#039;   exponent      ::= (&quot;e&quot; | &quot;E&quot;) [&quot;+&quot; | &quot;-&quot;] digit+\n&#039;
             &#039;\n&#039;
             &#039;Note that the integer and exponent parts of floating point &#039;
             &#039;numbers can\n&#039;
             &#039;look like octal integers, but are interpreted using radix 10.  &#039;
             &#039;For\n&#039;
             &#039;example, &quot;077e010&quot; is legal, and denotes the same number as &#039;
             &#039;&quot;77e10&quot;.\n&#039;
             &#039;The allowed range of floating point literals is implementation-\n&#039;
             &#039;dependent. Some examples of floating point literals:\n&#039;
             &#039;\n&#039;
             &#039;   3.14    10.    .001    1e100    3.14e-10    0e0\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; and &#039;
             &#039;the\n&#039;
             &#039;literal &quot;1&quot;.\n&#039;,
 &#039;for&#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; 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 of ascending indices.  Each\n&#039;
        &#039;item in turn is assigned to the target list using the standard rules\n&#039;
        &#039;for assignments, and then the suite is executed.  When the items are\n&#039;
        &#039;exhausted (which is immediately when the sequence is empty), the &#039;
        &#039;suite\n&#039;
        &#039;in the &quot;else&quot; clause, if present, is executed, and the 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\&#039;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 was no next\n&#039;
        &#039;item.\n&#039;
        &#039;\n&#039;
        &#039;The suite may assign to the variable(s) in the target list; this &#039;
        &#039;does\n&#039;
        &#039;not affect the next item assigned to it.\n&#039;
        &#039;\n&#039;
        &#039;The target list is not deleted when the loop is finished, but if the\n&#039;
        &#039;sequence is empty, it will not have been assigned to at all by the\n&#039;
        &#039;loop.  Hint: the built-in function &quot;range()&quot; returns a sequence of\n&#039;
        &#039;integers suitable to emulate the effect of Pascal\&#039;s &quot;for i := a to &#039;
        &#039;b\n&#039;
        &#039;do&quot;; e.g., &quot;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, i.e. 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;\n&#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).\n&#039;
                  &#039;\n&#039;
                  &#039;Format strings contain &quot;replacement fields&quot; 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 | integer]\n&#039;
                  &#039;      attribute_name    ::= identifier\n&#039;
                  &#039;      element_index     ::= integer | 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;\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;
                  &quot;number or a keyword.  If it&#039;s a number, it refers to a &quot;
                  &#039;positional\n&#039;
                  &quot;argument, and if it&#039;s a keyword, it refers to a named &quot;
                  &#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) &#039;
                  &#039;and the\n&#039;
                  &#039;numbers 0, 1, 2, ... will be automatically inserted in that &#039;
                  &#039;order.\n&#039;
                  &#039;Because *arg_name* is not quote-delimited, it is not &#039;
                  &#039;possible to\n&#039;
                  &#039;specify arbitrary dictionary keys (e.g., the strings &#039;
                  &#039;&quot;\&#039;10\&#039;&quot; or\n&#039;
                  &#039;&quot;\&#039;:-]\&#039;&quot;) within a format string. The *arg_name* can be &#039;
                  &#039;followed by any\n&#039;
                  &#039;number of index or attribute expressions. An expression of &#039;
                  &#039;the form\n&#039;
                  &#039;&quot;\&#039;.name\&#039;&quot; selects the named attribute using &quot;getattr()&quot;, &#039;
                  &#039;while an\n&#039;
                  &#039;expression of the form &quot;\&#039;[index]\&#039;&quot; does an index lookup &#039;
                  &#039;using\n&#039;
                  &#039;&quot;__getitem__()&quot;.\n&#039;
                  &#039;\n&#039;
                  &#039;Changed in version 2.7: The positional argument specifiers &#039;
                  &#039;can be\n&#039;
                  &#039;omitted, so &quot;\&#039;{} {}\&#039;&quot; is equivalent to &quot;\&#039;{0} {1}\&#039;&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;Two conversion flags are currently supported: &quot;\&#039;!s\&#039;&quot; &#039;
                  &#039;which calls\n&#039;
                  &#039;&quot;str()&quot; on the value, and &quot;\&#039;!r\&#039;&quot; which calls &quot;repr()&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;\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 &quot;formatting mini-language&quot; 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;&quot;Format specifications&quot; 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).  They can also be passed &#039;
                  &#039;directly to the\n&#039;
                  &#039;built-in &quot;format()&quot; function.  Each formattable type may &#039;
                  &#039;define how\n&#039;
                  &#039;the format specification is to be 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][,][.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       ::= integer\n&#039;
                  &#039;   precision   ::= integer\n&#039;
                  &#039;   type        ::= &quot;b&quot; | &quot;c&quot; | &quot;d&quot; | &quot;e&quot; | &quot;E&quot; | &quot;f&quot; | &quot;F&quot; &#039;
                  &#039;| &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;{&quot;&quot; or\n&#039;
                  &#039;&quot;&quot;}&quot;&quot;) as the *fill* character when using the &#039;
                  &#039;&quot;str.format()&quot; method.\n&#039;
                  &#039;However, it is possible to insert a curly brace with a &#039;
                  &#039;nested\n&#039;
                  &quot;replacement field.  This limitation doesn&#039;t affect the &quot;
                  &#039;&quot;format()&quot;\n&#039;
                  &#039;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;
                  &quot;   |           | in the form &#039;+000000120&#039;. This alignment &quot;
                  &#039;option is only    |\n&#039;
                  &#039;   |           | valid for numeric types.  It becomes the &#039;
                  &quot;default when &#039;0&#039;  |\n&quot;
                  &#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 is only valid for integers, and only for &#039;
                  &#039;binary,\n&#039;
                  &#039;octal, or hexadecimal output.  If present, it specifies &#039;
                  &#039;that the\n&#039;
                  &#039;output will be prefixed by &quot;\&#039;0b\&#039;&quot;, &quot;\&#039;0o\&#039;&quot;, or &quot;\&#039;0x\&#039;&quot;, &#039;
                  &#039;respectively.\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 2.7: Added the &quot;\&#039;,\&#039;&quot; option (see also &#039;
                  &#039;**PEP 378**).\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;
                  &quot;   |           | notation using the letter &#039;e&#039; to indicate &quot;
                  &#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;
                  &quot;   |           | case &#039;E&#039; as the separator &quot;
                  &#039;character.                       |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;f\&#039;&quot;     | Fixed point. Displays the number as a &#039;
                  &#039;fixed-point number.  |\n&#039;
                  &#039;   |           | The default precision is &#039;
                  &#039;&quot;6&quot;.                              |\n&#039;
                  &#039;   &#039;
                  &#039;+-----------+------------------------------------------------------------+\n&#039;
                  &#039;   | &quot;\&#039;F\&#039;&quot;     | Fixed point. Same as &#039;
                  &#039;&quot;\&#039;f\&#039;&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      | The same as &#039;
                  &#039;&quot;\&#039;g\&#039;&quot;.                                         |\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 follow 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;)  # 2.7+ 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;
                  &quot;Accessing arguments&#039; attributes:\n&quot;
                  &#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(object):\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;
                  &quot;Accessing arguments&#039; items:\n&quot;
                  &#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.5\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: 88.64%&#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;
                  &#039;base=base, width=width),\n&#039;
                  &#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;\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;   decorated      ::= decorators (classdef | funcdef)\n&#039;
             &#039;   decorators     ::= decorator+\n&#039;
             &#039;   decorator      ::= &quot;@&quot; dotted_name [&quot;(&quot; [argument_list [&quot;,&quot;]] &#039;
             &#039;&quot;)&quot;] NEWLINE\n&#039;
             &#039;   funcdef        ::= &quot;def&quot; funcname &quot;(&quot; [parameter_list] &quot;)&quot; &#039;
             &#039;&quot;:&quot; suite\n&#039;
             &#039;   dotted_name    ::= identifier (&quot;.&quot; identifier)*\n&#039;
             &#039;   parameter_list ::= (defparameter &quot;,&quot;)*\n&#039;
             &#039;                      (  &quot;*&quot; identifier [&quot;,&quot; &quot;**&quot; identifier]\n&#039;
             &#039;                      | &quot;**&quot; identifier\n&#039;
             &#039;                      | defparameter [&quot;,&quot;] )\n&#039;
             &#039;   defparameter   ::= parameter [&quot;=&quot; expression]\n&#039;
             &#039;   sublist        ::= parameter (&quot;,&quot; parameter)* [&quot;,&quot;]\n&#039;
             &#039;   parameter      ::= identifier | &quot;(&quot; sublist &quot;)&quot;\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. [3]\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 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;When one or more top-level *parameters* have the form &#039;
             &#039;*parameter* &quot;=&quot;\n&#039;
             &#039;*expression*, the function is said to have &quot;default parameter &#039;
             &#039;values.&quot;\n&#039;
             &#039;For a parameter with a default value, the corresponding &#039;
             &#039;*argument* may\n&#039;
             &quot;be omitted from a call, in which case the parameter&#039;s default &quot;
             &#039;value is\n&#039;
             &#039;substituted.  If a parameter has a default value, all following\n&#039;
             &#039;parameters must also have a default value --- this is a &#039;
             &#039;syntactic\n&#039;
             &#039;restriction that is not expressed by the grammar.\n&#039;
             &#039;\n&#039;
             &#039;**Default parameter values are evaluated when the function &#039;
             &#039;definition\n&#039;
             &#039;is executed.**  This means that the expression is evaluated &#039;
             &#039;once, when\n&#039;
             &#039;the function is defined, and that the same &quot;pre-computed&quot; value &#039;
             &#039;is\n&#039;
             &#039;used for each call.  This is especially important to understand &#039;
             &#039;when a\n&#039;
             &#039;default parameter is a mutable object, such as a list or a &#039;
             &#039;dictionary:\n&#039;
             &#039;if the function modifies the object (e.g. by appending an item &#039;
             &#039;to a\n&#039;
             &#039;list), the default value is in effect modified. This is &#039;
             &#039;generally not\n&#039;
             &#039;what was intended.  A way around this  is to use &quot;None&quot; as the\n&#039;
             &#039;default, and explicitly test for it in the body of the function, &#039;
             &#039;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;&quot;*identifier&quot;&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;&quot;**identifier&quot;&quot; is present, it is initialized to a new &#039;
             &#039;dictionary\n&#039;
             &#039;receiving any excess keyword arguments, defaulting to a new &#039;
             &#039;empty\n&#039;
             &#039;dictionary.\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;&quot;def&quot;&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;&quot;def&quot;&quot; form is actually more powerful since &#039;
             &#039;it\n&#039;
             &#039;allows the execution of multiple statements.\n&#039;
             &#039;\n&#039;
             &quot;**Programmer&#039;s note:** Functions are first-class objects.  A &quot;
             &#039;&quot;&quot;def&quot;&quot;\n&#039;
             &#039;form executed inside a function definition defines a local &#039;
             &#039;function\n&#039;
             &#039;that can be returned or passed around.  Free variables used in &#039;
             &#039;the\n&#039;
             &#039;nested function can access the local variables of the function\n&#039;
             &#039;containing the def.  See section Naming and binding for &#039;
             &#039;details.\n&#039;,
 &#039;global&#039;: &#039;\n&#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, or &quot;import&quot; statement.\n&#039;
           &#039;\n&#039;
           &#039;**CPython implementation detail:** The current implementation does &#039;
           &#039;not\n&#039;
           &#039;enforce the latter two restrictions, but programs should not &#039;
           &#039;abuse\n&#039;
           &#039;this freedom, as future implementations may enforce them or &#039;
           &#039;silently\n&#039;
           &#039;change the meaning of the program.\n&#039;
           &#039;\n&#039;
           &#039;**Programmer\&#039;s note:** &quot;global&quot; is a directive to the parser.  &#039;
           &#039;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 an &#039;
           &#039;&quot;exec&quot;\n&#039;
           &#039;statement does not affect the code block *containing* the &quot;exec&quot;\n&#039;
           &#039;statement, and code contained in an &quot;exec&quot; statement is unaffected &#039;
           &#039;by\n&#039;
           &#039;&quot;global&quot; statements in the code containing the &quot;exec&quot; statement.  &#039;
           &#039;The\n&#039;
           &#039;same applies to the &quot;eval()&quot;, &quot;execfile()&quot; and &quot;compile()&quot; &#039;
           &#039;functions.\n&#039;,
 &#039;id-classes&#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;__builtin__&quot; module.  &#039;
               &#039;When\n&#039;
               &#039;   not in interactive mode, &quot;_&quot; has no special meaning and is &#039;
               &#039;not\n&#039;
               &#039;   defined. 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 &quot;private&quot; attributes of &#039;
               &#039;base and\n&#039;
               &#039;   derived classes. See section Identifiers (Names).\n&#039;,
 &#039;identifiers&#039;: &#039;\n&#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;   identifier ::= (letter|&quot;_&quot;) (letter | digit | &quot;_&quot;)*\n&#039;
                &#039;   letter     ::= lowercase | uppercase\n&#039;
                &#039;   lowercase  ::= &quot;a&quot;...&quot;z&quot;\n&#039;
                &#039;   uppercase  ::= &quot;A&quot;...&quot;Z&quot;\n&#039;
                &#039;   digit      ::= &quot;0&quot;...&quot;9&quot;\n&#039;
                &#039;\n&#039;
                &#039;Identifiers are unlimited in length.  Case is significant.\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;   and       del       from      not       while\n&#039;
                &#039;   as        elif      global    or        with\n&#039;
                &#039;   assert    else      if        pass      yield\n&#039;
                &#039;   break     except    import    print\n&#039;
                &#039;   class     exec      in        raise\n&#039;
                &#039;   continue  finally   is        return\n&#039;
                &#039;   def       for       lambda    try\n&#039;
                &#039;\n&#039;
                &#039;Changed in version 2.4: &quot;None&quot; became a constant and is now &#039;
                &#039;recognized\n&#039;
                &#039;by the compiler as a name for the built-in object &quot;None&quot;.  &#039;
                &#039;Although it\n&#039;
                &#039;is not a keyword, you cannot assign a different object to &#039;
                &#039;it.\n&#039;
                &#039;\n&#039;
                &#039;Changed in version 2.5: Using &quot;as&quot; and &quot;with&quot; as identifiers &#039;
                &#039;triggers\n&#039;
                &#039;a warning.  To use them as keywords, enable the &#039;
                &#039;&quot;with_statement&quot;\n&#039;
                &#039;future feature .\n&#039;
                &#039;\n&#039;
                &#039;Changed in version 2.6: &quot;as&quot; and &quot;with&quot; are full keywords.\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;__builtin__&quot; &#039;
                &#039;module.  When\n&#039;
                &#039;   not in interactive mode, &quot;_&quot; has no special meaning and is &#039;
                &#039;not\n&#039;
                &#039;   defined. 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 &quot;private&quot; attributes of &#039;
                &#039;base and\n&#039;
                &#039;   derived classes. See section Identifiers (Names).\n&#039;,
 &#039;if&#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 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;\n&#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 | intpart) (&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\n&#039;,
 &#039;import&#039;: &#039;\n&#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; name] ( &quot;,&quot; module &#039;
           &#039;[&quot;as&quot; name] )*\n&#039;
           &#039;                   | &quot;from&quot; relative_module &quot;import&quot; identifier &#039;
           &#039;[&quot;as&quot; name]\n&#039;
           &#039;                   ( &quot;,&quot; identifier [&quot;as&quot; name] )*\n&#039;
           &#039;                   | &quot;from&quot; relative_module &quot;import&quot; &quot;(&quot; &#039;
           &#039;identifier [&quot;as&quot; name]\n&#039;
           &#039;                   ( &quot;,&quot; identifier [&quot;as&quot; name] )* [&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;   name            ::= identifier\n&#039;
           &#039;\n&#039;
           &#039;Import statements are executed in two steps: (1) find a module, &#039;
           &#039;and\n&#039;
           &#039;initialize it if necessary; (2) define a name or names in the &#039;
           &#039;local\n&#039;
           &#039;namespace (of the scope where the &quot;import&quot; statement occurs). The\n&#039;
           &#039;statement comes in two forms differing on whether it uses the &#039;
           &#039;&quot;from&quot;\n&#039;
           &#039;keyword. The first form (without &quot;from&quot;) repeats these steps for &#039;
           &#039;each\n&#039;
           &#039;identifier in the list. The form with &quot;from&quot; performs step (1) &#039;
           &#039;once,\n&#039;
           &#039;and then performs step (2) repeatedly.\n&#039;
           &#039;\n&#039;
           &#039;To understand how step (1) occurs, one must first understand how\n&#039;
           &#039;Python handles hierarchical naming of modules. To help organize\n&#039;
           &#039;modules and provide a hierarchy in naming, Python has a concept &#039;
           &#039;of\n&#039;
           &#039;packages. A package can contain other packages and modules while\n&#039;
           &#039;modules cannot contain other modules or packages. From a file &#039;
           &#039;system\n&#039;
           &#039;perspective, packages are directories and modules are files.\n&#039;
           &#039;\n&#039;
           &#039;Once the name of the module is known (unless otherwise specified, &#039;
           &#039;the\n&#039;
           &#039;term &quot;module&quot; will refer to both packages and modules), searching &#039;
           &#039;for\n&#039;
           &#039;the module or package can begin. The first place checked is\n&#039;
           &#039;&quot;sys.modules&quot;, the cache of all modules that have been imported\n&#039;
           &#039;previously. If the module is found there then it is used in step &#039;
           &#039;(2)\n&#039;
           &#039;of import.\n&#039;
           &#039;\n&#039;
           &#039;If the module is not found in the cache, then &quot;sys.meta_path&quot; is\n&#039;
           &#039;searched (the specification for &quot;sys.meta_path&quot; can be found in &#039;
           &#039;**PEP\n&#039;
           &#039;302**). The object is a list of *finder* objects which are queried &#039;
           &#039;in\n&#039;
           &#039;order as to whether they know how to load the module by calling &#039;
           &#039;their\n&#039;
           &#039;&quot;find_module()&quot; method with the name of the module. If the module\n&#039;
           &#039;happens to be contained within a package (as denoted by the &#039;
           &#039;existence\n&#039;
           &#039;of a dot in the name), then a second argument to &quot;find_module()&quot; &#039;
           &#039;is\n&#039;
           &#039;given as the value of the &quot;__path__&quot; attribute from the parent &#039;
           &#039;package\n&#039;
           &#039;(everything up to the last dot in the name of the module being\n&#039;
           &#039;imported). If a finder can find the module it returns a *loader*\n&#039;
           &#039;(discussed later) or returns &quot;None&quot;.\n&#039;
           &#039;\n&#039;
           &#039;If none of the finders on &quot;sys.meta_path&quot; are able to find the &#039;
           &#039;module\n&#039;
           &#039;then some implicitly defined finders are queried. Implementations &#039;
           &#039;of\n&#039;
           &#039;Python vary in what implicit meta path finders are defined. The &#039;
           &#039;one\n&#039;
           &#039;they all do define, though, is one that handles &quot;sys.path_hooks&quot;,\n&#039;
           &#039;&quot;sys.path_importer_cache&quot;, and &quot;sys.path&quot;.\n&#039;
           &#039;\n&#039;
           &#039;The implicit finder searches for the requested module in the &#039;
           &#039;&quot;paths&quot;\n&#039;
           &#039;specified in one of two places (&quot;paths&quot; do not have to be file &#039;
           &#039;system\n&#039;
           &#039;paths). If the module being imported is supposed to be contained\n&#039;
           &#039;within a package then the second argument passed to &#039;
           &#039;&quot;find_module()&quot;,\n&#039;
           &#039;&quot;__path__&quot; on the parent package, is used as the source of paths. &#039;
           &#039;If\n&#039;
           &#039;the module is not contained in a package then &quot;sys.path&quot; is used &#039;
           &#039;as\n&#039;
           &#039;the source of paths.\n&#039;
           &#039;\n&#039;
           &#039;Once the source of paths is chosen it is iterated over to find a\n&#039;
           &#039;finder that can handle that path. The dict at\n&#039;
           &#039;&quot;sys.path_importer_cache&quot; caches finders for paths and is checked &#039;
           &#039;for\n&#039;
           &#039;a finder. If the path does not have a finder cached then\n&#039;
           &#039;&quot;sys.path_hooks&quot; is searched by calling each object in the list &#039;
           &#039;with a\n&#039;
           &#039;single argument of the path, returning a finder or raises\n&#039;
           &#039;&quot;ImportError&quot;. If a finder is returned then it is cached in\n&#039;
           &#039;&quot;sys.path_importer_cache&quot; and then used for that path entry. If &#039;
           &#039;no\n&#039;
           &#039;finder can be found but the path exists then a value of &quot;None&quot; is\n&#039;
           &#039;stored in &quot;sys.path_importer_cache&quot; to signify that an implicit, &#039;
           &#039;file-\n&#039;
           &#039;based finder that handles modules stored as individual files &#039;
           &#039;should be\n&#039;
           &#039;used for that path. If the path does not exist then a finder &#039;
           &#039;which\n&#039;
           &#039;always returns &quot;None&quot; is placed in the cache for the path.\n&#039;
           &#039;\n&#039;
           &#039;If no finder can find the module then &quot;ImportError&quot; is raised.\n&#039;
           &#039;Otherwise some finder returned a loader whose &quot;load_module()&quot; &#039;
           &#039;method\n&#039;
           &#039;is called with the name of the module to load (see **PEP 302** for &#039;
           &#039;the\n&#039;
           &#039;original definition of loaders). A loader has several &#039;
           &#039;responsibilities\n&#039;
           &#039;to perform on a module it loads. First, if the module already &#039;
           &#039;exists\n&#039;
           &#039;in &quot;sys.modules&quot; (a possibility if the loader is called outside of &#039;
           &#039;the\n&#039;
           &#039;import machinery) then it is to use that module for initialization &#039;
           &#039;and\n&#039;
           &#039;not a new module. But if the module does not exist in &#039;
           &#039;&quot;sys.modules&quot;\n&#039;
           &#039;then it is to be added to that dict before initialization begins. &#039;
           &#039;If\n&#039;
           &#039;an error occurs during loading of the module and it was added to\n&#039;
           &#039;&quot;sys.modules&quot; it is to be removed from the dict. If an error &#039;
           &#039;occurs\n&#039;
           &#039;but the module was already in &quot;sys.modules&quot; it is left in the &#039;
           &#039;dict.\n&#039;
           &#039;\n&#039;
           &#039;The loader must set several attributes on the module. &quot;__name__&quot; &#039;
           &#039;is to\n&#039;
           &#039;be set to the name of the module. &quot;__file__&quot; is to be the &quot;path&quot; &#039;
           &#039;to\n&#039;
           &#039;the file unless the module is built-in (and thus listed in\n&#039;
           &#039;&quot;sys.builtin_module_names&quot;) in which case the attribute is not &#039;
           &#039;set. If\n&#039;
           &#039;what is being imported is a package then &quot;__path__&quot; is to be set &#039;
           &#039;to a\n&#039;
           &#039;list of paths to be searched when looking for modules and &#039;
           &#039;packages\n&#039;
           &#039;contained within the package being imported. &quot;__package__&quot; is &#039;
           &#039;optional\n&#039;
           &#039;but should be set to the name of package that contains the module &#039;
           &#039;or\n&#039;
           &#039;package (the empty string is used for module not contained in a\n&#039;
           &#039;package). &quot;__loader__&quot; is also optional but should be set to the\n&#039;
           &#039;loader object that is loading the module.\n&#039;
           &#039;\n&#039;
           &#039;If an error occurs during loading then the loader raises &#039;
           &#039;&quot;ImportError&quot;\n&#039;
           &#039;if some other exception is not already being propagated. Otherwise &#039;
           &#039;the\n&#039;
           &#039;loader returns the module that was loaded and initialized.\n&#039;
           &#039;\n&#039;
           &#039;When step (1) finishes without raising an exception, step (2) can\n&#039;
           &#039;begin.\n&#039;
           &#039;\n&#039;
           &#039;The first form of &quot;import&quot; statement binds the module name in the\n&#039;
           &#039;local namespace to the module object, and then goes on to import &#039;
           &#039;the\n&#039;
           &#039;next identifier, if any.  If the module name is followed by &quot;as&quot;, &#039;
           &#039;the\n&#039;
           &#039;name following &quot;as&quot; is used as the local name for the module.\n&#039;
           &#039;\n&#039;
           &#039;The &quot;from&quot; form does not bind the module name: it goes through &#039;
           &#039;the\n&#039;
           &#039;list of identifiers, looks each one of them up in the module found &#039;
           &#039;in\n&#039;
           &#039;step (1), and binds the name in the local namespace to the object &#039;
           &#039;thus\n&#039;
           &#039;found.  As with the first form of &quot;import&quot;, an alternate local &#039;
           &#039;name\n&#039;
           &#039;can be supplied by specifying &quot;&quot;as&quot; localname&quot;.  If a name is not\n&#039;
           &#039;found, &quot;ImportError&quot; is raised.  If the list of identifiers is\n&#039;
           &#039;replaced by a star (&quot;\&#039;*\&#039;&quot;), all public names defined in the &#039;
           &#039;module are\n&#039;
           &#039;bound in the local namespace of the &quot;import&quot; statement..\n&#039;
           &#039;\n&#039;
           &#039;The *public names* defined by a module are determined by checking &#039;
           &#039;the\n&#039;
           &#039;module\&#039;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;
           &quot;names includes all names found in the module&#039;s namespace which do &quot;
           &#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 &quot;from&quot; form with &quot;*&quot; may only occur in a module scope.  If &#039;
           &#039;the\n&#039;
           &#039;wild card form of import --- &quot;import *&quot; --- is used in a function &#039;
           &#039;and\n&#039;
           &#039;the function contains or is a nested block with free variables, &#039;
           &#039;the\n&#039;
           &#039;compiler 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 which modules need to be loaded dynamically.\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.  The future\n&#039;
           &#039;statement is intended to ease migration to future versions of &#039;
           &#039;Python\n&#039;
           &#039;that introduce incompatible changes to the language.  It allows &#039;
           &#039;use of\n&#039;
           &#039;the new features on a per-module basis before the release in which &#039;
           &#039;the\n&#039;
           &#039;feature becomes standard.\n&#039;
           &#039;\n&#039;
           &#039;   future_statement ::= &quot;from&quot; &quot;__future__&quot; &quot;import&quot; feature [&quot;as&quot; &#039;
           &#039;name]\n&#039;
           &#039;                        (&quot;,&quot; feature [&quot;as&quot; name])*\n&#039;
           &#039;                        | &quot;from&quot; &quot;__future__&quot; &quot;import&quot; &quot;(&quot; feature &#039;
           &#039;[&quot;as&quot; name]\n&#039;
           &#039;                        (&quot;,&quot; feature [&quot;as&quot; name])* [&quot;,&quot;] &quot;)&quot;\n&#039;
           &#039;   feature          ::= identifier\n&#039;
           &#039;   name             ::= 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 2.6 are &quot;unicode_literals&quot;,\n&#039;
           &#039;&quot;print_function&quot;, &quot;absolute_import&quot;, &quot;division&quot;, &quot;generators&quot;,\n&#039;
           &#039;&quot;nested_scopes&quot; and &quot;with_statement&quot;.  &quot;generators&quot;, &#039;
           &#039;&quot;with_statement&quot;,\n&#039;
           &#039;&quot;nested_scopes&quot; are redundant in Python version 2.6 and above &#039;
           &#039;because\n&#039;
           &#039;they are always enabled.\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;
           &quot;That is not a future statement; it&#039;s an ordinary import statement &quot;
           &#039;with\n&#039;
           &#039;no special semantics or syntax restrictions.\n&#039;
           &#039;\n&#039;
           &#039;Code compiled by an &quot;exec&quot; statement or calls to the built-in\n&#039;
           &#039;functions &quot;compile()&quot; and &quot;execfile()&quot; that occur in a module &quot;M&quot;\n&#039;
           &#039;containing a future statement will, by default, use the new  &#039;
           &#039;syntax or\n&#039;
           &#039;semantics associated with the future statement.  This can, &#039;
           &#039;starting\n&#039;
           &#039;with Python 2.2 be controlled by optional arguments to &quot;compile()&quot; &#039;
           &#039;---\n&#039;
           &#039;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;\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 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;\n&#039;
             &#039;Integer and long integer literals\n&#039;
             &#039;*********************************\n&#039;
             &#039;\n&#039;
             &#039;Integer and long integer literals are described by the &#039;
             &#039;following\n&#039;
             &#039;lexical definitions:\n&#039;
             &#039;\n&#039;
             &#039;   longinteger    ::= integer (&quot;l&quot; | &quot;L&quot;)\n&#039;
             &#039;   integer        ::= decimalinteger | octinteger | hexinteger | &#039;
             &#039;bininteger\n&#039;
             &#039;   decimalinteger ::= nonzerodigit digit* | &quot;0&quot;\n&#039;
             &#039;   octinteger     ::= &quot;0&quot; (&quot;o&quot; | &quot;O&quot;) octdigit+ | &quot;0&quot; octdigit+\n&#039;
             &#039;   hexinteger     ::= &quot;0&quot; (&quot;x&quot; | &quot;X&quot;) hexdigit+\n&#039;
             &#039;   bininteger     ::= &quot;0&quot; (&quot;b&quot; | &quot;B&quot;) bindigit+\n&#039;
             &#039;   nonzerodigit   ::= &quot;1&quot;...&quot;9&quot;\n&#039;
             &#039;   octdigit       ::= &quot;0&quot;...&quot;7&quot;\n&#039;
             &#039;   bindigit       ::= &quot;0&quot; | &quot;1&quot;\n&#039;
             &#039;   hexdigit       ::= digit | &quot;a&quot;...&quot;f&quot; | &quot;A&quot;...&quot;F&quot;\n&#039;
             &#039;\n&#039;
             &#039;Although both lower case &quot;\&#039;l\&#039;&quot; and upper case &quot;\&#039;L\&#039;&quot; are &#039;
             &#039;allowed as\n&#039;
             &#039;suffix for long integers, it is strongly recommended to always &#039;
             &#039;use\n&#039;
             &#039;&quot;\&#039;L\&#039;&quot;, since the letter &quot;\&#039;l\&#039;&quot; looks too much like the digit &#039;
             &#039;&quot;\&#039;1\&#039;&quot;.\n&#039;
             &#039;\n&#039;
             &#039;Plain integer literals that are above the largest representable &#039;
             &#039;plain\n&#039;
             &#039;integer (e.g., 2147483647 when using 32-bit arithmetic) are &#039;
             &#039;accepted\n&#039;
             &#039;as if they were long integers instead. [1]  There is no limit &#039;
             &#039;for long\n&#039;
             &#039;integer literals apart from what can be stored in available &#039;
             &#039;memory.\n&#039;
             &#039;\n&#039;
             &#039;Some examples of plain integer literals (first row) and long &#039;
             &#039;integer\n&#039;
             &#039;literals (second and third rows):\n&#039;
             &#039;\n&#039;
             &#039;   7     2147483647                        0177\n&#039;
             &#039;   3L    79228162514264337593543950336L    0377L   0x100000000L\n&#039;
             &#039;         79228162514264337593543950336             0xdeadbeef\n&#039;,
 &#039;lambda&#039;: &#039;\n&#039;
           &#039;Lambdas\n&#039;
           &#039;*******\n&#039;
           &#039;\n&#039;
           &#039;   lambda_expr     ::= &quot;lambda&quot; [parameter_list]: expression\n&#039;
           &#039;   old_lambda_expr ::= &quot;lambda&quot; [parameter_list]: old_expression\n&#039;
           &#039;\n&#039;
           &#039;Lambda expressions (sometimes called lambda forms) have the same\n&#039;
           &#039;syntactic position as expressions.  They are a shorthand to &#039;
           &#039;create\n&#039;
           &#039;anonymous functions; the expression &quot;lambda arguments: &#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 name(arguments):\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.\n&#039;,
 &#039;lists&#039;: &#039;\n&#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; [expression_list | &#039;
          &#039;list_comprehension] &quot;]&quot;\n&#039;
          &#039;   list_comprehension  ::= expression list_for\n&#039;
          &#039;   list_for            ::= &quot;for&quot; target_list &quot;in&quot; &#039;
          &#039;old_expression_list [list_iter]\n&#039;
          &#039;   old_expression_list ::= old_expression [(&quot;,&quot; old_expression)+ &#039;
          &#039;[&quot;,&quot;]]\n&#039;
          &#039;   old_expression      ::= or_test | old_lambda_expr\n&#039;
          &#039;   list_iter           ::= list_for | list_if\n&#039;
          &#039;   list_if             ::= &quot;if&quot; old_expression [list_iter]\n&#039;
          &#039;\n&#039;
          &#039;A list display yields a new list object.  Its contents are &#039;
          &#039;specified\n&#039;
          &#039;by providing either a list of expressions or a list comprehension.\n&#039;
          &#039;When a comma-separated list of expressions is supplied, its &#039;
          &#039;elements\n&#039;
          &#039;are evaluated from left to right and placed into the list object &#039;
          &#039;in\n&#039;
          &#039;that order.  When a list comprehension is supplied, it consists of &#039;
          &#039;a\n&#039;
          &#039;single expression followed by at least one &quot;for&quot; clause and zero &#039;
          &#039;or\n&#039;
          &#039;more &quot;for&quot; or &quot;if&quot; clauses.  In this case, the elements of the new\n&#039;
          &#039;list are those that would be produced by considering each of the &#039;
          &#039;&quot;for&quot;\n&#039;
          &#039;or &quot;if&quot; clauses a block, nesting from left to right, and &#039;
          &#039;evaluating\n&#039;
          &#039;the expression to produce a list element each time the innermost &#039;
          &#039;block\n&#039;
          &#039;is reached [1].\n&#039;,
 &#039;naming&#039;: &#039;\n&#039;
           &#039;Naming and binding\n&#039;
           &#039;******************\n&#039;
           &#039;\n&#039;
           &#039;*Names* refer to objects.  Names are introduced by name binding\n&#039;
           &#039;operations. Each occurrence of a name in the program text refers &#039;
           &#039;to\n&#039;
           &#039;the *binding* of that name established in the innermost function &#039;
           &#039;block\n&#039;
           &#039;containing the use.\n&#039;
           &#039;\n&#039;
           &#039;A *block* is a piece of Python program text that is executed as a\n&#039;
           &#039;unit. The following are blocks: a module, a function body, and a &#039;
           &#039;class\n&#039;
           &#039;definition. Each command typed interactively is a block.  A &#039;
           &#039;script\n&#039;
           &#039;file (a file given as standard input to the interpreter or &#039;
           &#039;specified\n&#039;
           &#039;on the interpreter command line the first argument) is a code &#039;
           &#039;block.\n&#039;
           &#039;A script command (a command specified on the interpreter command &#039;
           &#039;line\n&#039;
           &quot;with the &#039;**-c**&#039; option) is a code block.  The file read by the\n&quot;
           &#039;built-in function &quot;execfile()&quot; is a code block.  The string &#039;
           &#039;argument\n&#039;
           &#039;passed to the built-in function &quot;eval()&quot; and to the &quot;exec&quot; &#039;
           &#039;statement\n&#039;
           &#039;is a code block. The expression read and evaluated by the &#039;
           &#039;built-in\n&#039;
           &#039;function &quot;input()&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;
           &quot;where and how execution continues after the code block&#039;s execution &quot;
           &#039;has\n&#039;
           &#039;completed.\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.  The scope of names defined in &#039;
           &#039;a\n&#039;
           &#039;class block is limited to the class block; it does not extend to &#039;
           &#039;the\n&#039;
           &#039;code blocks of methods -- this includes generator expressions &#039;
           &#039;since\n&#039;
           &#039;they are implemented using a function scope.  This means that the\n&#039;
           &#039;following 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;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;
           &quot;is called the block&#039;s *environment*.\n&quot;
           &#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;If a name is bound at the module level, it is a global variable.  &#039;
           &#039;(The\n&#039;
           &#039;variables of the module code block are local and global.)  If a\n&#039;
           &#039;variable is used in a code block but not defined there, it is a &#039;
           &#039;*free\n&#039;
           &#039;variable*.\n&#039;
           &#039;\n&#039;
           &#039;When a name is not found at all, a &quot;NameError&quot; exception is &#039;
           &#039;raised.\n&#039;
           &#039;If the name refers to a local variable that has not been bound, a\n&#039;
           &#039;&quot;UnboundLocalError&quot; exception is raised.  &quot;UnboundLocalError&quot; is &#039;
           &#039;a\n&#039;
           &#039;subclass of &quot;NameError&quot;.\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, in &#039;
           &#039;the\n&#039;
           &#039;second position of an &quot;except&quot; clause header or after &quot;as&quot; in a &#039;
           &#039;&quot;with&quot;\n&#039;
           &#039;statement.  The &quot;import&quot; statement of the form &quot;from ... import &#039;
           &#039;*&quot;\n&#039;
           &#039;binds all names defined in the imported module, except those &#039;
           &#039;beginning\n&#039;
           &#039;with an underscore.  This form may only be used at the module &#039;
           &#039;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).  It\n&#039;
           &#039;is illegal to unbind a name that is referenced by an enclosing &#039;
           &#039;scope;\n&#039;
           &#039;the compiler will report a &quot;SyntaxError&quot;.\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 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 global 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 namespace &#039;
           &#039;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;__builtin__&quot;.  The global namespace is searched &#039;
           &#039;first.\n&#039;
           &#039;If the name is not found there, the builtins namespace is &#039;
           &#039;searched.\n&#039;
           &#039;The global statement must precede all uses of the name.\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;
           &quot;the module&#039;s dictionary is used).  By default, when in the &quot;
           &#039;&quot;__main__&quot;\n&#039;
           &#039;module, &quot;__builtins__&quot; is the built-in module &quot;__builtin__&quot; (note: &#039;
           &#039;no\n&#039;
           &#039;\&#039;s\&#039;); when in any other module, &quot;__builtins__&quot; is an alias for &#039;
           &#039;the\n&#039;
           &#039;dictionary of the &quot;__builtin__&quot; module itself.  &quot;__builtins__&quot; can &#039;
           &#039;be\n&#039;
           &#039;set to a user-created dictionary to create a weak form of &#039;
           &#039;restricted\n&#039;
           &#039;execution.\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;__builtin__&quot; (no \&#039;s\&#039;) module and modify its attributes\n&#039;
           &#039;appropriately.\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;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;A class definition is an executable statement that may use and &#039;
           &#039;define\n&#039;
           &#039;names. These references follow the normal rules for name &#039;
           &#039;resolution.\n&#039;
           &#039;The namespace of the class definition becomes the attribute &#039;
           &#039;dictionary\n&#039;
           &#039;of the class.  Names defined at the class scope are not visible &#039;
           &#039;in\n&#039;
           &#039;methods.\n&#039;
           &#039;\n&#039;
           &#039;\n&#039;
           &#039;Interaction with dynamic features\n&#039;
           &#039;=================================\n&#039;
           &#039;\n&#039;
           &#039;There are several cases where Python statements are illegal when &#039;
           &#039;used\n&#039;
           &#039;in conjunction with nested scopes that contain free variables.\n&#039;
           &#039;\n&#039;
           &#039;If a variable is referenced in an enclosing scope, it is illegal &#039;
           &#039;to\n&#039;
           &#039;delete the name.  An error will be reported at compile time.\n&#039;
           &#039;\n&#039;
           &#039;If the wild card form of import --- &quot;import *&quot; --- is used in a\n&#039;
           &#039;function and the function contains or is a nested block with free\n&#039;
           &#039;variables, the compiler will raise a &quot;SyntaxError&quot;.\n&#039;
           &#039;\n&#039;
           &#039;If &quot;exec&quot; is used in a function and the function contains or is a\n&#039;
           &#039;nested block with free variables, the compiler will raise a\n&#039;
           &#039;&quot;SyntaxError&quot; unless the exec explicitly specifies the local &#039;
           &#039;namespace\n&#039;
           &#039;for the &quot;exec&quot;.  (In other words, &quot;exec obj&quot; would be illegal, &#039;
           &#039;but\n&#039;
           &#039;&quot;exec obj in ns&quot; would be legal.)\n&#039;
           &#039;\n&#039;
           &#039;The &quot;eval()&quot;, &quot;execfile()&quot;, and &quot;input()&quot; functions and the &#039;
           &#039;&quot;exec&quot;\n&#039;
           &#039;statement do not have access to the full environment for &#039;
           &#039;resolving\n&#039;
           &#039;names.  Names may be resolved in the local and global namespaces &#039;
           &#039;of\n&#039;
           &#039;the caller.  Free variables are not resolved in the nearest &#039;
           &#039;enclosing\n&#039;
           &#039;namespace, but in the global namespace. [1] The &quot;exec&quot; statement &#039;
           &#039;and\n&#039;
           &#039;the &quot;eval()&quot; and &quot;execfile()&quot; functions have optional arguments &#039;
           &#039;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;numbers&#039;: &#039;\n&#039;
            &#039;Numeric literals\n&#039;
            &#039;****************\n&#039;
            &#039;\n&#039;
            &#039;There are four types of numeric literals: plain integers, long\n&#039;
            &#039;integers, floating point numbers, and imaginary numbers.  There &#039;
            &#039;are no\n&#039;
            &#039;complex literals (complex numbers can be formed by adding a real\n&#039;
            &#039;number and an 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 \&#039;&quot;-&quot;\&#039; &#039;
            &#039;and the\n&#039;
            &#039;literal &quot;1&quot;.\n&#039;,
 &#039;numeric-types&#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.__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;divmod()&quot;, &#039;
                  &#039;&quot;pow()&quot;, &quot;**&quot;,\n&#039;
                  &#039;   &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;).  For instance, to evaluate &#039;
                  &#039;the\n&#039;
                  &#039;   expression &quot;x + y&quot;, where *x* is an instance of a class &#039;
                  &#039;that has an\n&#039;
                  &#039;   &quot;__add__()&quot; method, &quot;x.__add__(y)&quot; is called.  The &#039;
                  &#039;&quot;__divmod__()&quot;\n&#039;
                  &#039;   method should be the equivalent to using &#039;
                  &#039;&quot;__floordiv__()&quot; and\n&#039;
                  &#039;   &quot;__mod__()&quot;; it should not be related to &quot;__truediv__()&quot; &#039;
                  &#039;(described\n&#039;
                  &#039;   below).  Note that &quot;__pow__()&quot; should be defined to &#039;
                  &#039;accept an\n&#039;
                  &#039;   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.__div__(self, other)\n&#039;
                  &#039;object.__truediv__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   The division operator (&quot;/&quot;) is implemented by these &#039;
                  &#039;methods.  The\n&#039;
                  &#039;   &quot;__truediv__()&quot; method is used when &#039;
                  &#039;&quot;__future__.division&quot; is in\n&#039;
                  &#039;   effect, otherwise &quot;__div__()&quot; is used.  If only one of &#039;
                  &#039;these two\n&#039;
                  &#039;   methods is defined, the object will not support division &#039;
                  &#039;in the\n&#039;
                  &#039;   alternate context; &quot;TypeError&quot; will be raised instead.\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.__rdiv__(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;divmod()&quot;, &#039;
                  &#039;&quot;pow()&quot;, &quot;**&quot;,\n&#039;
                  &#039;   &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;) with reflected (swapped) &#039;
                  &#039;operands.\n&#039;
                  &#039;   These functions are only called if the left operand does &#039;
                  &#039;not\n&#039;
                  &#039;   support the corresponding operation and the operands are &#039;
                  &#039;of\n&#039;
                  &#039;   different types. [2] 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;
                  &quot;   Note: If the right operand&#039;s type is a subclass of the &quot;
                  &#039;left\n&#039;
                  &quot;     operand&#039;s type and that subclass provides the &quot;
                  &#039;reflected method\n&#039;
                  &#039;     for the operation, this method will be called before &#039;
                  &#039;the left\n&#039;
                  &quot;     operand&#039;s non-reflected method.  This behavior allows &quot;
                  &#039;subclasses\n&#039;
                  &quot;     to override their ancestors&#039; operations.\n&quot;
                  &#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.__idiv__(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;&lt;&lt;=&quot;,\n&#039;
                  &#039;   &quot;&gt;&gt;=&quot;, &quot;&amp;=&quot;, &quot;^=&quot;, &quot;|=&quot;).  These methods should attempt &#039;
                  &#039;to do the\n&#039;
                  &#039;   operation in-place (modifying *self*) and return the &#039;
                  &#039;result (which\n&#039;
                  &#039;   could be, but does not have to be, *self*).  If a &#039;
                  &#039;specific method\n&#039;
                  &#039;   is not defined, the augmented assignment falls back to &#039;
                  &#039;the normal\n&#039;
                  &#039;   methods.  For instance, to execute the statement &quot;x += &#039;
                  &#039;y&quot;, where\n&#039;
                  &#039;   *x* is an instance of a class that has an &quot;__iadd__()&quot; &#039;
                  &#039;method,\n&#039;
                  &#039;   &quot;x.__iadd__(y)&quot; is called.  If *x* is an instance of a &#039;
                  &#039;class that\n&#039;
                  &#039;   does not define a &quot;__iadd__()&quot; method, &quot;x.__add__(y)&quot; &#039;
                  &#039;and\n&#039;
                  &#039;   &quot;y.__radd__(x)&quot; are considered, as with the evaluation &#039;
                  &#039;of &quot;x + y&quot;.\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.__long__(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;,\n&#039;
                  &#039;   &quot;long()&quot;, and &quot;float()&quot;.  Should return a value of the &#039;
                  &#039;appropriate\n&#039;
                  &#039;   type.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__oct__(self)\n&#039;
                  &#039;object.__hex__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement the built-in functions &quot;oct()&quot; and &#039;
                  &#039;&quot;hex()&quot;.\n&#039;
                  &#039;   Should return a string value.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__index__(self)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement &quot;operator.index()&quot;.  Also called &#039;
                  &#039;whenever\n&#039;
                  &#039;   Python needs an integer object (such as in slicing).  &#039;
                  &#039;Must return\n&#039;
                  &#039;   an integer (int or long).\n&#039;
                  &#039;\n&#039;
                  &#039;   New in version 2.5.\n&#039;
                  &#039;\n&#039;
                  &#039;object.__coerce__(self, other)\n&#039;
                  &#039;\n&#039;
                  &#039;   Called to implement &quot;mixed-mode&quot; numeric arithmetic.  &#039;
                  &#039;Should either\n&#039;
                  &#039;   return a 2-tuple containing *self* and *other* converted &#039;
                  &#039;to a\n&#039;
                  &#039;   common numeric type, or &quot;None&quot; if conversion is &#039;
                  &#039;impossible.  When\n&#039;
                  &#039;   the common type would be the type of &quot;other&quot;, it is &#039;
                  &#039;sufficient to\n&#039;
                  &#039;   return &quot;None&quot;, since the interpreter will also ask the &#039;
                  &#039;other object\n&#039;
                  &#039;   to attempt a coercion (but sometimes, if the &#039;
                  &#039;implementation of the\n&#039;
                  &#039;   other type cannot be changed, it is useful to do the &#039;
                  &#039;conversion to\n&#039;
                  &#039;   the other type here).  A return value of &#039;
                  &#039;&quot;NotImplemented&quot; is\n&#039;
                  &#039;   equivalent to returning &quot;None&quot;.\n&#039;,
 &#039;objects&#039;: &#039;\n&#039;
            &#039;Objects, values and types\n&#039;
            &#039;*************************\n&#039;
            &#039;\n&#039;
            &quot;*Objects* are Python&#039;s abstraction for data.  All data in a &quot;
            &#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\&#039;s model of a &quot;stored\n&#039;
            &#039;program computer,&quot; code is also represented by objects.)\n&#039;
            &#039;\n&#039;
            &quot;Every object has an identity, a type and a value.  An object&#039;s\n&quot;
            &#039;*identity* never changes once it has been created; you may think &#039;
            &#039;of it\n&#039;
            &#039;as the object\&#039;s address in memory.  The \&#039;&quot;is&quot;\&#039; operator &#039;
            &#039;compares the\n&#039;
            &#039;identity of two objects; the &quot;id()&quot; function returns an integer\n&#039;
            &#039;representing its identity (currently implemented as its address). &#039;
            &#039;An\n&#039;
            &quot;object&#039;s *type* is also unchangeable. [1] An object&#039;s type &quot;
            &#039;determines\n&#039;
            &#039;the operations that the object supports (e.g., &quot;does it have a\n&#039;
            &#039;length?&quot;) and also defines the possible values for objects of &#039;
            &#039;that\n&#039;
            &#039;type.  The &quot;type()&quot; function returns an object\&#039;s type (which is &#039;
            &#039;an\n&#039;
            &#039;object itself).  The *value* of some objects can change.  &#039;
            &#039;Objects\n&#039;
            &#039;whose value can change are said to be *mutable*; objects whose &#039;
            &#039;value\n&#039;
            &#039;is unchangeable once they are created are called *immutable*. &#039;
            &#039;(The\n&#039;
            &#039;value of an immutable container object that contains a reference &#039;
            &#039;to a\n&#039;
            &quot;mutable object can change when the latter&#039;s value is changed; &quot;
            &#039;however\n&#039;
            &#039;the container is still considered immutable, because the &#039;
            &#039;collection 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;
            &quot;An object&#039;s mutability is determined by its type; for instance,\n&quot;
            &#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 --- &#039;
            &#039;it is\n&#039;
            &#039;a 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;(ex:\n&#039;
            &#039;always close files).\n&#039;
            &#039;\n&#039;
            &quot;Note that the use of the implementation&#039;s tracing or debugging\n&quot;
            &#039;facilities may keep objects alive that would normally be &#039;
            &#039;collectable.\n&#039;
            &#039;Also note that catching an exception with a \&#039;&quot;try&quot;...&quot;except&quot;\&#039;\n&#039;
            &#039;statement may keep objects alive.\n&#039;
            &#039;\n&#039;
            &#039;Some objects contain references to &quot;external&quot; 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;\&#039;&quot;try&quot;...&quot;finally&quot;\&#039; statement provides a convenient way to do &#039;
            &#039;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;
            &quot;dictionaries.  The references are part of a container&#039;s value.  &quot;
            &#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;\n&#039;
                     &#039;Operator precedence\n&#039;
                     &#039;*******************\n&#039;
                     &#039;\n&#039;
                     &#039;The following table summarizes the operator precedences &#039;
                     &#039;in Python,\n&#039;
                     &#039;from lowest precedence (least binding) to highest &#039;
                     &#039;precedence (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;comparisons, including\n&#039;
                     &#039;tests, which all have the same precedence and chain from &#039;
                     &#039;left to right\n&#039;
                     &#039;--- see section Comparisons --- and exponentiation, &#039;
                     &#039;which groups from\n&#039;
                     &#039;right to left).\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;&lt;&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;                             | &#039;
                     &#039;Multiplication, division, remainder   |\n&#039;
                     &#039;|                                                 | &#039;
                     &#039;[7]                                   |\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 [8]                    |\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, string   |\n&#039;
                     &#039;|                                                 | &#039;
                     &#039;conversion                            |\n&#039;
                     &#039;+-------------------------------------------------+---------------------------------------+\n&#039;
                     &#039;\n&#039;
                     &#039;-[ Footnotes ]-\n&#039;
                     &#039;\n&#039;
                     &#039;[1] In Python 2.3 and later releases, a list &#039;
                     &#039;comprehension &quot;leaks&quot;\n&#039;
                     &#039;    the control variables of each &quot;for&quot; it contains into &#039;
                     &#039;the\n&#039;
                     &#039;    containing scope.  However, this behavior is &#039;
                     &#039;deprecated, and\n&#039;
                     &#039;    relying on it will not work in Python 3.\n&#039;
                     &#039;\n&#039;
                     &#039;[2] 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;[3] If x is very close to an exact integer multiple of &#039;
                     &quot;y, it&#039;s\n&quot;
                     &#039;    possible for &quot;floor(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;[4] The Unicode standard distinguishes between *code &#039;
                     &#039;points* (e.g.\n&#039;
                     &#039;    U+0041) and *abstract characters* (e.g. &quot;LATIN &#039;
                     &#039;CAPITAL LETTER A&quot;).\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;&quot;LATIN\n&#039;
                     &#039;    CAPITAL LETTER C WITH CEDILLA&quot; 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 unicode strings compare &#039;
                     &#039;at the level\n&#039;
                     &#039;    of Unicode code points. This may be &#039;
                     &#039;counter-intuitive to humans.\n&#039;
                     &#039;    For example, &quot;u&quot;\\u00C7&quot; == u&quot;\\u0043\\u0327&quot;&quot; is &#039;
                     &#039;&quot;False&quot;, even\n&#039;
                     &#039;    though both strings represent the same abstract &#039;
                     &#039;character &quot;LATIN\n&#039;
                     &#039;    CAPITAL LETTER C WITH CEDILLA&quot;.\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;[5] Earlier versions of Python used lexicographic &#039;
                     &#039;comparison of\n&#039;
                     &#039;    the sorted (key, value) lists, but this was very &#039;
                     &#039;expensive for the\n&#039;
                     &#039;    common case of comparing for equality.  An even &#039;
                     &#039;earlier version of\n&#039;
                     &#039;    Python compared dictionaries by identity only, but &#039;
                     &#039;this caused\n&#039;
                     &#039;    surprises because people expected to be able to test &#039;
                     &#039;a dictionary\n&#039;
                     &#039;    for emptiness by comparing it to &quot;{}&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;[6] 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;[7] 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;[8] 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;\n&#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 &#039;
         &#039;happens.\n&#039;
         &#039;It is useful as a placeholder when a statement is required\n&#039;
         &#039;syntactically, 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;\n&#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 ::= 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.  The result type is that of the\n&#039;
          &#039;arguments after coercion.\n&#039;
          &#039;\n&#039;
          &#039;With mixed operand types, the coercion rules for binary arithmetic\n&#039;
          &#039;operators apply. For int and long int operands, the result has the\n&#039;
          &#039;same type as the operands (after coercion) unless the second &#039;
          &#039;argument\n&#039;
          &#039;is negative; in that case, all arguments are converted to float and &#039;
          &#039;a\n&#039;
          &#039;float result is delivered. For example, &quot;10**2&quot; returns &quot;100&quot;, but\n&#039;
          &#039;&quot;10**-2&quot; returns &quot;0.01&quot;. (This last feature was added in Python &#039;
          &#039;2.2.\n&#039;
          &#039;In Python 2.1 and before, if both arguments were of integer types &#039;
          &#039;and\n&#039;
          &#039;the second argument was negative, an exception was raised).\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\n&#039;
          &#039;&quot;ValueError&quot;.\n&#039;,
 &#039;print&#039;: &#039;\n&#039;
          &#039;The &quot;print&quot; statement\n&#039;
          &#039;*********************\n&#039;
          &#039;\n&#039;
          &#039;   print_stmt ::= &quot;print&quot; ([expression (&quot;,&quot; expression)* [&quot;,&quot;]]\n&#039;
          &#039;                  | &quot;&gt;&gt;&quot; expression [(&quot;,&quot; expression)+ [&quot;,&quot;]])\n&#039;
          &#039;\n&#039;
          &#039;&quot;print&quot; evaluates each expression in turn and writes the resulting\n&#039;
          &#039;object to standard output (see below).  If an object is not a &#039;
          &#039;string,\n&#039;
          &#039;it is first converted to a string using the rules for string\n&#039;
          &#039;conversions.  The (resulting or original) string is then written.  &#039;
          &#039;A\n&#039;
          &#039;space is written before each object is (converted and) written, &#039;
          &#039;unless\n&#039;
          &#039;the output system believes it is positioned at the beginning of a\n&#039;
          &#039;line.  This is the case (1) when no characters have yet been &#039;
          &#039;written\n&#039;
          &#039;to standard output, (2) when the last character written to &#039;
          &#039;standard\n&#039;
          &#039;output is a whitespace character except &quot;\&#039; \&#039;&quot;, or (3) when the &#039;
          &#039;last\n&#039;
          &#039;write operation on standard output was not a &quot;print&quot; statement. &#039;
          &#039;(In\n&#039;
          &#039;some cases it may be functional to write an empty string to &#039;
          &#039;standard\n&#039;
          &#039;output for this reason.)\n&#039;
          &#039;\n&#039;
          &#039;Note: Objects which act like file objects but which are not the\n&#039;
          &#039;  built-in file objects often do not properly emulate this aspect &#039;
          &#039;of\n&#039;
          &quot;  the file object&#039;s behavior, so it is best not to rely on this.\n&quot;
          &#039;\n&#039;
          &#039;A &quot;\&#039;\\n\&#039;&quot; character is written at the end, unless the &quot;print&quot; &#039;
          &#039;statement\n&#039;
          &#039;ends with a comma.  This is the only action if the statement &#039;
          &#039;contains\n&#039;
          &#039;just the keyword &quot;print&quot;.\n&#039;
          &#039;\n&#039;
          &#039;Standard output is defined as the file object named &quot;stdout&quot; in &#039;
          &#039;the\n&#039;
          &#039;built-in module &quot;sys&quot;.  If no such object exists, or if it does &#039;
          &#039;not\n&#039;
          &#039;have a &quot;write()&quot; method, a &quot;RuntimeError&quot; exception is raised.\n&#039;
          &#039;\n&#039;
          &#039;&quot;print&quot; also has an extended form, defined by the second portion &#039;
          &#039;of\n&#039;
          &#039;the syntax described above. This form is sometimes referred to as\n&#039;
          &#039;&quot;&quot;print&quot; chevron.&quot; In this form, the first expression after the &#039;
          &#039;&quot;&gt;&gt;&quot;\n&#039;
          &#039;must evaluate to a &quot;file-like&quot; object, specifically an object that &#039;
          &#039;has\n&#039;
          &#039;a &quot;write()&quot; method as described above.  With this extended form, &#039;
          &#039;the\n&#039;
          &#039;subsequent expressions are printed to this file object.  If the &#039;
          &#039;first\n&#039;
          &#039;expression evaluates to &quot;None&quot;, then &quot;sys.stdout&quot; is used as the &#039;
          &#039;file\n&#039;
          &#039;for output.\n&#039;,
 &#039;raise&#039;: &#039;\n&#039;
          &#039;The &quot;raise&quot; statement\n&#039;
          &#039;*********************\n&#039;
          &#039;\n&#039;
          &#039;   raise_stmt ::= &quot;raise&quot; [expression [&quot;,&quot; expression [&quot;,&quot; &#039;
          &#039;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;TypeError&quot; exception is raised indicating &#039;
          &#039;that\n&#039;
          &#039;this is an error (if running under IDLE, a &quot;Queue.Empty&quot; exception &#039;
          &#039;is\n&#039;
          &#039;raised instead).\n&#039;
          &#039;\n&#039;
          &#039;Otherwise, &quot;raise&quot; evaluates the expressions to get three objects,\n&#039;
          &#039;using &quot;None&quot; as the value of omitted expressions.  The first two\n&#039;
          &#039;objects are used to determine the *type* and *value* of the &#039;
          &#039;exception.\n&#039;
          &#039;\n&#039;
          &#039;If the first object is an instance, the type of the exception is &#039;
          &#039;the\n&#039;
          &#039;class of the instance, the instance itself is the value, and the\n&#039;
          &#039;second object must be &quot;None&quot;.\n&#039;
          &#039;\n&#039;
          &#039;If the first object is a class, it becomes the type of the &#039;
          &#039;exception.\n&#039;
          &#039;The second object is used to determine the exception value: If it &#039;
          &#039;is\n&#039;
          &#039;an instance of the class, the instance becomes the exception value. &#039;
          &#039;If\n&#039;
          &#039;the second object is a tuple, it is used as the argument list for &#039;
          &#039;the\n&#039;
          &#039;class constructor; if it is &quot;None&quot;, an empty argument list is &#039;
          &#039;used,\n&#039;
          &#039;and any other object is treated as a single argument to the\n&#039;
          &#039;constructor.  The instance so created by calling the constructor &#039;
          &#039;is\n&#039;
          &#039;used as the exception value.\n&#039;
          &#039;\n&#039;
          &#039;If a third object is present and not &quot;None&quot;, it must be a &#039;
          &#039;traceback\n&#039;
          &#039;object (see section The standard type hierarchy), and it is\n&#039;
          &#039;substituted instead of the current location as the place where the\n&#039;
          &#039;exception occurred.  If the third object is present and not a\n&#039;
          &#039;traceback object or &quot;None&quot;, a &quot;TypeError&quot; exception is raised.  &#039;
          &#039;The\n&#039;
          &#039;three-expression form of &quot;raise&quot; is useful to re-raise an &#039;
          &#039;exception\n&#039;
          &#039;transparently in an except clause, but &quot;raise&quot; with no expressions\n&#039;
          &#039;should be preferred if the exception to be re-raised was the most\n&#039;
          &#039;recently active exception in the current scope.\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;return&#039;: &#039;\n&#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 is not allowed to\n&#039;
           &#039;include an &quot;expression_list&quot;.  In that context, a bare &quot;return&quot;\n&#039;
           &#039;indicates that the generator is done and will cause &#039;
           &#039;&quot;StopIteration&quot; to\n&#039;
           &#039;be raised.\n&#039;,
 &#039;sequence-types&#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 &#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. (For backwards compatibility, the method\n&#039;
                   &#039;&quot;__getslice__()&quot; (see below) can also be defined to handle &#039;
                   &#039;simple, but\n&#039;
                   &#039;not extended slices.) It is also recommended that mappings &#039;
                   &#039;provide the\n&#039;
                   &#039;methods &quot;keys()&quot;, &quot;values()&quot;, &quot;items()&quot;, &quot;has_key()&quot;, &#039;
                   &#039;&quot;get()&quot;,\n&#039;
                   &#039;&quot;clear()&quot;, &quot;setdefault()&quot;, &quot;iterkeys()&quot;, &quot;itervalues()&quot;,\n&#039;
                   &#039;&quot;iteritems()&quot;, &quot;pop()&quot;, &quot;popitem()&quot;, &quot;copy()&quot;, and &#039;
                   &#039;&quot;update()&quot; behaving\n&#039;
                   &quot;similar to those for Python&#039;s standard dictionary &quot;
                   &#039;objects.  The\n&#039;
                   &#039;&quot;UserDict&quot; module provides a &quot;DictMixin&quot; class to help &#039;
                   &#039;create those\n&#039;
                   &#039;methods from a base set of &quot;__getitem__()&quot;, &#039;
                   &#039;&quot;__setitem__()&quot;,\n&#039;
                   &#039;&quot;__delitem__()&quot;, and &quot;keys()&quot;. Mutable sequences should &#039;
                   &#039;provide\n&#039;
                   &#039;methods &quot;append()&quot;, &quot;count()&quot;, &quot;index()&quot;, &quot;extend()&quot;, &#039;
                   &#039;&quot;insert()&quot;,\n&#039;
                   &#039;&quot;pop()&quot;, &quot;remove()&quot;, &quot;reverse()&quot; and &quot;sort()&quot;, like Python &#039;
                   &#039;standard\n&#039;
                   &#039;list objects.  Finally, sequence types should implement &#039;
                   &#039;addition\n&#039;
                   &#039;(meaning concatenation) and multiplication (meaning &#039;
                   &#039;repetition) by\n&#039;
                   &#039;defining the methods &quot;__add__()&quot;, &quot;__radd__()&quot;, &#039;
                   &#039;&quot;__iadd__()&quot;,\n&#039;
                   &#039;&quot;__mul__()&quot;, &quot;__rmul__()&quot; and &quot;__imul__()&quot; described &#039;
                   &#039;below; they\n&#039;
                   &#039;should not define &quot;__coerce__()&quot; or other numerical &#039;
                   &#039;operators.  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 be equivalent of &quot;has_key()&quot;; &#039;
                   &#039;for sequences,\n&#039;
                   &#039;it should search through the values.  It is further &#039;
                   &#039;recommended that\n&#039;
                   &#039;both mappings and sequences implement the &quot;__iter__()&quot; &#039;
                   &#039;method 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;iterkeys()&quot;; for sequences, it &#039;
                   &#039;should 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\&#039;t define a &quot;__nonzero__()&quot; method and whose &#039;
                   &#039;&quot;__len__()&quot;\n&#039;
                   &#039;   method returns zero is considered to be false in a &#039;
                   &#039;Boolean 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;__nonzero__()&quot; &#039;
                   &#039;method.\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.__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.__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.__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, and should also &#039;
                   &#039;be made\n&#039;
                   &#039;   available as the method &quot;iterkeys()&quot;.\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;   New in version 2.6.\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\&#039;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;\n&#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 plain or long integers as arguments.  &#039;
             &#039;The\n&#039;
             &#039;arguments are converted to a common type.  They shift the 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 division by &quot;pow(2, &#039;
             &#039;n)&quot;.  A\n&#039;
             &#039;left shift by *n* bits is defined as multiplication with &quot;pow(2, &#039;
             &#039;n)&quot;.\n&#039;
             &#039;Negative shift counts raise a &quot;ValueError&quot; exception.\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;\n&#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          ::= simple_slicing | extended_slicing\n&#039;
             &#039;   simple_slicing   ::= primary &quot;[&quot; short_slice &quot;]&quot;\n&#039;
             &#039;   extended_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 | ellipsis\n&#039;
             &#039;   proper_slice     ::= short_slice | long_slice\n&#039;
             &#039;   short_slice      ::= [lower_bound] &quot;:&quot; [upper_bound]\n&#039;
             &#039;   long_slice       ::= short_slice &quot;:&quot; [stride]\n&#039;
             &#039;   lower_bound      ::= expression\n&#039;
             &#039;   upper_bound      ::= expression\n&#039;
             &#039;   stride           ::= expression\n&#039;
             &#039;   ellipsis         ::= &quot;...&quot;\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 nor ellipses).  Similarly, when the &#039;
             &#039;slice\n&#039;
             &#039;list has exactly one short slice and no trailing comma, the\n&#039;
             &#039;interpretation as a simple slicing takes priority over that as &#039;
             &#039;an\n&#039;
             &#039;extended slicing.\n&#039;
             &#039;\n&#039;
             &#039;The semantics for a simple slicing are as follows.  The primary &#039;
             &#039;must\n&#039;
             &#039;evaluate to a sequence object.  The lower and upper bound &#039;
             &#039;expressions,\n&#039;
             &#039;if present, must evaluate to plain integers; defaults are zero &#039;
             &#039;and the\n&#039;
             &#039;&quot;sys.maxint&quot;, respectively.  If either bound is negative, the\n&#039;
             &quot;sequence&#039;s length is added to it.  The slicing now selects all &quot;
             &#039;items\n&#039;
             &#039;with index *k* such that &quot;i &lt;= k &lt; j&quot; where *i* and *j* are the\n&#039;
             &#039;specified lower and upper bounds.  This may be an empty &#039;
             &#039;sequence.  It\n&#039;
             &#039;is not an error if *i* or *j* lie outside the range of valid &#039;
             &#039;indexes\n&#039;
             &quot;(such items don&#039;t exist so they aren&#039;t selected).\n&quot;
             &#039;\n&#039;
             &#039;The semantics for an extended slicing are as follows.  The &#039;
             &#039;primary\n&#039;
             &#039;must evaluate to a mapping object, and it is indexed with a key &#039;
             &#039;that\n&#039;
             &#039;is constructed from the slice list, as follows.  If the slice &#039;
             &#039;list\n&#039;
             &#039;contains at least one comma, the key is a tuple containing 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 an ellipsis &#039;
             &#039;slice\n&#039;
             &#039;item is the built-in &quot;Ellipsis&quot; object.  The conversion of a &#039;
             &#039;proper\n&#039;
             &#039;slice is a slice object (see section The standard type &#039;
             &#039;hierarchy)\n&#039;
             &#039;whose &quot;start&quot;, &quot;stop&quot; and &quot;step&quot; attributes are the values of &#039;
             &#039;the\n&#039;
             &#039;expressions given as lower bound, upper bound and stride,\n&#039;
             &#039;respectively, substituting &quot;None&quot; for missing expressions.\n&#039;,
 &#039;specialattrs&#039;: &#039;\n&#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;
                 &quot;object&#039;s\n&quot;
                 &#039;   (writable) attributes.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__methods__\n&#039;
                 &#039;\n&#039;
                 &#039;   Deprecated since version 2.2: Use the built-in function &#039;
                 &#039;&quot;dir()&quot; to\n&#039;
                 &quot;   get a list of an object&#039;s attributes. This attribute is &quot;
                 &#039;no longer\n&#039;
                 &#039;   available.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__members__\n&#039;
                 &#039;\n&#039;
                 &#039;   Deprecated since version 2.2: Use the built-in function &#039;
                 &#039;&quot;dir()&quot; to\n&#039;
                 &quot;   get a list of an object&#039;s attributes. This attribute is &quot;
                 &#039;no longer\n&#039;
                 &#039;   available.\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, type, function, method, &#039;
                 &#039;descriptor, or\n&#039;
                 &#039;   generator instance.\n&#039;
                 &#039;\n&#039;
                 &#039;The following attributes are only supported by *new-style &#039;
                 &#039;class*es.\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 new-style class keeps a list of weak references to &#039;
                 &#039;its\n&#039;
                 &#039;   immediate subclasses.  This method returns a list of all &#039;
                 &#039;those\n&#039;
                 &#039;   references still alive. Example:\n&#039;
                 &#039;\n&#039;
                 &#039;      &gt;&gt;&gt; int.__subclasses__()\n&#039;
                 &quot;      [&lt;type &#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;
                 &quot;[3] They must have since the parser can&#039;t tell the type of &quot;
                 &#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 &quot;Lu&quot; (Letter, uppercase), &quot;Ll&quot; (Letter, &#039;
                 &#039;lowercase),\n&#039;
                 &#039;    or &quot;Lt&quot; (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;\n&#039;
                 &#039;[6] The advantage of leaving the newline on is that &#039;
                 &#039;returning an\n&#039;
                 &#039;    empty string is then an unambiguous EOF indication.  It &#039;
                 &#039;is also\n&#039;
                 &#039;    possible (in cases where it might matter, for example, &#039;
                 &#039;if you want\n&#039;
                 &#039;    to make an exact copy of a file while scanning its &#039;
                 &#039;lines) to tell\n&#039;
                 &#039;    whether the last line of a file ended in a newline or &#039;
                 &#039;not (yes\n&#039;
                 &#039;    this happens!).\n&#039;,
 &#039;specialnames&#039;: &#039;\n&#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;
                 &quot;defining methods with special names. This is Python&#039;s &quot;
                 &#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;x.__getitem__(i)&quot; for &#039;
                 &#039;old-style\n&#039;
                 &#039;classes and &quot;type(x).__getitem__(x, i)&quot; for new-style &#039;
                 &#039;classes.  Except\n&#039;
                 &#039;where mentioned, attempts to execute an operation raise an &#039;
                 &#039;exception\n&#039;
                 &#039;when no appropriate method is defined (typically &#039;
                 &#039;&quot;AttributeError&quot; or\n&#039;
                 &#039;&quot;TypeError&quot;).\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\&#039;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\&#039;s &quot;__new__()&quot; method using\n&#039;
                 &#039;   &quot;super(currentclass, cls).__new__(cls[, ...])&quot; with &#039;
                 &#039;appropriate\n&#039;
                 &#039;   arguments and then modifying the newly-created instance &#039;
                 &#039;as\n&#039;
                 &#039;   necessary before returning 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\&#039;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\&#039;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\&#039;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;BaseClass.__init__(self, [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;customise\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 destructor.  If a base class has a &quot;__del__()&quot; &#039;
                 &#039;method, the\n&#039;
                 &#039;   derived class\&#039;s &quot;__del__()&quot; method, if any, must &#039;
                 &#039;explicitly call it\n&#039;
                 &#039;   to ensure proper deletion of the base class part of the &#039;
                 &#039;instance.\n&#039;
                 &#039;   Note that it is possible (though not recommended!) for &#039;
                 &#039;the\n&#039;
                 &#039;   &quot;__del__()&quot; method to postpone destruction of the &#039;
                 &#039;instance by\n&#039;
                 &#039;   creating a new reference to it.  It may then be called at &#039;
                 &#039;a later\n&#039;
                 &#039;   time when this new reference is deleted.  It is not &#039;
                 &#039;guaranteed that\n&#039;
                 &#039;   &quot;__del__()&quot; methods are called for objects that still &#039;
                 &#039;exist when\n&#039;
                 &#039;   the interpreter exits.\n&#039;
                 &#039;\n&#039;
                 &#039;   Note: &quot;del x&quot; doesn\&#039;t directly call &quot;x.__del__()&quot; --- &#039;
                 &#039;the 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;\&#039;s reference count reaches zero.  &#039;
                 &#039;Some common\n&#039;
                 &#039;     situations that may prevent the reference count of an &#039;
                 &#039;object from\n&#039;
                 &#039;     going to zero include: circular references between &#039;
                 &#039;objects (e.g.,\n&#039;
                 &#039;     a doubly-linked list or a tree data structure with &#039;
                 &#039;parent and\n&#039;
                 &#039;     child pointers); a reference to the object on the stack &#039;
                 &#039;frame of\n&#039;
                 &#039;     a function that caught an exception (the traceback &#039;
                 &#039;stored in\n&#039;
                 &#039;     &quot;sys.exc_traceback&quot; keeps the stack frame alive); or a &#039;
                 &#039;reference\n&#039;
                 &#039;     to the object on the stack frame that raised an &#039;
                 &#039;unhandled\n&#039;
                 &#039;     exception in interactive mode (the traceback stored in\n&#039;
                 &#039;     &quot;sys.last_traceback&quot; keeps the stack frame alive).  The &#039;
                 &#039;first\n&#039;
                 &#039;     situation can only be remedied by explicitly breaking &#039;
                 &#039;the cycles;\n&#039;
                 &#039;     the latter two situations can be resolved by storing &#039;
                 &#039;&quot;None&quot; in\n&#039;
                 &#039;     &quot;sys.exc_traceback&quot; or &quot;sys.last_traceback&quot;.  Circular &#039;
                 &#039;references\n&#039;
                 &#039;     which are garbage are detected when the option cycle &#039;
                 &#039;detector is\n&#039;
                 &quot;     enabled (it&#039;s on by default), but can only be cleaned &quot;
                 &#039;up if there\n&#039;
                 &#039;     are no Python-level &quot;__del__()&quot; methods involved. Refer &#039;
                 &#039;to the\n&#039;
                 &#039;     documentation for the &quot;gc&quot; module for more information &#039;
                 &#039;about how\n&#039;
                 &#039;     &quot;__del__()&quot; methods are handled by the cycle detector,\n&#039;
                 &#039;     particularly the description of the &quot;garbage&quot; value.\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. Also, when &quot;__del__()&quot; is invoked &#039;
                 &#039;in\n&#039;
                 &#039;     response to a module being deleted (e.g., when &#039;
                 &#039;execution of the\n&#039;
                 &#039;     program is done), other globals referenced by the &#039;
                 &#039;&quot;__del__()&quot;\n&#039;
                 &#039;     method may already have been deleted or in the process &#039;
                 &#039;of being\n&#039;
                 &#039;     torn down (e.g. the import machinery shutting down).  &#039;
                 &#039;For this\n&#039;
                 &#039;     reason, &quot;__del__()&quot; methods should do the absolute &#039;
                 &#039;minimum needed\n&#039;
                 &#039;     to maintain external invariants.  Starting with version &#039;
                 &#039;1.5,\n&#039;
                 &#039;     Python guarantees that globals whose name begins with a &#039;
                 &#039;single\n&#039;
                 &#039;     underscore are deleted from their module before other &#039;
                 &#039;globals are\n&#039;
                 &#039;     deleted; if no other references to such globals exist, &#039;
                 &#039;this may\n&#039;
                 &#039;     help in assuring that imported modules are still &#039;
                 &#039;available at the\n&#039;
                 &#039;     time when the &quot;__del__()&quot; method is called.\n&#039;
                 &#039;\n&#039;
                 &#039;   See also the &quot;-R&quot; command-line option.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__repr__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by the &quot;repr()&quot; built-in function and by string &#039;
                 &#039;conversions\n&#039;
                 &#039;   (reverse quotes) to compute the &quot;official&quot; string &#039;
                 &#039;representation of\n&#039;
                 &#039;   an object.  If at all possible, this should look like a &#039;
                 &#039;valid\n&#039;
                 &#039;   Python expression that could be used to recreate an &#039;
                 &#039;object with the\n&#039;
                 &#039;   same value (given an appropriate environment).  If this &#039;
                 &#039;is not\n&#039;
                 &#039;   possible, a string of the form &quot;&lt;...some useful &#039;
                 &#039;description...&gt;&quot;\n&#039;
                 &#039;   should be returned.  The return value must be a string &#039;
                 &#039;object. If a\n&#039;
                 &#039;   class defines &quot;__repr__()&quot; but not &quot;__str__()&quot;, then &#039;
                 &#039;&quot;__repr__()&quot;\n&#039;
                 &#039;   is also used when an &quot;informal&quot; string representation of &#039;
                 &#039;instances\n&#039;
                 &#039;   of that class is 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 the &quot;str()&quot; built-in function and by the &#039;
                 &#039;&quot;print&quot;\n&#039;
                 &#039;   statement to compute the &quot;informal&quot; string representation &#039;
                 &#039;of an\n&#039;
                 &#039;   object.  This differs from &quot;__repr__()&quot; in that it does &#039;
                 &#039;not have to\n&#039;
                 &#039;   be a valid Python expression: a more convenient or &#039;
                 &#039;concise\n&#039;
                 &#039;   representation may be used instead. The return value must &#039;
                 &#039;be a\n&#039;
                 &#039;   string object.\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;   New in version 2.1.\n&#039;
                 &#039;\n&#039;
                 &#039;   These are the so-called &quot;rich comparison&quot; methods, and &#039;
                 &#039;are called\n&#039;
                 &#039;   for comparison operators in preference to &quot;__cmp__()&quot; &#039;
                 &#039;below. 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; and &quot;x&lt;&gt;y&quot; call &#039;
                 &#039;&quot;x.__ne__(y)&quot;,\n&#039;
                 &#039;   &quot;x&gt;y&quot; calls &quot;x.__gt__(y)&quot;, and &quot;x&gt;=y&quot; calls &#039;
                 &#039;&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;   There are no implied relationships among the comparison &#039;
                 &#039;operators.\n&#039;
                 &#039;   The truth of &quot;x==y&quot; does not imply that &quot;x!=y&quot; is false.\n&#039;
                 &#039;   Accordingly, when defining &quot;__eq__()&quot;, one should also &#039;
                 &#039;define\n&#039;
                 &#039;   &quot;__ne__()&quot; so that the operators will behave as &#039;
                 &#039;expected.  See the\n&#039;
                 &#039;   paragraph on &quot;__hash__()&quot; for some important notes on &#039;
                 &#039;creating\n&#039;
                 &#039;   *hashable* objects which support custom comparison &#039;
                 &#039;operations and\n&#039;
                 &#039;   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;
                 &quot;each other&#039;s\n&quot;
                 &#039;   reflection, &quot;__le__()&quot; and &quot;__ge__()&quot; are each other\&#039;s &#039;
                 &#039;reflection,\n&#039;
                 &#039;   and &quot;__eq__()&quot; and &quot;__ne__()&quot; are their own reflection.\n&#039;
                 &#039;\n&#039;
                 &#039;   Arguments to rich comparison methods are never coerced.\n&#039;
                 &#039;\n&#039;
                 &#039;   To automatically generate ordering operations from a &#039;
                 &#039;single root\n&#039;
                 &#039;   operation, see &quot;functools.total_ordering()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__cmp__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called by comparison operations if rich comparison (see &#039;
                 &#039;above) is\n&#039;
                 &#039;   not defined.  Should return a negative integer if &quot;self &lt; &#039;
                 &#039;other&quot;,\n&#039;
                 &#039;   zero if &quot;self == other&quot;, a positive integer if &quot;self &gt; &#039;
                 &#039;other&quot;.  If\n&#039;
                 &#039;   no &quot;__cmp__()&quot;, &quot;__eq__()&quot; or &quot;__ne__()&quot; operation is &#039;
                 &#039;defined,\n&#039;
                 &#039;   class instances are compared by object identity &#039;
                 &#039;(&quot;address&quot;).  See\n&#039;
                 &#039;   also the description of &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. (Note: the\n&#039;
                 &#039;   restriction that exceptions are not propagated by &#039;
                 &#039;&quot;__cmp__()&quot; has\n&#039;
                 &#039;   been removed since Python 1.5.)\n&#039;
                 &#039;\n&#039;
                 &#039;object.__rcmp__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   Changed in version 2.1: No longer supported.\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;   If a class does not define a &quot;__cmp__()&quot; or &quot;__eq__()&quot; &#039;
                 &#039;method it\n&#039;
                 &#039;   should not define a &quot;__hash__()&quot; operation either; if it &#039;
                 &#039;defines\n&#039;
                 &#039;   &quot;__cmp__()&quot; or &quot;__eq__()&quot; but not &quot;__hash__()&quot;, its &#039;
                 &#039;instances will\n&#039;
                 &#039;   not be usable in hashed collections.  If a class defines &#039;
                 &#039;mutable\n&#039;
                 &#039;   objects and implements a &quot;__cmp__()&quot; or &quot;__eq__()&quot; &#039;
                 &#039;method, it\n&#039;
                 &#039;   should not implement &quot;__hash__()&quot;, since hashable &#039;
                 &#039;collection\n&#039;
                 &quot;   implementations require that an object&#039;s hash value is &quot;
                 &#039;immutable\n&#039;
                 &quot;   (if the object&#039;s hash value changes, it will be in the &quot;
                 &#039;wrong hash\n&#039;
                 &#039;   bucket).\n&#039;
                 &#039;\n&#039;
                 &#039;   User-defined classes have &quot;__cmp__()&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 a result derived &#039;
                 &#039;from\n&#039;
                 &#039;   &quot;id(x)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   Classes which inherit a &quot;__hash__()&quot; method from a parent &#039;
                 &#039;class but\n&#039;
                 &#039;   change the meaning of &quot;__cmp__()&quot; or &quot;__eq__()&quot; such that &#039;
                 &#039;the hash\n&#039;
                 &#039;   value returned is no longer appropriate (e.g. by &#039;
                 &#039;switching to a\n&#039;
                 &#039;   value-based concept of equality instead of the default &#039;
                 &#039;identity\n&#039;
                 &#039;   based equality) can explicitly flag themselves as being &#039;
                 &#039;unhashable\n&#039;
                 &#039;   by setting &quot;__hash__ = None&quot; in the class definition. &#039;
                 &#039;Doing so\n&#039;
                 &#039;   means that not only will instances of the class raise an\n&#039;
                 &#039;   appropriate &quot;TypeError&quot; when a program attempts to &#039;
                 &#039;retrieve their\n&#039;
                 &#039;   hash value, but they will also be correctly identified &#039;
                 &#039;as\n&#039;
                 &#039;   unhashable when checking &quot;isinstance(obj, &#039;
                 &#039;collections.Hashable)&quot;\n&#039;
                 &#039;   (unlike classes which define their own &quot;__hash__()&quot; to &#039;
                 &#039;explicitly\n&#039;
                 &#039;   raise &quot;TypeError&quot;).\n&#039;
                 &#039;\n&#039;
                 &#039;   Changed in version 2.5: &quot;__hash__()&quot; may now also return &#039;
                 &#039;a long\n&#039;
                 &#039;   integer object; the 32-bit integer is then derived from &#039;
                 &#039;the hash of\n&#039;
                 &#039;   that object.\n&#039;
                 &#039;\n&#039;
                 &#039;   Changed in version 2.6: &quot;__hash__&quot; may now be set to &#039;
                 &#039;&quot;None&quot; to\n&#039;
                 &#039;   explicitly flag instances of a class as unhashable.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__nonzero__(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;, or their &#039;
                 &#039;integer\n&#039;
                 &#039;   equivalents &quot;0&quot; or &quot;1&quot;.  When this method is not &#039;
                 &#039;defined,\n&#039;
                 &#039;   &quot;__len__()&quot; is called, if it is defined, and the object &#039;
                 &#039;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;__nonzero__()&quot;, all its &#039;
                 &#039;instances are\n&#039;
                 &#039;   considered true.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__unicode__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement &quot;unicode()&quot; built-in; should return a &#039;
                 &#039;Unicode\n&#039;
                 &#039;   object. When this method is not defined, string &#039;
                 &#039;conversion is\n&#039;
                 &#039;   attempted, and the result of string conversion is &#039;
                 &#039;converted to\n&#039;
                 &#039;   Unicode using the system default encoding.\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 an attribute lookup has not found the &#039;
                 &#039;attribute in the\n&#039;
                 &#039;   usual places (i.e. it is not an instance attribute nor is &#039;
                 &#039;it found\n&#039;
                 &#039;   in the class tree for &quot;self&quot;).  &quot;name&quot; is the attribute &#039;
                 &#039;name. This\n&#039;
                 &#039;   method should return the (computed) attribute value or &#039;
                 &#039;raise an\n&#039;
                 &#039;   &quot;AttributeError&quot; 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 in new-style classes.\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 not simply execute &quot;self.name = value&quot; --- this &#039;
                 &#039;would cause\n&#039;
                 &#039;   a recursive call to itself.  Instead, it should insert &#039;
                 &#039;the value in\n&#039;
                 &#039;   the dictionary of instance attributes, e.g., &#039;
                 &#039;&quot;self.__dict__[name] =\n&#039;
                 &#039;   value&quot;.  For new-style classes, rather than accessing the &#039;
                 &#039;instance\n&#039;
                 &#039;   dictionary, it should call the base class method with the &#039;
                 &#039;same\n&#039;
                 &#039;   name, for example, &quot;object.__setattr__(self, name, &#039;
                 &#039;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;\n&#039;
                 &#039;More attribute access for new-style classes\n&#039;
                 &#039;-------------------------------------------\n&#039;
                 &#039;\n&#039;
                 &#039;The following methods only apply to new-style classes.\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 for &#039;
                 &#039;new-style\n&#039;
                 &#039;     classes.\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;
                 &quot;*owner* class (the descriptor must be in either the owner&#039;s &quot;
                 &#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, &quot;the attribute&quot; refers to the attribute &#039;
                 &#039;whose name is\n&#039;
                 &#039;the key of the property in the owner class\&#039; &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;\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;&quot;binding\n&#039;
                 &#039;behavior&quot;, 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;
                 &quot;the attribute from an object&#039;s dictionary. For instance, &quot;
                 &#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.  Note that descriptors are only &#039;
                 &#039;invoked for new\n&#039;
                 &#039;style objects or classes (ones that subclass &quot;object()&quot; or &#039;
                 &#039;&quot;type()&quot;).\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 a new-style object instance, &quot;a.x&quot; is &#039;
                 &#039;transformed\n&#039;
                 &#039;   into the call: &quot;type(a).__dict__[\&#039;x\&#039;].__get__(a, &#039;
                 &#039;type(a))&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Class Binding\n&#039;
                 &#039;   If binding to a new-style class, &quot;A.x&quot; is transformed &#039;
                 &#039;into the\n&#039;
                 &#039;   call: &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;
                 &quot;object&#039;s\n&quot;
                 &#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;By default, instances of both old and new-style classes have &#039;
                 &#039;a\n&#039;
                 &#039;dictionary for attribute storage.  This wastes space for &#039;
                 &#039;objects\n&#039;
                 &#039;having very few instance variables.  The space consumption &#039;
                 &#039;can become\n&#039;
                 &#039;acute when creating large numbers of instances.\n&#039;
                 &#039;\n&#039;
                 &#039;The default can be overridden by defining *__slots__* in a &#039;
                 &#039;new-style\n&#039;
                 &#039;class definition.  The *__slots__* declaration takes a &#039;
                 &#039;sequence of\n&#039;
                 &#039;instance variables and reserves just enough space in each &#039;
                 &#039;instance to\n&#039;
                 &#039;hold a value for each variable.  Space is saved because &#039;
                 &#039;*__dict__* is\n&#039;
                 &#039;not created for each instance.\n&#039;
                 &#039;\n&#039;
                 &#039;__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.  If &#039;
                 &#039;defined in a\n&#039;
                 &#039;   new-style class, *__slots__* reserves space for the &#039;
                 &#039;declared\n&#039;
                 &#039;   variables and prevents the automatic creation of &#039;
                 &#039;*__dict__* and\n&#039;
                 &#039;   *__weakref__* for each instance.\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 2.2.\n&#039;
                 &#039;\n&#039;
                 &#039;Notes on using *__slots__*\n&#039;
                 &#039;\n&#039;
                 &#039;* When inheriting from a class without *__slots__*, the &#039;
                 &#039;*__dict__*\n&#039;
                 &#039;  attribute of that class will always be accessible, so a &#039;
                 &#039;*__slots__*\n&#039;
                 &#039;  definition in the subclass is meaningless.\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;  Changed in version 2.3: Previously, adding &quot;\&#039;__dict__\&#039;&quot; &#039;
                 &#039;to the\n&#039;
                 &#039;  *__slots__* declaration would not enable the assignment of &#039;
                 &#039;new\n&#039;
                 &#039;  attributes not specifically listed in the sequence of &#039;
                 &#039;instance\n&#039;
                 &#039;  variable names.\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;  Changed in version 2.3: Previously, adding &#039;
                 &#039;&quot;\&#039;__weakref__\&#039;&quot; to the\n&#039;
                 &#039;  *__slots__* declaration would not enable support for weak\n&#039;
                 &#039;  references.\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 limited to the &#039;
                 &#039;class\n&#039;
                 &#039;  where it is defined.  As a result, subclasses will have a &#039;
                 &#039;*__dict__*\n&#039;
                 &#039;  unless they also define *__slots__* (which must only &#039;
                 &#039;contain names\n&#039;
                 &#039;  of any *additional* 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;  &quot;variable-length&quot; built-in types such as &quot;long&quot;, &quot;str&quot; and &#039;
                 &#039;&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;  Changed in version 2.6: Previously, *__class__* assignment &#039;
                 &#039;raised an\n&#039;
                 &#039;  error if either new or old class had *__slots__*.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Customizing class creation\n&#039;
                 &#039;==========================\n&#039;
                 &#039;\n&#039;
                 &#039;By default, new-style classes are constructed using &#039;
                 &#039;&quot;type()&quot;. A class\n&#039;
                 &#039;definition is read into a separate namespace and the value &#039;
                 &#039;of class\n&#039;
                 &#039;name is bound to the result of &quot;type(name, bases, dict)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;When the class definition is read, if *__metaclass__* is &#039;
                 &#039;defined then\n&#039;
                 &#039;the callable assigned to it will be called instead of &#039;
                 &#039;&quot;type()&quot;. This\n&#039;
                 &#039;allows classes or functions to be written which monitor or &#039;
                 &#039;alter the\n&#039;
                 &#039;class creation process:\n&#039;
                 &#039;\n&#039;
                 &#039;* Modifying the class dictionary prior to the class being &#039;
                 &#039;created.\n&#039;
                 &#039;\n&#039;
                 &#039;* Returning an instance of another class -- essentially &#039;
                 &#039;performing\n&#039;
                 &#039;  the role of a factory function.\n&#039;
                 &#039;\n&#039;
                 &quot;These steps will have to be performed in the metaclass&#039;s &quot;
                 &#039;&quot;__new__()&quot;\n&#039;
                 &#039;method -- &quot;type.__new__()&quot; can then be called from this &#039;
                 &#039;method to\n&#039;
                 &#039;create a class with different properties.  This example adds &#039;
                 &#039;a new\n&#039;
                 &#039;element to the class dictionary before creating the class:\n&#039;
                 &#039;\n&#039;
                 &#039;   class metacls(type):\n&#039;
                 &#039;       def __new__(mcs, name, bases, dict):\n&#039;
                 &quot;           dict[&#039;foo&#039;] = &#039;metacls was here&#039;\n&quot;
                 &#039;           return type.__new__(mcs, name, bases, dict)\n&#039;
                 &#039;\n&#039;
                 &#039;You can of course also override other class methods (or add &#039;
                 &#039;new\n&#039;
                 &#039;methods); for example defining a custom &quot;__call__()&quot; method &#039;
                 &#039;in the\n&#039;
                 &#039;metaclass allows custom behavior when the class is called, &#039;
                 &#039;e.g. not\n&#039;
                 &#039;always creating a new instance.\n&#039;
                 &#039;\n&#039;
                 &#039;__metaclass__\n&#039;
                 &#039;\n&#039;
                 &#039;   This variable can be any callable accepting arguments for &#039;
                 &#039;&quot;name&quot;,\n&#039;
                 &#039;   &quot;bases&quot;, and &quot;dict&quot;.  Upon class creation, the callable &#039;
                 &#039;is used\n&#039;
                 &#039;   instead of the built-in &quot;type()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 2.2.\n&#039;
                 &#039;\n&#039;
                 &#039;The appropriate metaclass is determined by the following &#039;
                 &#039;precedence\n&#039;
                 &#039;rules:\n&#039;
                 &#039;\n&#039;
                 &#039;* If &quot;dict[\&#039;__metaclass__\&#039;]&quot; exists, it is used.\n&#039;
                 &#039;\n&#039;
                 &#039;* Otherwise, if there is at least one base class, its &#039;
                 &#039;metaclass is\n&#039;
                 &#039;  used (this looks for a *__class__* attribute first and if &#039;
                 &#039;not found,\n&#039;
                 &#039;  uses its type).\n&#039;
                 &#039;\n&#039;
                 &#039;* Otherwise, if a global variable named __metaclass__ &#039;
                 &#039;exists, it is\n&#039;
                 &#039;  used.\n&#039;
                 &#039;\n&#039;
                 &#039;* Otherwise, the old-style, classic metaclass &#039;
                 &#039;(types.ClassType) is\n&#039;
                 &#039;  used.\n&#039;
                 &#039;\n&#039;
                 &#039;The potential uses for metaclasses are boundless. Some ideas &#039;
                 &#039;that have\n&#039;
                 &#039;been explored including 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;New in version 2.6.\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;&quot;virtual base classes&quot; 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 &quot;called&quot; 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. (For backwards compatibility, the method\n&#039;
                 &#039;&quot;__getslice__()&quot; (see below) can also be defined to handle &#039;
                 &#039;simple, but\n&#039;
                 &#039;not extended slices.) It is also recommended that mappings &#039;
                 &#039;provide the\n&#039;
                 &#039;methods &quot;keys()&quot;, &quot;values()&quot;, &quot;items()&quot;, &quot;has_key()&quot;, &#039;
                 &#039;&quot;get()&quot;,\n&#039;
                 &#039;&quot;clear()&quot;, &quot;setdefault()&quot;, &quot;iterkeys()&quot;, &quot;itervalues()&quot;,\n&#039;
                 &#039;&quot;iteritems()&quot;, &quot;pop()&quot;, &quot;popitem()&quot;, &quot;copy()&quot;, and &#039;
                 &#039;&quot;update()&quot; behaving\n&#039;
                 &quot;similar to those for Python&#039;s standard dictionary objects.  &quot;
                 &#039;The\n&#039;
                 &#039;&quot;UserDict&quot; module provides a &quot;DictMixin&quot; class to help &#039;
                 &#039;create those\n&#039;
                 &#039;methods from a base set of &quot;__getitem__()&quot;, &#039;
                 &#039;&quot;__setitem__()&quot;,\n&#039;
                 &#039;&quot;__delitem__()&quot;, and &quot;keys()&quot;. Mutable sequences should &#039;
                 &#039;provide\n&#039;
                 &#039;methods &quot;append()&quot;, &quot;count()&quot;, &quot;index()&quot;, &quot;extend()&quot;, &#039;
                 &#039;&quot;insert()&quot;,\n&#039;
                 &#039;&quot;pop()&quot;, &quot;remove()&quot;, &quot;reverse()&quot; and &quot;sort()&quot;, like Python &#039;
                 &#039;standard\n&#039;
                 &#039;list objects.  Finally, sequence types should implement &#039;
                 &#039;addition\n&#039;
                 &#039;(meaning concatenation) and multiplication (meaning &#039;
                 &#039;repetition) by\n&#039;
                 &#039;defining the methods &quot;__add__()&quot;, &quot;__radd__()&quot;, &#039;
                 &#039;&quot;__iadd__()&quot;,\n&#039;
                 &#039;&quot;__mul__()&quot;, &quot;__rmul__()&quot; and &quot;__imul__()&quot; described below; &#039;
                 &#039;they\n&#039;
                 &#039;should not define &quot;__coerce__()&quot; or other numerical &#039;
                 &#039;operators.  It 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 be equivalent of &quot;has_key()&quot;; for &#039;
                 &#039;sequences,\n&#039;
                 &#039;it should search through the values.  It is further &#039;
                 &#039;recommended that\n&#039;
                 &#039;both mappings and sequences implement the &quot;__iter__()&quot; &#039;
                 &#039;method 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;iterkeys()&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\&#039;t define a &quot;__nonzero__()&quot; method and whose &#039;
                 &#039;&quot;__len__()&quot;\n&#039;
                 &#039;   method returns zero is considered to be false in a &#039;
                 &#039;Boolean 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;__nonzero__()&quot; method.\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.__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.__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.__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, and should also &#039;
                 &#039;be made\n&#039;
                 &#039;   available as the method &quot;iterkeys()&quot;.\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;   New in version 2.6.\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\&#039;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;Additional methods for emulation of sequence types\n&#039;
                 &#039;==================================================\n&#039;
                 &#039;\n&#039;
                 &#039;The following optional methods can be defined to further &#039;
                 &#039;emulate\n&#039;
                 &#039;sequence objects.  Immutable sequences methods should at &#039;
                 &#039;most only\n&#039;
                 &#039;define &quot;__getslice__()&quot;; mutable sequences might define all &#039;
                 &#039;three\n&#039;
                 &#039;methods.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__getslice__(self, i, j)\n&#039;
                 &#039;\n&#039;
                 &#039;   Deprecated since version 2.0: Support slice objects as &#039;
                 &#039;parameters\n&#039;
                 &#039;   to the &quot;__getitem__()&quot; method. (However, built-in types &#039;
                 &#039;in CPython\n&#039;
                 &#039;   currently still implement &quot;__getslice__()&quot;.  Therefore, &#039;
                 &#039;you have to\n&#039;
                 &#039;   override it in derived classes when implementing &#039;
                 &#039;slicing.)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement evaluation of &quot;self[i:j]&quot;. The &#039;
                 &#039;returned object\n&#039;
                 &#039;   should be of the same type as *self*.  Note that missing &#039;
                 &#039;*i* or *j*\n&#039;
                 &#039;   in the slice expression are replaced by zero or &#039;
                 &#039;&quot;sys.maxsize&quot;,\n&#039;
                 &#039;   respectively.  If negative indexes are used in the slice, &#039;
                 &#039;the\n&#039;
                 &#039;   length of the sequence is added to that index. If the &#039;
                 &#039;instance does\n&#039;
                 &#039;   not implement the &quot;__len__()&quot; method, an &quot;AttributeError&quot; &#039;
                 &#039;is\n&#039;
                 &#039;   raised. No guarantee is made that indexes adjusted this &#039;
                 &#039;way are not\n&#039;
                 &#039;   still negative.  Indexes which are greater than the &#039;
                 &#039;length of the\n&#039;
                 &#039;   sequence are not modified. If no &quot;__getslice__()&quot; is &#039;
                 &#039;found, a slice\n&#039;
                 &#039;   object is created instead, and passed to &quot;__getitem__()&quot; &#039;
                 &#039;instead.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__setslice__(self, i, j, sequence)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement assignment to &quot;self[i:j]&quot;. Same notes &#039;
                 &#039;for *i*\n&#039;
                 &#039;   and *j* as for &quot;__getslice__()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   This method is deprecated. If no &quot;__setslice__()&quot; is &#039;
                 &#039;found, or for\n&#039;
                 &#039;   extended slicing of the form &quot;self[i:j:k]&quot;, a slice &#039;
                 &#039;object is\n&#039;
                 &#039;   created, and passed to &quot;__setitem__()&quot;, instead of &#039;
                 &#039;&quot;__setslice__()&quot;\n&#039;
                 &#039;   being called.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__delslice__(self, i, j)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement deletion of &quot;self[i:j]&quot;. Same notes &#039;
                 &#039;for *i* and\n&#039;
                 &#039;   *j* as for &quot;__getslice__()&quot;. This method is deprecated. &#039;
                 &#039;If no\n&#039;
                 &#039;   &quot;__delslice__()&quot; is found, or for extended slicing of the &#039;
                 &#039;form\n&#039;
                 &#039;   &quot;self[i:j:k]&quot;, a slice object is created, and passed to\n&#039;
                 &#039;   &quot;__delitem__()&quot;, instead of &quot;__delslice__()&quot; being &#039;
                 &#039;called.\n&#039;
                 &#039;\n&#039;
                 &#039;Notice that these methods are only invoked when a single &#039;
                 &#039;slice with a\n&#039;
                 &#039;single colon is used, and the slice method is available.  &#039;
                 &#039;For slice\n&#039;
                 &#039;operations involving extended slice notation, or in absence &#039;
                 &#039;of the\n&#039;
                 &#039;slice methods, &quot;__getitem__()&quot;, &quot;__setitem__()&quot; or &#039;
                 &#039;&quot;__delitem__()&quot; is\n&#039;
                 &#039;called with a slice object as argument.\n&#039;
                 &#039;\n&#039;
                 &#039;The following example demonstrate how to make your program &#039;
                 &#039;or module\n&#039;
                 &#039;compatible with earlier versions of Python (assuming that &#039;
                 &#039;methods\n&#039;
                 &#039;&quot;__getitem__()&quot;, &quot;__setitem__()&quot; and &quot;__delitem__()&quot; support &#039;
                 &#039;slice\n&#039;
                 &#039;objects as arguments):\n&#039;
                 &#039;\n&#039;
                 &#039;   class MyClass:\n&#039;
                 &#039;       ...\n&#039;
                 &#039;       def __getitem__(self, index):\n&#039;
                 &#039;           ...\n&#039;
                 &#039;       def __setitem__(self, index, value):\n&#039;
                 &#039;           ...\n&#039;
                 &#039;       def __delitem__(self, index):\n&#039;
                 &#039;           ...\n&#039;
                 &#039;\n&#039;
                 &#039;       if sys.version_info &lt; (2, 0):\n&#039;
                 &quot;           # They won&#039;t be defined if version is at least &quot;
                 &#039;2.0 final\n&#039;
                 &#039;\n&#039;
                 &#039;           def __getslice__(self, i, j):\n&#039;
                 &#039;               return self[max(0, i):max(0, j):]\n&#039;
                 &#039;           def __setslice__(self, i, j, seq):\n&#039;
                 &#039;               self[max(0, i):max(0, j):] = seq\n&#039;
                 &#039;           def __delslice__(self, i, j):\n&#039;
                 &#039;               del self[max(0, i):max(0, j):]\n&#039;
                 &#039;       ...\n&#039;
                 &#039;\n&#039;
                 &#039;Note the calls to &quot;max()&quot;; these are necessary because of &#039;
                 &#039;the handling\n&#039;
                 &#039;of negative indices before the &quot;__*slice__()&quot; methods are &#039;
                 &#039;called.\n&#039;
                 &#039;When negative indexes are used, the &quot;__*item__()&quot; methods &#039;
                 &#039;receive them\n&#039;
                 &#039;as provided, but the &quot;__*slice__()&quot; methods get a &quot;cooked&quot; &#039;
                 &#039;form of the\n&#039;
                 &#039;index values.  For each negative index value, the length of &#039;
                 &#039;the\n&#039;
                 &#039;sequence is added to the index before calling the method &#039;
                 &#039;(which may\n&#039;
                 &#039;still result in a negative index); this is the customary &#039;
                 &#039;handling of\n&#039;
                 &#039;negative indexes by the built-in sequence types, and the &#039;
                 &#039;&quot;__*item__()&quot;\n&#039;
                 &#039;methods are expected to do this as well.  However, since &#039;
                 &#039;they should\n&#039;
                 &#039;already be doing that, negative indexes cannot be passed in; &#039;
                 &#039;they must\n&#039;
                 &#039;be constrained to the bounds of the sequence before being &#039;
                 &#039;passed to\n&#039;
                 &#039;the &quot;__*item__()&quot; methods. Calling &quot;max(0, i)&quot; conveniently &#039;
                 &#039;returns\n&#039;
                 &#039;the proper value.\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.__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;divmod()&quot;, &#039;
                 &#039;&quot;pow()&quot;, &quot;**&quot;,\n&#039;
                 &#039;   &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;).  For instance, to evaluate &#039;
                 &#039;the\n&#039;
                 &#039;   expression &quot;x + y&quot;, where *x* is an instance of a class &#039;
                 &#039;that has an\n&#039;
                 &#039;   &quot;__add__()&quot; method, &quot;x.__add__(y)&quot; is called.  The &#039;
                 &#039;&quot;__divmod__()&quot;\n&#039;
                 &#039;   method should be the equivalent to using &quot;__floordiv__()&quot; &#039;
                 &#039;and\n&#039;
                 &#039;   &quot;__mod__()&quot;; it should not be related to &quot;__truediv__()&quot; &#039;
                 &#039;(described\n&#039;
                 &#039;   below).  Note that &quot;__pow__()&quot; should be defined to &#039;
                 &#039;accept an\n&#039;
                 &#039;   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.__div__(self, other)\n&#039;
                 &#039;object.__truediv__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   The division operator (&quot;/&quot;) is implemented by these &#039;
                 &#039;methods.  The\n&#039;
                 &#039;   &quot;__truediv__()&quot; method is used when &quot;__future__.division&quot; &#039;
                 &#039;is in\n&#039;
                 &#039;   effect, otherwise &quot;__div__()&quot; is used.  If only one of &#039;
                 &#039;these two\n&#039;
                 &#039;   methods is defined, the object will not support division &#039;
                 &#039;in the\n&#039;
                 &#039;   alternate context; &quot;TypeError&quot; will be raised instead.\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.__rdiv__(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;divmod()&quot;, &quot;pow()&quot;, &#039;
                 &#039;&quot;**&quot;,\n&#039;
                 &#039;   &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&amp;&quot;, &quot;^&quot;, &quot;|&quot;) with reflected (swapped) &#039;
                 &#039;operands.\n&#039;
                 &#039;   These functions are only called if the left operand does &#039;
                 &#039;not\n&#039;
                 &#039;   support the corresponding operation and the operands are &#039;
                 &#039;of\n&#039;
                 &#039;   different types. [2] 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;
                 &quot;   Note: If the right operand&#039;s type is a subclass of the &quot;
                 &#039;left\n&#039;
                 &quot;     operand&#039;s type and that subclass provides the reflected &quot;
                 &#039;method\n&#039;
                 &#039;     for the operation, this method will be called before &#039;
                 &#039;the left\n&#039;
                 &quot;     operand&#039;s non-reflected method.  This behavior allows &quot;
                 &#039;subclasses\n&#039;
                 &quot;     to override their ancestors&#039; operations.\n&quot;
                 &#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.__idiv__(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;&lt;&lt;=&quot;,\n&#039;
                 &#039;   &quot;&gt;&gt;=&quot;, &quot;&amp;=&quot;, &quot;^=&quot;, &quot;|=&quot;).  These methods should attempt &#039;
                 &#039;to do the\n&#039;
                 &#039;   operation in-place (modifying *self*) and return the &#039;
                 &#039;result (which\n&#039;
                 &#039;   could be, but does not have to be, *self*).  If a &#039;
                 &#039;specific method\n&#039;
                 &#039;   is not defined, the augmented assignment falls back to &#039;
                 &#039;the normal\n&#039;
                 &#039;   methods.  For instance, to execute the statement &quot;x += &#039;
                 &#039;y&quot;, where\n&#039;
                 &#039;   *x* is an instance of a class that has an &quot;__iadd__()&quot; &#039;
                 &#039;method,\n&#039;
                 &#039;   &quot;x.__iadd__(y)&quot; is called.  If *x* is an instance of a &#039;
                 &#039;class that\n&#039;
                 &#039;   does not define a &quot;__iadd__()&quot; method, &quot;x.__add__(y)&quot; &#039;
                 &#039;and\n&#039;
                 &#039;   &quot;y.__radd__(x)&quot; are considered, as with the evaluation of &#039;
                 &#039;&quot;x + y&quot;.\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.__long__(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;,\n&#039;
                 &#039;   &quot;long()&quot;, and &quot;float()&quot;.  Should return a value of the &#039;
                 &#039;appropriate\n&#039;
                 &#039;   type.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__oct__(self)\n&#039;
                 &#039;object.__hex__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement the built-in functions &quot;oct()&quot; and &#039;
                 &#039;&quot;hex()&quot;.\n&#039;
                 &#039;   Should return a string value.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__index__(self)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement &quot;operator.index()&quot;.  Also called &#039;
                 &#039;whenever\n&#039;
                 &#039;   Python needs an integer object (such as in slicing).  &#039;
                 &#039;Must return\n&#039;
                 &#039;   an integer (int or long).\n&#039;
                 &#039;\n&#039;
                 &#039;   New in version 2.5.\n&#039;
                 &#039;\n&#039;
                 &#039;object.__coerce__(self, other)\n&#039;
                 &#039;\n&#039;
                 &#039;   Called to implement &quot;mixed-mode&quot; numeric arithmetic.  &#039;
                 &#039;Should either\n&#039;
                 &#039;   return a 2-tuple containing *self* and *other* converted &#039;
                 &#039;to a\n&#039;
                 &#039;   common numeric type, or &quot;None&quot; if conversion is &#039;
                 &#039;impossible.  When\n&#039;
                 &#039;   the common type would be the type of &quot;other&quot;, it is &#039;
                 &#039;sufficient to\n&#039;
                 &#039;   return &quot;None&quot;, since the interpreter will also ask the &#039;
                 &#039;other object\n&#039;
                 &#039;   to attempt a coercion (but sometimes, if the &#039;
                 &#039;implementation of the\n&#039;
                 &#039;   other type cannot be changed, it is useful to do the &#039;
                 &#039;conversion to\n&#039;
                 &#039;   the other type here).  A return value of &quot;NotImplemented&quot; &#039;
                 &#039;is\n&#039;
                 &#039;   equivalent to returning &quot;None&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Coercion rules\n&#039;
                 &#039;==============\n&#039;
                 &#039;\n&#039;
                 &#039;This section used to document the rules for coercion.  As &#039;
                 &#039;the language\n&#039;
                 &#039;has evolved, the coercion rules have become hard to &#039;
                 &#039;document\n&#039;
                 &#039;precisely; documenting what one version of one particular\n&#039;
                 &#039;implementation does is undesirable.  Instead, here are some &#039;
                 &#039;informal\n&#039;
                 &#039;guidelines regarding coercion.  In Python 3, coercion will &#039;
                 &#039;not be\n&#039;
                 &#039;supported.\n&#039;
                 &#039;\n&#039;
                 &#039;* If the left operand of a % operator is a string or Unicode &#039;
                 &#039;object,\n&#039;
                 &#039;  no coercion takes place and the string formatting &#039;
                 &#039;operation is\n&#039;
                 &#039;  invoked instead.\n&#039;
                 &#039;\n&#039;
                 &#039;* It is no longer recommended to define a coercion &#039;
                 &#039;operation. Mixed-\n&#039;
                 &quot;  mode operations on types that don&#039;t define coercion pass &quot;
                 &#039;the\n&#039;
                 &#039;  original arguments to the operation.\n&#039;
                 &#039;\n&#039;
                 &#039;* New-style classes (those derived from &quot;object&quot;) never &#039;
                 &#039;invoke the\n&#039;
                 &#039;  &quot;__coerce__()&quot; method in response to a binary operator; &#039;
                 &#039;the only\n&#039;
                 &#039;  time &quot;__coerce__()&quot; is invoked is when the built-in &#039;
                 &#039;function\n&#039;
                 &#039;  &quot;coerce()&quot; is called.\n&#039;
                 &#039;\n&#039;
                 &#039;* For most intents and purposes, an operator that returns\n&#039;
                 &#039;  &quot;NotImplemented&quot; is treated the same as one that is not &#039;
                 &#039;implemented\n&#039;
                 &#039;  at all.\n&#039;
                 &#039;\n&#039;
                 &#039;* Below, &quot;__op__()&quot; and &quot;__rop__()&quot; are used to signify the &#039;
                 &#039;generic\n&#039;
                 &#039;  method names corresponding to an operator; &quot;__iop__()&quot; is &#039;
                 &#039;used for\n&#039;
                 &#039;  the corresponding in-place operator.  For example, for the &#039;
                 &#039;operator\n&#039;
                 &#039;  \&#039;&quot;+&quot;\&#039;, &quot;__add__()&quot; and &quot;__radd__()&quot; are used for the &#039;
                 &#039;left and right\n&#039;
                 &#039;  variant of the binary operator, and &quot;__iadd__()&quot; for the &#039;
                 &#039;in-place\n&#039;
                 &#039;  variant.\n&#039;
                 &#039;\n&#039;
                 &#039;* For objects *x* and *y*, first &quot;x.__op__(y)&quot; is tried.  If &#039;
                 &#039;this is\n&#039;
                 &#039;  not implemented or returns &quot;NotImplemented&quot;, &#039;
                 &#039;&quot;y.__rop__(x)&quot; is\n&#039;
                 &#039;  tried.  If this is also not implemented or returns &#039;
                 &#039;&quot;NotImplemented&quot;,\n&#039;
                 &#039;  a &quot;TypeError&quot; exception is raised.  But see the following &#039;
                 &#039;exception:\n&#039;
                 &#039;\n&#039;
                 &#039;* Exception to the previous item: if the left operand is an &#039;
                 &#039;instance\n&#039;
                 &#039;  of a built-in type or a new-style class, and the right &#039;
                 &#039;operand is an\n&#039;
                 &#039;  instance of a proper subclass of that type or class and &#039;
                 &#039;overrides\n&#039;
                 &#039;  the base\&#039;s &quot;__rop__()&quot; method, the right operand\&#039;s &#039;
                 &#039;&quot;__rop__()&quot;\n&#039;
                 &#039;  method is tried *before* the left operand\&#039;s &quot;__op__()&quot; &#039;
                 &#039;method.\n&#039;
                 &#039;\n&#039;
                 &#039;  This is done so that a subclass can completely override &#039;
                 &#039;binary\n&#039;
                 &#039;  operators. Otherwise, the left operand\&#039;s &quot;__op__()&quot; &#039;
                 &#039;method would\n&#039;
                 &#039;  always accept the right operand: when an instance of a &#039;
                 &#039;given class\n&#039;
                 &#039;  is expected, an instance of a subclass of that class is &#039;
                 &#039;always\n&#039;
                 &#039;  acceptable.\n&#039;
                 &#039;\n&#039;
                 &#039;* When either operand type defines a coercion, this coercion &#039;
                 &#039;is\n&#039;
                 &#039;  called before that type\&#039;s &quot;__op__()&quot; or &quot;__rop__()&quot; &#039;
                 &#039;method is\n&#039;
                 &#039;  called, but no sooner.  If the coercion returns an object &#039;
                 &#039;of a\n&#039;
                 &#039;  different type for the operand whose coercion is invoked, &#039;
                 &#039;part of\n&#039;
                 &#039;  the process is redone using the new object.\n&#039;
                 &#039;\n&#039;
                 &#039;* When an in-place operator (like \&#039;&quot;+=&quot;\&#039;) is used, if the &#039;
                 &#039;left\n&#039;
                 &#039;  operand implements &quot;__iop__()&quot;, it is invoked without any &#039;
                 &#039;coercion.\n&#039;
                 &#039;  When the operation falls back to &quot;__op__()&quot; and/or &#039;
                 &#039;&quot;__rop__()&quot;, the\n&#039;
                 &#039;  normal coercion rules apply.\n&#039;
                 &#039;\n&#039;
                 &#039;* In &quot;x + y&quot;, if *x* is a sequence that implements sequence\n&#039;
                 &#039;  concatenation, sequence concatenation is invoked.\n&#039;
                 &#039;\n&#039;
                 &#039;* In &quot;x * y&quot;, if one operand is a sequence that implements &#039;
                 &#039;sequence\n&#039;
                 &#039;  repetition, and the other is an integer (&quot;int&quot; or &quot;long&quot;), &#039;
                 &#039;sequence\n&#039;
                 &#039;  repetition is invoked.\n&#039;
                 &#039;\n&#039;
                 &#039;* Rich comparisons (implemented by methods &quot;__eq__()&quot; and so &#039;
                 &#039;on)\n&#039;
                 &#039;  never use coercion.  Three-way comparison (implemented by\n&#039;
                 &#039;  &quot;__cmp__()&quot;) does use coercion under the same conditions &#039;
                 &#039;as other\n&#039;
                 &#039;  binary operations use it.\n&#039;
                 &#039;\n&#039;
                 &#039;* In the current implementation, the built-in numeric types &#039;
                 &#039;&quot;int&quot;,\n&#039;
                 &#039;  &quot;long&quot;, &quot;float&quot;, and &quot;complex&quot; do not use coercion. All &#039;
                 &#039;these types\n&#039;
                 &#039;  implement a &quot;__coerce__()&quot; method, for use by the &#039;
                 &#039;built-in\n&#039;
                 &#039;  &quot;coerce()&quot; function.\n&#039;
                 &#039;\n&#039;
                 &#039;  Changed in version 2.7: The complex type no longer makes &#039;
                 &#039;implicit\n&#039;
                 &#039;  calls to the &quot;__coerce__()&quot; method for mixed-type binary &#039;
                 &#039;arithmetic\n&#039;
                 &#039;  operations.\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;With Statement Context Managers\n&#039;
                 &#039;===============================\n&#039;
                 &#039;\n&#039;
                 &#039;New in version 2.5.\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;
                 &quot;   statement will bind this method&#039;s return value to the &quot;
                 &#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;
                 &quot;   exception; this is the caller&#039;s responsibility.\n&quot;
                 &#039;\n&#039;
                 &#039;See also:\n&#039;
                 &#039;\n&#039;
                 &#039;  **PEP 343** - The &quot;with&quot; 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 for old-style classes\n&#039;
                 &#039;===========================================\n&#039;
                 &#039;\n&#039;
                 &#039;For old-style classes, special methods are always looked up &#039;
                 &#039;in exactly\n&#039;
                 &#039;the same way as any other method or attribute. This is the &#039;
                 &#039;case\n&#039;
                 &#039;regardless of whether the method is being looked up &#039;
                 &#039;explicitly as in\n&#039;
                 &#039;&quot;x.__getitem__(i)&quot; or implicitly as in &quot;x[i]&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;This behaviour means that special methods may exhibit &#039;
                 &#039;different\n&#039;
                 &#039;behaviour for different instances of a single old-style &#039;
                 &#039;class if the\n&#039;
                 &#039;appropriate special attributes are set differently:\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; class C:\n&#039;
                 &#039;   ...     pass\n&#039;
                 &#039;   ...\n&#039;
                 &#039;   &gt;&gt;&gt; c1 = C()\n&#039;
                 &#039;   &gt;&gt;&gt; c2 = C()\n&#039;
                 &#039;   &gt;&gt;&gt; c1.__len__ = lambda: 5\n&#039;
                 &#039;   &gt;&gt;&gt; c2.__len__ = lambda: 9\n&#039;
                 &#039;   &gt;&gt;&gt; len(c1)\n&#039;
                 &#039;   5\n&#039;
                 &#039;   &gt;&gt;&gt; len(c2)\n&#039;
                 &#039;   9\n&#039;
                 &#039;\n&#039;
                 &#039;\n&#039;
                 &#039;Special method lookup for new-style classes\n&#039;
                 &#039;===========================================\n&#039;
                 &#039;\n&#039;
                 &#039;For new-style classes, implicit invocations of special &#039;
                 &#039;methods are\n&#039;
                 &quot;only guaranteed to work correctly if defined on an object&#039;s &quot;
                 &#039;type, not\n&#039;
                 &quot;in the object&#039;s instance dictionary.  That behaviour is the &quot;
                 &#039;reason why\n&#039;
                 &#039;the following code raises an exception (unlike the &#039;
                 &#039;equivalent example\n&#039;
                 &#039;with old-style classes):\n&#039;
                 &#039;\n&#039;
                 &#039;   &gt;&gt;&gt; class C(object):\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;
                 &quot;way is sometimes referred to as &#039;metaclass confusion&#039;, and &quot;
                 &#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\&#039;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):\n&#039;
                 &#039;   ...     __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;\n&#039;
                 &#039;-[ Footnotes ]-\n&#039;
                 &#039;\n&#039;
                 &quot;[1] It *is* possible in some cases to change an object&#039;s &quot;
                 &#039;type,\n&#039;
                 &quot;    under certain controlled conditions. It generally isn&#039;t &quot;
                 &#039;a good\n&#039;
                 &#039;    idea though, since it can lead to some very strange &#039;
                 &#039;behaviour if\n&#039;
                 &#039;    it is handled incorrectly.\n&#039;
                 &#039;\n&#039;
                 &#039;[2] For operands of the same type, it is assumed that if the &#039;
                 &#039;non-\n&#039;
                 &#039;    reflected method (such as &quot;__add__()&quot;) fails the &#039;
                 &#039;operation is not\n&#039;
                 &#039;    supported, which is why the reflected method is not &#039;
                 &#039;called.\n&#039;,
 &#039;string-methods&#039;: &#039;\n&#039;
                   &#039;String Methods\n&#039;
                   &#039;**************\n&#039;
                   &#039;\n&#039;
                   &#039;Below are listed the string methods which both 8-bit &#039;
                   &#039;strings and\n&#039;
                   &#039;Unicode objects support.  Some of them are also available &#039;
                   &#039;on\n&#039;
                   &#039;&quot;bytearray&quot; objects.\n&#039;
                   &#039;\n&#039;
                   &quot;In addition, Python&#039;s strings support the sequence type &quot;
                   &#039;methods\n&#039;
                   &#039;described in the Sequence Types --- str, unicode, list, &#039;
                   &#039;tuple,\n&#039;
                   &#039;bytearray, buffer, xrange section. To output formatted &#039;
                   &#039;strings use\n&#039;
                   &#039;template strings or the &quot;%&quot; operator described in the &#039;
                   &#039;String\n&#039;
                   &#039;Formatting Operations section. Also, see the &quot;re&quot; module &#039;
                   &#039;for string\n&#039;
                   &#039;functions based on regular expressions.\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;   For 8-bit strings, this method is locale-dependent.\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 a space).\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 2.4: Support for the *fillchar* &#039;
                   &#039;argument.\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.decode([encoding[, errors]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Decodes the string using the codec registered for &#039;
                   &#039;*encoding*.\n&#039;
                   &#039;   *encoding* defaults to the default string encoding.  &#039;
                   &#039;*errors* may\n&#039;
                   &#039;   be given to set a different error handling scheme.  The &#039;
                   &#039;default is\n&#039;
                   &#039;   &quot;\&#039;strict\&#039;&quot;, meaning that encoding errors raise &#039;
                   &#039;&quot;UnicodeError&quot;.\n&#039;
                   &#039;   Other possible values are &quot;\&#039;ignore\&#039;&quot;, &quot;\&#039;replace\&#039;&quot; &#039;
                   &#039;and any other\n&#039;
                   &#039;   name registered via &quot;codecs.register_error()&quot;, see &#039;
                   &#039;section Codec\n&#039;
                   &#039;   Base Classes.\n&#039;
                   &#039;\n&#039;
                   &#039;   New in version 2.2.\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 2.3: Support for other error &#039;
                   &#039;handling schemes\n&#039;
                   &#039;   added.\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 2.7: Support for keyword arguments &#039;
                   &#039;added.\n&#039;
                   &#039;\n&#039;
                   &#039;str.encode([encoding[, errors]])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return an encoded version of the string.  Default &#039;
                   &#039;encoding is the\n&#039;
                   &#039;   current default string encoding.  *errors* may be given &#039;
                   &#039;to set a\n&#039;
                   &#039;   different error handling scheme.  The default for &#039;
                   &#039;*errors* is\n&#039;
                   &#039;   &quot;\&#039;strict\&#039;&quot;, meaning that encoding errors raise a &#039;
                   &#039;&quot;UnicodeError&quot;.\n&#039;
                   &#039;   Other possible values are &quot;\&#039;ignore\&#039;&quot;, &quot;\&#039;replace\&#039;&quot;,\n&#039;
                   &#039;   &quot;\&#039;xmlcharrefreplace\&#039;&quot;, &quot;\&#039;backslashreplace\&#039;&quot; and any &#039;
                   &#039;other name\n&#039;
                   &#039;   registered via &quot;codecs.register_error()&quot;, see section &#039;
                   &#039;Codec Base\n&#039;
                   &#039;   Classes. For a list of possible encodings, see section &#039;
                   &#039;Standard\n&#039;
                   &#039;   Encodings.\n&#039;
                   &#039;\n&#039;
                   &#039;   New in version 2.0.\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 2.3: Support for &#039;
                   &#039;&quot;\&#039;xmlcharrefreplace\&#039;&quot; and\n&#039;
                   &#039;   &quot;\&#039;backslashreplace\&#039;&quot; and other error handling schemes &#039;
                   &#039;added.\n&#039;
                   &#039;\n&#039;
                   &#039;   Changed in version 2.7: 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;   Changed in version 2.5: Accept tuples as *suffix*.\n&#039;
                   &#039;\n&#039;
                   &#039;str.expandtabs([tabsize])\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;   This method of string formatting is the new standard in &#039;
                   &#039;Python 3,\n&#039;
                   &#039;   and should be preferred to the &quot;%&quot; formatting described &#039;
                   &#039;in String\n&#039;
                   &#039;   Formatting Operations in new code.\n&#039;
                   &#039;\n&#039;
                   &#039;   New in version 2.6.\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.\n&#039;
                   &#039;\n&#039;
                   &#039;   For 8-bit strings, this method is locale-dependent.\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.\n&#039;
                   &#039;\n&#039;
                   &#039;   For 8-bit strings, this method is locale-dependent.\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.\n&#039;
                   &#039;\n&#039;
                   &#039;   For 8-bit strings, this method is locale-dependent.\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;   For 8-bit strings, this method is locale-dependent.\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.\n&#039;
                   &#039;\n&#039;
                   &#039;   For 8-bit strings, this method is locale-dependent.\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;   For 8-bit strings, this method is locale-dependent.\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;   For 8-bit strings, this method is locale-dependent.\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 a\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;   Changed in version 2.4: Support for the *fillchar* &#039;
                   &#039;argument.\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;   For 8-bit strings, this method is locale-dependent.\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;   Changed in version 2.2.2: Support for the *chars* &#039;
                   &#039;argument.\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;   New in version 2.5.\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 a\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;   Changed in version 2.4: Support for the *fillchar* &#039;
                   &#039;argument.\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;   New in version 2.5.\n&#039;
                   &#039;\n&#039;
                   &#039;str.rsplit([sep[, maxsplit]])\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;   New in version 2.4.\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;   Changed in version 2.2.2: Support for the *chars* &#039;
                   &#039;argument.\n&#039;
                   &#039;\n&#039;
                   &#039;str.split([sep[, maxsplit]])\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;   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, &quot;\&#039; 1  2   3  \&#039;.split()&quot; returns &quot;[\&#039;1\&#039;, &#039;
                   &#039;\&#039;2\&#039;, \&#039;3\&#039;]&quot;, and\n&#039;
                   &#039;   &quot;\&#039;  1  2   3  \&#039;.split(None, 1)&quot; returns &quot;[\&#039;1\&#039;, &#039;
                   &#039;\&#039;2   3  \&#039;]&quot;.\n&#039;
                   &#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. This method uses the *universal newlines* &#039;
                   &#039;approach to\n&#039;
                   &#039;   splitting lines. 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;   Python recognizes &quot;&quot;\\r&quot;&quot;, &quot;&quot;\\n&quot;&quot;, and &quot;&quot;\\r\\n&quot;&quot; as &#039;
                   &#039;line boundaries\n&#039;
                   &#039;   for 8-bit strings.\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 fg\\rkl\\r\\n&#039;.splitlines(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;unicode.splitlines([keepends])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a list of the lines in the string, like &#039;
                   &#039;&quot;str.splitlines()&quot;.\n&#039;
                   &#039;   However, the Unicode method splits on the following &#039;
                   &#039;line\n&#039;
                   &#039;   boundaries, which are a superset of the *universal &#039;
                   &#039;newlines*\n&#039;
                   &#039;   recognized for 8-bit strings.\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 2.7: &quot;\\v&quot; and &quot;\\f&quot; added to list &#039;
                   &#039;of line\n&#039;
                   &#039;   boundaries.\n&#039;
                   &#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;   Changed in version 2.5: Accept tuples as *prefix*.\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;   Changed in version 2.2.2: Support for the *chars* &#039;
                   &#039;argument.\n&#039;
                   &#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.\n&#039;
                   &#039;\n&#039;
                   &#039;   For 8-bit strings, this method is locale-dependent.\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;   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;   For 8-bit strings, this method is locale-dependent.\n&#039;
                   &#039;\n&#039;
                   &#039;str.translate(table[, deletechars])\n&#039;
                   &#039;\n&#039;
                   &#039;   Return a copy of the string where all characters &#039;
                   &#039;occurring in the\n&#039;
                   &#039;   optional argument *deletechars* are removed, and the &#039;
                   &#039;remaining\n&#039;
                   &#039;   characters have been mapped through the given &#039;
                   &#039;translation table,\n&#039;
                   &#039;   which must be a string of length 256.\n&#039;
                   &#039;\n&#039;
                   &#039;   You can use the &quot;maketrans()&quot; helper function in the &#039;
                   &#039;&quot;string&quot;\n&#039;
                   &#039;   module to create a translation table. For string &#039;
                   &#039;objects, set the\n&#039;
                   &#039;   *table* argument to &quot;None&quot; for translations that only &#039;
                   &#039;delete\n&#039;
                   &#039;   characters:\n&#039;
                   &#039;\n&#039;
                   &quot;   &gt;&gt;&gt; &#039;read this short text&#039;.translate(None, &#039;aeiou&#039;)\n&quot;
                   &quot;   &#039;rd ths shrt txt&#039;\n&quot;
                   &#039;\n&#039;
                   &#039;   New in version 2.6: Support for a &quot;None&quot; *table* &#039;
                   &#039;argument.\n&#039;
                   &#039;\n&#039;
                   &#039;   For Unicode objects, the &quot;translate()&quot; method does not &#039;
                   &#039;accept the\n&#039;
                   &#039;   optional *deletechars* argument.  Instead, it returns a &#039;
                   &#039;copy of the\n&#039;
                   &#039;   *s* where all characters have been mapped through the &#039;
                   &#039;given\n&#039;
                   &#039;   translation table which must be a mapping of Unicode &#039;
                   &#039;ordinals to\n&#039;
                   &#039;   Unicode ordinals, Unicode strings or &quot;None&quot;. Unmapped &#039;
                   &#039;characters\n&#039;
                   &#039;   are left untouched. Characters mapped to &quot;None&quot; are &#039;
                   &#039;deleted.  Note,\n&#039;
                   &#039;   a more flexible approach is to create a custom &#039;
                   &#039;character mapping\n&#039;
                   &#039;   codec using the &quot;codecs&quot; module (see &quot;encodings.cp1251&quot; &#039;
                   &#039;for an\n&#039;
                   &#039;   example).\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;str.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 &quot;Lu&quot; &#039;
                   &#039;(Letter,\n&#039;
                   &#039;   uppercase), but e.g. &quot;Lt&quot; (Letter, titlecase).\n&#039;
                   &#039;\n&#039;
                   &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
                   &#039;\n&#039;
                   &#039;str.zfill(width)\n&#039;
                   &#039;\n&#039;
                   &#039;   Return the numeric string left filled with zeros in a &#039;
                   &#039;string of\n&#039;
                   &#039;   length *width*.  A sign prefix is handled correctly.  &#039;
                   &#039;The original\n&#039;
                   &#039;   string is returned if *width* is less than or equal to &#039;
                   &#039;&quot;len(s)&quot;.\n&#039;
                   &#039;\n&#039;
                   &#039;   New in version 2.2.2.\n&#039;
                   &#039;\n&#039;
                   &#039;The following methods are present only on unicode &#039;
                   &#039;objects:\n&#039;
                   &#039;\n&#039;
                   &#039;unicode.isnumeric()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return &quot;True&quot; if there are only numeric characters in &#039;
                   &#039;S, &quot;False&quot;\n&#039;
                   &#039;   otherwise. Numeric characters include digit characters, &#039;
                   &#039;and all\n&#039;
                   &#039;   characters that have the Unicode numeric value &#039;
                   &#039;property, e.g.\n&#039;
                   &#039;   U+2155, VULGAR FRACTION ONE FIFTH.\n&#039;
                   &#039;\n&#039;
                   &#039;unicode.isdecimal()\n&#039;
                   &#039;\n&#039;
                   &#039;   Return &quot;True&quot; if there are only decimal characters in &#039;
                   &#039;S, &quot;False&quot;\n&#039;
                   &#039;   otherwise. Decimal characters include digit characters, &#039;
                   &#039;and all\n&#039;
                   &#039;   characters that can be used to form decimal-radix &#039;
                   &#039;numbers, e.g.\n&#039;
                   &#039;   U+0660, ARABIC-INDIC DIGIT ZERO.\n&#039;,
 &#039;strings&#039;: &#039;\n&#039;
            &#039;String 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;ur&quot; | &quot;R&quot; | &quot;U&quot; | &quot;UR&quot; | &quot;Ur&quot; &#039;
            &#039;| &quot;uR&quot;\n&#039;
            &#039;                    | &quot;b&quot; | &quot;B&quot; | &quot;br&quot; | &quot;Br&quot; | &quot;bR&quot; | &quot;BR&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;\n&#039;
            &#039;                  | \&#039;&quot;&quot;&quot;\&#039; longstringitem* \&#039;&quot;&quot;&quot;\&#039;\n&#039;
            &#039;   shortstringitem ::= shortstringchar | escapeseq\n&#039;
            &#039;   longstringitem  ::= longstringchar | escapeseq\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;   escapeseq       ::= &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; and the rest &#039;
            &#039;of\n&#039;
            &#039;the string literal. The source character set is defined by the\n&#039;
            &#039;encoding declaration; it is ASCII if no encoding declaration is &#039;
            &#039;given\n&#039;
            &#039;in the source file; see section Encoding declarations.\n&#039;
            &#039;\n&#039;
            &#039;In plain English: String literals can be enclosed in matching &#039;
            &#039;single\n&#039;
            &#039;quotes (&quot;\&#039;&quot;) or double quotes (&quot;&quot;&quot;).  They can also be enclosed &#039;
            &#039;in\n&#039;
            &#039;matching groups of three single or double quotes (these are &#039;
            &#039;generally\n&#039;
            &#039;referred to as *triple-quoted strings*).  The backslash (&quot;\\&quot;)\n&#039;
            &#039;character is used to escape characters that otherwise have a &#039;
            &#039;special\n&#039;
            &#039;meaning, such as newline, backslash itself, or the quote &#039;
            &#039;character.\n&#039;
            &#039;String literals may optionally be prefixed with a letter &quot;\&#039;r\&#039;&quot; &#039;
            &#039;or\n&#039;
            &#039;&quot;\&#039;R\&#039;&quot;; such strings are called *raw strings* and use different &#039;
            &#039;rules\n&#039;
            &#039;for interpreting backslash escape sequences.  A prefix of &quot;\&#039;u\&#039;&quot; &#039;
            &#039;or\n&#039;
            &#039;&quot;\&#039;U\&#039;&quot; makes the string a Unicode string.  Unicode strings use &#039;
            &#039;the\n&#039;
            &#039;Unicode character set as defined by the Unicode Consortium and &#039;
            &#039;ISO\n&#039;
            &#039;10646.  Some additional escape sequences, described below, are\n&#039;
            &#039;available in Unicode strings. A prefix of &quot;\&#039;b\&#039;&quot; or &quot;\&#039;B\&#039;&quot; is &#039;
            &#039;ignored in\n&#039;
            &#039;Python 2; it indicates that the literal should become a bytes &#039;
            &#039;literal\n&#039;
            &#039;in Python 3 (e.g. when code is automatically converted with &#039;
            &#039;2to3).  A\n&#039;
            &#039;&quot;\&#039;u\&#039;&quot; or &quot;\&#039;b\&#039;&quot; prefix may be followed by an &quot;\&#039;r\&#039;&quot; prefix.\n&#039;
            &#039;\n&#039;
            &#039;In triple-quoted strings, 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 string.  (A &quot;quote&quot; is the character used to open &#039;
            &#039;the\n&#039;
            &#039;string, 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\n&#039;
            &#039;strings are interpreted according to rules similar to those used &#039;
            &#039;by\n&#039;
            &#039;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;        | 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;\\N{name}&quot;        | Character named *name* in the     &#039;
            &#039;|         |\n&#039;
            &#039;|                   | Unicode database (Unicode only)   |         &#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;\\uxxxx&quot;          | Character with 16-bit hex value   | &#039;
            &#039;(1)     |\n&#039;
            &#039;|                   | *xxxx* (Unicode only)             |         &#039;
            &#039;|\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\Uxxxxxxxx&quot;      | Character with 32-bit hex value   | &#039;
            &#039;(2)     |\n&#039;
            &#039;|                   | *xxxxxxxx* (Unicode only)         |         &#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;(3,5)   |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;| &quot;\\xhh&quot;            | Character with hex value *hh*     | &#039;
            &#039;(4,5)   |\n&#039;
            &#039;+-------------------+-----------------------------------+---------+\n&#039;
            &#039;\n&#039;
            &#039;Notes:\n&#039;
            &#039;\n&#039;
            &#039;1. Individual code units which form parts of a surrogate pair &#039;
            &#039;can\n&#039;
            &#039;   be encoded using this escape sequence.\n&#039;
            &#039;\n&#039;
            &#039;2. Any Unicode character can be encoded this way, but characters\n&#039;
            &#039;   outside the Basic Multilingual Plane (BMP) will be encoded &#039;
            &#039;using a\n&#039;
            &#039;   surrogate pair if Python is compiled to use 16-bit code units &#039;
            &#039;(the\n&#039;
            &#039;   default).\n&#039;
            &#039;\n&#039;
            &#039;3. As in Standard C, up to three octal digits are accepted.\n&#039;
            &#039;\n&#039;
            &#039;4. Unlike in Standard C, exactly two hex digits are required.\n&#039;
            &#039;\n&#039;
            &#039;5. In a string literal, hexadecimal and octal escapes denote the\n&#039;
            &#039;   byte with the given value; it is not necessary that the byte\n&#039;
            &#039;   encodes a character in the source character set. In a Unicode\n&#039;
            &#039;   literal, these escapes denote a Unicode character with the &#039;
            &#039;given\n&#039;
            &#039;   value.\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 string*.  &#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 marked as &quot;(Unicode &#039;
            &#039;only)&quot;\n&#039;
            &#039;in the table above fall into the category of unrecognized escapes &#039;
            &#039;for\n&#039;
            &#039;non-Unicode string literals.\n&#039;
            &#039;\n&#039;
            &#039;When an &quot;\&#039;r\&#039;&quot; or &quot;\&#039;R\&#039;&quot; prefix is present, a character &#039;
            &#039;following a\n&#039;
            &#039;backslash is included in the string without change, and *all\n&#039;
            &#039;backslashes are left in the string*.  For example, the string &#039;
            &#039;literal\n&#039;
            &#039;&quot;r&quot;\\n&quot;&quot; consists of two characters: a backslash and a lowercase &#039;
            &#039;&quot;\&#039;n\&#039;&quot;.\n&#039;
            &#039;String quotes can be escaped with a backslash, but the backslash\n&#039;
            &#039;remains in the string; for example, &quot;r&quot;\\&quot;&quot;&quot; is a valid string &#039;
            &#039;literal\n&#039;
            &#039;consisting of two characters: a backslash and a double quote; &#039;
            &#039;&quot;r&quot;\\&quot;&quot;\n&#039;
            &#039;is not a valid string literal (even a raw string cannot end in an &#039;
            &#039;odd\n&#039;
            &#039;number of backslashes).  Specifically, *a raw string cannot end &#039;
            &#039;in a\n&#039;
            &#039;single backslash* (since the backslash would escape the &#039;
            &#039;following\n&#039;
            &#039;quote character).  Note also that a single backslash followed by &#039;
            &#039;a\n&#039;
            &#039;newline is interpreted as those two characters as part of the &#039;
            &#039;string,\n&#039;
            &#039;*not* as a line continuation.\n&#039;
            &#039;\n&#039;
            &#039;When an &quot;\&#039;r\&#039;&quot; or &quot;\&#039;R\&#039;&quot; prefix is used in conjunction with a &#039;
            &#039;&quot;\&#039;u\&#039;&quot; or\n&#039;
            &#039;&quot;\&#039;U\&#039;&quot; prefix, then the &quot;\\uXXXX&quot; and &quot;\\UXXXXXXXX&quot; escape &#039;
            &#039;sequences are\n&#039;
            &#039;processed while  *all other backslashes are left in the string*. &#039;
            &#039;For\n&#039;
            &#039;example, the string literal &quot;ur&quot;\\u0062\\n&quot;&quot; consists of three &#039;
            &#039;Unicode\n&#039;
            &quot;characters: &#039;LATIN SMALL LETTER B&#039;, &#039;REVERSE SOLIDUS&#039;, and &quot;
            &quot;&#039;LATIN\n&quot;
            &quot;SMALL LETTER N&#039;. Backslashes can be escaped with a preceding\n&quot;
            &#039;backslash; however, both remain in the string.  As a result, &#039;
            &#039;&quot;\\uXXXX&quot;\n&#039;
            &#039;escape sequences are only recognized when there are an odd number &#039;
            &#039;of\n&#039;
            &#039;backslashes.\n&#039;,
 &#039;subscriptions&#039;: &#039;\n&#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 of a sequence or &#039;
                  &#039;mapping type.\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 a\n&#039;
                  &#039;plain integer.  If this value is negative, the length of &#039;
                  &#039;the sequence\n&#039;
                  &#039;is added to it (so that, e.g., &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).\n&#039;
                  &#039;\n&#039;
                  &quot;A string&#039;s items are characters.  A character is not a &quot;
                  &#039;separate data\n&#039;
                  &#039;type but a string of exactly one character.\n&#039;,
 &#039;truth&#039;: &#039;\n&#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. &#039;
          &#039;The\n&#039;
          &#039;following values are considered false:\n&#039;
          &#039;\n&#039;
          &#039;* &quot;None&quot;\n&#039;
          &#039;\n&#039;
          &#039;* &quot;False&quot;\n&#039;
          &#039;\n&#039;
          &#039;* zero of any numeric type, for example, &quot;0&quot;, &quot;0L&quot;, &quot;0.0&quot;, &quot;0j&quot;.\n&#039;
          &#039;\n&#039;
          &#039;* any empty sequence, for example, &quot;\&#039;\&#039;&quot;, &quot;()&quot;, &quot;[]&quot;.\n&#039;
          &#039;\n&#039;
          &#039;* any empty mapping, for example, &quot;{}&quot;.\n&#039;
          &#039;\n&#039;
          &#039;* instances of user-defined classes, if the class defines a\n&#039;
          &#039;  &quot;__nonzero__()&quot; or &quot;__len__()&quot; method, when that method returns &#039;
          &#039;the\n&#039;
          &#039;  integer zero or &quot;bool&quot; value &quot;False&quot;. [1]\n&#039;
          &#039;\n&#039;
          &#039;All other values are considered true --- so objects of many types &#039;
          &#039;are\n&#039;
          &#039;always true.\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;\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 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; | &quot;,&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;Changed in version 2.5: In previous versions of Python,\n&#039;
        &#039;&quot;try&quot;...&quot;except&quot;...&quot;finally&quot; did not work. &quot;try&quot;...&quot;except&quot; had to &#039;
        &#039;be\n&#039;
        &#039;nested in &quot;try&quot;...&quot;finally&quot;.\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 &quot;compatible&quot; 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 in that except clause, if present, and the &#039;
        &#039;except\n&#039;
        &quot;clause&#039;s suite is executed.  All except clauses must have an\n&quot;
        &#039;executable block.  When the end of this block is reached, execution\n&#039;
        &#039;continues normally after the entire try statement.  (This means that\n&#039;
        &#039;if two nested handlers exist for the same exception, and the &#039;
        &#039;exception\n&#039;
        &#039;occurs in the try clause of the inner handler, the outer handler &#039;
        &#039;will\n&#039;
        &#039;not handle the exception.)\n&#039;
        &#039;\n&#039;
        &quot;Before an except clause&#039;s suite is executed, details about the\n&quot;
        &#039;exception are assigned to three variables in the &quot;sys&quot; module:\n&#039;
        &#039;&quot;sys.exc_type&quot; receives the object identifying the exception;\n&#039;
        &#039;&quot;sys.exc_value&quot; receives the exception\&#039;s parameter;\n&#039;
        &#039;&quot;sys.exc_traceback&quot; receives a traceback object (see section The\n&#039;
        &#039;standard type hierarchy) identifying the point in the program where\n&#039;
        &#039;the exception occurred. These details are also available through the\n&#039;
        &#039;&quot;sys.exc_info()&quot; function, which returns a tuple &quot;(exc_type,\n&#039;
        &#039;exc_value, exc_traceback)&quot;.  Use of the corresponding variables is\n&#039;
        &#039;deprecated in favor of this function, since their use is unsafe in a\n&#039;
        &#039;threaded program.  As of Python 1.5, the variables are restored to\n&#039;
        &#039;their previous values (before the call) when returning from a &#039;
        &#039;function\n&#039;
        &#039;that handled an exception.\n&#039;
        &#039;\n&#039;
        &#039;The optional &quot;else&quot; clause is executed if and when control flows off\n&#039;
        &#039;the end of the &quot;try&quot; clause. [2] 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 \&#039;cleanup\&#039; 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\n&#039;
        &#039;&quot;finally&quot; clause. If the &quot;finally&quot; clause raises another exception &#039;
        &#039;or\n&#039;
        &#039;executes a &quot;return&quot; or &quot;break&quot; statement, the saved exception is\n&#039;
        &#039;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 &#039;
        &#039;is\n&#039;
        &#039;also executed \&#039;on the way out.\&#039; A &quot;continue&quot; statement is illegal &#039;
        &#039;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;\n&#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.).\n&#039;
          &#039;\n&#039;
          &#039;Some of the type descriptions below contain a paragraph listing\n&#039;
          &quot;&#039;special attributes.&#039;  These are attributes that provide access to &quot;
          &#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;
          &quot;   it is returned from functions that don&#039;t explicitly return\n&quot;
          &#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 &#039;
          &#039;may\n&#039;
          &#039;   return this value if they do not implement the operation for &#039;
          &#039;the\n&#039;
          &#039;   operands provided.  (The interpreter will then try the &#039;
          &#039;reflected\n&#039;
          &#039;   operation, or some other fallback, depending on the operator.)  &#039;
          &#039;Its\n&#039;
          &#039;   truth value is true.\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 built-in name\n&#039;
          &#039;   &quot;Ellipsis&quot;. It is used to indicate the presence of the &quot;...&quot; &#039;
          &#039;syntax\n&#039;
          &#039;   in a slice.  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 three types of integers:\n&#039;
          &#039;\n&#039;
          &#039;      Plain integers\n&#039;
          &#039;         These represent numbers in the range -2147483648 through\n&#039;
          &#039;         2147483647. (The range may be larger on machines with a\n&#039;
          &#039;         larger natural word size, but not smaller.)  When the &#039;
          &#039;result\n&#039;
          &#039;         of an operation would fall outside this range, the result &#039;
          &#039;is\n&#039;
          &#039;         normally returned as a long integer (in some cases, the\n&#039;
          &#039;         exception &quot;OverflowError&quot; is raised instead).  For the\n&#039;
          &#039;         purpose of shift and mask operations, integers are assumed &#039;
          &#039;to\n&#039;
          &quot;         have a binary, 2&#039;s complement notation using 32 or more &quot;
          &#039;bits,\n&#039;
          &#039;         and hiding no bits from the user (i.e., all 4294967296\n&#039;
          &#039;         different bit patterns correspond to different values).\n&#039;
          &#039;\n&#039;
          &#039;      Long integers\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;
          &quot;         negative numbers are represented in a variant of 2&#039;s\n&quot;
          &#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\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;plain\n&#039;
          &#039;         integers, and Boolean values behave like the values 0 and &#039;
          &#039;1,\n&#039;
          &#039;         respectively, in almost all contexts, the exception 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 and the least surprises when\n&#039;
          &#039;      switching between the plain and long integer domains.  Any\n&#039;
          &#039;      operation, if it yields a result in the plain integer &#039;
          &#039;domain,\n&#039;
          &#039;      will yield the same result in the long integer domain or &#039;
          &#039;when\n&#039;
          &#039;      using mixed operands.  The switch between domains is &#039;
          &#039;transparent\n&#039;
          &#039;      to the programmer.\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;\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 &quot;extended slicing&quot; with a third &#039;
          &#039;&quot;step&quot;\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;         The items of a string are characters.  There is no &#039;
          &#039;separate\n&#039;
          &#039;         character type; a character is represented by a string of &#039;
          &#039;one\n&#039;
          &#039;         item. Characters represent (at least) 8-bit bytes.  The\n&#039;
          &#039;         built-in functions &quot;chr()&quot; and &quot;ord()&quot; convert between\n&#039;
          &#039;         characters and nonnegative integers representing the byte\n&#039;
          &#039;         values.  Bytes with the values 0--127 usually represent &#039;
          &#039;the\n&#039;
          &#039;         corresponding ASCII values, but the interpretation of &#039;
          &#039;values\n&#039;
          &#039;         is up to the program.  The string data type is also used &#039;
          &#039;to\n&#039;
          &#039;         represent arrays of bytes, e.g., to hold data read from a\n&#039;
          &#039;         file.\n&#039;
          &#039;\n&#039;
          &#039;         (On systems whose native character set is not ASCII, &#039;
          &#039;strings\n&#039;
          &#039;         may use EBCDIC in their internal representation, provided &#039;
          &#039;the\n&#039;
          &#039;         functions &quot;chr()&quot; and &quot;ord()&quot; implement a mapping between\n&#039;
          &#039;         ASCII and EBCDIC, and string comparison preserves the &#039;
          &#039;ASCII\n&#039;
          &#039;         order. Or perhaps someone can propose a better rule?)\n&#039;
          &#039;\n&#039;
          &#039;      Unicode\n&#039;
          &#039;         The items of a Unicode object are Unicode code units.  A\n&#039;
          &#039;         Unicode code unit is represented by a Unicode object of &#039;
          &#039;one\n&#039;
          &#039;         item and can hold either a 16-bit or 32-bit value\n&#039;
          &#039;         representing a Unicode ordinal (the maximum value for the\n&#039;
          &#039;         ordinal is given in &quot;sys.maxunicode&quot;, and depends on how\n&#039;
          &#039;         Python is configured at compile time).  Surrogate pairs &#039;
          &#039;may\n&#039;
          &#039;         be present in the Unicode object, and will be reported as &#039;
          &#039;two\n&#039;
          &#039;         separate items.  The built-in functions &quot;unichr()&quot; and\n&#039;
          &#039;         &quot;ord()&quot; convert between code units and nonnegative &#039;
          &#039;integers\n&#039;
          &#039;         representing the Unicode ordinals as defined in the &#039;
          &#039;Unicode\n&#039;
          &#039;         Standard 3.0. Conversion from and to other encodings are\n&#039;
          &#039;         possible through the Unicode method &quot;encode()&quot; and the &#039;
          &#039;built-\n&#039;
          &#039;         in function &quot;unicode()&quot;.\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;
          &quot;         expressions.  A tuple of one item (a &#039;singleton&#039;) can be\n&quot;
          &#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;   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 bytes\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.\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;
          &quot;      dictionaries requires a key&#039;s hash value to remain constant.\n&quot;
          &#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&quot;, &quot;gdbm&quot;, and &quot;bsddb&quot; provide\n&#039;
          &#039;      additional examples of mapping types.\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;
          &quot;      as the function&#039;s formal parameter list.\n&quot;
          &#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; &quot;func_doc&quot;    | The function\&#039;s documentation    &#039;
          &#039;| Writable    |\n&#039;
          &#039;      |                         | string, or &quot;None&quot; if            &#039;
          &#039;|             |\n&#039;
          &#039;      |                         | unavailable.                    &#039;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+-------------------------+---------------------------------+-------------+\n&#039;
          &#039;      | &quot;__name__&quot; &quot;func_name&quot;  | The function\&#039;s name             &#039;
          &#039;| Writable    |\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;      | &quot;func_defaults&quot;         | 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; &quot;func_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;      | &quot;func_globals&quot;          | that holds the function\&#039;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; &quot;func_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;      | &quot;func_closure&quot;          | contain bindings for the        &#039;
          &#039;|             |\n&#039;
          &quot;      |                         | function&#039;s free variables.      &quot;
          &#039;|             |\n&#039;
          &#039;      &#039;
          &#039;+-------------------------+---------------------------------+-------------+\n&#039;
          &#039;\n&#039;
          &#039;      Most of the attributes labelled &quot;Writable&quot; check the type of &#039;
          &#039;the\n&#039;
          &#039;      assigned value.\n&#039;
          &#039;\n&#039;
          &#039;      Changed in version 2.4: &quot;func_name&quot; is now writable.\n&#039;
          &#039;\n&#039;
          &#039;      Changed in version 2.6: The double-underscore attributes\n&#039;
          &#039;      &quot;__closure__&quot;, &quot;__code__&quot;, &quot;__defaults__&quot;, and &quot;__globals__&quot;\n&#039;
          &#039;      were introduced as aliases for the corresponding &quot;func_*&quot;\n&#039;
          &#039;      attributes for forwards compatibility with Python 3.\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;
          &quot;      Additional information about a function&#039;s definition can be\n&quot;
          &#039;      retrieved from its code object; see the description of &#039;
          &#039;internal\n&#039;
          &#039;      types below.\n&#039;
          &#039;\n&#039;
          &#039;   User-defined methods\n&#039;
          &#039;      A user-defined method object combines a class, a class &#039;
          &#039;instance\n&#039;
          &#039;      (or &quot;None&quot;) and any callable object (normally a user-defined\n&#039;
          &#039;      function).\n&#039;
          &#039;\n&#039;
          &#039;      Special read-only attributes: &quot;im_self&quot; is the class &#039;
          &#039;instance\n&#039;
          &#039;      object, &quot;im_func&quot; is the function object; &quot;im_class&quot; is the\n&#039;
          &#039;      class of &quot;im_self&quot; for bound methods or the class that asked &#039;
          &#039;for\n&#039;
          &#039;      the method for unbound methods; &quot;__doc__&quot; is the method\&#039;s\n&#039;
          &#039;      documentation (same as &quot;im_func.__doc__&quot;); &quot;__name__&quot; is the\n&#039;
          &#039;      method name (same as &quot;im_func.__name__&quot;); &quot;__module__&quot; is &#039;
          &#039;the\n&#039;
          &#039;      name of the module the method was defined in, or &quot;None&quot; if\n&#039;
          &#039;      unavailable.\n&#039;
          &#039;\n&#039;
          &#039;      Changed in version 2.2: &quot;im_self&quot; used to refer to the class\n&#039;
          &#039;      that defined the method.\n&#039;
          &#039;\n&#039;
          &#039;      Changed in version 2.6: For Python 3 forward-compatibility,\n&#039;
          &#039;      &quot;im_func&quot; is also available as &quot;__func__&quot;, and &quot;im_self&quot; as\n&#039;
          &#039;      &quot;__self__&quot;.\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, an unbound\n&#039;
          &#039;      user-defined method object, or a class method object. When &#039;
          &#039;the\n&#039;
          &#039;      attribute is a user-defined method object, a new method &#039;
          &#039;object\n&#039;
          &#039;      is only created if the class from which it is being retrieved &#039;
          &#039;is\n&#039;
          &#039;      the same as, or a derived class of, the class stored in the\n&#039;
          &#039;      original method object; otherwise, the original method object &#039;
          &#039;is\n&#039;
          &#039;      used as it is.\n&#039;
          &#039;\n&#039;
          &#039;      When a user-defined method object is created by retrieving a\n&#039;
          &#039;      user-defined function object from a class, its &quot;im_self&quot;\n&#039;
          &#039;      attribute is &quot;None&quot; and the method object is said to be &#039;
          &#039;unbound.\n&#039;
          &#039;      When one is created by retrieving a user-defined function &#039;
          &#039;object\n&#039;
          &#039;      from a class via one of its instances, its &quot;im_self&quot; &#039;
          &#039;attribute\n&#039;
          &#039;      is the instance, and the method object is said to be bound. &#039;
          &#039;In\n&#039;
          &#039;      either case, the new method\&#039;s &quot;im_class&quot; attribute is the &#039;
          &#039;class\n&#039;
          &#039;      from which the retrieval takes place, and its &quot;im_func&quot;\n&#039;
          &#039;      attribute is 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 &quot;im_func&quot;\n&#039;
          &#039;      attribute of the new instance is not the original method &#039;
          &#039;object\n&#039;
          &#039;      but its &quot;im_func&quot; attribute.\n&#039;
          &#039;\n&#039;
          &#039;      When a user-defined method object is created by retrieving a\n&#039;
          &#039;      class method object from a class or instance, its &quot;im_self&quot;\n&#039;
          &#039;      attribute is the class itself, and its &quot;im_func&quot; attribute &#039;
          &#039;is\n&#039;
          &#039;      the function object underlying the class method.\n&#039;
          &#039;\n&#039;
          &#039;      When an unbound user-defined method object is called, the\n&#039;
          &#039;      underlying function (&quot;im_func&quot;) is called, with the &#039;
          &#039;restriction\n&#039;
          &#039;      that the first argument must be an instance of the proper &#039;
          &#039;class\n&#039;
          &#039;      (&quot;im_class&quot;) or of a derived class thereof.\n&#039;
          &#039;\n&#039;
          &#039;      When a bound user-defined method object is called, the\n&#039;
          &#039;      underlying function (&quot;im_func&quot;) is called, inserting the &#039;
          &#039;class\n&#039;
          &#039;      instance (&quot;im_self&quot;) in front of the argument list.  For\n&#039;
          &#039;      instance, when &quot;C&quot; is a class which contains a definition for &#039;
          &#039;a\n&#039;
          &#039;      function &quot;f()&quot;, and &quot;x&quot; is an instance of &quot;C&quot;, calling &#039;
          &#039;&quot;x.f(1)&quot;\n&#039;
          &#039;      is equivalent to calling &quot;C.f(x, 1)&quot;.\n&#039;
          &#039;\n&#039;
          &#039;      When a user-defined method object is derived from a class &#039;
          &#039;method\n&#039;
          &#039;      object, the &quot;class instance&quot; stored in &quot;im_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 (unbound &#039;
          &#039;or\n&#039;
          &#039;      bound) method object happens each time the attribute is\n&#039;
          &#039;      retrieved from the class or instance. In some cases, a &#039;
          &#039;fruitful\n&#039;
          &#039;      optimization is to assign the attribute to a local variable &#039;
          &#039;and\n&#039;
          &#039;      call that local variable. Also notice that this &#039;
          &#039;transformation\n&#039;
          &#039;      only happens for user-defined functions; other callable &#039;
          &#039;objects\n&#039;
          &#039;      (and all non-callable objects) are retrieved without\n&#039;
          &#039;      transformation.  It is also important to note that &#039;
          &#039;user-defined\n&#039;
          &#039;      functions which are attributes of a class instance are not\n&#039;
          &#039;      converted to bound methods; this *only* happens when the\n&#039;
          &#039;      function is an attribute 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\&#039;s &quot;next()&quot; method will cause the function to\n&#039;
          &#039;      execute until it provides a value using the &quot;yield&quot; &#039;
          &#039;statement.\n&#039;
          &#039;      When the function executes a &quot;return&quot; statement or falls off &#039;
          &#039;the\n&#039;
          &#039;      end, a &quot;StopIteration&quot; exception is raised and the iterator &#039;
          &#039;will\n&#039;
          &#039;      have reached the end of the set of values to be returned.\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\&#039;s documentation\n&#039;
          &#039;      string, or &quot;None&quot; if unavailable; &quot;__name__&quot; is the &#039;
          &quot;function&#039;s\n&quot;
          &#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;   Class Types\n&#039;
          &#039;      Class types, or &quot;new-style classes,&quot; are callable.  These\n&#039;
          &#039;      objects normally act as factories for new instances of\n&#039;
          &#039;      themselves, but variations are possible for class types that\n&#039;
          &#039;      override &quot;__new__()&quot;.  The arguments of the call are passed &#039;
          &#039;to\n&#039;
          &#039;      &quot;__new__()&quot; and, in the typical case, to &quot;__init__()&quot; to\n&#039;
          &#039;      initialize the new instance.\n&#039;
          &#039;\n&#039;
          &#039;   Classic Classes\n&#039;
          &#039;      Class objects are described below.  When a class object is\n&#039;
          &#039;      called, a new class instance (also described below) is &#039;
          &#039;created\n&#039;
          &quot;      and returned.  This implies a call to the class&#039;s &quot;
          &#039;&quot;__init__()&quot;\n&#039;
          &#039;      method if it has one.  Any arguments are passed on to the\n&#039;
          &#039;      &quot;__init__()&quot; method.  If there is no &quot;__init__()&quot; method, &#039;
          &#039;the\n&#039;
          &#039;      class must be called without arguments.\n&#039;
          &#039;\n&#039;
          &#039;   Class instances\n&#039;
          &#039;      Class instances are described below.  Class instances are\n&#039;
          &#039;      callable only when the class has a &quot;__call__()&quot; method;\n&#039;
          &#039;      &quot;x(arguments)&quot; is a shorthand for &quot;x.__call__(arguments)&quot;.\n&#039;
          &#039;\n&#039;
          &#039;Modules\n&#039;
          &#039;   Modules are imported by the &quot;import&quot; statement (see section The\n&#039;
          &#039;   import statement). A module object has a namespace implemented &#039;
          &#039;by a\n&#039;
          &#039;   dictionary object (this is the dictionary referenced by the\n&#039;
          &#039;   func_globals attribute of functions defined in the module).\n&#039;
          &#039;   Attribute references are translated to lookups in this &#039;
          &#039;dictionary,\n&#039;
          &#039;   e.g., &quot;m.x&quot; is equivalent to &quot;m.__dict__[&quot;x&quot;]&quot;. A module object\n&#039;
          &#039;   does not contain the code object used to initialize the module\n&#039;
          &quot;   (since it isn&#039;t needed once the initialization is done).\n&quot;
          &#039;\n&#039;
          &quot;   Attribute assignment updates the module&#039;s namespace dictionary,\n&quot;
          &#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;   Special read-only attribute: &quot;__dict__&quot; is the module\&#039;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;   Predefined (writable) attributes: &quot;__name__&quot; is the module\&#039;s &#039;
          &#039;name;\n&#039;
          &#039;   &quot;__doc__&quot; is the module\&#039;s documentation string, or &quot;None&quot; if\n&#039;
          &#039;   unavailable; &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 is not present for C modules that are statically &#039;
          &#039;linked\n&#039;
          &#039;   into the interpreter; for extension modules loaded dynamically &#039;
          &#039;from\n&#039;
          &#039;   a shared library, it is the pathname of the shared library &#039;
          &#039;file.\n&#039;
          &#039;\n&#039;
          &#039;Classes\n&#039;
          &#039;   Both class types (new-style classes) and class objects (old-\n&#039;
          &#039;   style/classic classes) are typically created by class &#039;
          &#039;definitions\n&#039;
          &#039;   (see section Class definitions).  A class has a namespace\n&#039;
          &#039;   implemented by a dictionary object. Class attribute references &#039;
          &#039;are\n&#039;
          &#039;   translated to lookups in this dictionary, e.g., &quot;C.x&quot; is &#039;
          &#039;translated\n&#039;
          &#039;   to &quot;C.__dict__[&quot;x&quot;]&quot; (although for new-style classes in &#039;
          &#039;particular\n&#039;
          &#039;   there are a number of hooks which allow for other means of &#039;
          &#039;locating\n&#039;
          &#039;   attributes). When the attribute name is not found there, the\n&#039;
          &#039;   attribute search continues in the base classes.  For old-style\n&#039;
          &#039;   classes, the search is depth-first, left-to-right in the order &#039;
          &#039;of\n&#039;
          &#039;   occurrence in the base class list. New-style classes use the &#039;
          &#039;more\n&#039;
          &#039;   complex C3 method resolution order which behaves correctly even &#039;
          &#039;in\n&#039;
          &quot;   the presence of &#039;diamond&#039; inheritance structures where there &quot;
          &#039;are\n&#039;
          &#039;   multiple inheritance paths leading back to a common ancestor.\n&#039;
          &#039;   Additional details on the C3 MRO used by new-style classes can &#039;
          &#039;be\n&#039;
          &#039;   found in the 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;   user-defined function object or an unbound user-defined method\n&#039;
          &#039;   object whose associated class is either &quot;C&quot; or one of its base\n&#039;
          &#039;   classes, it is transformed into an unbound user-defined method\n&#039;
          &#039;   object whose &quot;im_class&quot; attribute is &quot;C&quot;. When it would yield a\n&#039;
          &#039;   class method object, it is transformed into a bound &#039;
          &#039;user-defined\n&#039;
          &#039;   method object whose &quot;im_self&quot; attribute is &quot;C&quot;.  When it would\n&#039;
          &#039;   yield a static method object, it is transformed into the object\n&#039;
          &#039;   wrapped by the static method object. See section Implementing\n&#039;
          &#039;   Descriptors for another way in which attributes retrieved from &#039;
          &#039;a\n&#039;
          &#039;   class may differ from those actually contained in its &#039;
          &#039;&quot;__dict__&quot;\n&#039;
          &#039;   (note that only new-style classes support descriptors).\n&#039;
          &#039;\n&#039;
          &quot;   Class attribute assignments update the class&#039;s dictionary, &quot;
          &#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\&#039;s namespace; &quot;__bases__&quot; is a &#039;
          &#039;tuple\n&#039;
          &#039;   (possibly empty or a singleton) containing the base classes, in &#039;
          &#039;the\n&#039;
          &#039;   order of their occurrence in the base class list; &quot;__doc__&quot; is &#039;
          &#039;the\n&#039;
          &#039;   class\&#039;s documentation string, or &quot;None&quot; if undefined.\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;
          &quot;   When an attribute is not found there, and the instance&#039;s class &quot;
          &#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 or an unbound user-defined method object whose\n&#039;
          &#039;   associated class is the class (call it &quot;C&quot;) of the instance for\n&#039;
          &#039;   which the attribute reference was initiated or one of its bases, &#039;
          &#039;it\n&#039;
          &#039;   is transformed into a bound user-defined method object whose\n&#039;
          &#039;   &quot;im_class&quot; attribute is &quot;C&quot; and whose &quot;im_self&quot; attribute is &#039;
          &#039;the\n&#039;
          &#039;   instance. Static method and class method objects are also\n&#039;
          &#039;   transformed, as if they had been retrieved from class &quot;C&quot;; see\n&#039;
          &#039;   above under &quot;Classes&quot;. See section Implementing Descriptors for\n&#039;
          &#039;   another way in which attributes of a class retrieved via its\n&#039;
          &#039;   instances may differ from the objects actually stored in the\n&#039;
          &#039;   class\&#039;s &quot;__dict__&quot;. If no class attribute is found, and the\n&#039;
          &#039;   object\&#039;s class has a &quot;__getattr__()&quot; method, that is called to\n&#039;
          &#039;   satisfy the lookup.\n&#039;
          &#039;\n&#039;
          &quot;   Attribute assignments and deletions update the instance&#039;s\n&quot;
          &quot;   dictionary, never a class&#039;s dictionary.  If the class has a\n&quot;
          &#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\&#039;s class.\n&#039;
          &#039;\n&#039;
          &#039;Files\n&#039;
          &#039;   A file object represents an open file.  File objects are created &#039;
          &#039;by\n&#039;
          &#039;   the &quot;open()&quot; built-in function, and also by &quot;os.popen()&quot;,\n&#039;
          &#039;   &quot;os.fdopen()&quot;, and the &quot;makefile()&quot; method of socket objects &#039;
          &#039;(and\n&#039;
          &#039;   perhaps by other functions or methods provided by extension\n&#039;
          &#039;   modules).  The objects &quot;sys.stdin&quot;, &quot;sys.stdout&quot; and &#039;
          &#039;&quot;sys.stderr&quot;\n&#039;
          &#039;   are initialized to file objects corresponding to the &#039;
          &quot;interpreter&#039;s\n&quot;
          &#039;   standard input, output and error streams.  See File Objects for\n&#039;
          &#039;   complete documentation of file objects.\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;
          &quot;      reference to the function&#039;s globals (the module in which it &quot;
          &#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;\n&#039;
          &#039;      &quot;f_restricted&quot; is a flag indicating whether the function is\n&#039;
          &#039;      executing in restricted execution mode; &quot;f_lasti&quot; gives the\n&#039;
          &#039;      precise instruction (this is an index into the bytecode &#039;
          &#039;string\n&#039;
          &#039;      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_exc_type&quot;, &quot;f_exc_value&quot;,\n&#039;
          &#039;      &quot;f_exc_traceback&quot; represent the last exception raised in the\n&#039;
          &#039;      parent frame provided another exception was ever raised in &#039;
          &#039;the\n&#039;
          &#039;      current frame (in all other cases they are &quot;None&quot;); &#039;
          &#039;&quot;f_lineno&quot;\n&#039;
          &#039;      is the current line number of the frame --- writing to this &#039;
          &#039;from\n&#039;
          &#039;      within a trace function jumps to the given line (only for &#039;
          &#039;the\n&#039;
          &#039;      bottom-most frame).  A debugger can implement a Jump command\n&#039;
          &#039;      (aka Set Next Statement) by writing to f_lineno.\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 &quot;sys.exc_traceback&quot;, &#039;
          &#039;and\n&#039;
          &#039;      also as the third item of the tuple returned by\n&#039;
          &#039;      &quot;sys.exc_info()&quot;.  The latter is the preferred interface, &#039;
          &#039;since\n&#039;
          &#039;      it works correctly when the program is using multiple &#039;
          &#039;threads.\n&#039;
          &#039;      When the program contains no suitable handler, the stack &#039;
          &#039;trace\n&#039;
          &#039;      is written (nicely formatted) to the standard error stream; &#039;
          &#039;if\n&#039;
          &#039;      the interpreter is interactive, it is also made available to &#039;
          &#039;the\n&#039;
          &#039;      user as &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 when *extended &#039;
          &#039;slice\n&#039;
          &#039;      syntax* is used. This is a slice using two colons, or &#039;
          &#039;multiple\n&#039;
          &#039;      slices or ellipses separated by commas, e.g., &quot;a[i:j:step]&quot;,\n&#039;
          &#039;      &quot;a[i:j, k:l]&quot;, or &quot;a[..., i:j]&quot;.  They are also created by &#039;
          &#039;the\n&#039;
          &#039;      built-in &quot;slice()&quot; 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 extended slice that the &#039;
          &#039;slice\n&#039;
          &#039;         object would describe if applied to a sequence of &#039;
          &#039;*length*\n&#039;
          &#039;         items.  It returns a tuple of three integers; &#039;
          &#039;respectively\n&#039;
          &#039;         these are the *start* and *stop* indices and the *step* &#039;
          &#039;or\n&#039;
          &#039;         stride length of the slice. Missing or out-of-bounds &#039;
          &#039;indices\n&#039;
          &#039;         are handled in a manner consistent with regular slices.\n&#039;
          &#039;\n&#039;
          &#039;         New in version 2.3.\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 &quot;User-defined methods&quot;. Class method objects are &#039;
          &#039;created\n&#039;
          &#039;      by the built-in &quot;classmethod()&quot; constructor.\n&#039;,
 &#039;typesfunctions&#039;: &#039;\n&#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;\n&#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;
                 &quot;A dictionary&#039;s keys are *almost* arbitrary values.  Values &quot;
                 &#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;   New in version 2.2.\n&#039;
                 &#039;\n&#039;
                 &#039;   Changed in version 2.3: Support for building a dictionary &#039;
                 &#039;from\n&#039;
                 &#039;   keyword arguments added.\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;      New in version 2.5: Recognition of __missing__ methods &#039;
                 &#039;of dict\n&#039;
                 &#039;      subclasses.\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;      New in version 2.2.\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;      New in version 2.2.\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;iterkeys()&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;   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;      New in version 2.3.\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;   has_key(key)\n&#039;
                 &#039;\n&#039;
                 &#039;      Test for the presence of *key* in the dictionary.  &#039;
                 &#039;&quot;has_key()&quot;\n&#039;
                 &#039;      is deprecated in favor of &quot;key in d&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   items()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return a copy of the dictionary\&#039;s list of &quot;(key, &#039;
                 &#039;value)&quot; pairs.\n&#039;
                 &#039;\n&#039;
                 &#039;      **CPython implementation detail:** Keys and values are &#039;
                 &#039;listed in\n&#039;
                 &#039;      an arbitrary order which is non-random, varies across &#039;
                 &#039;Python\n&#039;
                 &quot;      implementations, and depends on the dictionary&#039;s &quot;
                 &#039;history of\n&#039;
                 &#039;      insertions and deletions.\n&#039;
                 &#039;\n&#039;
                 &#039;      If &quot;items()&quot;, &quot;keys()&quot;, &quot;values()&quot;, &quot;iteritems()&quot;, &#039;
                 &#039;&quot;iterkeys()&quot;,\n&#039;
                 &#039;      and &quot;itervalues()&quot; are called with no intervening &#039;
                 &#039;modifications\n&#039;
                 &#039;      to the dictionary, the lists will directly &#039;
                 &#039;correspond.  This\n&#039;
                 &#039;      allows the creation of &quot;(value, key)&quot; pairs using &#039;
                 &#039;&quot;zip()&quot;:\n&#039;
                 &#039;      &quot;pairs = zip(d.values(), d.keys())&quot;.  The same &#039;
                 &#039;relationship\n&#039;
                 &#039;      holds for the &quot;iterkeys()&quot; and &quot;itervalues()&quot; methods: &#039;
                 &#039;&quot;pairs =\n&#039;
                 &#039;      zip(d.itervalues(), d.iterkeys())&quot; provides the same &#039;
                 &#039;value for\n&#039;
                 &#039;      &quot;pairs&quot;. Another way to create the same list is &quot;pairs &#039;
                 &#039;= [(v, k)\n&#039;
                 &#039;      for (k, v) in d.iteritems()]&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   iteritems()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return an iterator over the dictionary\&#039;s &quot;(key, &#039;
                 &#039;value)&quot; pairs.\n&#039;
                 &#039;      See the note for &quot;dict.items()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;      Using &quot;iteritems()&quot; while adding or deleting entries &#039;
                 &#039;in the\n&#039;
                 &#039;      dictionary may raise a &quot;RuntimeError&quot; or fail to &#039;
                 &#039;iterate over\n&#039;
                 &#039;      all entries.\n&#039;
                 &#039;\n&#039;
                 &#039;      New in version 2.2.\n&#039;
                 &#039;\n&#039;
                 &#039;   iterkeys()\n&#039;
                 &#039;\n&#039;
                 &quot;      Return an iterator over the dictionary&#039;s keys.  See &quot;
                 &#039;the note for\n&#039;
                 &#039;      &quot;dict.items()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;      Using &quot;iterkeys()&quot; while adding or deleting entries in &#039;
                 &#039;the\n&#039;
                 &#039;      dictionary may raise a &quot;RuntimeError&quot; or fail to &#039;
                 &#039;iterate over\n&#039;
                 &#039;      all entries.\n&#039;
                 &#039;\n&#039;
                 &#039;      New in version 2.2.\n&#039;
                 &#039;\n&#039;
                 &#039;   itervalues()\n&#039;
                 &#039;\n&#039;
                 &quot;      Return an iterator over the dictionary&#039;s values.  See &quot;
                 &#039;the note\n&#039;
                 &#039;      for &quot;dict.items()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;      Using &quot;itervalues()&quot; while adding or deleting entries &#039;
                 &#039;in the\n&#039;
                 &#039;      dictionary may raise a &quot;RuntimeError&quot; or fail to &#039;
                 &#039;iterate over\n&#039;
                 &#039;      all entries.\n&#039;
                 &#039;\n&#039;
                 &#039;      New in version 2.2.\n&#039;
                 &#039;\n&#039;
                 &#039;   keys()\n&#039;
                 &#039;\n&#039;
                 &quot;      Return a copy of the dictionary&#039;s list of keys.  See &quot;
                 &#039;the note\n&#039;
                 &#039;      for &quot;dict.items()&quot;.\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;      New in version 2.3.\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;      Changed in version 2.4: Allowed the argument to be an &#039;
                 &#039;iterable\n&#039;
                 &#039;      of key/value pairs and allowed keyword arguments.\n&#039;
                 &#039;\n&#039;
                 &#039;   values()\n&#039;
                 &#039;\n&#039;
                 &quot;      Return a copy of the dictionary&#039;s list of values.  See &quot;
                 &#039;the note\n&#039;
                 &#039;      for &quot;dict.items()&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;   viewitems()\n&#039;
                 &#039;\n&#039;
                 &#039;      Return a new view of the dictionary\&#039;s items (&quot;(key, &#039;
                 &#039;value)&quot;\n&#039;
                 &#039;      pairs).  See below for documentation of view objects.\n&#039;
                 &#039;\n&#039;
                 &#039;      New in version 2.7.\n&#039;
                 &#039;\n&#039;
                 &#039;   viewkeys()\n&#039;
                 &#039;\n&#039;
                 &quot;      Return a new view of the dictionary&#039;s keys.  See below &quot;
                 &#039;for\n&#039;
                 &#039;      documentation of view objects.\n&#039;
                 &#039;\n&#039;
                 &#039;      New in version 2.7.\n&#039;
                 &#039;\n&#039;
                 &#039;   viewvalues()\n&#039;
                 &#039;\n&#039;
                 &quot;      Return a new view of the dictionary&#039;s values.  See &quot;
                 &#039;below for\n&#039;
                 &#039;      documentation of view objects.\n&#039;
                 &#039;\n&#039;
                 &#039;      New in version 2.7.\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.\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.viewkeys()&quot;, &#039;
                 &#039;&quot;dict.viewvalues()&quot; and\n&#039;
                 &#039;&quot;dict.viewitems()&quot; are *view objects*.  They provide a &#039;
                 &#039;dynamic view on\n&#039;
                 &quot;the dictionary&#039;s entries, which means that when the &quot;
                 &#039;dictionary\n&#039;
                 &#039;changes, 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;
                 &quot;   the dictionary&#039;s history of insertions and deletions. If &quot;
                 &#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\&#039;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 (key, value) pairs are &#039;
                 &#039;unique and\n&#039;
                 &#039;hashable, then the items view is also set-like.  (Values &#039;
                 &#039;views are not\n&#039;
                 &#039;treated as set-like since the entries are generally not &#039;
                 &#039;unique.)  Then\n&#039;
                 &#039;these set operations are available (&quot;other&quot; refers either to &#039;
                 &#039;another\n&#039;
                 &#039;view or a set):\n&#039;
                 &#039;\n&#039;
                 &#039;dictview &amp; other\n&#039;
                 &#039;\n&#039;
                 &#039;   Return the intersection of the dictview and the other &#039;
                 &#039;object as a\n&#039;
                 &#039;   new set.\n&#039;
                 &#039;\n&#039;
                 &#039;dictview | other\n&#039;
                 &#039;\n&#039;
                 &#039;   Return the union of the dictview and the other object as &#039;
                 &#039;a new set.\n&#039;
                 &#039;\n&#039;
                 &#039;dictview - other\n&#039;
                 &#039;\n&#039;
                 &#039;   Return the difference between the dictview and the other &#039;
                 &#039;object\n&#039;
                 &quot;   (all elements in *dictview* that aren&#039;t in *other*) as a &quot;
                 &#039;new set.\n&#039;
                 &#039;\n&#039;
                 &#039;dictview ^ other\n&#039;
                 &#039;\n&#039;
                 &#039;   Return the symmetric difference (all elements either in &#039;
                 &#039;*dictview*\n&#039;
                 &#039;   or *other*, but not in both) of the dictview and the &#039;
                 &#039;other object\n&#039;
                 &#039;   as a new set.\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.viewkeys()\n&#039;
                 &#039;   &gt;&gt;&gt; values = dishes.viewvalues()\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;,
 &#039;typesmethods&#039;: &#039;\n&#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;The implementation adds two special read-only attributes to &#039;
                 &#039;class\n&#039;
                 &#039;instance methods: &quot;m.im_self&quot; is the object on which the &#039;
                 &#039;method\n&#039;
                 &#039;operates, and &quot;m.im_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.im_func(m.im_self, arg-1, arg-2, ..., arg-n)&quot;.\n&#039;
                 &#039;\n&#039;
                 &#039;Class instance methods are either *bound* or *unbound*, &#039;
                 &#039;referring to\n&#039;
                 &#039;whether the method was accessed through an instance or a &#039;
                 &#039;class,\n&#039;
                 &#039;respectively.  When a method is unbound, its &quot;im_self&quot; &#039;
                 &#039;attribute will\n&#039;
                 &#039;be &quot;None&quot; and if called, an explicit &quot;self&quot; object must be &#039;
                 &#039;passed as\n&#039;
                 &#039;the first argument.  In this case, &quot;self&quot; must be an &#039;
                 &#039;instance of the\n&#039;
                 &quot;unbound method&#039;s class (or a subclass of that class), &quot;
                 &#039;otherwise a\n&#039;
                 &#039;&quot;TypeError&quot; is raised.\n&#039;
                 &#039;\n&#039;
                 &#039;Like function objects, methods 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.im_func&quot;), setting &#039;
                 &#039;method\n&#039;
                 &#039;attributes on either bound or unbound methods is &#039;
                 &#039;disallowed.\n&#039;
                 &#039;Attempting to set an attribute on a method results in an\n&#039;
                 &#039;&quot;AttributeError&quot; being raised.  In order to set a method &#039;
                 &#039;attribute,\n&#039;
                 &#039;you need to explicitly set it on the underlying function &#039;
                 &#039;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;instancemethod&#039; object has no attribute &quot;
                 &quot;&#039;whoami&#039;\n&quot;
                 &quot;   &gt;&gt;&gt; c.method.im_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;\n&#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;
                 &quot;*m*&#039;s\n&quot;
                 &#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;
                 &quot;dictionary containing the module&#039;s symbol table. Modifying &quot;
                 &#039;this\n&#039;
                 &quot;dictionary will actually change the module&#039;s symbol table, &quot;
                 &#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;
                 &quot;you can&#039;t\n&quot;
                 &#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;\n&#039;
             &#039;Sequence Types --- &quot;str&quot;, &quot;unicode&quot;, &quot;list&quot;, &quot;tuple&quot;, &#039;
             &#039;&quot;bytearray&quot;, &quot;buffer&quot;, &quot;xrange&quot;\n&#039;
             &#039;*************************************************************************************\n&#039;
             &#039;\n&#039;
             &#039;There are seven sequence types: strings, Unicode strings, &#039;
             &#039;lists,\n&#039;
             &#039;tuples, bytearrays, buffers, and xrange objects.\n&#039;
             &#039;\n&#039;
             &#039;For other containers see the built in &quot;dict&quot; and &quot;set&quot; classes, &#039;
             &#039;and\n&#039;
             &#039;the &quot;collections&quot; module.\n&#039;
             &#039;\n&#039;
             &#039;String literals are written in single or double quotes: &#039;
             &#039;&quot;\&#039;xyzzy\&#039;&quot;,\n&#039;
             &#039;&quot;&quot;frobozz&quot;&quot;.  See String literals for more about string &#039;
             &#039;literals.\n&#039;
             &#039;Unicode strings are much like strings, but are specified in the &#039;
             &#039;syntax\n&#039;
             &#039;using a preceding &quot;\&#039;u\&#039;&quot; character: &quot;u\&#039;abc\&#039;&quot;, &quot;u&quot;def&quot;&quot;. In &#039;
             &#039;addition to\n&#039;
             &#039;the functionality described here, there are also &#039;
             &#039;string-specific\n&#039;
             &#039;methods described in the String Methods section. Lists are &#039;
             &#039;constructed\n&#039;
             &#039;with square brackets, separating items with commas: &quot;[a, b, &#039;
             &#039;c]&quot;.\n&#039;
             &#039;Tuples are constructed by the comma operator (not within square\n&#039;
             &#039;brackets), with or without enclosing parentheses, but an empty &#039;
             &#039;tuple\n&#039;
             &#039;must have the enclosing parentheses, such as &quot;a, b, c&quot; or &quot;()&quot;.  &#039;
             &#039;A\n&#039;
             &#039;single item tuple must have a trailing comma, such as &quot;(d,)&quot;.\n&#039;
             &#039;\n&#039;
             &#039;Bytearray objects are created with the built-in function\n&#039;
             &#039;&quot;bytearray()&quot;.\n&#039;
             &#039;\n&#039;
             &#039;Buffer objects are not directly supported by Python syntax, but &#039;
             &#039;can be\n&#039;
             &#039;created by calling the built-in function &quot;buffer()&quot;.  They &#039;
             &quot;don&#039;t\n&quot;
             &#039;support concatenation or repetition.\n&#039;
             &#039;\n&#039;
             &#039;Objects of type xrange are similar to buffers in that there is &#039;
             &#039;no\n&#039;
             &#039;specific syntax to create them, but they are created using the\n&#039;
             &#039;&quot;xrange()&quot; function.  They don\&#039;t support slicing, concatenation &#039;
             &#039;or\n&#039;
             &#039;repetition, and using &quot;in&quot;, &quot;not in&quot;, &quot;min()&quot; or &quot;max()&quot; on them &#039;
             &#039;is\n&#039;
             &#039;inefficient.\n&#039;
             &#039;\n&#039;
             &#039;Most sequence types support the following operations.  The &quot;in&quot; &#039;
             &#039;and\n&#039;
             &#039;&quot;not in&quot; operations have the same priorities as the comparison\n&#039;
             &#039;operations.  The &quot;+&quot; and &quot;*&quot; operations have the same priority &#039;
             &#039;as the\n&#039;
             &#039;corresponding numeric operations. [3] Additional methods are &#039;
             &#039;provided\n&#039;
             &#039;for Mutable 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* and\n&#039;
             &#039;*j* are integers:\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)        |\n&#039;
             &#039;+--------------------+----------------------------------+------------+\n&#039;
             &#039;| &quot;s * n, n * s&quot;     | equivalent to adding *s* to      | &#039;
             &#039;(2)        |\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)&quot;       | index of the first occurrence of &#039;
             &#039;|            |\n&#039;
             &#039;|                    | *x* in *s*                       &#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;Sequence types also support comparisons. In particular, tuples &#039;
             &#039;and\n&#039;
             &#039;lists are compared lexicographically by comparing corresponding\n&#039;
             &#039;elements. This means that to compare equal, every element must &#039;
             &#039;compare\n&#039;
             &#039;equal and the two sequences must be of the same type and have &#039;
             &#039;the same\n&#039;
             &#039;length. (For full details see Comparisons in the language &#039;
             &#039;reference.)\n&#039;
             &#039;\n&#039;
             &#039;Notes:\n&#039;
             &#039;\n&#039;
             &#039;1. When *s* is a string or Unicode string object the &quot;in&quot; and &#039;
             &#039;&quot;not\n&#039;
             &#039;   in&quot; operations act like a substring test.  In Python &#039;
             &#039;versions\n&#039;
             &#039;   before 2.3, *x* had to be a string of length 1. In Python 2.3 &#039;
             &#039;and\n&#039;
             &#039;   beyond, *x* may be a string of any length.\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 &quot;end&quot; 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. **CPython implementation detail:** If *s* and *t* are both\n&#039;
             &#039;   strings, some Python implementations such as CPython can &#039;
             &#039;usually\n&#039;
             &#039;   perform an in-place optimization for assignments of the form &#039;
             &#039;&quot;s = s\n&#039;
             &#039;   + t&quot; or &quot;s += t&quot;.  When applicable, this optimization makes\n&#039;
             &#039;   quadratic run-time much less likely.  This optimization is &#039;
             &#039;both\n&#039;
             &#039;   version and implementation dependent.  For performance &#039;
             &#039;sensitive\n&#039;
             &#039;   code, it is preferable to use the &quot;str.join()&quot; method which &#039;
             &#039;assures\n&#039;
             &#039;   consistent linear concatenation performance across versions &#039;
             &#039;and\n&#039;
             &#039;   implementations.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.4: Formerly, string concatenation never\n&#039;
             &#039;   occurred in-place.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;String Methods\n&#039;
             &#039;==============\n&#039;
             &#039;\n&#039;
             &#039;Below are listed the string methods which both 8-bit strings &#039;
             &#039;and\n&#039;
             &#039;Unicode objects support.  Some of them are also available on\n&#039;
             &#039;&quot;bytearray&quot; objects.\n&#039;
             &#039;\n&#039;
             &quot;In addition, Python&#039;s strings support the sequence type methods\n&quot;
             &#039;described in the Sequence Types --- str, unicode, list, tuple,\n&#039;
             &#039;bytearray, buffer, xrange section. To output formatted strings &#039;
             &#039;use\n&#039;
             &#039;template strings or the &quot;%&quot; operator described in the String\n&#039;
             &#039;Formatting Operations section. Also, see the &quot;re&quot; module for &#039;
             &#039;string\n&#039;
             &#039;functions based on regular expressions.\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;   For 8-bit strings, this method is locale-dependent.\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 is &#039;
             &#039;done\n&#039;
             &#039;   using the specified *fillchar* (default is a space).\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.4: Support for the *fillchar* argument.\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 substring &#039;
             &#039;*sub*\n&#039;
             &#039;   in the range [*start*, *end*].  Optional arguments *start* &#039;
             &#039;and\n&#039;
             &#039;   *end* are interpreted as in slice notation.\n&#039;
             &#039;\n&#039;
             &#039;str.decode([encoding[, errors]])\n&#039;
             &#039;\n&#039;
             &#039;   Decodes the string using the codec registered for &#039;
             &#039;*encoding*.\n&#039;
             &#039;   *encoding* defaults to the default string encoding.  *errors* &#039;
             &#039;may\n&#039;
             &#039;   be given to set a different error handling scheme.  The &#039;
             &#039;default is\n&#039;
             &#039;   &quot;\&#039;strict\&#039;&quot;, meaning that encoding errors raise &#039;
             &#039;&quot;UnicodeError&quot;.\n&#039;
             &#039;   Other possible values are &quot;\&#039;ignore\&#039;&quot;, &quot;\&#039;replace\&#039;&quot; and any &#039;
             &#039;other\n&#039;
             &#039;   name registered via &quot;codecs.register_error()&quot;, see section &#039;
             &#039;Codec\n&#039;
             &#039;   Base Classes.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 2.2.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.3: Support for other error handling &#039;
             &#039;schemes\n&#039;
             &#039;   added.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.7: Support for keyword arguments added.\n&#039;
             &#039;\n&#039;
             &#039;str.encode([encoding[, errors]])\n&#039;
             &#039;\n&#039;
             &#039;   Return an encoded version of the string.  Default encoding is &#039;
             &#039;the\n&#039;
             &#039;   current default string encoding.  *errors* may be given to &#039;
             &#039;set a\n&#039;
             &#039;   different error handling scheme.  The default for *errors* &#039;
             &#039;is\n&#039;
             &#039;   &quot;\&#039;strict\&#039;&quot;, meaning that encoding errors raise a &#039;
             &#039;&quot;UnicodeError&quot;.\n&#039;
             &#039;   Other possible values are &quot;\&#039;ignore\&#039;&quot;, &quot;\&#039;replace\&#039;&quot;,\n&#039;
             &#039;   &quot;\&#039;xmlcharrefreplace\&#039;&quot;, &quot;\&#039;backslashreplace\&#039;&quot; and any other &#039;
             &#039;name\n&#039;
             &#039;   registered via &quot;codecs.register_error()&quot;, see section Codec &#039;
             &#039;Base\n&#039;
             &#039;   Classes. For a list of possible encodings, see section &#039;
             &#039;Standard\n&#039;
             &#039;   Encodings.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 2.0.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.3: Support for &quot;\&#039;xmlcharrefreplace\&#039;&quot; &#039;
             &#039;and\n&#039;
             &#039;   &quot;\&#039;backslashreplace\&#039;&quot; and other error handling schemes &#039;
             &#039;added.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.7: Support for keyword arguments 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 of &#039;
             &#039;suffixes\n&#039;
             &#039;   to look for.  With optional *start*, test beginning at that\n&#039;
             &#039;   position.  With optional *end*, stop comparing at that &#039;
             &#039;position.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.5: Accept tuples as *suffix*.\n&#039;
             &#039;\n&#039;
             &#039;str.expandtabs([tabsize])\n&#039;
             &#039;\n&#039;
             &#039;   Return a copy of the string where all tab characters are &#039;
             &#039;replaced\n&#039;
             &#039;   by one or more spaces, depending on the current column and &#039;
             &#039;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 and &#039;
             &#039;so on).\n&#039;
             &#039;   To expand the string, the current column is set to zero and &#039;
             &#039;the\n&#039;
             &#039;   string is examined character by character.  If the character &#039;
             &#039;is a\n&#039;
             &#039;   tab (&quot;\\t&quot;), one or more space characters are inserted in the &#039;
             &#039;result\n&#039;
             &#039;   until the current column is equal to the next tab position. &#039;
             &#039;(The\n&#039;
             &#039;   tab character itself is not copied.)  If the character is a &#039;
             &#039;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 and &#039;
             &#039;the\n&#039;
             &#039;   current column is incremented by one regardless of how 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 *sub* &#039;
             &#039;is\n&#039;
             &#039;   found within the slice &quot;s[start:end]&quot;.  Optional arguments &#039;
             &#039;*start*\n&#039;
             &#039;   and *end* are interpreted as in slice notation.  Return &quot;-1&quot; &#039;
             &#039;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 need to &#039;
             &#039;know\n&#039;
             &#039;     the position of *sub*.  To check if *sub* is a substring or &#039;
             &#039;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 which &#039;
             &#039;this\n&#039;
             &#039;   method is called can contain literal text or replacement &#039;
             &#039;fields\n&#039;
             &#039;   delimited by braces &quot;{}&quot;.  Each replacement field contains &#039;
             &#039;either\n&#039;
             &#039;   the numeric index of a positional argument, or the name of a\n&#039;
             &#039;   keyword argument.  Returns a copy of the string where each\n&#039;
             &#039;   replacement field is replaced with the string value of 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 various\n&#039;
             &#039;   formatting options that can be specified in format strings.\n&#039;
             &#039;\n&#039;
             &#039;   This method of string formatting is the new standard in &#039;
             &#039;Python 3,\n&#039;
             &#039;   and should be preferred to the &quot;%&quot; formatting described in &#039;
             &#039;String\n&#039;
             &#039;   Formatting Operations in new code.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 2.6.\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 substring is &#039;
             &#039;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 alphanumeric &#039;
             &#039;and\n&#039;
             &#039;   there is at least one character, false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.isalpha()\n&#039;
             &#039;\n&#039;
             &#039;   Return true if all characters in the string are alphabetic &#039;
             &#039;and\n&#039;
             &#039;   there is at least one character, false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.isdigit()\n&#039;
             &#039;\n&#039;
             &#039;   Return true if all characters in the string are digits and &#039;
             &#039;there is\n&#039;
             &#039;   at least one character, false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.islower()\n&#039;
             &#039;\n&#039;
             &#039;   Return true if all cased characters [4] in the string are &#039;
             &#039;lowercase\n&#039;
             &#039;   and there is at least one cased character, false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.isspace()\n&#039;
             &#039;\n&#039;
             &#039;   Return true if there are only whitespace characters in the &#039;
             &#039;string\n&#039;
             &#039;   and there is at least one character, false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.istitle()\n&#039;
             &#039;\n&#039;
             &#039;   Return true if the string is a titlecased string and there is &#039;
             &#039;at\n&#039;
             &#039;   least one character, for example uppercase characters may &#039;
             &#039;only\n&#039;
             &#039;   follow uncased characters and lowercase characters only cased &#039;
             &#039;ones.\n&#039;
             &#039;   Return false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.isupper()\n&#039;
             &#039;\n&#039;
             &#039;   Return true if all cased characters [4] in the string are &#039;
             &#039;uppercase\n&#039;
             &#039;   and there is at least one cased character, false otherwise.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.join(iterable)\n&#039;
             &#039;\n&#039;
             &#039;   Return a string which is the concatenation of the strings in\n&#039;
             &#039;   *iterable*. A &quot;TypeError&quot; will be raised if there are any &#039;
             &#039;non-\n&#039;
             &#039;   string values in *iterable*, including &quot;bytes&quot; 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 is a\n&#039;
             &#039;   space).  The original string is returned if *width* is less &#039;
             &#039;than or\n&#039;
             &#039;   equal to &quot;len(s)&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.4: Support for the *fillchar* argument.\n&#039;
             &#039;\n&#039;
             &#039;str.lower()\n&#039;
             &#039;\n&#039;
             &#039;   Return a copy of the string with all the cased characters &#039;
             &#039;[4]\n&#039;
             &#039;   converted to lowercase.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.lstrip([chars])\n&#039;
             &#039;\n&#039;
             &#039;   Return a copy of the string with leading characters removed.  &#039;
             &#039;The\n&#039;
             &#039;   *chars* argument is a string specifying the set of characters &#039;
             &#039;to be\n&#039;
             &#039;   removed.  If omitted or &quot;None&quot;, the *chars* argument defaults &#039;
             &#039;to\n&#039;
             &#039;   removing whitespace.  The *chars* argument is not a prefix; &#039;
             &#039;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;   Changed in version 2.2.2: Support for the *chars* argument.\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 return &#039;
             &#039;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 separator &#039;
             &#039;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;   New in version 2.5.\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 substring &#039;
             &#039;*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 *sub* &#039;
             &#039;is\n&#039;
             &#039;   found, such that *sub* is contained within &quot;s[start:end]&quot;.\n&#039;
             &#039;   Optional arguments *start* and *end* are interpreted as in &#039;
             &#039;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 substring &#039;
             &#039;*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 is a\n&#039;
             &#039;   space). The original string is returned if *width* is less &#039;
             &#039;than or\n&#039;
             &#039;   equal to &quot;len(s)&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.4: Support for the *fillchar* argument.\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 return &#039;
             &#039;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 separator &#039;
             &#039;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;   New in version 2.5.\n&#039;
             &#039;\n&#039;
             &#039;str.rsplit([sep[, maxsplit]])\n&#039;
             &#039;\n&#039;
             &#039;   Return a list of the words in the string, using *sep* as the\n&#039;
             &#039;   delimiter string. If *maxsplit* is given, at most *maxsplit* &#039;
             &#039;splits\n&#039;
             &#039;   are done, the *rightmost* ones.  If *sep* is not specified &#039;
             &#039;or\n&#039;
             &#039;   &quot;None&quot;, any whitespace string is a separator.  Except for &#039;
             &#039;splitting\n&#039;
             &#039;   from the right, &quot;rsplit()&quot; behaves like &quot;split()&quot; which is\n&#039;
             &#039;   described in detail below.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 2.4.\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 characters &#039;
             &#039;to be\n&#039;
             &#039;   removed.  If omitted or &quot;None&quot;, the *chars* argument defaults &#039;
             &#039;to\n&#039;
             &#039;   removing whitespace.  The *chars* argument is not a suffix; &#039;
             &#039;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;   Changed in version 2.2.2: Support for the *chars* argument.\n&#039;
             &#039;\n&#039;
             &#039;str.split([sep[, maxsplit]])\n&#039;
             &#039;\n&#039;
             &#039;   Return a list of the words in the string, using *sep* 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;, then &#039;
             &#039;there is\n&#039;
             &#039;   no limit on the number of splits (all possible splits are &#039;
             &#039;made).\n&#039;
             &#039;\n&#039;
             &#039;   If *sep* is given, consecutive delimiters are not grouped &#039;
             &#039;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;2\&#039;]&quot;).  The &#039;
             &#039;*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;3\&#039;]&quot;). &#039;
             &#039;Splitting an\n&#039;
             &#039;   empty string with a specified separator returns &quot;[\&#039;\&#039;]&quot;.\n&#039;
             &#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 are &#039;
             &#039;regarded\n&#039;
             &#039;   as a single separator, and the result will contain no empty &#039;
             &#039;strings\n&#039;
             &#039;   at the start or end if the string has leading or trailing\n&#039;
             &#039;   whitespace.  Consequently, splitting an empty string or a &#039;
             &#039;string\n&#039;
             &#039;   consisting of just whitespace with a &quot;None&quot; separator returns &#039;
             &#039;&quot;[]&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   For example, &quot;\&#039; 1  2   3  \&#039;.split()&quot; returns &quot;[\&#039;1\&#039;, &#039;
             &#039;\&#039;2\&#039;, \&#039;3\&#039;]&quot;, and\n&#039;
             &#039;   &quot;\&#039;  1  2   3  \&#039;.split(None, 1)&quot; returns &quot;[\&#039;1\&#039;, \&#039;2   3  &#039;
             &#039;\&#039;]&quot;.\n&#039;
             &#039;\n&#039;
             &#039;str.splitlines([keepends])\n&#039;
             &#039;\n&#039;
             &#039;   Return a list of the lines in the string, breaking at line\n&#039;
             &#039;   boundaries. This method uses the *universal newlines* &#039;
             &#039;approach to\n&#039;
             &#039;   splitting lines. 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;   Python recognizes &quot;&quot;\\r&quot;&quot;, &quot;&quot;\\n&quot;&quot;, and &quot;&quot;\\r\\n&quot;&quot; as line &#039;
             &#039;boundaries\n&#039;
             &#039;   for 8-bit strings.\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 fg\\rkl\\r\\n&#039;.splitlines(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 given, &#039;
             &#039;this\n&#039;
             &#039;   method returns an empty list for the empty string, and a &#039;
             &#039;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;unicode.splitlines([keepends])\n&#039;
             &#039;\n&#039;
             &#039;   Return a list of the lines in the string, like &#039;
             &#039;&quot;str.splitlines()&quot;.\n&#039;
             &#039;   However, the Unicode method splits on the following line\n&#039;
             &#039;   boundaries, which are a superset of the *universal newlines*\n&#039;
             &#039;   recognized for 8-bit strings.\n&#039;
             &#039;\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | Representation          | Description                   |\n&#039;
             &#039;   +=========================+===============================+\n&#039;
             &#039;   | &quot;\\n&quot;                    | Line Feed                     |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\r&quot;                    | Carriage Return               |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\r\\n&quot;                  | Carriage Return + Line Feed   &#039;
             &#039;|\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\v&quot; or &quot;\\x0b&quot;          | Line Tabulation               &#039;
             &#039;|\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\f&quot; or &quot;\\x0c&quot;          | Form Feed                     &#039;
             &#039;|\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\x1c&quot;                  | File Separator                |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\x1d&quot;                  | Group Separator               |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\x1e&quot;                  | Record Separator              |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\x85&quot;                  | Next Line (C1 Control Code)   |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\u2028&quot;                | Line Separator                |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;   | &quot;\\u2029&quot;                | Paragraph Separator           |\n&#039;
             &#039;   +-------------------------+-------------------------------+\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.7: &quot;\\v&quot; and &quot;\\f&quot; added to list of &#039;
             &#039;line\n&#039;
             &#039;   boundaries.\n&#039;
             &#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*, otherwise &#039;
             &#039;return\n&#039;
             &#039;   &quot;False&quot;. *prefix* can also be a tuple of prefixes to look &#039;
             &#039;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 position.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.5: Accept tuples as *prefix*.\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 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;, the &#039;
             &#039;*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;   Changed in version 2.2.2: Support for the *chars* argument.\n&#039;
             &#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.\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.title()\n&#039;
             &#039;\n&#039;
             &#039;   Return a titlecased version of the string where words start &#039;
             &#039;with an\n&#039;
             &#039;   uppercase character and the remaining characters are &#039;
             &#039;lowercase.\n&#039;
             &#039;\n&#039;
             &#039;   The algorithm uses a simple language-independent definition &#039;
             &#039;of a\n&#039;
             &#039;   word as groups of consecutive letters.  The definition works &#039;
             &#039;in\n&#039;
             &#039;   many contexts but it means that apostrophes in contractions &#039;
             &#039;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: mo.group(0)[0].upper() +\n&#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;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.translate(table[, deletechars])\n&#039;
             &#039;\n&#039;
             &#039;   Return a copy of the string where all characters occurring in &#039;
             &#039;the\n&#039;
             &#039;   optional argument *deletechars* are removed, and the &#039;
             &#039;remaining\n&#039;
             &#039;   characters have been mapped through the given translation &#039;
             &#039;table,\n&#039;
             &#039;   which must be a string of length 256.\n&#039;
             &#039;\n&#039;
             &#039;   You can use the &quot;maketrans()&quot; helper function in the &#039;
             &#039;&quot;string&quot;\n&#039;
             &#039;   module to create a translation table. For string objects, set &#039;
             &#039;the\n&#039;
             &#039;   *table* argument to &quot;None&quot; for translations that only delete\n&#039;
             &#039;   characters:\n&#039;
             &#039;\n&#039;
             &quot;   &gt;&gt;&gt; &#039;read this short text&#039;.translate(None, &#039;aeiou&#039;)\n&quot;
             &quot;   &#039;rd ths shrt txt&#039;\n&quot;
             &#039;\n&#039;
             &#039;   New in version 2.6: Support for a &quot;None&quot; *table* argument.\n&#039;
             &#039;\n&#039;
             &#039;   For Unicode objects, the &quot;translate()&quot; method does not accept &#039;
             &#039;the\n&#039;
             &#039;   optional *deletechars* argument.  Instead, it returns a copy &#039;
             &#039;of the\n&#039;
             &#039;   *s* where all characters have been mapped through the given\n&#039;
             &#039;   translation table which must be a mapping of Unicode ordinals &#039;
             &#039;to\n&#039;
             &#039;   Unicode ordinals, Unicode strings or &quot;None&quot;. Unmapped &#039;
             &#039;characters\n&#039;
             &#039;   are left untouched. Characters mapped to &quot;None&quot; are deleted.  &#039;
             &#039;Note,\n&#039;
             &#039;   a more flexible approach is to create a custom character &#039;
             &#039;mapping\n&#039;
             &#039;   codec using the &quot;codecs&quot; module (see &quot;encodings.cp1251&quot; for &#039;
             &#039;an\n&#039;
             &#039;   example).\n&#039;
             &#039;\n&#039;
             &#039;str.upper()\n&#039;
             &#039;\n&#039;
             &#039;   Return a copy of the string with all the cased characters &#039;
             &#039;[4]\n&#039;
             &#039;   converted to uppercase.  Note that &quot;str.upper().isupper()&quot; &#039;
             &#039;might be\n&#039;
             &#039;   &quot;False&quot; if &quot;s&quot; contains uncased characters or if the Unicode\n&#039;
             &#039;   category of the resulting character(s) is not &quot;Lu&quot; (Letter,\n&#039;
             &#039;   uppercase), but e.g. &quot;Lt&quot; (Letter, titlecase).\n&#039;
             &#039;\n&#039;
             &#039;   For 8-bit strings, this method is locale-dependent.\n&#039;
             &#039;\n&#039;
             &#039;str.zfill(width)\n&#039;
             &#039;\n&#039;
             &#039;   Return the numeric string left filled with zeros in a string &#039;
             &#039;of\n&#039;
             &#039;   length *width*.  A sign prefix is handled correctly.  The &#039;
             &#039;original\n&#039;
             &#039;   string is returned if *width* is less than or equal to &#039;
             &#039;&quot;len(s)&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   New in version 2.2.2.\n&#039;
             &#039;\n&#039;
             &#039;The following methods are present only on unicode objects:\n&#039;
             &#039;\n&#039;
             &#039;unicode.isnumeric()\n&#039;
             &#039;\n&#039;
             &#039;   Return &quot;True&quot; if there are only numeric characters in S, &#039;
             &#039;&quot;False&quot;\n&#039;
             &#039;   otherwise. Numeric characters include digit characters, and &#039;
             &#039;all\n&#039;
             &#039;   characters that have the Unicode numeric value property, &#039;
             &#039;e.g.\n&#039;
             &#039;   U+2155, VULGAR FRACTION ONE FIFTH.\n&#039;
             &#039;\n&#039;
             &#039;unicode.isdecimal()\n&#039;
             &#039;\n&#039;
             &#039;   Return &quot;True&quot; if there are only decimal characters in S, &#039;
             &#039;&quot;False&quot;\n&#039;
             &#039;   otherwise. Decimal characters include digit characters, and &#039;
             &#039;all\n&#039;
             &#039;   characters that can be used to form decimal-radix numbers, &#039;
             &#039;e.g.\n&#039;
             &#039;   U+0660, ARABIC-INDIC DIGIT ZERO.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;String Formatting Operations\n&#039;
             &#039;============================\n&#039;
             &#039;\n&#039;
             &#039;String and Unicode objects have one unique built-in operation: &#039;
             &#039;the &quot;%&quot;\n&#039;
             &#039;operator (modulo).  This is also known as the string &#039;
             &#039;*formatting* or\n&#039;
             &#039;*interpolation* operator.  Given &quot;format % values&quot; (where &#039;
             &#039;*format* is\n&#039;
             &#039;a string or Unicode object), &quot;%&quot; conversion specifications in &#039;
             &#039;*format*\n&#039;
             &#039;are replaced with zero or more elements of *values*.  The effect &#039;
             &#039;is\n&#039;
             &#039;similar to the using &quot;sprintf()&quot; in the C language.  If *format* &#039;
             &#039;is a\n&#039;
             &#039;Unicode object, or if any of the objects being converted using &#039;
             &#039;the\n&#039;
             &#039;&quot;%s&quot; conversion are Unicode objects, the result will also be a &#039;
             &#039;Unicode\n&#039;
             &#039;object.\n&#039;
             &#039;\n&#039;
             &#039;If *format* requires a single argument, *values* may be a single &#039;
             &#039;non-\n&#039;
             &#039;tuple object. [5]  Otherwise, *values* must be a tuple with &#039;
             &#039;exactly\n&#039;
             &#039;the number of items specified by the format string, or a single\n&#039;
             &#039;mapping object (for example, a dictionary).\n&#039;
             &#039;\n&#039;
             &#039;A conversion specifier contains two or more characters and has &#039;
             &#039;the\n&#039;
             &#039;following components, which must occur in this order:\n&#039;
             &#039;\n&#039;
             &#039;1. The &quot;\&#039;%\&#039;&quot; character, which marks the start of the &#039;
             &#039;specifier.\n&#039;
             &#039;\n&#039;
             &#039;2. Mapping key (optional), consisting of a parenthesised &#039;
             &#039;sequence\n&#039;
             &#039;   of characters (for example, &quot;(somename)&quot;).\n&#039;
             &#039;\n&#039;
             &#039;3. Conversion flags (optional), which affect the result of some\n&#039;
             &#039;   conversion types.\n&#039;
             &#039;\n&#039;
             &#039;4. Minimum field width (optional).  If specified as an &quot;\&#039;*\&#039;&quot;\n&#039;
             &#039;   (asterisk), the actual width is read from the next element of &#039;
             &#039;the\n&#039;
             &#039;   tuple in *values*, and the object to convert comes after the\n&#039;
             &#039;   minimum field width and optional precision.\n&#039;
             &#039;\n&#039;
             &#039;5. Precision (optional), given as a &quot;\&#039;.\&#039;&quot; (dot) followed by &#039;
             &#039;the\n&#039;
             &#039;   precision.  If specified as &quot;\&#039;*\&#039;&quot; (an asterisk), the actual &#039;
             &#039;width\n&#039;
             &#039;   is read from the next element of the tuple in *values*, and &#039;
             &#039;the\n&#039;
             &#039;   value to convert comes after the precision.\n&#039;
             &#039;\n&#039;
             &#039;6. Length modifier (optional).\n&#039;
             &#039;\n&#039;
             &#039;7. Conversion type.\n&#039;
             &#039;\n&#039;
             &#039;When the right argument is a dictionary (or other mapping type), &#039;
             &#039;then\n&#039;
             &#039;the formats in the string *must* include a parenthesised mapping &#039;
             &#039;key\n&#039;
             &#039;into that dictionary inserted immediately after the &quot;\&#039;%\&#039;&quot; &#039;
             &#039;character.\n&#039;
             &#039;The mapping key selects the value to be formatted from the &#039;
             &#039;mapping.\n&#039;
             &#039;For example:\n&#039;
             &#039;\n&#039;
             &quot;&gt;&gt;&gt; print &#039;%(language)s has %(number)03d quote types.&#039; % \\\n&quot;
             &#039;...       {&quot;language&quot;: &quot;Python&quot;, &quot;number&quot;: 2}\n&#039;
             &#039;Python has 002 quote types.\n&#039;
             &#039;\n&#039;
             &#039;In this case no &quot;*&quot; specifiers may occur in a format (since &#039;
             &#039;they\n&#039;
             &#039;require a sequential parameter list).\n&#039;
             &#039;\n&#039;
             &#039;The conversion flag characters are:\n&#039;
             &#039;\n&#039;
             &#039;+-----------+-----------------------------------------------------------------------+\n&#039;
             &#039;| Flag      | &#039;
             &#039;Meaning                                                               &#039;
             &#039;|\n&#039;
             &#039;+===========+=======================================================================+\n&#039;
             &#039;| &quot;\&#039;#\&#039;&quot;     | The value conversion will use the &quot;alternate &#039;
             &#039;form&quot; (where defined     |\n&#039;
             &#039;|           | &#039;
             &#039;below).                                                               &#039;
             &#039;|\n&#039;
             &#039;+-----------+-----------------------------------------------------------------------+\n&#039;
             &#039;| &quot;\&#039;0\&#039;&quot;     | The conversion will be zero padded for numeric &#039;
             &#039;values.                |\n&#039;
             &#039;+-----------+-----------------------------------------------------------------------+\n&#039;
             &#039;| &quot;\&#039;-\&#039;&quot;     | The converted value is left adjusted (overrides &#039;
             &#039;the &quot;\&#039;0\&#039;&quot; conversion  |\n&#039;
             &#039;|           | if both are &#039;
             &#039;given).                                                   |\n&#039;
             &#039;+-----------+-----------------------------------------------------------------------+\n&#039;
             &#039;| &quot;\&#039; \&#039;&quot;     | (a space) A blank should be left before a &#039;
             &#039;positive number (or empty   |\n&#039;
             &#039;|           | string) produced by a signed &#039;
             &#039;conversion.                              |\n&#039;
             &#039;+-----------+-----------------------------------------------------------------------+\n&#039;
             &#039;| &quot;\&#039;+\&#039;&quot;     | A sign character (&quot;\&#039;+\&#039;&quot; or &quot;\&#039;-\&#039;&quot;) will &#039;
             &#039;precede the conversion         |\n&#039;
             &#039;|           | (overrides a &quot;space&quot; &#039;
             &#039;flag).                                           |\n&#039;
             &#039;+-----------+-----------------------------------------------------------------------+\n&#039;
             &#039;\n&#039;
             &#039;A length modifier (&quot;h&quot;, &quot;l&quot;, or &quot;L&quot;) may be present, but is &#039;
             &#039;ignored as\n&#039;
             &#039;it is not necessary for Python -- so e.g. &quot;%ld&quot; is identical to &#039;
             &#039;&quot;%d&quot;.\n&#039;
             &#039;\n&#039;
             &#039;The conversion types are:\n&#039;
             &#039;\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| Conversion   | &#039;
             &#039;Meaning                                               | Notes   &#039;
             &#039;|\n&#039;
             &#039;+==============+=======================================================+=========+\n&#039;
             &#039;| &quot;\&#039;d\&#039;&quot;        | Signed integer &#039;
             &#039;decimal.                               |         |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;i\&#039;&quot;        | Signed integer &#039;
             &#039;decimal.                               |         |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;o\&#039;&quot;        | Signed octal &#039;
             &#039;value.                                   | (1)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;u\&#039;&quot;        | Obsolete type -- it is identical to &#039;
             &#039;&quot;\&#039;d\&#039;&quot;.            | (7)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;x\&#039;&quot;        | Signed hexadecimal &#039;
             &#039;(lowercase).                       | (2)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;X\&#039;&quot;        | Signed hexadecimal &#039;
             &#039;(uppercase).                       | (2)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;e\&#039;&quot;        | Floating point exponential format &#039;
             &#039;(lowercase).        | (3)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;E\&#039;&quot;        | Floating point exponential format &#039;
             &#039;(uppercase).        | (3)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;f\&#039;&quot;        | Floating point decimal &#039;
             &#039;format.                        | (3)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;F\&#039;&quot;        | Floating point decimal &#039;
             &#039;format.                        | (3)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;g\&#039;&quot;        | Floating point format. Uses lowercase &#039;
             &#039;exponential     | (4)     |\n&#039;
             &#039;|              | format if exponent is less than -4 or not less &#039;
             &#039;than   |         |\n&#039;
             &#039;|              | precision, decimal format &#039;
             &#039;otherwise.                  |         |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;G\&#039;&quot;        | Floating point format. Uses uppercase &#039;
             &#039;exponential     | (4)     |\n&#039;
             &#039;|              | format if exponent is less than -4 or not less &#039;
             &#039;than   |         |\n&#039;
             &#039;|              | precision, decimal format &#039;
             &#039;otherwise.                  |         |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;c\&#039;&quot;        | Single character (accepts integer or single &#039;
             &#039;character |         |\n&#039;
             &#039;|              | &#039;
             &#039;string).                                              |         &#039;
             &#039;|\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;r\&#039;&quot;        | String (converts any Python object using &#039;
             &#039;repr()).     | (5)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;s\&#039;&quot;        | String (converts any Python object using &#039;
             &#039;&quot;str()&quot;).    | (6)     |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;| &quot;\&#039;%\&#039;&quot;        | No argument is converted, results in a &#039;
             &#039;&quot;\&#039;%\&#039;&quot;          |         |\n&#039;
             &#039;|              | character in the &#039;
             &#039;result.                              |         |\n&#039;
             &#039;+--------------+-------------------------------------------------------+---------+\n&#039;
             &#039;\n&#039;
             &#039;Notes:\n&#039;
             &#039;\n&#039;
             &#039;1. The alternate form causes a leading zero (&quot;\&#039;0\&#039;&quot;) to be &#039;
             &#039;inserted\n&#039;
             &#039;   between left-hand padding and the formatting of the number if &#039;
             &#039;the\n&#039;
             &#039;   leading character of the result is not already a zero.\n&#039;
             &#039;\n&#039;
             &#039;2. The alternate form causes a leading &quot;\&#039;0x\&#039;&quot; or &quot;\&#039;0X\&#039;&quot; &#039;
             &#039;(depending\n&#039;
             &#039;   on whether the &quot;\&#039;x\&#039;&quot; or &quot;\&#039;X\&#039;&quot; format was used) to be &#039;
             &#039;inserted\n&#039;
             &#039;   before the first digit.\n&#039;
             &#039;\n&#039;
             &#039;3. The alternate form causes the result to always contain a &#039;
             &#039;decimal\n&#039;
             &#039;   point, even if no digits follow it.\n&#039;
             &#039;\n&#039;
             &#039;   The precision determines the number of digits after the &#039;
             &#039;decimal\n&#039;
             &#039;   point and defaults to 6.\n&#039;
             &#039;\n&#039;
             &#039;4. The alternate form causes the result to always contain a &#039;
             &#039;decimal\n&#039;
             &#039;   point, and trailing zeroes are not removed as they would &#039;
             &#039;otherwise\n&#039;
             &#039;   be.\n&#039;
             &#039;\n&#039;
             &#039;   The precision determines the number of significant digits &#039;
             &#039;before\n&#039;
             &#039;   and after the decimal point and defaults to 6.\n&#039;
             &#039;\n&#039;
             &#039;5. The &quot;%r&quot; conversion was added in Python 2.0.\n&#039;
             &#039;\n&#039;
             &#039;   The precision determines the maximal number of characters &#039;
             &#039;used.\n&#039;
             &#039;\n&#039;
             &#039;6. If the object or format provided is a &quot;unicode&quot; string, the\n&#039;
             &#039;   resulting string will also be &quot;unicode&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   The precision determines the maximal number of characters &#039;
             &#039;used.\n&#039;
             &#039;\n&#039;
             &#039;7. See **PEP 237**.\n&#039;
             &#039;\n&#039;
             &#039;Since Python strings have an explicit length, &quot;%s&quot; conversions &#039;
             &#039;do not\n&#039;
             &#039;assume that &quot;\&#039;\\0\&#039;&quot; is the end of the string.\n&#039;
             &#039;\n&#039;
             &#039;Changed in version 2.7: &quot;%f&quot; conversions for numbers whose &#039;
             &#039;absolute\n&#039;
             &#039;value is over 1e50 are no longer replaced by &quot;%g&quot; conversions.\n&#039;
             &#039;\n&#039;
             &#039;Additional string operations are defined in standard modules &#039;
             &#039;&quot;string&quot;\n&#039;
             &#039;and &quot;re&quot;.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;XRange Type\n&#039;
             &#039;===========\n&#039;
             &#039;\n&#039;
             &#039;The &quot;xrange&quot; type is an immutable sequence which is commonly &#039;
             &#039;used for\n&#039;
             &#039;looping.  The advantage of the &quot;xrange&quot; type is that an &#039;
             &#039;&quot;xrange&quot;\n&#039;
             &#039;object will always take the same amount of memory, no matter the &#039;
             &#039;size\n&#039;
             &#039;of the range it represents.  There are no consistent &#039;
             &#039;performance\n&#039;
             &#039;advantages.\n&#039;
             &#039;\n&#039;
             &#039;XRange objects have very little behavior: they only support &#039;
             &#039;indexing,\n&#039;
             &#039;iteration, and the &quot;len()&quot; function.\n&#039;
             &#039;\n&#039;
             &#039;\n&#039;
             &#039;Mutable Sequence Types\n&#039;
             &#039;======================\n&#039;
             &#039;\n&#039;
             &#039;List and &quot;bytearray&quot; objects support additional operations that &#039;
             &#039;allow\n&#039;
             &#039;in-place modification of the object. Other mutable sequence &#039;
             &#039;types\n&#039;
             &#039;(when added to the language) should also support these &#039;
             &#039;operations.\n&#039;
             &#039;Strings and tuples are immutable sequence types: such objects &#039;
             &#039;cannot\n&#039;
             &#039;be modified once created. The following operations are defined &#039;
             &#039;on\n&#039;
             &#039;mutable sequence types (where *x* is an arbitrary object):\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;                  | same as &quot;s[len(s):len(s)] = &#039;
             &#039;[x]&quot; | (2)                   |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.extend(t)&quot; or &quot;s += t&quot;      | for the most part the same &#039;
             &#039;as    | (3)                   |\n&#039;
             &#039;|                                | &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    | (11)                  |\n&#039;
             &#039;|                                | repeated *n* &#039;
             &#039;times               |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.count(x)&quot;                   | return number of *i*\&#039;s for &#039;
             &#039;which |                       |\n&#039;
             &#039;|                                | &quot;s[i] == &#039;
             &#039;x&quot;                      |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.index(x[, i[, j]])&quot;         | return smallest *k* such &#039;
             &#039;that    | (4)                   |\n&#039;
             &#039;|                                | &quot;s[k] == x&quot; and &quot;i &lt;= k &lt; &#039;
             &#039;j&quot;     |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.insert(i, x)&quot;               | same as &quot;s[i:i] = &#039;
             &#039;[x]&quot;           | (5)                   |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.pop([i])&quot;                   | same as &quot;x = s[i]; del &#039;
             &#039;s[i];     | (6)                   |\n&#039;
             &#039;|                                | return &#039;
             &#039;x&quot;                        |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.remove(x)&quot;                  | same as &quot;del &#039;
             &#039;s[s.index(x)]&quot;      | (4)                   |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.reverse()&quot;                  | reverses the items of *s* &#039;
             &#039;in     | (7)                   |\n&#039;
             &#039;|                                | &#039;
             &#039;place                            |                       |\n&#039;
             &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
             &#039;| &quot;s.sort([cmp[, key[,           | sort the items of *s* in &#039;
             &#039;place   | (7)(8)(9)(10)         |\n&#039;
             &#039;| reverse]]])&quot;                   &#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  replacing.\n&#039;
             &#039;\n&#039;
             &#039;2. The C implementation of Python has historically accepted\n&#039;
             &#039;   multiple parameters and implicitly joined them into a tuple; &#039;
             &#039;this\n&#039;
             &#039;   no longer works in Python 2.0.  Use of this misfeature has &#039;
             &#039;been\n&#039;
             &#039;   deprecated since Python 1.4.\n&#039;
             &#039;\n&#039;
             &#039;3. *t* can be any iterable object.\n&#039;
             &#039;\n&#039;
             &#039;4. Raises &quot;ValueError&quot; when *x* is not found in *s*. When a\n&#039;
             &#039;   negative index is passed as the second or third parameter to &#039;
             &#039;the\n&#039;
             &#039;   &quot;index()&quot; method, the list length is added, as for slice &#039;
             &#039;indices.\n&#039;
             &#039;   If it is still negative, it is truncated to zero, as for &#039;
             &#039;slice\n&#039;
             &#039;   indices.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.3: Previously, &quot;index()&quot; didn\&#039;t have &#039;
             &#039;arguments\n&#039;
             &#039;   for specifying start and stop positions.\n&#039;
             &#039;\n&#039;
             &#039;5. When a negative index is passed as the first parameter to &#039;
             &#039;the\n&#039;
             &#039;   &quot;insert()&quot; method, the list length is added, as for slice &#039;
             &#039;indices.\n&#039;
             &#039;   If it is still negative, it is truncated to zero, as for &#039;
             &#039;slice\n&#039;
             &#039;   indices.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.3: Previously, all negative indices &#039;
             &#039;were\n&#039;
             &#039;   truncated to zero.\n&#039;
             &#039;\n&#039;
             &#039;6. The &quot;pop()&quot; method\&#039;s optional argument *i* defaults to &quot;-1&quot;, &#039;
             &#039;so\n&#039;
             &#039;   that by default the last item is removed and returned.\n&#039;
             &#039;\n&#039;
             &#039;7. The &quot;sort()&quot; and &quot;reverse()&quot; methods modify the list in &#039;
             &#039;place\n&#039;
             &#039;   for economy of space when sorting or reversing a large list.  &#039;
             &#039;To\n&#039;
             &quot;   remind you that they operate by side effect, they don&#039;t &quot;
             &#039;return the\n&#039;
             &#039;   sorted or reversed list.\n&#039;
             &#039;\n&#039;
             &#039;8. The &quot;sort()&quot; method takes optional arguments for controlling &#039;
             &#039;the\n&#039;
             &#039;   comparisons.\n&#039;
             &#039;\n&#039;
             &#039;   *cmp* specifies a custom comparison function of two arguments &#039;
             &#039;(list\n&#039;
             &#039;   items) which should return a negative, zero or positive &#039;
             &#039;number\n&#039;
             &#039;   depending on whether the first argument is considered smaller &#039;
             &#039;than,\n&#039;
             &#039;   equal to, or larger than the second argument: &quot;cmp=lambda &#039;
             &#039;x,y:\n&#039;
             &#039;   cmp(x.lower(), y.lower())&quot;.  The default value is &quot;None&quot;.\n&#039;
             &#039;\n&#039;
             &#039;   *key* specifies a function of one argument that is used to &#039;
             &#039;extract\n&#039;
             &#039;   a comparison key from each list element: &quot;key=str.lower&quot;.  &#039;
             &#039;The\n&#039;
             &#039;   default value is &quot;None&quot;.\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;   In general, the *key* and *reverse* conversion processes are &#039;
             &#039;much\n&#039;
             &#039;   faster than specifying an equivalent *cmp* function.  This &#039;
             &#039;is\n&#039;
             &#039;   because *cmp* is called multiple times for each list element &#039;
             &#039;while\n&#039;
             &#039;   *key* and *reverse* touch each element only once.  Use\n&#039;
             &#039;   &quot;functools.cmp_to_key()&quot; to convert an old-style *cmp* &#039;
             &#039;function to\n&#039;
             &#039;   a *key* function.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.3: Support for &quot;None&quot; as an equivalent &#039;
             &#039;to\n&#039;
             &#039;   omitting *cmp* was added.\n&#039;
             &#039;\n&#039;
             &#039;   Changed in version 2.4: Support for *key* and *reverse* was &#039;
             &#039;added.\n&#039;
             &#039;\n&#039;
             &#039;9. Starting with Python 2.3, the &quot;sort()&quot; method is guaranteed &#039;
             &#039;to\n&#039;
             &#039;   be stable.  A sort is stable if it guarantees not to change &#039;
             &#039;the\n&#039;
             &#039;   relative order of elements that compare equal --- this is &#039;
             &#039;helpful\n&#039;
             &#039;   for sorting in multiple passes (for example, sort by &#039;
             &#039;department,\n&#039;
             &#039;   then by salary grade).\n&#039;
             &#039;\n&#039;
             &#039;10. **CPython implementation detail:** While a list is being\n&#039;
             &#039;    sorted, the effect of attempting to mutate, or even inspect, &#039;
             &#039;the\n&#039;
             &#039;    list is undefined.  The C implementation of Python 2.3 and &#039;
             &#039;newer\n&#039;
             &#039;    makes the list appear empty for the duration, and raises\n&#039;
             &#039;    &quot;ValueError&quot; if it can detect that the list has been &#039;
             &#039;mutated\n&#039;
             &#039;    during a sort.\n&#039;
             &#039;\n&#039;
             &#039;11. The value *n* is an integer, or an object implementing\n&#039;
             &#039;    &quot;__index__()&quot;.  Zero and negative values of *n* clear the\n&#039;
             &#039;    sequence.  Items in the sequence are not copied; they are\n&#039;
             &#039;    referenced multiple times, as explained for &quot;s * n&quot; under &#039;
             &#039;Sequence\n&#039;
             &#039;    Types --- str, unicode, list, tuple, bytearray, buffer, &#039;
             &#039;xrange.\n&#039;,
 &#039;typesseq-mutable&#039;: &#039;\n&#039;
                     &#039;Mutable Sequence Types\n&#039;
                     &#039;**********************\n&#039;
                     &#039;\n&#039;
                     &#039;List and &quot;bytearray&quot; objects support additional &#039;
                     &#039;operations that allow\n&#039;
                     &#039;in-place modification of the object. Other mutable &#039;
                     &#039;sequence types\n&#039;
                     &#039;(when added to the language) should also support these &#039;
                     &#039;operations.\n&#039;
                     &#039;Strings and tuples are immutable sequence types: such &#039;
                     &#039;objects cannot\n&#039;
                     &#039;be modified once created. The following operations are &#039;
                     &#039;defined on\n&#039;
                     &#039;mutable sequence types (where *x* is an arbitrary &#039;
                     &#039;object):\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;                  | same as &#039;
                     &#039;&quot;s[len(s):len(s)] = [x]&quot; | (2)                   |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.extend(t)&quot; or &quot;s += t&quot;      | for the most part the &#039;
                     &#039;same as    | (3)                   |\n&#039;
                     &#039;|                                | &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    | (11)                  |\n&#039;
                     &#039;|                                | repeated *n* &#039;
                     &#039;times               |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.count(x)&quot;                   | return number of &#039;
                     &quot;*i*&#039;s for which |                       |\n&quot;
                     &#039;|                                | &quot;s[i] == &#039;
                     &#039;x&quot;                      |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.index(x[, i[, j]])&quot;         | return smallest *k* &#039;
                     &#039;such that    | (4)                   |\n&#039;
                     &#039;|                                | &quot;s[k] == x&quot; and &quot;i &lt;= &#039;
                     &#039;k &lt; j&quot;     |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.insert(i, x)&quot;               | same as &quot;s[i:i] = &#039;
                     &#039;[x]&quot;           | (5)                   |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.pop([i])&quot;                   | same as &quot;x = s[i]; &#039;
                     &#039;del s[i];     | (6)                   |\n&#039;
                     &#039;|                                | return &#039;
                     &#039;x&quot;                        |                       |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.remove(x)&quot;                  | same as &quot;del &#039;
                     &#039;s[s.index(x)]&quot;      | (4)                   |\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.reverse()&quot;                  | reverses the items of &#039;
                     &#039;*s* in     | (7)                   |\n&#039;
                     &#039;|                                | &#039;
                     &#039;place                            |                       &#039;
                     &#039;|\n&#039;
                     &#039;+--------------------------------+----------------------------------+-----------------------+\n&#039;
                     &#039;| &quot;s.sort([cmp[, key[,           | sort the items of *s* &#039;
                     &#039;in place   | (7)(8)(9)(10)         |\n&#039;
                     &#039;| reverse]]])&quot;                   &#039;
                     &#039;|                                  &#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 C implementation of Python has historically &#039;
                     &#039;accepted\n&#039;
                     &#039;   multiple parameters and implicitly joined them into a &#039;
                     &#039;tuple; this\n&#039;
                     &#039;   no longer works in Python 2.0.  Use of this &#039;
                     &#039;misfeature has been\n&#039;
                     &#039;   deprecated since Python 1.4.\n&#039;
                     &#039;\n&#039;
                     &#039;3. *t* can be any iterable object.\n&#039;
                     &#039;\n&#039;
                     &#039;4. Raises &quot;ValueError&quot; when *x* is not found in *s*. &#039;
                     &#039;When a\n&#039;
                     &#039;   negative index is passed as the second or third &#039;
                     &#039;parameter to the\n&#039;
                     &#039;   &quot;index()&quot; method, the list length is added, as for &#039;
                     &#039;slice indices.\n&#039;
                     &#039;   If it is still negative, it is truncated to zero, as &#039;
                     &#039;for slice\n&#039;
                     &#039;   indices.\n&#039;
                     &#039;\n&#039;
                     &#039;   Changed in version 2.3: Previously, &quot;index()&quot; didn\&#039;t &#039;
                     &#039;have arguments\n&#039;
                     &#039;   for specifying start and stop positions.\n&#039;
                     &#039;\n&#039;
                     &#039;5. When a negative index is passed as the first &#039;
                     &#039;parameter to the\n&#039;
                     &#039;   &quot;insert()&quot; method, the list length is added, as for &#039;
                     &#039;slice indices.\n&#039;
                     &#039;   If it is still negative, it is truncated to zero, as &#039;
                     &#039;for slice\n&#039;
                     &#039;   indices.\n&#039;
                     &#039;\n&#039;
                     &#039;   Changed in version 2.3: Previously, all negative &#039;
                     &#039;indices were\n&#039;
                     &#039;   truncated to zero.\n&#039;
                     &#039;\n&#039;
                     &#039;6. The &quot;pop()&quot; method\&#039;s optional argument *i* defaults &#039;
                     &#039;to &quot;-1&quot;, so\n&#039;
                     &#039;   that by default the last item is removed and &#039;
                     &#039;returned.\n&#039;
                     &#039;\n&#039;
                     &#039;7. The &quot;sort()&quot; and &quot;reverse()&quot; methods modify the list &#039;
                     &#039;in place\n&#039;
                     &#039;   for economy of space when sorting or reversing a &#039;
                     &#039;large list.  To\n&#039;
                     &#039;   remind you that they operate by side effect, they &#039;
                     &quot;don&#039;t return the\n&quot;
                     &#039;   sorted or reversed list.\n&#039;
                     &#039;\n&#039;
                     &#039;8. The &quot;sort()&quot; method takes optional arguments for &#039;
                     &#039;controlling the\n&#039;
                     &#039;   comparisons.\n&#039;
                     &#039;\n&#039;
                     &#039;   *cmp* specifies a custom comparison function of two &#039;
                     &#039;arguments (list\n&#039;
                     &#039;   items) which should return a negative, zero or &#039;
                     &#039;positive number\n&#039;
                     &#039;   depending on whether the first argument is considered &#039;
                     &#039;smaller than,\n&#039;
                     &#039;   equal to, or larger than the second argument: &#039;
                     &#039;&quot;cmp=lambda x,y:\n&#039;
                     &#039;   cmp(x.lower(), y.lower())&quot;.  The default value is &#039;
                     &#039;&quot;None&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;   *key* specifies a function of one argument that is &#039;
                     &#039;used to extract\n&#039;
                     &#039;   a comparison key from each list element: &#039;
                     &#039;&quot;key=str.lower&quot;.  The\n&#039;
                     &#039;   default value is &quot;None&quot;.\n&#039;
                     &#039;\n&#039;
                     &#039;   *reverse* is a boolean value.  If set to &quot;True&quot;, then &#039;
                     &#039;the list\n&#039;
                     &#039;   elements are sorted as if each comparison were &#039;
                     &#039;reversed.\n&#039;
                     &#039;\n&#039;
                     &#039;   In general, the *key* and *reverse* conversion &#039;
                     &#039;processes are much\n&#039;
                     &#039;   faster than specifying an equivalent *cmp* function.  &#039;
                     &#039;This is\n&#039;
                     &#039;   because *cmp* is called multiple times for each list &#039;
                     &#039;element while\n&#039;
                     &#039;   *key* and *reverse* touch each element only once.  &#039;
                     &#039;Use\n&#039;
                     &#039;   &quot;functools.cmp_to_key()&quot; to convert an old-style &#039;
                     &#039;*cmp* function to\n&#039;
                     &#039;   a *key* function.\n&#039;
                     &#039;\n&#039;
                     &#039;   Changed in version 2.3: Support for &quot;None&quot; as an &#039;
                     &#039;equivalent to\n&#039;
                     &#039;   omitting *cmp* was added.\n&#039;
                     &#039;\n&#039;
                     &#039;   Changed in version 2.4: Support for *key* and &#039;
                     &#039;*reverse* was added.\n&#039;
                     &#039;\n&#039;
                     &#039;9. Starting with Python 2.3, the &quot;sort()&quot; method is &#039;
                     &#039;guaranteed to\n&#039;
                     &#039;   be stable.  A sort is stable if it guarantees not to &#039;
                     &#039;change the\n&#039;
                     &#039;   relative order of elements that compare equal --- &#039;
                     &#039;this is helpful\n&#039;
                     &#039;   for sorting in multiple passes (for example, sort by &#039;
                     &#039;department,\n&#039;
                     &#039;   then by salary grade).\n&#039;
                     &#039;\n&#039;
                     &#039;10. **CPython implementation detail:** While a list is &#039;
                     &#039;being\n&#039;
                     &#039;    sorted, the effect of attempting to mutate, or even &#039;
                     &#039;inspect, the\n&#039;
                     &#039;    list is undefined.  The C implementation of Python &#039;
                     &#039;2.3 and newer\n&#039;
                     &#039;    makes the list appear empty for the duration, and &#039;
                     &#039;raises\n&#039;
                     &#039;    &quot;ValueError&quot; if it can detect that the list has been &#039;
                     &#039;mutated\n&#039;
                     &#039;    during a sort.\n&#039;
                     &#039;\n&#039;
                     &#039;11. The value *n* is an integer, or an object &#039;
                     &#039;implementing\n&#039;
                     &#039;    &quot;__index__()&quot;.  Zero and negative values of *n* &#039;
                     &#039;clear the\n&#039;
                     &#039;    sequence.  Items in the sequence are not copied; &#039;
                     &#039;they are\n&#039;
                     &#039;    referenced multiple times, as explained for &quot;s * n&quot; &#039;
                     &#039;under Sequence\n&#039;
                     &#039;    Types --- str, unicode, list, tuple, bytearray, &#039;
                     &#039;buffer, xrange.\n&#039;,
 &#039;unary&#039;: &#039;\n&#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;plain or long integer argument.  The bitwise inversion of &quot;x&quot; is\n&#039;
          &#039;defined as &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;\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 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\&#039;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;\n&#039;
         &#039;The &quot;with&quot; statement\n&#039;
         &#039;********************\n&#039;
         &#039;\n&#039;
         &#039;New in version 2.5.\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;\n&#039;
         &#039;usage 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 &quot;item&quot; 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\&#039;s &quot;__exit__()&quot; is loaded for later use.\n&#039;
         &#039;\n&#039;
         &#039;3. The context manager\&#039;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\&#039;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;Note: In Python 2.5, the &quot;with&quot; statement is only allowed when the\n&#039;
         &#039;  &quot;with_statement&quot; feature has been enabled.  It is always enabled &#039;
         &#039;in\n&#039;
         &#039;  Python 2.6.\n&#039;
         &#039;\n&#039;
         &#039;Changed in version 2.7: Support for multiple context expressions.\n&#039;
         &#039;\n&#039;
         &#039;See also:\n&#039;
         &#039;\n&#039;
         &#039;  **PEP 343** - The &quot;with&quot; 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;\n&#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;The &quot;yield&quot; statement is only used when defining a generator &#039;
          &#039;function,\n&#039;
          &#039;and is only used in the body of the generator function. Using a\n&#039;
          &#039;&quot;yield&quot; statement in a function definition is sufficient to cause &#039;
          &#039;that\n&#039;
          &#039;definition to create a generator function instead of a normal\n&#039;
          &#039;function.\n&#039;
          &#039;\n&#039;
          &#039;When a generator function is called, it returns an iterator known &#039;
          &#039;as a\n&#039;
          &#039;generator iterator, or more commonly, a generator.  The body of &#039;
          &#039;the\n&#039;
          &quot;generator function is executed by calling the generator&#039;s &quot;
          &#039;&quot;next()&quot;\n&#039;
          &#039;method repeatedly until it raises an exception.\n&#039;
          &#039;\n&#039;
          &#039;When a &quot;yield&quot; statement is executed, the state of the generator &#039;
          &#039;is\n&#039;
          &#039;frozen and the value of &quot;expression_list&quot; is returned to &#039;
          &#039;&quot;next()&quot;\&#039;s\n&#039;
          &#039;caller.  By &quot;frozen&quot; we mean that all local state is retained,\n&#039;
          &#039;including the current bindings of local variables, the instruction\n&#039;
          &#039;pointer, and the internal evaluation stack: enough information is\n&#039;
          &#039;saved so that the next time &quot;next()&quot; is invoked, the function can\n&#039;
          &#039;proceed exactly as if the &quot;yield&quot; statement were just another &#039;
          &#039;external\n&#039;
          &#039;call.\n&#039;
          &#039;\n&#039;
          &#039;As of Python version 2.5, the &quot;yield&quot; statement is now allowed in &#039;
          &#039;the\n&#039;
          &#039;&quot;try&quot; clause of a &quot;try&quot; ...  &quot;finally&quot; construct.  If the generator &#039;
          &#039;is\n&#039;
          &#039;not resumed before it is finalized (by reaching a zero reference &#039;
          &#039;count\n&#039;
          &quot;or by being garbage collected), the generator-iterator&#039;s &quot;
          &#039;&quot;close()&quot;\n&#039;
          &#039;method will be called, allowing any pending &quot;finally&quot; clauses to\n&#039;
          &#039;execute.\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;
          &#039;\n&#039;
          &#039;Note: In Python 2.2, the &quot;yield&quot; statement was only allowed when &#039;
          &#039;the\n&#039;
          &#039;  &quot;generators&quot; feature has been enabled.  This &quot;__future__&quot; import\n&#039;
          &#039;  statement was used to enable the feature:\n&#039;
          &#039;\n&#039;
          &#039;     from __future__ import generators\n&#039;
          &#039;\n&#039;
          &#039;See also:\n&#039;
          &#039;\n&#039;
          &#039;  **PEP 255** - Simple Generators\n&#039;
          &#039;     The proposal for adding generators and the &quot;yield&quot; statement &#039;
          &#039;to\n&#039;
          &#039;     Python.\n&#039;
          &#039;\n&#039;
          &#039;  **PEP 342** - Coroutines via Enhanced Generators\n&#039;
          &#039;     The proposal that, among other generator enhancements, &#039;
          &#039;proposed\n&#039;
          &#039;     allowing &quot;yield&quot; to appear inside a &quot;try&quot; ... &quot;finally&quot; &#039;
          &#039;block.\n&#039;}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/pydoc_data/topics.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython2.7%2Fpydoc_data' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>