NI                    ! " # $ % & ' ( ) * + , - . / 0 1 23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH! NoneLIJK L MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~IJK L MNOPQRSZ[\]^_`abcdeghijklmnopqr:IJK L MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ NoneDCreate a new byte array from any object which implements the buffer  protocol.  None!ECreate a new byte string from any object which implements the buffer  protocol.  !"# !"# !"# !"# None&BRetrieve the pointer stored in the capsule. On failure, throws an  exception. KThe 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 9. 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 . )EImport a pointer to a C object from a capsule attribute in a module. I The name parameter should specify the full name to the attribute, as in  "module.attribute"1. The name stored in the capsule must match this , string exactly. If the second parameter is , import the module  without blocking (using PyImport_ImportModuleNoBlock()). Otherwise, * imports the module conventionally (using PyImport_ImportModule()). Return the capsule 1s internal pointer on success. On failure, throw H an exception. If the module could not be imported, and if importing in  non-blocking mode, returns . *=Determines 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 & for information on how  capsule names are compared.) In other words, if * returns , 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/2Create and return a new cell containing the value obj. 0Return the contents of a cell. 1Set the contents of a cell to obj%. This releases the reference to any  current content of the cell. -   ./01  -./01-./01 -   ./01  None23232323None 456745674567 4567None :5Empty an existing dictionary of all key-value pairs. ;#Determine if a dictionary contains key. If an item in the dictionary  matches key , return , otherwise return . On error, throws ; an exception. This is equivalent to the Python expression key in d. <FReturn 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 3 containing all the items in the dictionary, as in  the Python method  dict.items(). A Return a 2 containing all the keys in the dictionary, as in  the Python method  dict.keys(). B Return a 4 containing all the values in the dictionary, as in  the Python method  dict.values(). CDReturn the number of items in the dictionary. This is equivalent to  len(d). DIterate over mapping object b) adding key-value pairs to a dictionary.  b/ may be a dictionary, or any object supporting A and =.  If the third parameter is *, existing pairs in will be replaced if a  matching key is found in b., otherwise pairs will only be added if there  is not already a matching key. EThis is the same as (\a b -> D a b True) in Haskell, or   a.update(b) in Python. F?Update or merge into a dictionary, from the key-value pairs in seq2.  seq2D must be an iterable object producing iterable objects of length 2, H viewed as key-value pairs. In case of duplicate keys, the last wins if  the third parameter is ', otherwise the first wins. Equivalent  Python:  ' def mergeFromSeq2(a, seq2, override):  for key, value in seq2:  if override or key not in a:  a[key] = value ! !"#$%&'()89:;<=>?@ABCDEF*89:;<=>?@ABCDEF89:;<=>?@ABCDEF! !"#$%&'()89:;<=>?@ABCDEF*None  None G+,-.HIJ/0GHIJGHIJ G+,-.HIJ/0None K1234LMN56KLMNKLMN K1234LMN56NoneS Return an , that works with a general sequence object, seq. - The iteration ends when the sequence raises  IndexError for the  subscripting operation. T Return a new . The first parameter, callable , can be any I 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. O7P89:;<QRST=>?@ABOPQRSTPQSORTO7P89:;<QRST=>?@ABNone UCDEFGVWXYHIUVWXYUVWXY UCDEFGVWXYHINone\5Return a new slice object with the given values. The start, stop,  and step7 parameters are used as the values of the slice object 8 attributes of the same names. Any of the values may be  , in which  case None/ will be used for the corresponding attribute. ]8Retrieve the start, stop, step, and slice length from a Z, * assuming a sequence of the given length. ZJKLM[\]Sequence length NOZ[\]Z[\] ZJKLM[\]NONone`;Convert any object implementing the iterator protocol to a  . c;Return the object at a given index from a tuple, or throws  IndexError  if the index is out of bounds. dTake a slice of a tuple from low to high, and return it as a new  tuple. PQRSTUVW^_`abcdeX ^_`abcde ^_`abcdePQRSTUVW^_`abcdeXNone h;Convert any object implementing the iterator protocol to a . kIReturns the object at a given position in the list. The position must be F positive; indexing from the end of the list is not supported. If the & position is out of bounds, throws an  IndexError exception. lSet the item at a given index. mInserts item6 into the list in front of the given index. Throws an ) exception if unsuccessful. Analogous to list.insert(index, item). nAppend item= to the end of th list. Throws an exception if unsuccessful.  Analogous to list.append(item). oDReturn a list of the objects in list containing the objects between F the given indexes. Throws an exception if unsuccessful. Analogous to   list[low:high]9. Negative indices, as when slicing from Python, are not  supported. p!Sets the slice of a list between low and high to the contents of " a replacement list. Analogous to  list[low:high] = replacement. The  replacement may be -, indicating the assignment of an empty list J (slice deletion). Negative indices, as when slicing from Python, are not  supported. q9Sort the items of a list in place. This is equivalent to  list.sort(). r=Reverses the items of a list in place. This is equivalent to  list.reverse(). s Return a new  2 containing the contents of a list; equivalent to   tuple(list). YZ[\]^_`abcdeffghijklmnopLow High  Replacement qrsgfghijklmnopqrsfghijklmnopqrsYZ[\]^_`abcdeffghijklmnopqrsgNone{ 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  if found, ! if not found. Unlike the Python  __contains__()9 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  !) it can be used to fill-in the values of  brand new t3s 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. Return  if found and removed,  if not found (no action  taken). Does not throw KeyError for missing keys. Throws a  TypeError  if key" is unhashable. Unlike the Python  discard() method, this K computation does not automatically convert unhashable sets into temporary  ts. GReturn an arbitrary object in the set, and removes the object from the  set. Throws KeyError if the set is empty.  Remove all elements from a set. "thuivjklmnopqrswxyz{|}~tuvwxytuvwxyz{|}~vutwxyz{|}~ thuivjklmnopqrswxyz{|}~tuvwxyNoneReturns 3 if the first parameter is a subtype of the second  parameter. z{|z{|NoneCoerce an encoded object obj to an Unicode object. C 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  object. H The encoding and error mode have the same meaning as the parameters of  the the  str.encode()1 method. The codec to be used is looked up using  the Python codec registry.  Create a  object by decoding a  object. The encoding and ? error mode have the same meaning as the parameters of the the   str.encode()< 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  B, splitting will be done at all whitespace substrings. Otherwise, I splits occur at the given separator. Separators are not included in the  resulting list. Split a , string at line breaks, returning a list of  K strings. CRLF is considered to be one line break. If the second parameter  is >, the line break characters are not included in the resulting  strings. @Translate a string by applying a character mapping table to it. GThe 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__() interface; I dictionaries and sequences work well. Unmapped character ordinals (ones  which cause a  LookupError+) are left untouched and are copied as-is. 1The error mode has the usual meaning for codecs. 6Join a sequence of strings using the given separator. Return  if the substring matches string*[*start:end] at the  given tail end (either a  or  match),  otherwise. .Return the first position of the substring in string*[*start:end] G using the given direction. The return value is the index of the first  match; a value of $ indicates that no match was found. EReturn the number of non-overlapping occurrences of the substring in  string[start:end]. FReplace occurrences of the substring with a given replacement. If the  maximum count is , replace all occurences.  Return a new 0 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}~ Separator Maximum splits String  Substring Start End String  Substring Start End String  Substring Start End String  Substring  Replacement Maximum count /}~NoneFReturn a weak reference for the object. This will always return a new F reference, but is not guaranteed to create a new object; an existing 9 reference object may be returned. The second parameter, callback, can 6 be a callable object that receives notification when obj is garbage H collected; it should accept a single parameter, which will be the weak K reference object itself. If ob is not a weakly-referencable object, or if  callback$ is not callable, this will throw a  TypeError. HReturn a weak reference proxy for the object. This will always return a J 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 K 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. GReturn the referenced object from a weak reference. If the referent is  no longer live, returns None.  None The Python None! object, denoting lack of value.  The Python True object.  The Python False object. None HReturn a new function associated with the given code object. The second C parameter will be used as the globals accessible to the function.  The function's docstring, name, and  __module__ are retrieved from the < code object. The parameter defaults and closure are set to . 3Return the code object associated with a function. :Return the globals dictionary associated with a function.  Return the  __module__+ attribute of a function. This is normally  a Unicode9 containing the module name, but can be set to any other  object by Python code. HReturn 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. ESet the closure associated with a function. The tuple should contain  Cells. IReturn the annotations for a function. This can be a mutable dictionary,  or . +Set the annotations for a function object.   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  if inst is an instance of the class cls or a  subclass of cls, or ( if not. On error, throws an exception.  If cls. is a type object rather than a class object,   returns  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  when $ at least one of the checks returns , otherwise it will be . 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  __class__ attribute  < the class relationship of the value of that attribute with cls will be 0 used to determine the result of this function. DSubclass determination is done in a fairly straightforward way, but H includes a wrinkle that implementors of extensions to the class system K may want to be aware of. If A and B are class objects, B is a subclass of K A if it inherits from A either directly or indirectly. If either is not a G class object, a more general mechanism is used to determine the class K relationship of the two objects. When testing if B is a subclass of A, if  A is B,  returns $. If A and B are different objects,  Bs  __bases__4 attribute is searched in a depth-first fashion for  A  the presence of the  __bases__ attribute is considered $ sufficient for this determination. Returns  if the class derived! is identical to or derived from  the class cls, otherwise returns . In case of an error, throws  an exception. If cls2 is a tuple, the check will be done against every  entry in cls. The result will be ! when at least one of the checks  returns , otherwise it will be  . If either derived or cls J is not an actual class object (or tuple), this function uses the generic  algorithm described above. @Attempt to cast an object to some concrete class. If the object  isn'0t an instance of the class or subclass, returns . Returns  if self+ has an attribute with the given name, and  8 otherwise. This is equivalent to the Python expression  hasattr(self, name) 6Retrieve an attribute with the given name from object self . Returns J 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 v9. 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 self . Throws an F 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 self, or throw an exception = on failure. This is the equivalent of the Python expression  repr(self). *Compute a string representation of object self, or throw an exception = on failure. This is the equivalent of the Python expression  str(self). )Compute a bytes representation of object self, or throw an exception 9 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 J tuple and named arguments given by the dictionary. Returns the result of E 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 J tuple and named arguments given by the dictionary. Returns the result of E 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 I 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 b! using the specified comparison. 1 If an exception is raised, throws an exception. Returns  if the object self is considered to be true, and  8 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 self. On failure, F throws an exception. This is the equivalent of the Python expression   hash(self). ,This is equivalent to the Python expression  dir(self), returning a G (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). It returns a J 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. 9""-None  None $Return a new module object with the __name__ attribute set. Only the  module s __doc__ and __name__ attributes are filled in; the ' caller is responsible for providing a __file__ attribute. 5Return the dictionary object that implements a module  s namespace;  this object is the same as the __dict__ attribute of the module. This A computation never fails. It is recommended extensions use other 6 computations rather than directly manipulate a module s __dict__. Returns a module s __name__ value. If the module does not / provide one, or if it is not a string, throws  SystemError. FReturns the name of the file from which a module was loaded using the  module s __file__0 attribute. If this is not defined, or if it is  not a string, throws  SystemError. EAdd an object to a module with the given name. This is a convenience . computation which can be used from the module s initialization  computation. IAdd an integer constant to a module. This convenience computation can be  used from the module s initialization computation. GAdd a string constant to a module. This convenience computation can be  used from the module s initialization computation. 8This 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 K current globals. This means that the import is done using whatever import 1 hooks are installed in the current environment. /This computation always uses absolute imports. HReload a module. If an error occurs, an exception is thrown and the old  module still exists.  "NoneG  $%-.2345678GHIJKLOPQRUVZ[^_`afghituvwxyz{|}G$-24 GKPOUvutZ %.358HLQRfVwx[^ 67IJghiyz{|}_`aNone*Attempt to convert an object to a generic . If the object does . not implement the iterator protocol, returns . -Return the next value from the iteration, or  if there are no  remaining items. None  NoneN          $     $     L          None*Attempt to convert an object to a generic . If the object does . not implement the sequence protocol, returns . &Return the first index i for which self[i] == v. This is equivalent  to the Python expression  self.index(v). 'FReturn a list object with the same contents as the arbitrary sequence  seq-. The returned list is guaranteed to be new. (GReturn a tuple object with the same contents as the arbitrary sequence  seq. If seq7 is already a tuple, it is re-used rather than copied. )Returns the sequence seq- 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. ) !"#$%&'()* !"#$%&'()+,-./ !"#$%&'() !"#$%&'()) !"#$%&'()* !"#$%&'()+,-./None* Return a 1 of the builtins in the current execution frame, L or the interpreter of the thread state if no frame is currently executing. + Return a 1 of the local variables in the current execution  frame, or % if no frame is currently executing. , Return a 2 of the global variables in the current execution  frame, or % if no frame is currently executing. -Return the current thread state's frame, which is  if no frame  is currently executing. .Return the name of func0 if it is a function, class or instance object,  else the name of func's type. /CReturn 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. 012345*+,-./*+,-./*+,-./ 012345*+,-./None0Return the object name from the sys module, or  if it does  not exist. 1Set name in the sys module to a value. 2Delete name from the sys module. 3Reset sys.warnoptions to an empty list. 4Add an entry to sys.warnoptions. 5Set sys.path9 to a list object of paths found in the parameter, which 6 should be a list of paths separated with the platform's search path  delimiter (':' on Unix, ';' on Windows). 6789:012345012345012345 6789:012345None6GInitialize the Python interpreter. In an application embedding Python, 4 this should be called before using any other Python/C API computations;  with the exception of <,  initThreads,   releaseLock, and  acquireLock. 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 F for that. This ; is a no-op when called for a second time (without calling 8 M first). There is no return value; it is a fatal error if the initialization  fails. 7Return 3 when the Python interpreter has been initialized,   if not. After 8 is called, this returns  until  6 is called again. 8!Undo all initializations made by 6 and subsequent use of  Python/:C API computations, and destroy all sub-interpreters (see  9: below) that were created and not yet destroyed since the  last call to 62. Ideally, this frees all memory allocated by the L Python interpreter. This is a no-op when called for a second time (without  calling 67 again first). There is no return value; errors during  finalization are ignored. CThis computation is provided for a number of reasons. An embedding H application might want to restart Python without having to restart the K application itself. An application that has loaded the Python interpreter L from a dynamically loadable library (or DLL) might want to free all memory H allocated by Python before unloading the DLL. During a hunt for memory C leaks in an application a developer might want to free all memory : allocated by Python before exiting from the application. Bugs and caveats7: The destruction of modules and objects in modules is 6 done in arbitrary order; this may cause destructors ( __del__() methods) H to fail when they depend on other objects (even functions) or modules. I Dynamically loaded extension modules loaded by Python are not unloaded. H Small amounts of memory allocated by the Python interpreter may not be J freed (if you find a leak, please report it). Memory tied up in circular M references between objects is not freed. Some memory allocated by extension J modules may not be freed. Some extensions may not work properly if their H initialization routine is called more than once; this can happen if an  application calls 6 and 8 more than once. 9CCreate a new sub-interpreter. This is an (almost) totally separate F environment for the execution of Python code. In particular, the new I 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.argv  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). EThe return value points to the first thread state created in the new I sub-interpreter. This thread state is made in the current thread state. L Note that no actual thread is created; see the discussion of thread states < below. If creation of the new interpreter is unsuccessful,  is J returned; no exception is set since the exception state is stored in the I current thread state and there may not be a current thread state. (Like  all other Python/8C API computations, the global interpreter lock must be I 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.) HExtension modules are shared between (sub-)interpreters as follows: the L first time a particular extension is imported, it is initialized normally, # and a (shallow) copy of its module !s dictionary is squirreled away. I When the same extension is imported by another (sub-)interpreter, a new F module is initialized and filled with the contents of this copy; the  extension s init, procedure is not called. Note that this is E different from what happens when an extension is imported after the ; interpreter has been completely re-initialized by calling 8 and  6; in that case, the extension s initmodule  procedure is called again. Bugs and caveats6: Because sub-interpreters (and the main interpreter) > are part of the same process, the insulation between them isn t  perfect  3 for example, using low-level file operations like   os.close()4 they can (accidentally or maliciously) affect each  other 7s open files. Because of the way extensions are shared I between (sub-)interpreters, some extensions may not work properly; this F is especially likely when the extension makes use of (static) global 8 variables, or when the extension manipulates its module s G dictionary after its initialization. It is possible to insert objects < created in one sub-interpreter into a namespace of another G sub-interpreter; this should be done with great care to avoid sharing ? user-defined functions, methods, instances or classes between H sub-interpreters, since import operations executed by such objects may # affect the wrong (sub-)interpreter  s dictionary of loaded modules. M (XXX This is a hard-to-fix bug that will be addressed in a future release.) BAlso 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_*() procedures L work). Simple things may work, but confusing behavior will always be near. :EDestroy the (sub-)interpreter represented by the given thread state. B The given thread state must be the current thread state. See the G discussion of thread states below. When the call returns, the current  thread state is NULL). All thread states associated with this F interpreter are destroyed. (The global interpreter lock must be held E before calling this computation and is still held when it returns.)  8- 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 6 is called for the K 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 @6 and some other computations below to find the Python H run-time libraries relative to the interpreter executable. The default  value is "python"4. No code in the Python interpreter will change the  program name. =DReturn the prefix for installed platform-independent files. This is I derived through a number of complicated rules from the program name set  with <5 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  configure script 9 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 H is derived through a number of complicated rules from the program name  set with setProgramName'1 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  configure @ script at build time. The value is available to Python code as  sys.exec_prefix. It is only useful on UNIX. BBackground: The exec-prefix differs from the prefix when platform J dependent files (such as executables and shared libraries) are installed D in a different directory tree. In a typical installation, platform ) dependent files may be installed in the /usr/local/plat subtree while * platform independent may be installed in /usr/local. IGenerally speaking, a platform is a combination of hardware and software H families, e.g. Sparc machines running the Solaris 2.x operating system F are considered the same platform, but Intel machines running Solaris D 2.x are another platform, and Intel machines running Linux are yet J another platform. Different major revisions of the same operating system K generally also form different platforms. Non-UNIX operating systems are a F different story; the installation strategies on those systems are so K different that the prefix and exec-prefix are meaningless, and set to the E empty string. Note that compiled Python bytecode files are platform H 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. ?HReturn the full program name of the Python executable; this is computed F as a side-effect of deriving the default module search path from the  program name (set by <# above). The value is available to  Python code as sys.executable. @AReturn the default module search path; this is computed from the  program name (set by < above) and some environment H variables. The returned string consists of a series of directory names F 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.path, which may be modified 6 to change the future search path for loaded modules. AEReturn 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]" GThe first word (up to the first space character) is the current Python E version; the first three characters are the major and minor version A separated by a period. The value is available to Python code as   sys.version. BGReturn the platform identifier for the current platform. On Unix, this  is formed from the  official  name of the operating system, K 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. CEReturn the official copyright string for the current Python version,  for example    "=Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam" )The value is available to Python code as  sys.copyright. DFReturn 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. EHReturn information about the sequence number and build date and time of 6 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. FSet sys.argv2. The first parameter is similar to the result of   getProgName9, with the difference that it should refer to the script C file to be executed rather than the executable hosting the Python  interpreter. If there isn 't a script that will be run, the first H 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 -c I or just the interactive interpreter), the empty string is used instead. GReturn the default  home , that is, the value set by a  previous call to H, or the value of the  PYTHONHOME $ environment variable if it is set. HSet the default  home " directory, that is, the location A of the standard Python libraries. The libraries are searched in  home/lib/python version and home/lib/python version. No = code in the Python interpreter will change the Python home. (;<=>?@ABCDEFGHIJKLMNO6789:;<=>?@ABCDEFGH6789:;<=>?@ABCDEFGH6789:;<=>?@ABCDEFGH';<=>?@ABCDEFGHIJKLMNO6789:;<=>?@ABCDEFGHP # $ % & ' ( ) * + , - . / 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 QRSTUVWXOYZ[\!]^_`abcdefghijOklmnopqrsOktuvOwxyz{>\|!}~>\!=|yaZY><=ZO        OH\!]a_`^     g>=\!]|Z~y !"#$%&'()*+,-./012345678 % ( + , 0 1 2 3 9 : 7 ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e fghijklgmngmogmpgmqghrjksgtugtvgtwgtxgyzgy{g|}g~ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg g g g g ggggggggggggggggggg g!g"g#g$g%g&g'g(g)g*g+g,g-g.g/g0g1g2g3g45g46g47g48g49g4:g4;g4<g4=g4>g4?g4@g4Ag4Bg4Cg4Dg4Eg4Fg4Gg4HgIJgIKgILgIMgINgIOgIgIPgIQgIOgRSgRTgRUgRVgRWgRXgRYgRZgR[g\]g^_g^`g^ag^bg^cgdegdfgdggdhgdigdjgdkg|lg|mg|ng|og|pg|qg|rg|sg|tg|ugvwgvwgvxgvxgvygvygvzgvzgv{gv{gv|gv|gv}gv}gv~gv~gvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgvgggggggggghghghghgygygygygygygygygyggggggggggggggggggggggggg 8           @        gjkjk D             M      RTei lm    ru !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r s t u v w x y z { | } ~           2% cpython-3.3.0CPython.Protocols.IteratorCPython.Protocols.SequenceCPython.Protocols.MappingCPython.Types.ExceptionCPython.Types.TupleCPython.Types.ListCPython.Types.DictionaryCPython.Types.TypeCPython.Protocols.ObjectCPython.Types.ByteArrayCPython.Types.BytesCPython.Types.CapsuleCPython.Types.CellCPython.Types.CodeCPython.Types.ComplexCPython.Types.FloatCPython.Types.InstanceMethodCPython.Types.IteratorCPython.Types.MethodCPython.Types.SliceCPython.Types.SetCPython.Types.UnicodeCPython.Types.WeakReferenceCPython.ConstantsCPython.Types.FunctionCPython.Types.IntegerCPython.Types.ModuleCPython.Protocols.NumberCPython.ReflectionCPython.SystemCPythonCPython.InternalsetItem CPython.TypesIterator toIterator SomeIteratorSequence toSequence SomeSequenceMapping toMapping SomeMapping Exception exceptionTypeexceptionValueexceptionTracebackTupleList DictionaryTypeConcreteObjecttoObject SomeObject ByteArray byteArrayType toByteArray fromByteArray fromObjectappendlengthresizeBytes bytesTypetoBytes fromBytesCapsule capsuleType getPointer getContextgetName importNamedisValid setPointer setContextCellcellTypenewgetsetCodecodeTypeComplex complexType toComplex fromComplexdictionaryTypeclearcontainscopygetItem deleteItemitemskeysvaluessizemergeupdate mergeFromSeq2Float floatTypetoFloat fromFloatInstanceMethodinstanceMethodTypefunctionCallableIteratorSequenceIteratorsequenceIteratorTypecallableIteratorTypesequenceIteratorNewcallableIteratorNewMethod methodTypeselfSlice sliceType getIndices tupleTypetoTupleiterableToTuple fromTuplegetSlicelistTypetoListiterableToListfromListinsertsetSlicesortreverse FrozenSetSetAnySetsetType frozenSetTypetoSet toFrozenSet iterableToSetiterableToFrozenSetfromSetadddiscardpoptypeType isSubtype FindDirection BackwardsForwardsMatchDirectionSuffixPrefix ErrorHandlingIgnoreReplaceStrictEncodingUnicode unicodeType toUnicode fromUnicodefromEncodedObjectencodedecodesplit splitLines translatejoin tailMatchfindcountreplaceformatProxy Reference newReferencenewProxy getObjectnonetruefalseisNoneisTrueisFalseFunction functionTypegetCode getGlobals getModule getDefaults setDefaults getClosure setClosuregetAnnotationssetAnnotations ComparisonGEGTNEEQLELTgetType isInstance isSubclasscast hasAttribute getAttribute setAttributedeleteAttributeprintreprasciistringbytescallablecallcallArgs callMethodcallMethodArgs richComparetoBoolhashdir getIteratorInteger integerType toInteger fromIntegerModule moduleType getDictionary getFilename addObjectaddIntegerConstantaddTextConstant importModulereloadcastToIteratornext castToMappinghasKeyNumbertoNumber SomeNumber castToNumbersubtractmultiply floorDivide trueDivide remainderdivmodpowernegativepositiveabsoluteinvertshiftLshiftRandxoror inPlaceAddinPlaceSubtractinPlaceMultiplyinPlaceFloorDivideinPlaceTrueDivideinPlaceRemainder inPlacePower inPlaceShiftL inPlaceShiftR inPlaceAnd inPlaceXor inPlaceOrtoBasecastToSequencerepeat inPlaceAppend inPlaceRepeat deleteSliceindexfast getBuiltins getLocalsgetFramegetFunctionNamegetFunctionDescription setObject deleteObjectresetWarnOptions addWarnOptionsetPath 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.MarshalunsafeLocalStateForeign.Marshal.PoolpooledNewArray0pooledNewArray pooledNewpooledReallocArray0pooledReallocArraypooledMallocArray0pooledMallocArraypooledReallocBytes pooledReallocpooledMallocBytes pooledMallocwithPoolfreePoolnewPoolPoolForeign.Marshal.Errorvoid throwIfNull throwIfNeg_ throwIfNegthrowIf_throwIfForeign.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 eOPNOTSUPPeNXIOeNOTTYeNOTSOCK 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.Array advancePtr lengthArray0 moveArray copyArray withArrayLen0 withArray0 withArrayLen withArray newArray0newArray pokeArray0 pokeArray peekArray0 peekArray reallocArray0 reallocArray allocaArray0 allocaArray mallocArray0 mallocArrayForeign.Marshal.Utils moveBytes copyByteswithMany maybePeek maybeWithmaybeNewfromBoolwithForeign.Marshal.Allocfree reallocBytesreallocallocaBytesAligned allocaBytesalloca mallocBytesmalloc finalizerFreeForeign.ForeignPtrunsafeForeignPtrToPtrForeign.ForeignPtr.ImpmallocForeignPtrArray0mallocForeignPtrArraynewForeignPtrEnvwithForeignPtr newForeignPtr Foreign.Ptr intPtrToPtr ptrToIntPtr wordPtrToPtr ptrToWordPtrfreeHaskellFunPtrWordPtrIntPtrfinalizeForeignPtrcastForeignPtrtouchForeignPtrnewForeignPtr_addForeignPtrFinalizerEnvaddForeignPtrFinalizermallocForeignPtrBytesmallocForeignPtr FinalizerPtrFinalizerEnvPtrForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxForeign.Storablepokepeek pokeByteOff peekByteOff pokeElemOff peekElemOff alignmentsizeOfStorablecastPtrToStablePtrcastStablePtrToPtrdeRefStablePtr freeStablePtrcastPtrToFunPtrcastFunPtrToPtr castFunPtr nullFunPtrminusPtralignPtrplusPtrcastPtrnullPtr Data.BitspopCountDefaulttestBitDefault bitDefaultpopCountrotateRrotateL unsafeShiftR unsafeShiftLisSignedbitSizetestBit complementBitclearBitsetBitbitrotateshift complement.|..&.BitsGHC.IOunsafePerformIOresize'_length'_append'_ fromObject'_pyByteArrayAsStringpyByteArraySizepyByteArrayFromStringAndSizebyteArrayType'_$fConcreteByteArray$fObjectByteArray pyBytesConcatpyBytesAsStringAndSizepyBytesFromStringAndSize bytesType'_$fConcreteBytes $fObjectBytes Data.MaybeNothingFalseTrue setContext'_ setPointer'_pyCapsuleIsValidpyCapsuleImportpyCapsuleGetName pyErrOccurredpyCapsuleGetContext pyErrClearpyCapsuleGetPointer capsuleType'_$fConcreteCapsule$fObjectCapsule pyCellSet pyCellGet pyCellNew cellType'_$fConcreteCell $fObjectCell codeType'_$fConcreteCode $fObjectCodepyComplexImagAsDoublepyComplexRealAsDoublepyComplexFromDoubles complexType'_$fConcreteComplex$fObjectComplexmergeFromSeq2'_update'_merge'_size'_values'_keys'_items'_ deleteItem'_ setItem'_pyDictGetItemWithErrorcopy'_ contains'_clear'_new'_dictionaryType'_$fConcreteDictionary fromFloat'_ toFloat'_ floatType'_$fConcreteFloat $fObjectFloat function'_instanceMethodType'_$fConcreteInstanceMethod$fObjectInstanceMethodcallableIteratorNew'_sequenceIteratorNew'_callableIteratorType'_sequenceIteratorType'_$fConcreteCallableIterator$fObjectCallableIterator$fIteratorCallableIterator$fConcreteSequenceIterator$fObjectSequenceIterator$fIteratorSequenceIteratorself'_ methodType'_$fConcreteMethod$fObjectMethodpySliceGetIndicesEx pySliceNew sliceType'_$fConcreteSlice $fObjectSlicepyTupleSetItem getSlice'_ getItem'_hscpython_peek_tuple pyTupleSizehscpython_poke_tuple tupleType'_$fConcreteTuple toTuple'_ reverse'_sort'_pyListSetSliceinsert'_ pyListSetItemhscpython_peek_list pyListSizehscpython_poke_list listType'_$fConcreteListpop'_ discard'_add'_iterableToFrozenSet'_iterableToSet'_frozenSetType'_ setType'_$fAnySetFrozenSet $fAnySetSet$fConcreteFrozenSet$fObjectFrozenSet $fConcreteSet $fObjectSet isSubtype'_ typeType'_$fConcreteTypeformat'_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$fConcreteUnicode$fObjectUnicode getObject'_pyWeakrefNewProxypyWeakrefNewRef $fObjectProxy$fObjectReference rawFalse'_ rawTrue'_ rawNone'_false'_true'_none'_rawNonerawTruerawFalsesetAnnotations'_getAnnotations'_ setClosure'_ getClosure'_ setDefaults'_ getDefaults'_ getModule'_ getGlobals'_ getCode'_functionType'_withNullableObjectpeekNullableObject$fConcreteFunction$fObjectFunctionHSCPythonComparisonEnum HSCPYTHON_GE HSCPYTHON_GT HSCPYTHON_NE HSCPYTHON_EQ HSCPYTHON_LE HSCPYTHON_LT getIterator'_dir'_hash'_toBool'_ richCompare'_ pyObjectCall callable'_bytes'_string'_ascii'_repr'_deleteAttribute'_setAttribute'_getAttribute'_hasAttribute'_ isSubclass'_ isInstance'_ getType'_comparisonToInt$fEnumHSCPythonComparisonEnumpyLongAsLongAndOverflowpyLongFromStringpyLongFromLongLong integerType'_$fConcreteInteger$fObjectIntegerreload'_pyImportImportpyModuleAddObjectpyModuleGetFilenamepyModuleGetNamegetDictionary'_ moduleType'_$fConcreteModule$fObjectModule pyIterNexthscpythonPyIterCheckhasKey'_pyMappingCheck$fMappingDictionarytoBase'_ 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'_ pyNumberCheckunsafeCastToNumber$fNumberFrozenSet $fNumberSet$fNumberComplex $fNumberFloat$fNumberInteger$fNumberSomeNumber$fObjectSomeNumberfast'_toList'_index'_count'_ deleteSlice'_ setSlice'_inPlaceRepeat'_inPlaceAppend'_repeat'_pySequenceCheck$fSequenceUnicode$fSequenceTuple$fSequenceList$fSequenceBytes$fSequenceByteArraygetFunctionDescription'_getFunctionName'_pyEvalGetFramepyEvalGetGlobalspyEvalGetLocals getBuiltins'_resetWarnOptions'_pySysSetObjectpySysGetObject pySysSetPathpySysAddWarnOption ThreadStategetBuildInfo'_ getCompiler'_getCopyright'_ getPlatform'_ getVersion'_pyEndInterpreterpyNewInterpreter finalize'_isInitialized'_ initialize'_cSetPythonHomepyGetPythonHome pySetArgv pyGetPathpyGetProgramFullPathpyGetExecPrefix pyGetPrefixcSetProgramNamepyGetProgramName