This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter. It is always available.
argv[0] is the script name (it is operating system dependent
  whether this is a full pathname or not).  If the command was
  executed using the -c command line option to the
  interpreter, argv[0] is set to the string '-c'.  If no
  script name was passed to the Python interpreter, argv has
  zero length.
'big' on big-endian (most-signigicant byte first) platforms,
  and 'little' on little-endian (least-significant byte first)
  platforms.
  
New in version 2.0.
modules.keys() only lists the imported
  modules.)
| value) | 
None, this function prints it to
  sys.stdout, and saves it in __builtin__._.
sys.displayhook is called on the result of evaluating an
  expression entered in an interactive Python session.  The display of
  these values can be customized by assigning another one-argument
  function to sys.displayhook.
| type, value, traceback) | 
sys.stderr.
When an exception is raised and uncaught, the interpreter calls
  sys.excepthook with three arguments, the exception class,
  exception instance, and a traceback object.  In an interactive
  session this happens just before control is returned to the prompt;
  in a Python program this happens just before the program exits.  The
  handling of such top-level exceptions can be customized by assigning
  another three-argument function to sys.excepthook.
displayhook and
  excepthook at the start of the program.  They are saved so
  that displayhook and excepthook can be restored in
  case they happen to get replaced with broken objects.
| ) | 
If no exception is being handled anywhere on the stack, a tuple
  containing three None values is returned.  Otherwise, the
  values returned are (type, value,
  traceback).  Their meaning is: type gets the exception
  type of the exception being handled (a class object);
  value gets the exception parameter (its associated value
  or the second argument to raise, which is always a class
  instance if the exception type is a class object); traceback
  gets a traceback object (see the Reference Manual) which
  encapsulates the call stack at the point where the exception
  originally occurred.  
If exc_clear() is called, this function will return three
  None values until either another exception is raised in the
  current thread or the execution stack returns to a frame where
  another exception is being handled.
Warning:
Assigning the traceback return value to a
  local variable in a function that is handling an exception will
  cause a circular reference.  This will prevent anything referenced
  by a local variable in the same function or by the traceback from
  being garbage collected.  Since most functions don't need access to
  the traceback, the best solution is to use something like
  exctype, value = sys.exc_info()[:2] to extract only the
  exception type and value.  If you do need the traceback, make sure
  to delete it after use (best done with a try
  ... finally statement) or to call exc_info() in
  a function that does not itself handle an exception. Note:
Beginning
  with Python 2.2, such cycles are automatically reclaimed when garbage
  collection is enabled and they become unreachable, but it remains more
  efficient to avoid creating cycles.
| ) | 
None values until
  another exception is raised in the current thread or the execution stack
  returns to a frame where another exception is being handled.
This function is only needed in only a few obscure situations. These include logging and error handling systems that report information on the last or current exception. This function can also be used to try to free resources and trigger object finalization, though no guarantee is made as to what objects will be freed, if any. New in version 2.3.
exc_type is set
  to None and the other two are undefined.
'/usr/local'.  This can be set at build time with the
  --exec-prefix argument to the configure
  script.  Specifically, all configuration files (e.g. the
  pyconfig.h header file) are installed in the directory
  exec_prefix + '/lib/pythonversion/config', and shared
  library modules are installed in exec_prefix +
  '/lib/pythonversion/lib-dynload', where version is
  equal to version[:3].
| [arg]) | 
None is equivalent to
  passing zero, and any other object is printed to sys.stderr
  and results in an exit code of 1.  In particular,
  sys.exit("some error message") is a quick way to exit a
  program when an error occurs.
os._exit() is called.
  
| ) | 
| ) | 
| ) | 
| ) | 
None if the system default encoding
  is used. The result value depends on the operating system:
getfilesystemencoding still returns ``mbcs'',
      as this is the encoding that applications should use when they
      explicitly want to convert Unicode strings to byte strings that
      are equivalent when used as file names.
| object) | 
| ) | 
| [depth]) | 
This function should be used for internal and specialized purposes only.
| ) | 
platform may be one of the following values:
| Constant | Platform | 
|---|---|
| 0 (VER_PLATFORM_WIN32s) | Win32s on Windows 3.1 | 
| 1 (VER_PLATFORM_WIN32_WINDOWS) | Windows 95/98/ME | 
| 2 (VER_PLATFORM_WIN32_NT) | Windows NT/2000/XP | 
| 3 (VER_PLATFORM_WIN32_CE) | Windows CE | 
This function wraps the Win32 GetVersionEx() function; see the Microsoft documentation for more information about these fields.
Availability: Windows. New in version 2.3.
if sys.hexversion >= 0x010502F0:
    # use some advanced feature
    ...
