| \chapter{Top-level components\label{top-level}} |
| |
| The Python interpreter can get its input from a number of sources: |
| from a script passed to it as standard input or as program argument, |
| typed in interactively, from a module source file, etc. This chapter |
| gives the syntax used in these cases. |
| \index{interpreter} |
| |
| \section{Complete Python programs\label{programs}} |
| \index{program} |
| |
| While a language specification need not prescribe how the language |
| interpreter is invoked, it is useful to have a notion of a complete |
| Python program. A complete Python program is executed in a minimally |
| initialized environment: all built-in and standard modules are |
| available, but none have been initialized, except for \module{sys} |
| (various system services), \module{__builtin__} (built-in functions, |
| exceptions and \code{None}) and \module{__main__}. The latter is used |
| to provide the local and global namespace for execution of the |
| complete program. |
| \refbimodindex{sys} |
| \refbimodindex{__main__} |
| \refbimodindex{__builtin__} |
| |
| The syntax for a complete Python program is that for file input, |
| described in the next section. |
| |
| The interpreter may also be invoked in interactive mode; in this case, |
| it does not read and execute a complete program but reads and executes |
| one statement (possibly compound) at a time. The initial environment |
| is identical to that of a coplete program; each statement is executed |
| in the namespace of \module{__main__}. |
| \index{interactive mode} |
| \refbimodindex{__main__} |
| |
| Under {\UNIX}, a complete program can be passed to the interpreter in |
| three forms: with the \program{-c} \var{string} command line option, as a |
| file passed as the first command line argument, or as standard input. |
| If the file or standard input is a tty device, the interpreter enters |
| interactive mode; otherwise, it executes the file as a complete |
| program. |
| \index{UNIX} |
| \index{command line} |
| \index{standard input} |
| |
| \section{File input\label{file-input}} |
| |
| All input read from non-interactive files has the same form: |
| |
| \begin{verbatim} |
| file_input: (NEWLINE | statement)* |
| \end{verbatim} |
| |
| This syntax is used in the following situations: |
| |
| \begin{itemize} |
| |
| \item when parsing a complete Python program (from a file or from a string); |
| |
| \item when parsing a module; |
| |
| \item when parsing a string passed to the \keyword{exec} statement; |
| |
| \end{itemize} |
| |
| \section{Interactive input\label{interactive}} |
| |
| Input in interactive mode is parsed using the following grammar: |
| |
| \begin{verbatim} |
| interactive_input: [stmt_list] NEWLINE | compound_stmt NEWLINE |
| \end{verbatim} |
| |
| Note that a (top-level) compound statement must be followed by a blank |
| line in interactive mode; this is needed to help the parser detect the |
| end of the input. |
| |
| \section{Expression input\label{expression-input}} |
| \index{input} |
| |
| There are two forms of expression input. Both ignore leading |
| whitespace. |
| The string argument to \function{eval()} must have the following form: |
| \bifuncindex{eval} |
| |
| \begin{verbatim} |
| eval_input: expression_list NEWLINE* |
| \end{verbatim} |
| |
| The input line read by \function{input()} must have the following form: |
| \bifuncindex{input} |
| |
| \begin{verbatim} |
| input_input: expression_list NEWLINE |
| \end{verbatim} |
| |
| Note: to read `raw' input line without interpretation, you can use the |
| built-in function \function{raw_input()} or the \method{readline()} method |
| of file objects. |
| \obindex{file} |
| \index{input!raw} |
| \index{raw input} |
| \bifuncindex{raw_input} |
| \withsubitem{(file method)}{\ttindex{readline()}} |