python - an interpreted, interactive, object-oriented pro­
       gramming language


SYNOPSIS

       python [ -d ] [ -i ] [ -O ] [ -S ] [ -t ] [ -u ] [ -v ]  [
       -x ] [ -h ] [ -V ] [ -W argument ]
              [ -c command | script | - ] [ arguments ]


DESCRIPTION

       Python  is  an  interpreted,  interactive, object-oriented
       programming language that combines remarkable  power  with
       very  clear syntax.  For an introduction to programming in
       Python you are  referred  to  the  Python  Tutorial.   The
       Python  Library  Reference documents built-in and standard
       types, constants, functions  and  modules.   Finally,  the
       Python Reference Manual describes the syntax and semantics
       of the core language in (perhaps too) much detail.  (These
       documents may be located via the INTERNET RESOURCES below;
       they may be installed on your system as well.)

       Python's basic power can be extended with your own modules
       written  in C or C++.  On most systems such modules may be
       dynamically loaded.  Python is also adaptable as an exten­
       sion language for existing applications.  See the internal
       documentation for hints.

       Documentation for installed Python  modules  and  packages
       can be viewed by running the pydoc program.


COMMAND LINE OPTIONS

       -d     Turn  on parser debugging output (for wizards only,
              depending on compilation options).

       -i     When a script is passed as first argument or the -c
              option  is  used, enter interactive mode after exe­
              cuting the script or the command.  It does not read
              the  $PYTHONSTARTUP  file.   This  can be useful to
              inspect global variables or a stack  trace  when  a
              script raises an exception.

       -O     Turn  on  basic  optimizations.   This  changes the
              filename extension for  compiled  (bytecode)  files
              from  .pyc to .pyo.  Given twice, causes docstrings
              to be discarded.

       -S     Disable the import of the module site and the site-
              dependent   manipulations   of   sys.path  that  it
              entails.

       -t     Issue a warning when a source file mixes  tabs  and
              spaces  for  indentation  in  a  way  that makes it
              depend on the worth of a tab expressed  in  spaces.
              Issue an error when the option is given twice.

              unbuffered.

       -v     Print a message each time a module is  initialized,
              showing  the  place  (filename  or built-in module)
              from which it is loaded.  When given twice, print a
              message  for  each  file  that  is checked for when
              searching for a module.  Also provides  information
              on module cleanup at exit.

       -x     Skip  the  first  line  of  the  source.   This  is
              intended for a DOS specific  hack  only.   Warning:
              the  line  numbers in error messages will be off by
              one!

       -h     Prints the usage for the interpreter executable and
              exits.

       -V     Prints  the Python version number of the executable
              and exits.

       -W argument
              Warning control.  Python sometimes  prints  warning
              message  to  sys.stderr.  A typical warning message
              has the following form: file:line:  category:  mes­
              sage.  By default, each warning is printed once for
              each source line where it occurs.  This option con­
              trols  how often warnings are printed.  Multiple -W
              options may be given; when a warning  matches  more
              than  one  option, the action for the last matching
              option  is  performed.   Invalid  -W  options   are
              ignored (a warning message is printed about invalid
              options when the first warning is  issued).   Warn­
              ings  can  also  be controlled from within a Python
              program using the warnings module.

              The simplest form of argument is one of the follow­
              ing  action  strings  (or  a  unique abbreviation):
              ignore to ignore all warnings; default  to  explic­
              itly  request  the  default behavior (printing each
              warning once per source line); all to print a warn­
              ing  each  time  it  occurs (this may generate many
              messages if a warning is triggered  repeatedly  for
              the  same  source line, e.g. inside a loop); module
              to print each warning only only the first  time  it
              occurs  in  each module; once to print each warning
              only the first time it occurs in  the  program;  or
              error  to  raise an exception instead of printing a
              warning message.

              The full form of argument  is  action:message:cate­
              gory:module:line.   Here,  action  is  as explained
              above but only applies to messages that  match  the
              remaining  fields.   Empty fields match all values;

              field  matches  the  start  of  the warning message
              printed; this match is case-insensitive.  The cate­
              gory field matches the warning category.  This must
              be a class name; the match test whether the  actual
              warning  category  of  the message is a subclass of
              the specified warning  category.   The  full  class
              name  must  be given.  The module field matches the
              (fully-qualified) module name; this match is  case-
              sensitive.  The line field matches the line number,
              where zero matches all line  numbers  and  is  thus
              equivalent to an omitted line number.

       -c command
              Specify  the command to execute (see next section).
              This terminates the option list (following  options
              are passed as arguments to the command).