else:
    # use an alternative implementation or warn the user
    ...
This is called "hexversion" since it only really looks
  meaningful when viewed as the result of passing it to the built-in
  hex() function.  The version_info value may be
  used for a more human-friendly encoding of the same information.
  
New in version 1.5.2.
The meaning of the variables is the same as that of the return
  values from exc_info() above.  (Since there is only one
  interactive thread, thread-safety is not a concern for these
  variables, unlike for exc_type etc.)
-maxint-1 -- the asymmetry results from the use of 2's
  complement binary arithmetic.
As initialized upon program startup,
  the first item of this list, path[0], is the directory
  containing the script that was used to invoke the Python
  interpreter.  If the script directory is not available (e.g.  if the
  interpreter is invoked interactively or if the script is read from
  standard input), path[0] is the empty string, which directs
  Python to search modules in the current directory first.  Notice
  that the script directory is inserted before the entries
  inserted as a result of PYTHONPATH.
A program is free to modify this list for its own purposes.
Changed in version 2.3: Unicode strings are no longer ignored.
'sunos5' or
  'linux1'.  This can be used to append platform-specific
  components to path, for instance.
'/usr/local'.  This can be set at build time with
  the --prefix argument to the configure
  script.  The main collection of Python library modules is installed
  in the directory prefix + '/lib/pythonversion' while
  the platform independent header files (all except pyconfig.h)
  are stored in prefix + '/include/pythonversion', where
  version is equal to version[:3].
'>>> ' and '... '.  If a non-string object is
  assigned to either variable, its str() is re-evaluated
  each time the interpreter prepares to read a new interactive
  command; this can be used to implement a dynamic prompt.
| interval) | 
100,
  meaning the check is performed every 100 Python virtual instructions.
  Setting it to a larger value may increase performance for programs
  using threads.  Setting it to a value <= 0 checks every
  virtual instruction, maximizing responsiveness as well as overhead.
| name) | 
| n) | 
sys.setdlopenflags(0).  To
  share symbols across extension modules, call as
  sys.setdlopenflags(dl.RTLD_NOW | dl.RTLD_GLOBAL).  Symbolic
  names for the flag modules can be either found in the dl
  module, or in the DLFCN module. If DLFCN is not
  available, it can be generated from /usr/include/dlfcn.h
  using the h2py script.
  Availability: Unix.
  
New in version 2.2.
| profilefunc) | 
None.
| limit) | 
The highest possible limit is platform-dependent. A user may need to set the limit higher when she has a program that requires deep recursion and a platform that supports a higher limit. This should be done with care, because a too-high limit can lead to a crash.
| tracefunc) | 
| on_flag) | 
stdin is used for all interpreter
  input except for scripts but including calls to
  input() and
  raw_input().  stdout is
  used for the output of print and expression statements and
  for the prompts of input() and raw_input().
  The interpreter's own prompts and (almost all of) its error messages
  go to stderr.  stdout and stderr needn't be
  built-in file objects: any object is acceptable as long as it has a
  write() method that takes a string argument.  (Changing
  these objects doesn't affect the standard I/O streams of processes
  executed by os.popen(), os.system() or the
  exec*() family of functions in the os
  module.)
stdin,
  stderr and stdout at the start of the program.  They
  are used during finalization, and could be useful to restore the
  actual files to known working file objects in case they have been
  overwritten with a broken object.
1000.  When set
  to 0 or less, all traceback information is suppressed and
  only the exception type and value are printed.
'version
  (#build_number, build_date, build_time)
  [compiler]'.  The first three characters are used to identify
  the version in the installation directories (where appropriate on
  each platform).  An example:
>>> import sys >>> sys.version '1.5.2 (#0 Apr 13 1999, 10:51:12) [MSC 32 bit (Intel)]'
'alpha', 'beta',
  'candidate', or 'final'.  The version_info
  value corresponding to the Python version 2.0 is (2, 0, 0,
  'final', 0).
  
New in version 2.0.
See Also:
sys.path.