eK"                    ! " # $ % & ' ( ) * + , - . /0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                   "!None 0ATL        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:  :   None Return the object name from the sys module, or ; if it does not exist.Set name in the sys module to a value.Delete name from the sys module.Reset sys.warnoptions to an empty list.Add an entry to sys.warnoptions.Set sys.path to a list object of paths found in the parameter, which should be a list of paths separated with the platform's search path delimiter (':' on Unix, ';' on Windows). <=>?@ <=>?@ None  Return a | of the builtins in the current execution frame, or the interpreter of the thread state if no frame is currently executing. Return a < of the local variables in the current execution frame, or ;$ if no frame is currently executing. Return a = of the global variables in the current execution frame, or ;$ if no frame is currently executing.2Return the current thread state's frame, which is ;% if no frame is currently executing.Return the name of funcB if it is a function, class or instance object, else the name of func's type. SReturn a description string, depending on the type of func. Return values include "()" for functions and methods,  "constructor",  "instance", and "object"#. Concatenated with the result of &, the result will be a description of func. ABCDEF   ABCDEF None ! The Python None object, denoting lack of value." The Python True object.# The Python False object.GHIJKL!"#MNO$%&!"#$%&!"#$%&GHIJKL!"#MNO$%& Safe'()*+,-.'()*+,-'()*+,-.'()*+,-.None PQRSTUVWX/012345678 /01234567 /01234567PQRSTUVWX/012345678None 9*Attempt to convert an object to a generic C. If the object does not implement the iterator protocol, returns ;.:-Return the next value from the iteration, or ;" if there are no remaining items.YZ[9:9:9:YZ[9:None =Return a weak reference for the object. This will always return a new reference, but is not guaranteed to create a new object; an existing reference object may be returned. The second parameter, callback<, can be a callable object that receives notification when obj is garbage collected; it should accept a single parameter, which will be the weak reference object itself. If ob is not a weakly-referencable object, or if callback$ is not callable, this will throw a  TypeError.>Return a weak reference proxy for the object. This will always return a new reference, but is not guaranteed to create a new object; an existing proxy may be returned. The second parameter, callback<, can be a callable object that receives notification when obj is garbage collected; it should accept a single parameter, which will be the weak reference object itself. If ob is not a weakly-referencable object, or if callback% is not callable, this will throw a  TypeError.?`Return the referenced object from a weak reference. If the referent is no longer live, returns None. ;\<]^_`=>?@A;<=>?<;=>? ;\<]^_`=>?@ANone CReturns a> if the first parameter is a subtype of the second parameter.bcBCDBCBCbcBCDNone G;Convert any object implementing the iterator protocol to a  .J;Return the object at a given index from a tuple, or throws  IndexError if the index is out of bounds.KTake a slice of a tuple from low to high , and return it as a new tuple.defghijkEFGHIJKLM EFGHIJKL EFGHIJKLdefghijkEFGHIJKLMNone P5Return a new slice object with the given values. The start, stop, and stepo parameters are used as the values of the slice object attributes of the same names. Any of the values may be ;, in which case None. will be used for the corresponding attribute.Q8Retrieve the start, stop, step, and slice length from a N+, assuming a sequence of the given length. NlmnoOPQSequence lengthRSNOPQNOPQ NlmnoOPQRSNone [ Return a new U" from the contents of an iterable . The object may be ;" to create an empty set. Throws a  TypeError if the object is not iterable.\ Return a new T" from the contents of an iterable . The object may be ;) to create an empty frozen set. Throws a  TypeError if the object is not iterable.^Return the size of a U or T._Return a if found, p" if not found. Unlike the Python contains()E method, this computation does not automatically convert unhashable Us into temporary T s. Throws a  TypeError if the key is unhashable.`Add key to a U. Also works with T (like "4 it can be used to fill-in the values of brand new T4s before they are exposed to other code). Throws a  TypeError$ if the key is unhashable. Throws a  MemoryError if there is no room to grow.aReturn a if found and removed, p1 if not found (no action taken). Does not throw KeyError for missing keys. Throws a  TypeError if key" is unhashable. Unlike the Python  discard()Z method, this computation does not automatically convert unhashable sets into temporary Ts.bTReturn an arbitrary object in the set, and removes the object from the set. Throws KeyError if the set is empty.cRemove all elements from a set.#TqUrVstuvwxyz{|WXYZ[\]^_`}abcdefghiTUVWXYZ[\]^_`abcVUTWXYZ[\]^_`abc!TqUrVstuvwxyz{|WXYZ[\]^_`}abcdefghiNone j~klmnopjklmnjklmn j~klmnopNone s;Convert any object implementing the iterator protocol to a .vReturns the object at a given position in the list. The position must be positive; indexing from the end of the list is not supported. If the position is out of bounds, throws an  IndexError exception.wSet the item at a given index.xInserts item_ into the list in front of the given index. Throws an exception if unsuccessful. Analogous to list.insert(index, item).yAppend itemK to the end of th list. Throws an exception if unsuccessful. Analogous to list.append(item).zReturn a list of the objects in list containing the objects between the given indexes. Throws an exception if unsuccessful. Analogous to list[low:high]D. Negative indices, as when slicing from Python, are not supported.{!Sets the slice of a list between low and high6 to the contents of a replacement list. Analogous to list[low:high] = replacement. The replacement may be ;, indicating the assignment of an empty list (slice deletion). Negative indices, as when slicing from Python, are not supported.|9Sort the items of a list in place. This is equivalent to  list.sort().}>Reverses the items of a list in place. This is equivalent to list.reverse().~ Return a new  3 containing the contents of a list; equivalent to  tuple(list).qrstuvwxyz{LowHigh Replacement|}~qrstuvwxyz{|}~qrstuvwxyz{|}~qrstuvwxyz{|}~None  Return an , that works with a general sequence object, seq/. The iteration ends when the sequence raises  IndexError! for the subscripting operation. Return a new . The first parameter, callable, can be any Python callable object that can be called with no parameters; each call to it should return the next item in the iteration. When callable returns a value equal to sentinel#, the iteration will be terminated.None  None  None   None 4Empty an existing dictionary of all key-value pairs.#Determine if a dictionary contains key(. If an item in the dictionary matches key , return a, otherwise return pN. On error, throws an exception. This is equivalent to the Python expression key in d.VReturn a new dictionary that contains the same key-value pairs as the old dictionary.4Return the object from a dictionary which has a key key . Return ; if the key is not present.Inserts value! into a dictionary with a key of key. key( must be hashable; if it isn t, throws  TypeError.*Remove the entry in a dictionary with key key. key( must be hashable; if it isn t, throws  TypeError. Return a F containing all the items in the dictionary, as in the Python method  dict.items(). Return a E containing all the keys in the dictionary, as in the Python method  dict.keys(). Return a G containing all the values in the dictionary, as in the Python method  dict.values().EReturn the number of items in the dictionary. This is equivalent to len(d).Iterate over mapping object b* adding key-value pairs to a dictionary. b/ may be a dictionary, or any object supporting  and . If the third parameter is aD, existing pairs in will be replaced if a matching key is found in bM, otherwise pairs will only be added if there is not already a matching key.This is the same as  (\a b ->  a b True) in Haskell, or  a.update(b) in Python.?Update or merge into a dictionary, from the key-value pairs in seq2. seq2 must be an iterable object producing iterable objects of length 2, viewed as key-value pairs. In case of duplicate keys, the last wins if the third parameter is a/, otherwise the first wins. Equivalent Python: pdef mergeFromSeq2(a, seq2, override): for key, value in seq2: if override or key not in a: a[key] = value !!None  None None Return a new function associated with the given code object. The second parameter will be used as the globals accessible to the function.$The function's docstring, name, and moduleT are retrieved from the code object. The parameter defaults and closure are set to ;.2Return the code object associated with a function.9Return the globals dictionary associated with a function. Return the module. attribute of a function. This is normally a UnicodeP containing the module name, but can be set to any other object by Python code.LReturn the default parameter values for a function. This can be a tuple or ;.&Set the default values for a function.;Return the closure associated with a function. This can be ;, or a tuple of Cells.FSet the closure associated with a function. The tuple should contain Cells.MReturn the annotations for a function. This can be a mutable dictionary, or ;.*Set the annotations for a function object. None 2Create and return a new cell containing the value obj.Return the contents of a cell.Set the contents of a cell to objB. This releases the reference to any current content of the cell.  None MRetrieve the pointer stored in the capsule. On failure, throws an exception.qThe name parameter must compare exactly to the name stored in the capsule. If the name stored in the capsule is ;#, the name passed in must also be ;@. Python uses the C function strcmp() to compare capsule names.AReturn the current context stored in the capsule, which might be NULL.>Return the current name stored in the capsule, which might be ;.Import a pointer to a C object from a capsule attribute in a module. The name parameter should specify the full name to the attribute, as in "module.attribute"]. The name stored in the capsule must match this string exactly. If the second parameter is p-, import the module without blocking (using PyImport_ImportModuleNoBlock()8). Otherwise, imports the module conventionally (using PyImport_ImportModule()).Return the capsule s internal pointer on success. On failure, throw an exception. If the module could not be imported, and if importing in non-blocking mode, returns ;.IDetermines whether or not a capsule is valid. A valid capsule's type is _, has a non-NULL pointer stored in it, and its internal name matches the name parameter. (See 5 for information on how capsule names are compared.)In other words, if  returns a=, calls to any of the accessors (any function starting with get) are guaranteed to succeed.@Set the void pointer inside the capsule. The pointer may not be NULL.+Set the context pointer inside the capsule. None OCreate a new byte string from any object which implements the buffer protocol.None Coerce an encoded object obj to an Unicode object.o and other char buffer compatible objects are decoded according to the given encoding and error handling mode.All other objects, including  objects, cause a  TypeError to be thrown. Shortcut for  "utf-8"  Encode a ! object and return the result as Z object. The encoding and error mode have the same meaning as the parameters of the the  str.encode()L method. The codec to be used is looked up using the Python codec registry. Create a  object by decoding a Z object. The encoding and error mode have the same meaning as the parameters of the the  str.encode()L method. The codec to be used is looked up using the Python codec registry.Split a string giving a  of  objects. If the separator is ;, splitting will be done at all whitespace substrings. Otherwise, splits occur at the given separator. Separators are not included in the resulting list.Split a , string at line breaks, returning a list of P strings. CRLF is considered to be one line break. If the second parameter is pG, the line break characters are not included in the resulting strings.?Translate a string by applying a character mapping table to it.TThe mapping table must map Unicode ordinal integers to Unicode ordinal integers or None% (causing deletion of the character).%Mapping tables need only provide the getitem()d interface; dictionaries and sequences work well. Unmapped character ordinals (ones which cause a  LookupError*) are left untouched and are copied as-is.0The error mode has the usual meaning for codecs.5Join a sequence of strings using the given separator.Return a if the substring matches string*[*start:end]" at the given tail end (either a  or  match), p otherwise..Return the first position of the substring in string*[*start:end][ using the given direction. The return value is the index of the first match; a value of ;# indicates that no match was found.FReturn the number of non-overlapping occurrences of the substring in string[start:end].XReplace occurrences of the substring with a given replacement. If the maximum count is ;, replace all occurences. Return a new > object from the given format and args; this is analogous to  format % args.Check whether element is contained in a string.element' has to coerce to a one element string.7 SeparatorMaximum splitsString SubstringStartEndString SubstringStartEndString SubstringStartEndString Substring Replacement Maximum count/ None   Returns a , object corresponding to the object type of self. On failure, throws  SystemError/. This is equivalent to the Python expression type(o). Returns a if inst is an instance of the class cls or a subclass of cls, or p, if not. On error, throws an exception. If cls. is a type object rather than a class object,   returns a if inst is of type cls. If cls< is a tuple, the check will be done against every entry in cls. The result will be a* when at least one of the checks returns a, otherwise it will be p. If inst is not a class instance and cls= is neither a type object, nor a class object, nor a tuple, inst must have a classI attribute  the class relationship of the value of that attribute with cls8 will be used to determine the result of this function.Subclass determination is done in a fairly straightforward way, but includes a wrinkle that implementors of extensions to the class system may want to be aware of. If A and B are class objects, B is a subclass of A if it inherits from A either directly or indirectly. If either is not a class object, a more general mechanism is used to determine the class relationship of the two objects. When testing if B is a subclass of A, if A is B,   returns a). If A and B are different objects, Bs basesM attribute is searched in a depth-first fashion for A  the presence of the bases< attribute is considered sufficient for this determination. Returns a if the class derived, is identical to or derived from the class cls, otherwise returns p0. In case of an error, throws an exception. If cls< is a tuple, the check will be done against every entry in cls. The result will be a* when at least one of the checks returns a, otherwise it will be p . If either derived or clsf is not an actual class object (or tuple), this function uses the generic algorithm described above. uAttempt to cast an object to some concrete class. If the object isn't an instance of the class or subclass, returns ;. Returns a if self, has an attribute with the given name, and p9 otherwise. This is equivalent to the Python expression hasattr(self, name)6Retrieve an attribute with the given name from object self. Returns the attribute value on success, and throws an exception on failure. This is the equivalent of the Python expression  self.name.?Set the value of the attribute with the given name, for object self, to the value vR. THrows an exception on failure. This is the equivalent of the Python statement  self.name = v.4Delete an attribute with the given name, for object selfS. Throws an exception on failure. This is the equivalent of the Python statement  del self.name.Print  repr(self) to a handle.*Compute a string representation of object selfU, or throw an exception on failure. This is the equivalent of the Python expression  repr(self).*Compute a string representation of object selfU, or throw an exception on failure. This is the equivalent of the Python expression  str(self).)Compute a bytes representation of object selfQ, or throw an exception on failure. This is equivalent to the Python expression  bytes(self).Determine if the object self is callable.Call a callable Python object self, with arguments given by the tuple and named arguments given by the dictionary. Returns the result of the call on success, or throws an exception on failure. This is the equivalent of the Python expression self(*args, **kw).Call a callable Python object self#, with arguments given by the list. Call the named method of object self, with arguments given by the tuple and named arguments given by the dictionary. Returns the result of the call on success, or throws an exception on failure. This is the equivalent of the Python expression self.method(args). Call the named method of object self, with arguments given by the list. Returns the result of the call on success, or throws an exception on failure. This is the equivalent of the Python expression self.method(args).Compare the values of a and bQ using the specified comparison. If an exception is raised, throws an exception.Returns a if the object self is considered to be true, and p9 otherwise. This is equivalent to the Python expression  not not self#. On failure, throws an exception./Compute and return the hash value of an object selfU. On failure, throws an exception. This is the equivalent of the Python expression  hash(self).,This is equivalent to the Python expression  dir(self), returning a (possibly empty) list of strings appropriate for the object argument, or throws an exception if there was an error.,This is equivalent to the Python expression  iter(self)y. It returns a new iterator for the object argument, or the object itself if the object is already an iterator. Throws  TypeError# if the object cannot be iterated.1     "     #     +     None ! "#$%&!"#$!"#$ ! "#$%&None )$Return a new module object with the name# attribute set. Only the module s doc and nameF attributes are filled in; the caller is responsible for providing a file attribute.*cReturn the dictionary object that implements a module s namespace; this object is the same as the dict attribute of the module. This computation never fails. It is recommended extensions use other computations rather than directly manipulate a module s dict.+Returns a module s nameN value. If the module does not provide one, or if it is not a string, throws  SystemError.,PReturns the name of the file from which a module was loaded using the module s fileF attribute. If this is not defined, or if it is not a string, throws  SystemError.-Add an object to a module with the given name. This is a convenience computation which can be used from the module s initialization computation..|Add an integer constant to a module. This convenience computation can be used from the module s initialization computation./zAdd a string constant to a module. This convenience computation can be used from the module s initialization computation.0bThis is a higher-level interface that calls the current import hook  (with an explicit level of 0,, meaning absolute import). It invokes the import() computation from the builtins of the current globals. This means that the import is done using whatever import hooks are installed in the current environment..This computation always uses absolute imports.1]Reload a module. If an error occurs, an exception is thrown and the old module still exists.'    ()*+,-./0123 '()*+,-./01 '()*+,-./01'    ()*+,-./0123None ATO456 !"#$%&'()*+,-./0123457869:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^$456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW$456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWM456 !"#$%&'()*+,-./0123457869:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^None cNCreate a new byte array from any object which implements the buffer protocol._789:;<=>?`abcdefgh_`abcdef_`abcdef_789:;<=>?`abcdefghNone i*Attempt to convert an object to a generic C. If the object does not implement the sequence protocol, returns ;.wReturn the first index i for which  self[i] == v/. This is equivalent to the Python expression  self.index(v).xGReturn a list object with the same contents as the arbitrary sequence seq,. The returned list is guaranteed to be new.yHReturn a tuple object with the same contents as the arbitrary sequence seq. If seq6 is already a tuple, it is re-used rather than copied.zReturns the sequence seqB as a tuple, unless it is already a tuple or list, in which case seq* is returned. If an error occurs, throws  TypeError+ with the given text as the exception text.)@ABCDEFGHIJKLMNOPQijklmnopqrstuvwxyz{|}~ijklmnopqrstuvwxyzijklmnopqrstuvwxyz)@ABCDEFGHIJKLMNOPQijklmnopqrstuvwxyz{|}~#NoneG ;<BEFGHNOTUVWXYZ[\]jkqrst!"#$'(_`abG_ !j'VUTN <;`"qk(WXOEBab#$rstYZ[\]FGH None Initialize the Python interpreter. In an application embedding Python, this should be called before using any other Python/C API computations; with the exception of ,  initThreads,  releaseLock, and  acquireLock1. This initializes the table of loaded modules ( sys.modules(), and creates the fundamental modules builtins, main and sys/. It also initializes the module search path (sys.path). It does not set sys.argv; use K for that. This is a no-op when called for a second time (without calling U first). There is no return value; it is a fatal error if the initialization fails.Return a3 when the Python interpreter has been initialized, p if not. After  is called, this returns p until  is called again.!Undo all initializations made by Z and subsequent use of Python/C API computations, and destroy all sub-interpreters (see H below) that were created and not yet destroyed since the last call to . Ideally, this frees all memory allocated by the Python interpreter. This is a no-op when called for a second time (without calling Q again first). There is no return value; errors during finalization are ignored.This computation is provided for a number of reasons. An embedding application might want to restart Python without having to restart the application itself. An application that has loaded the Python interpreter from a dynamically loadable library (or DLL) might want to free all memory allocated by Python before unloading the DLL. During a hunt for memory leaks in an application a developer might want to free all memory allocated by Python before exiting from the application.Bugs and caveatsm: The destruction of modules and objects in modules is done in arbitrary order; this may cause destructors (del() methods) to fail when they depend on other objects (even functions) or modules. Dynamically loaded extension modules loaded by Python are not unloaded. Small amounts of memory allocated by the Python interpreter may not be freed (if you find a leak, please report it). Memory tied up in circular references between objects is not freed. Some memory allocated by extension modules may not be freed. Some extensions may not work properly if their initialization routine is called more than once; this can happen if an application calls  and  more than once.Create a new sub-interpreter. This is an (almost) totally separate environment for the execution of Python code. In particular, the new interpreter has separate, independent versions of all imported modules, including the fundamental modules builtins, main and sys . The table of loaded modules ( sys.modules) and the module search path (sys.path0) are also separate. The new environment has no sys.argv8 variable. It has new standard I/O stream file objects  sys.stdin,  sys.stdout and  sys.stderr. (however these refer to the same underlying FILE structures in the C library).The return value points to the first thread state created in the new sub-interpreter. This thread state is made in the current thread state. Note that no actual thread is created; see the discussion of thread states below. If creation of the new interpreter is unsuccessful, ; is returned; no exception is set since the exception state is stored in the current thread state and there may not be a current thread state. (Like all other Python/C API computations, the global interpreter lock must be held before calling this computation and is still held when it returns; however, unlike most other Python/C API computations, there needn t be a current thread state on entry.)uExtension modules are shared between (sub-)interpreters as follows: the first time a particular extension is imported, it is initialized normally, and a (shallow) copy of its module s dictionary is squirreled away. When the same extension is imported by another (sub-)interpreter, a new module is initialized and filled with the contents of this copy; the extension s init procedure is not called. Note that this is different from what happens when an extension is imported after the interpreter has been completely re-initialized by calling  and  ; in that case, the extension s initmodule procedure is called again.Bugs and caveats: Because sub-interpreters (and the main interpreter) are part of the same process, the insulation between them isn t perfect  for example, using low-level file operations like  os.close() they can (accidentally or maliciously) affect each other s open files. Because of the way extensions are shared between (sub-)interpreters, some extensions may not work properly; this is especially likely when the extension makes use of (static) global variables, or when the extension manipulates its module s dictionary after its initialization. It is possible to insert objects created in one sub-interpreter into a namespace of another sub-interpreter; this should be done with great care to avoid sharing user-defined functions, methods, instances or classes between sub-interpreters, since import operations executed by such objects may affect the wrong (sub-)interpreter s dictionary of loaded modules. (XXX This is a hard-to-fix bug that will be addressed in a future release.)|Also note that the use of this functionality is incompatible with extension modules such as PyObjC and ctypes that use the PyGILState_*(), APIs (and this is inherent in the way the PyGILState_*()W procedures work). Simple things may work, but confusing behavior will always be near.Destroy the (sub-)interpreter represented by the given thread state. The given thread state must be the current thread state. See the discussion of thread states below. When the call returns, the current thread state is NULL. All thread states associated with this interpreter are destroyed. (The global interpreter lock must be held before calling this computation and is still held when it returns.) Y will destroy all sub-interpreters that haven t been explicitly destroyed at that point.!Return the program name set with , or the default.)This computation should be called before c is called for the first time, if it is called at all. It tells the interpreter the value of the argv[0] argument to the main, procedure of the program. This is used by  and some other computations below to find the Python run-time libraries relative to the interpreter executable. The default value is "python"B. No code in the Python interpreter will change the program name.Return the prefix for installed platform-independent files. This is derived through a number of complicated rules from the program name set with F and some environment variables; for example, if the program name is "/usr/local/bin/python", the prefix is  "/usr/local". This corresponds to the prefix- variable in the top-level Makefile and the --prefix argument to the  configureA script at build time. The value is available to Python code as  sys.prefix'. It is only useful on UNIX. See also . Return the  exec-prefix for installed platform- dependent files. This is derived through a number of complicated rules from the program name set with setProgramName' and some environment variables; for example, if the program name is "/usr/local/bin/python", the exec-prefix is  "/usr/local". This corresponds to the  exec_prefix- variable in the top-level Makefile and the  --exec-prefix argument to the  configureB script at build time. The value is available to Python code as sys.exec_prefix. It is only useful on UNIX.Background: The exec-prefix differs from the prefix when platform dependent files (such as executables and shared libraries) are installed in a different directory tree. In a typical installation, platform dependent files may be installed in the /usr/local/plat9 subtree while platform independent may be installed in  /usr/local.Generally speaking, a platform is a combination of hardware and software families, e.g. Sparc machines running the Solaris 2.x operating system are considered the same platform, but Intel machines running Solaris 2.x are another platform, and Intel machines running Linux are yet another platform. Different major revisions of the same operating system generally also form different platforms. Non-UNIX operating systems are a different story; the installation strategies on those systems are so different that the prefix and exec-prefix are meaningless, and set to the empty string. Note that compiled Python bytecode files are platform independent (but not independent from the Python version by which they were compiled!).5System administrators will know how to configure the mount or  automount programs to share  /usr/local! between platforms while having /usr/local/plat- be a different filesystem for each platform.Return the full program name of the Python executable; this is computed as a side-effect of deriving the default module search path from the program name (set by 3 above). The value is available to Python code as sys.executable.WReturn the default module search path; this is computed from the program name (set by  above) and some environment variables. The returned string consists of a series of directory names separated by a platform dependent delimiter character. The delimiter character is ':' on Unix and Mac OS X, ';'@ on Windows. The value is available to Python code as the list sys.pathM, which may be modified to change the future search path for loaded modules.ZReturn the version of this Python interpreter. This is a string that looks something like = "3.0a5+ (py3k:63103M, May 12 2008, 00:53:55) \n[GCC 4.2.3]" The first word (up to the first space character) is the current Python version; the first three characters are the major and minor version separated by a period. The value is available to Python code as  sys.version. Return the platform identifier for the current platform. On Unix, this is formed from the official  name of the operating system, converted to lower case, followed by the major revision number; e.g., for Solaris 2.x, which is also known as SunOS 5.x, the value is "sunos5". On Mac OS X, it is "darwin". On Windows, it is "win",. The value is available to Python code as  sys.platform.QReturn the official copyright string for the current Python version, for example A "Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam" )The value is available to Python code as  sys.copyright.pReturn an indication of the compiler used to build the current Python version, in square brackets, for example:  "[GCC 2.7.2.2]" ?The value is available to Python code as part of the variable  sys.version.}Return information about the sequence number and build date and time of the current Python interpreter instance, for example  "#67, Aug 1 1997, 22:34:28" ?The value is available to Python code as part of the variable  sys.version.Set sys.argv3. The first parameter is similar to the result of  getProgName, with the difference that it should refer to the script file to be executed rather than the executable hosting the Python interpreter. If there isn t a script that will be run, the first parameter can be an empty string. If this function fails to initialize sys.argv', a fatal condition is signalled using Py_FatalError().;This function also prepends the executed script s path to sys.path3. If no script is executed (in the case of calling  python -cI or just the interactive interpreter), the empty string is used instead.IReturn the default home , that is, the value set by a previous call to , or the value of the  PYTHONHOME$ environment variable if it is set.zSet the default home  directory, that is, the location of the standard Python libraries. The libraries are searched in home/lib/python version and home/lib/python versionA. No code in the Python interpreter will change the Python home.(RSTUVWXYZ[\]^_`abcdef'RSTUVWXYZ[\]^_`abcdefg!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q RST"UVWXYZ[\]^_`a9bcdefghijkTl"mnopqrstuvwxyz{|}V~pkT"lhpp~T"UZXYVpApkk~                            ! " # $%&'()*+,p-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU'VWXYZ[\]^_`akbcdekfghT"Uli~jhklmnop q r s t u v w x y z { | } ~     !&!)!,!-!1!2!3!4!!!8!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHHIJIKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_I`IaIbIcIdIeIfghgigjgkglgmgngogpgqgrgsgtgugvwxwywzw{w|w}~~~~~~~~~~~~~~~~~~~~~~ pH     EF       ! " # $ % & ' ( ) * + , - ./0123456789:^_;<=>?@AB6CDEFGnHIJKtuLMNOP3QRSTUVWXYZ[\]B^_`6CabcdefghWXijklmno301/458pqrPLXstuvwxyz{|}~X8qCP^C                   %+X8kOU^C^ZPB456^C                     $cpython-3.4.0-6EPIHN0753A7ebduG0MMCiCPython.Protocols.IteratorCPython.Protocols.SequenceCPython.Protocols.MappingCPython.Types.ExceptionCPython.Types.TupleCPython.Types.ListCPython.Types.DictionaryCPython.Types.TypeCPython.Protocols.ObjectCPython.SystemCPython.ReflectionCPython.ConstantsCPython.Protocols.Object.EnumsCPython.Types.WeakReferenceCPython.Types.SliceCPython.Types.SetCPython.Types.MethodCPython.Types.IteratorCPython.Types.InstanceMethodCPython.Types.FloatCPython.Types.ComplexCPython.Types.CodeCPython.Types.FunctionCPython.Types.CellCPython.Types.CapsuleCPython.Types.BytesCPython.Types.UnicodeCPython.Types.IntegerCPython.Types.ModuleCPython.Protocols.NumberCPython.Types.ByteArrayCPythonCPython.InternalsetItem CPython.TypesIterator toIterator SomeIteratorSequence toSequence SomeSequenceMapping toMapping SomeMapping Exception exceptionTypeexceptionValueexceptionTracebackTupleList DictionaryTypeConcreteObjecttoObject SomeObject getObject setObject deleteObjectresetWarnOptions addWarnOptionsetPath getBuiltins getLocals getGlobalsgetFramegetFunctionNamegetFunctionDescriptionnonetruefalseisNoneisTrueisFalseHSCPythonComparisonEnum HSCPYTHON_LT HSCPYTHON_LE HSCPYTHON_EQ HSCPYTHON_NE HSCPYTHON_GT HSCPYTHON_GE$fEnumHSCPythonComparisonEnum castToMappinggetItem deleteItemsizehasKeykeysvaluesitems$fMappingDictionarycastToIteratornextProxy Reference newReferencenewProxy $fObjectProxy$fObjectReferencetypeType isSubtype$fConcreteType tupleTypetoTupleiterableToTuple fromTuplelengthgetSlice$fConcreteTupleSlice sliceTypenew getIndices$fConcreteSlice $fObjectSlice FrozenSetSetAnySetsetType frozenSetTypetoSet toFrozenSet iterableToSetiterableToFrozenSetfromSetcontainsadddiscardpopclear$fAnySetFrozenSet $fAnySetSet$fConcreteFrozenSet$fObjectFrozenSet $fConcreteSet $fObjectSetMethod methodTypefunctionself$fConcreteMethod$fObjectMethodlistTypetoListiterableToListfromListinsertappendsetSlicesortreverse$fConcreteListCallableIteratorSequenceIteratorsequenceIteratorTypecallableIteratorTypesequenceIteratorNewcallableIteratorNew$fConcreteCallableIterator$fObjectCallableIterator$fIteratorCallableIterator$fConcreteSequenceIterator$fObjectSequenceIterator$fIteratorSequenceIteratorInstanceMethodinstanceMethodType$fConcreteInstanceMethod$fObjectInstanceMethodFloat floatTypetoFloat fromFloat$fConcreteFloat $fObjectFloatdictionaryTypecopymergeupdate mergeFromSeq2$fConcreteDictionaryComplex complexType toComplex fromComplex$fConcreteComplex$fObjectComplexCodecodeType$fConcreteCode $fObjectCodeFunction functionTypegetCode getModule getDefaults setDefaults getClosure setClosuregetAnnotationssetAnnotations$fConcreteFunction$fObjectFunctionCellcellTypegetset$fConcreteCell $fObjectCellCapsule capsuleType getPointer getContextgetName importNamedisValid setPointer setContext$fConcreteCapsule$fObjectCapsuleBytes bytesTypetoBytes fromBytes fromObject$fConcreteBytes $fObjectBytes FindDirectionForwards BackwardsMatchDirectionPrefixSuffix ErrorHandlingStrictReplaceIgnoreEncodingUnicode unicodeType toUnicode fromUnicodefromEncodedObjectencodedecodesplit splitLines translatejoin tailMatchfindcountreplaceformat$fConcreteUnicode$fObjectUnicode$fShowErrorHandling$fEqErrorHandling$fShowMatchDirection$fEqMatchDirection$fShowFindDirection$fEqFindDirection ComparisonLTLEEQNEGTGEgetType isInstance isSubclasscast hasAttribute getAttribute setAttributedeleteAttributeprintreprasciistringbytescallablecallcallArgs callMethodcallMethodArgs richComparetoBoolhashdir getIterator$fShowComparisonInteger integerType toInteger fromInteger$fConcreteInteger$fObjectIntegerModule moduleType getDictionary getFilename addObjectaddIntegerConstantaddTextConstant importModulereload$fConcreteModule$fObjectModuleNumbertoNumber SomeNumber castToNumbersubtractmultiply floorDivide trueDivide remainderdivmodpowernegativepositiveabsoluteinvertshiftLshiftRandxoror inPlaceAddinPlaceSubtractinPlaceMultiplyinPlaceFloorDivideinPlaceTrueDivideinPlaceRemainder inPlacePower inPlaceShiftL inPlaceShiftR inPlaceAnd inPlaceXor inPlaceOrtoBase$fNumberFrozenSet $fNumberSet$fNumberComplex $fNumberFloat$fNumberInteger$fNumberSomeNumber$fObjectSomeNumber ByteArray byteArrayType toByteArray fromByteArrayresize$fConcreteByteArray$fObjectByteArraycastToSequencerepeat inPlaceAppend inPlaceRepeat deleteSliceindexfast$fSequenceUnicode$fSequenceTuple$fSequenceList$fSequenceBytes$fSequenceByteArray initialize isInitializedfinalizenewInterpreterendInterpretergetProgramNamesetProgramName getPrefix getExecPrefixgetProgramFullPathgetPath getVersion getPlatform getCopyright getCompiler getBuildInfosetArgv getPythonHome setPythonHome concreteTypefromForeignPtrpyErrNormalizeException pyErrFetchcallObjectRaw'_decref'_incref'_ staticDecrefcToBool cFromBoolpeekText peekTextWpeekMaybeTextWwithText withTextWwithMaybeTextWmapWith withObject peekObjectpeekStaticObjectunsafeStealObject stealObjectincrefdecref callObjectRaw unsafeCast exceptionIfcheckStatusCodecheckBoolReturncheckIntReturnunsafeCastToMappingunsafeCastToSequenceunsafeCastToIterator$fIteratorSomeIterator$fObjectSomeIterator$fSequenceSomeSequence$fObjectSomeSequence$fMappingSomeMapping$fObjectSomeMapping$fExceptionException$fShowException $fObjectTuple $fObjectList$fObjectDictionary $fObjectType$fObjectSomeObjectbase GHC.Stable newStablePtrghc-prim GHC.TypesIntGHC.IntInt8Int16Int32Int64 StablePtrWordGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtrGHC.ForeignPtr ForeignPtrForeign.C.ErrorerrnoToIOErrorthrowErrnoPathIfMinus1_throwErrnoPathIfMinus1throwErrnoPathIfNullthrowErrnoPathIf_throwErrnoPathIfthrowErrnoPaththrowErrnoIfNullRetryMayBlockthrowErrnoIfNullRetrythrowErrnoIfNull throwErrnoIfMinus1RetryMayBlock_throwErrnoIfMinus1RetryMayBlockthrowErrnoIfMinus1Retry_throwErrnoIfMinus1RetrythrowErrnoIfMinus1_throwErrnoIfMinus1throwErrnoIfRetryMayBlock_throwErrnoIfRetry_throwErrnoIfRetryMayBlockthrowErrnoIfRetry throwErrnoIf_ throwErrnoIf throwErrno resetErrnogetErrno isValidErrnoeXDEV eWOULDBLOCKeUSERSeTXTBSY eTOOMANYREFS eTIMEDOUTeTIMEeSTALEeSRMNTeSRCHeSPIPEeSOCKTNOSUPPORT eSHUTDOWNeRREMOTE eRPCMISMATCHeROFSeREMOTEeREMCHGeRANGE ePROTOTYPEePROTONOSUPPORTePROTO ePROGUNAVAIL ePROGMISMATCH ePROCUNAVAILePROCLIMePIPE ePFNOSUPPORTePERM eOPNOTSUPPeNXIOeNOTTYeNOTSUPeNOTSOCK eNOTEMPTYeNOTDIReNOTCONNeNOTBLKeNOSYSeNOSTReNOSReNOSPC eNOPROTOOPTeNONETeNOMSGeNOMEMeNOLINKeNOLCKeNOEXECeNOENTeNODEVeNODATAeNOBUFSeNFILE eNETUNREACH eNETRESETeNETDOWN eNAMETOOLONG eMULTIHOPeMSGSIZEeMLINKeMFILEeLOOPeISDIReISCONNeIOeINVALeINTR eINPROGRESSeILSEQeIDRM eHOSTUNREACH eHOSTDOWNeFTYPEeFBIGeFAULTeEXISTeDQUOTeDOMeDIRTY eDESTADDRREQeDEADLK eCONNRESET eCONNREFUSED eCONNABORTEDeCOMMeCHILDeBUSYeBADRPCeBADMSGeBADFeALREADYeAGAIN eAFNOSUPPORTeADV eADDRNOTAVAIL eADDRINUSEeACCESe2BIGeOKErrnoForeign.C.StringwithCWStringLen withCWStringnewCWStringLen newCWStringpeekCWStringLen peekCWStringwithCAStringLen withCAStringnewCAStringLen newCAStringpeekCAStringLen peekCAStringcastCharToCSCharcastCSCharToCharcastCharToCUCharcastCUCharToCharcastCharToCCharcastCCharToCharcharIsRepresentablewithCStringLen withCString newCStringLen newCStringpeekCStringLen peekCStringCString CStringLenCWString CWStringLenForeign.Marshal.PoolpooledNewArray0pooledNewArray pooledNewpooledReallocArray0pooledReallocArraypooledMallocArray0pooledMallocArraypooledReallocBytes pooledReallocpooledMallocBytes pooledMallocwithPoolfreePoolnewPoolPoolForeign.Marshal.Errorvoid throwIfNull throwIfNeg_ throwIfNegthrowIf_throwIfForeign.Marshal.Array advancePtr lengthArray0 moveArray copyArray withArrayLen0 withArray0 withArrayLen withArray newArray0newArray pokeArray0 pokeArray peekArray0 peekArray reallocArray0 reallocArray allocaArray0 allocaArray callocArray0 callocArray mallocArray0 mallocArrayForeign.Marshal.Utils fillBytes moveBytes copyByteswithMany maybePeek maybeWithmaybeNewfromBoolwithForeign.Marshal.Allocfree reallocBytesreallocallocaBytesAligned allocaBytesalloca callocBytes mallocBytescallocmalloc finalizerFreeForeign.ForeignPtr.ImpmallocForeignPtrArray0mallocForeignPtrArraynewForeignPtrEnvwithForeignPtr newForeignPtrfinalizeForeignPtrcastForeignPtrtouchForeignPtrnewForeignPtr_addForeignPtrFinalizerEnvaddForeignPtrFinalizermallocForeignPtrBytesmallocForeignPtr FinalizerPtrFinalizerEnvPtr Foreign.Ptr intPtrToPtr ptrToIntPtr wordPtrToPtr ptrToWordPtrfreeHaskellFunPtrWordPtrIntPtrForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxForeign.StorableStorablesizeOf alignment peekElemOff pokeElemOff peekByteOff pokeByteOffpeekpokecastPtrToStablePtrcastStablePtrToPtrdeRefStablePtr freeStablePtrcastPtrToFunPtrcastFunPtrToPtr castFunPtr nullFunPtrminusPtralignPtrplusPtrcastPtrnullPtr byteSwap64 byteSwap32 byteSwap16 Data.BitstoIntegralSizedpopCountDefaulttestBitDefault bitDefaultBits.&..|. complementshiftrotatezeroBitsbitsetBitclearBit complementBittestBit bitSizeMaybebitSizeisSigned unsafeShiftL unsafeShiftRrotateLrotateRpopCount FiniteBits finiteBitSizecountLeadingZeroscountTrailingZeros GHC.IO.UnsafeunsafePerformIOGHC.BaseNothingresetWarnOptions'_pySysSetObjectpySysGetObject pySysSetPathpySysAddWarnOptiongetFunctionDescription'_getFunctionName'_pyEvalGetFramepyEvalGetGlobalspyEvalGetLocals getBuiltins'_ rawFalse'_ rawTrue'_ rawNone'_false'_true'_none'_rawNonerawTruerawFalseitems'_values'_keys'_hasKey'_size'_ deleteItem'_ setItem'_ getItem'_pyMappingCheck pyErrOccurred pyIterNexthscpythonPyIterCheck getObject'_pyWeakrefNewProxypyWeakrefNewRefTrue isSubtype'_ typeType'_pyTupleSetItem getSlice'_length'_hscpython_peek_tuple pyTupleSizehscpython_poke_tuple tupleType'_pySliceGetIndicesEx pySliceNew sliceType'_Falseclear'_pop'_ discard'_c_add'_ contains'_iterableToFrozenSet'_iterableToSet'_frozenSetType'_ setType'_c_addself'_ function'_new'_ methodType'_ toTuple'_ reverse'_sort'_pyListSetSliceappend'_insert'_ pyListSetItemhscpython_peek_list pyListSizehscpython_poke_list listType'_callableIteratorNew'_sequenceIteratorNew'_callableIteratorType'_sequenceIteratorType'_instanceMethodType'_ fromFloat'_ toFloat'_ floatType'_mergeFromSeq2'_update'_merge'_pyDictGetItemWithError pyErrClearcopy'_dictionaryType'_pyComplexImagAsDoublepyComplexRealAsDoublepyComplexFromDoubles complexType'_ codeType'_setAnnotations'_getAnnotations'_ setClosure'_ getClosure'_ setDefaults'_ getDefaults'_ getModule'_ getGlobals'_ getCode'_functionType'_withNullableObjectpeekNullableObject pyCellSet pyCellGet pyCellNew cellType'_ setContext'_ setPointer'_pyCapsuleIsValidpyCapsuleImportpyCapsuleGetNamepyCapsuleGetContextpyCapsuleGetPointer capsuleType'_ pyBytesConcat fromObject'_pyBytesAsStringAndSizepyBytesFromStringAndSize bytesType'_format'_hscpython_PyUnicode_Replacehscpython_PyUnicode_Counthscpython_PyUnicode_Findhscpython_PyUnicode_Tailmatchjoin'_ translate'_ splitLines'_hscpython_PyUnicode_Splithscpython_PyUnicode_Decodeencode'_fromEncodedObject'_hscpython_PyUnicode_GetSizehscpython_PyUnicode_AsUnicodehscpython_PyUnicode_FromUnicode unicodeType'_ withErrors getIterator'_dir'_hash'_toBool'_ richCompare'_ pyObjectCall callable'_bytes'_string'_ascii'_repr'_deleteAttribute'_setAttribute'_getAttribute'_hasAttribute'_ isSubclass'_ isInstance'_ getType'_comparisonToIntpyLongAsLongAndOverflowpyLongFromStringpyLongFromLongLong integerType'_reload'_pyImportImportpyModuleAddObjectpyModuleGetFilenamepyModuleGetNamegetDictionary'_ moduleType'_toBase'_ toInteger'_ inPlaceOr'_ inPlaceXor'_ inPlaceAnd'_inPlaceShiftR'_inPlaceShiftL'_pyNumberInPlacePowerinPlaceRemainder'_inPlaceTrueDivide'_inPlaceFloorDivide'_inPlaceMultiply'_inPlaceSubtract'_ inPlaceAdd'_or'_xor'_and'_shiftR'_shiftL'_invert'_ absolute'_ positive'_ negative'_ pyNumberPowerdivmod'_ remainder'_ trueDivide'_ floorDivide'_ multiply'_ subtract'_ pyNumberCheckunsafeCastToNumberresize'_pyByteArrayAsStringpyByteArraySizepyByteArrayFromStringAndSizebyteArrayType'_fast'_toList'_index'_count'_ deleteSlice'_ setSlice'_inPlaceRepeat'_inPlaceAppend'_repeat'_pySequenceCheck ThreadStategetBuildInfo'_ getCompiler'_getCopyright'_ getPlatform'_ getVersion'_pyEndInterpreterpyNewInterpreter finalize'_isInitialized'_ initialize'_cSetPythonHomepyGetPythonHome pySetArgv pyGetPathpyGetProgramFullPathpyGetExecPrefix pyGetPrefixcSetProgramNamepyGetProgramName