INTERPRETER INTERFACE

       The  interpreter  interface  resembles  that  of  the UNIX
       shell: when called with standard input connected to a  tty
       device, it prompts for commands and executes them until an
       EOF is read; when called with a file name argument or with
       a  file  as standard input, it reads and executes a script
       from that file; when called with -c command,  it  executes
       the  Python  statement(s)  given as command.  Here command
       may contain multiple  statements  separated  by  newlines.
       Leading  whitespace  is  significant in Python statements!
       In  non-interactive  mode,  the  entire  input  is  parsed
       befored it is executed.

       If  available,  the  script  name and additional arguments
       thereafter are passed to the script in the Python variable
       sys.argv  ,  which  is  a  list of strings (you must first
       import sys to be able to access it).  If no script name is
       given,  sys.argv[0]  is  an  empty  string; if -c is used,
       sys.argv[0] contains the string '-c'.  Note  that  options
       interpreted  by  the  Python  interpreter  itself  are not
       placed in sys.argv.

       In interactive mode, the primary prompt is `>>>'; the sec­
       ond  prompt (which appears when a command is not complete)
       is `...'.  The prompts can be  changed  by  assignment  to
       sys.ps1  or  sys.ps2.  The interpreter quits when it reads
       an EOF at a prompt.  When an unhandled exception occurs, a
       stack  trace is printed and control returns to the primary
       prompt; in non-interactive  mode,  the  interpreter  exits
       after  printing  the  stack  trace.   The interrupt signal
       raises the KeyboardInterrupt exception; other UNIX signals
       are  not caught (except that SIGPIPE is sometimes ignored,
       in favor of the IOError exception).   Error  messages  are
       written to stderr.

       These are subject to difference depending on local instal­
       lation  conventions;  ${prefix}  and  ${exec_prefix}   are
       installation-dependent  and  should  be interpreted as for
       GNU software; they may be the same.  The default for  both
       is /usr/local.

       ${exec_prefix}/bin/python
              Recommended location of the interpreter.

       ${prefix}/lib/python<version>
       ${exec_prefix}/lib/python<version>
              Recommended locations of the directories containing
              the standard modules.

       ${prefix}/include/python<version>
       ${exec_prefix}/include/python<version>
              Recommended locations of the directories containing
              the  include  files  needed  for  developing Python
              extensions and embedding the interpreter.

       ~/.pythonrc.py
              User-specific initialization  file  loaded  by  the
              user  module; not used by default or by most appli­
              cations.


ENVIRONMENT VARIABLES

       PYTHONHOME
              Change  the  location  of   the   standard   Python
              libraries.   By default, the libraries are searched
              in  ${prefix}/lib/python<version>  and  ${exec_pre­
              fix}/lib/python<version>,   where   ${prefix}   and
              ${exec_prefix} are installation-dependent  directo­
              ries, both defaulting to /usr/local.  When $PYTHON­
              HOME is  set  to  a  single  directory,  its  value
              replaces  both  ${prefix}  and  ${exec_prefix}.  To
              specify different values for these, set $PYTHONHOME
              to ${prefix}:${exec_prefix}.

       PYTHONPATH
              Augments  the default search path for module files.
              The format is the same as the shell's $PATH: one or
              more directory pathnames separated by colons.  Non-
              existant directories  are  silently  ignored.   The
              default  search path is installation dependent, but
              generally begins with ${prefix}/lib/python<version>
              (see PYTHONHOME above).  The default search path is
              always appended to $PYTHONPATH.  If a script  argu­
              ment  is given, the directory containing the script
              is inserted in the path in  front  of  $PYTHONPATH.
              The  search  path  can be manipulated from within a
              Python program as the variable sys.path .

              If this is the name of a readable file, the  Python
              commands in that file are executed before the first
              prompt is displayed in interactive mode.  The  file
              is  executed  in the same name space where interac­
              tive commands are executed so that objects  defined
              or imported in it can be used without qualification
              in the interactive session.  You  can  also  change
              the prompts sys.ps1 and sys.ps2 in this file.

       PYTHONDEBUG
              If  this is set to a non-empty string it is equiva­
              lent to specifying the -d option.

       PYTHONINSPECT
              If this is set to a non-empty string it is  equiva­
              lent to specifying the -i option.

       PYTHONUNBUFFERED
              If  this is set to a non-empty string it is equiva­
              lent to specifying the -u option.

       PYTHONVERBOSE
              If this is set to a non-empty string it is  equiva­
              lent to specifying the -v option.


AUTHOR

       Guido van Rossum

       E-mail: guido@python.org

       And a cast of thousands.


INTERNET RESOURCES

       Main website: http://www.python.org
       Community website: http://starship.python.net
       Developer resources:
         http://sourceforge.net/project/?group_id=5470
       FTP: ftp://ftp.python.org/pub/python
       Module repository: http://www.vex.net/parnassus/
       Newsgroups: comp.lang.python, comp.lang.python.announce


LICENSING

       Python  is  distributed under an Open Source license.  See
       the file "LICENSE" in the Python source  distribution  for
       information on terms & conditions for accessing and other­
       wise using Python and for a DISCLAIMER OF ALL  WARRANTIES.


Man(1) output converted with man2html