diff options
Diffstat (limited to 'Doc/ref6.tex')
| -rw-r--r-- | Doc/ref6.tex | 511 |
1 files changed, 0 insertions, 511 deletions
diff --git a/Doc/ref6.tex b/Doc/ref6.tex deleted file mode 100644 index e05d83c..0000000 --- a/Doc/ref6.tex +++ /dev/null @@ -1,511 +0,0 @@ -\chapter{Simple statements} -\indexii{simple}{statement} - -Simple statements are comprised within a single logical line. -Several simple statements may occur on a single line separated -by semicolons. The syntax for simple statements is: - -\begin{verbatim} -simple_stmt: expression_stmt - | assignment_stmt - | pass_stmt - | del_stmt - | print_stmt - | return_stmt - | raise_stmt - | break_stmt - | continue_stmt - | import_stmt - | global_stmt - | exec_stmt -\end{verbatim} - -\section{Expression statements} -\indexii{expression}{statement} - -Expression statements are used (mostly interactively) to compute and -write a value, or (usually) to call a procedure (a function that -returns no meaningful result; in Python, procedures return the value -\code{None}): - -\begin{verbatim} -expression_stmt: condition_list -\end{verbatim} - -An expression statement evaluates the condition list (which may be a -single condition). -\indexii{expression}{list} - -In interactive mode, if the value is not \code{None}, it is converted -to a string using the rules for string conversions (expressions in -reverse quotes), and the resulting string is written to standard -output (see section \ref{print}) on a line by itself. -(The exception for \code{None} is made so that procedure calls, which -are syntactically equivalent to expressions, do not cause any output.) -\ttindex{None} -\indexii{string}{conversion} -\index{output} -\indexii{standard}{output} -\indexii{writing}{values} -\indexii{procedure}{call} - -\section{Assignment statements} -\indexii{assignment}{statement} - -Assignment statements are used to (re)bind names to values and to -modify attributes or items of mutable objects: -\indexii{binding}{name} -\indexii{rebinding}{name} -\obindex{mutable} -\indexii{attribute}{assignment} - -\begin{verbatim} -assignment_stmt: (target_list "=")+ expression_list -target_list: target ("," target)* [","] -target: identifier | "(" target_list ")" | "[" target_list "]" - | attributeref | subscription | slicing -\end{verbatim} - -(See section \ref{primaries} for the syntax definitions for the last -three symbols.) - -An assignment statement evaluates the expression list (remember that -this can be a single expression or a comma-separated list, the latter -yielding a tuple) and assigns the single resulting object to each of -the target lists, from left to right. -\indexii{expression}{list} - -Assignment is defined recursively depending on the form of the target -(list). When a target is part of a mutable object (an attribute -reference, subscription or slicing), the mutable object must -ultimately perform the assignment and decide about its validity, and -may raise an exception if the assignment is unacceptable. The rules -observed by various types and the exceptions raised are given with the -definition of the object types (see section \ref{types}). -\index{target} -\indexii{target}{list} - -Assignment of an object to a target list is recursively defined as -follows. -\indexiii{target}{list}{assignment} - -\begin{itemize} -\item -If the target list is a single target: the object is assigned to that -target. - -\item -If the target list is a comma-separated list of targets: the object -must be a tuple with the same number of items as the list contains -targets, and the items are assigned, from left to right, to the -corresponding targets. - -\end{itemize} - -Assignment of an object to a single target is recursively defined as -follows. - -\begin{itemize} % nested - -\item -If the target is an identifier (name): - -\begin{itemize} - -\item -If the name does not occur in a \keyword{global} statement in the current -code block: the name is bound to the object in the current local name -space. -\stindex{global} - -\item -Otherwise: the name is bound to the object in the current global name -space. - -\end{itemize} % nested - -The name is rebound if it was already bound. - -\item -If the target is a target list enclosed in parentheses: the object is -assigned to that target list as described above. - -\item -If the target is a target list enclosed in square brackets: the object -must be a list with the same number of items as the target list -contains targets, and its items are assigned, from left to right, to -the corresponding targets. - -\item -If the target is an attribute reference: The primary expression in the -reference is evaluated. It should yield an object with assignable -attributes; if this is not the case, \exception{TypeError} is raised. That -object is then asked to assign the assigned object to the given -attribute; if it cannot perform the assignment, it raises an exception -(usually but not necessarily \exception{AttributeError}). -\indexii{attribute}{assignment} - -\item -If the target is a subscription: The primary expression in the -reference is evaluated. It should yield either a mutable sequence -(list) object or a mapping (dictionary) object. Next, the subscript -expression is evaluated. -\indexii{subscription}{assignment} -\obindex{mutable} - -If the primary is a mutable sequence object (a list), the subscript -must yield a plain integer. If it is negative, the sequence's length -is added to it. The resulting value must be a nonnegative integer -less than the sequence's length, and the sequence is asked to assign -the assigned object to its item with that index. If the index is out -of range, \exception{IndexError} is raised (assignment to a subscripted -sequence cannot add new items to a list). -\obindex{sequence} -\obindex{list} - -If the primary is a mapping (dictionary) object, the subscript must -have a type compatible with the mapping's key type, and the mapping is -then asked to create a key/datum pair which maps the subscript to -the assigned object. This can either replace an existing key/value -pair with the same key value, or insert a new key/value pair (if no -key with the same value existed). -\obindex{mapping} -\obindex{dictionary} - -\item -If the target is a slicing: The primary expression in the reference is -evaluated. It should yield a mutable sequence object (e.g. a list). The -assigned object should be a sequence object of the same type. Next, -the lower and upper bound expressions are evaluated, insofar they are -present; defaults are zero and the sequence's length. The bounds -should evaluate to (small) integers. If either bound is negative, the -sequence's length is added to it. The resulting bounds are clipped to -lie between zero and the sequence's length, inclusive. Finally, the -sequence object is asked to replace the slice with the items of the -assigned sequence. The length of the slice may be different from the -length of the assigned sequence, thus changing the length of the -target sequence, if the object allows it. -\indexii{slicing}{assignment} - -\end{itemize} - -(In the current implementation, the syntax for targets is taken -to be the same as for expressions, and invalid syntax is rejected -during the code generation phase, causing less detailed error -messages.) - -WARNING: Although the definition of assignment implies that overlaps -between the left-hand side and the right-hand side are `safe' (e.g. -\code{a, b = b, a} swaps two variables), overlaps within the -collection of assigned-to variables are not safe! For instance, the -following program prints \code{[0, 2]}: - -\begin{verbatim} -x = [0, 1] -i = 0 -i, x[i] = 1, 2 -print x -\end{verbatim} - - -\section{The \keyword{pass} statement} -\stindex{pass} - -\begin{verbatim} -pass_stmt: "pass" -\end{verbatim} - -\keyword{pass} is a null operation --- when it is executed, nothing -happens. It is useful as a placeholder when a statement is -required syntactically, but no code needs to be executed, for example: -\indexii{null}{operation} - -\begin{verbatim} -def f(arg): pass # a function that does nothing (yet) - -class C: pass # a class with no methods (yet) -\end{verbatim} - -\section{The \keyword{del} statement} -\stindex{del} - -\begin{verbatim} -del_stmt: "del" target_list -\end{verbatim} - -Deletion is recursively defined very similar to the way assignment is -defined. Rather that spelling it out in full details, here are some -hints. -\indexii{deletion}{target} -\indexiii{deletion}{target}{list} - -Deletion of a target list recursively deletes each target, from left -to right. - -Deletion of a name removes the binding of that name (which must exist) -from the local or global name space, depending on whether the name -occurs in a \keyword{global} statement in the same code block. -\stindex{global} -\indexii{unbinding}{name} - -Deletion of attribute references, subscriptions and slicings -is passed to the primary object involved; deletion of a slicing -is in general equivalent to assignment of an empty slice of the -right type (but even this is determined by the sliced object). -\indexii{attribute}{deletion} - -\section{The \keyword{print} statement} \label{print} -\stindex{print} - -\begin{verbatim} -print_stmt: "print" [ condition ("," condition)* [","] ] -\end{verbatim} - -\keyword{print} evaluates each condition in turn and writes the resulting -object to standard output (see below). If an object is not a string, -it is first converted to a string using the rules for string -conversions. The (resulting or original) string is then written. A -space is written before each object is (converted and) written, unless -the output system believes it is positioned at the beginning of a -line. This is the case: (1) when no characters have yet been written -to standard output; or (2) when the last character written to standard -output is \character{\\n}; or (3) when the last write operation on standard -output was not a \keyword{print} statement. (In some cases it may be -functional to write an empty string to standard output for this -reason.) -\index{output} -\indexii{writing}{values} - -A \character{\\n} character is written at the end, unless the \keyword{print} -statement ends with a comma. This is the only action if the statement -contains just the keyword \keyword{print}. -\indexii{trailing}{comma} -\indexii{newline}{suppression} - -Standard output is defined as the file object named \code{stdout} -in the built-in module \module{sys}. If no such object exists, -or if it is not a writable file, a \exception{RuntimeError} exception is raised. -(The original implementation attempts to write to the system's original -standard output instead, but this is not safe, and should be fixed.) -\indexii{standard}{output} -\refbimodindex{sys} -\ttindex{stdout} -\exindex{RuntimeError} - -\section{The \keyword{return} statement} -\stindex{return} - -\begin{verbatim} -return_stmt: "return" [condition_list] -\end{verbatim} - -\keyword{return} may only occur syntactically nested in a function -definition, not within a nested class definition. -\indexii{function}{definition} -\indexii{class}{definition} - -If a condition list is present, it is evaluated, else \code{None} -is substituted. - -\keyword{return} leaves the current function call with the condition -list (or \code{None}) as return value. - -When \keyword{return} passes control out of a \keyword{try} statement -with a finally clause, that finally clause is executed -before really leaving the function. -\kwindex{finally} - -\section{The \keyword{raise} statement} -\stindex{raise} - -\begin{verbatim} -raise_stmt: "raise" condition ["," condition ["," condition]] -\end{verbatim} - -\keyword{raise} evaluates its first condition, which must yield -a string, class, or instance object. If there is a second condition, -this is evaluated, else \code{None} is substituted. If the first -condition is a class object, then the second condition must be an -instance of that class or one of its derivatives. If the first -condition is an instance object, the second condition must be -\code{None}. -\index{exception} -\indexii{raising}{exception} - -If the first object is a class or string, it then raises the exception -identified by the first object, with the second one (or \code{None}) -as its parameter. If the first object is an instance, it raises the -exception identified by the class of the object, with the instance as -its parameter (and there should be no second object, or the second -object should be \code{None}). - -If a third object is present, and it it not \code{None}, it should be -a traceback object (see section \ref{traceback}), and it is -substituted instead of the current location as the place where the -exception occurred. This is useful to re-raise an exception -transparently in an except clause. -\obindex{traceback} - -\section{The \keyword{break} statement} -\stindex{break} - -\begin{verbatim} -break_stmt: "break" -\end{verbatim} - -\keyword{break} may only occur syntactically nested in a \keyword{for} -or \keyword{while} loop, but not nested in a function or class definition -within that loop. -\stindex{for} -\stindex{while} -\indexii{loop}{statement} - -It terminates the nearest enclosing loop, skipping the optional -else clause if the loop has one. -\kwindex{else} - -If a \keyword{for} loop is terminated by \keyword{break}, the loop control -target keeps its current value. -\indexii{loop control}{target} - -When \keyword{break} passes control out of a \keyword{try} statement -with a finally clause, that finally clause is executed -before really leaving the loop. -\kwindex{finally} - -\section{The \keyword{continue} statement} -\stindex{continue} - -\begin{verbatim} -continue_stmt: "continue" -\end{verbatim} - -\keyword{continue} may only occur syntactically nested in a \keyword{for} or -\keyword{while} loop, but not nested in a function or class definition or -\keyword{try} statement within that loop.\footnote{Except that it may -currently occur within an except clause.} -\stindex{for} -\stindex{while} -\indexii{loop}{statement} -\kwindex{finally} - -It continues with the next cycle of the nearest enclosing loop. - -\section{The \keyword{import} statement} \label{import} -\stindex{import} - -\begin{verbatim} -import_stmt: "import" identifier ("," identifier)* - | "from" identifier "import" identifier ("," identifier)* - | "from" identifier "import" "*" -\end{verbatim} - -Import statements are executed in two steps: (1) find a module, and -initialize it if necessary; (2) define a name or names in the local -name space (of the scope where the \keyword{import} statement occurs). -The first form (without \keyword{from}) repeats these steps for each -identifier in the list, the \keyword{from} form performs them once, with -the first identifier specifying the module name. -\indexii{importing}{module} -\indexii{name}{binding} -\kwindex{from} - -The system maintains a table of modules that have been initialized, -indexed by module name. (The current implementation makes this table -accessible as \code{sys.modules}.) When a module name is found in -this table, step (1) is finished. If not, a search for a module -definition is started. This first looks for a built-in module -definition, and if no built-in module if the given name is found, it -searches a user-specified list of directories for a file whose name is -the module name with extension \file{.py}. (The current -implementation uses the list of strings \code{sys.path} as the search -path; it is initialized from the shell environment variable -\envvar{PYTHONPATH}, with an installation-dependent default.) -\ttindex{modules} -\ttindex{sys.modules} -\indexii{module}{name} -\indexii{built-in}{module} -\indexii{user-defined}{module} -\refbimodindex{sys} -\indexii{filename}{extension} -\indexiii{module}{search}{path} - -If a built-in module is found, its built-in initialization code is -executed and step (1) is finished. If no matching file is found, -\exception{ImportError} is raised. If a file is found, it is parsed, -yielding an executable code block. If a syntax error occurs, -\exception{SyntaxError} is raised. Otherwise, an empty module of the given -name is created and inserted in the module table, and then the code -block is executed in the context of this module. Exceptions during -this execution terminate step (1). -\indexii{module}{initialization} -\exindex{SyntaxError} -\exindex{ImportError} -\index{code block} - -When step (1) finishes without raising an exception, step (2) can -begin. - -The first form of \keyword{import} statement binds the module name in the -local name space to the module object, and then goes on to import the -next identifier, if any. The \keyword{from} from does not bind the -module name: it goes through the list of identifiers, looks each one -of them up in the module found in step (1), and binds the name in the -local name space to the object thus found. If a name is not found, -\exception{ImportError} is raised. If the list of identifiers is replaced -by a star (\code{*}), all names defined in the module are bound, -except those beginning with an underscore(\code{_}). -\indexii{name}{binding} -\exindex{ImportError} - -Names bound by import statements may not occur in \keyword{global} -statements in the same scope. -\stindex{global} - -The \keyword{from} form with \code{*} may only occur in a module scope. -\kwindex{from} -\ttindex{from ... import *} - -(The current implementation does not enforce the latter two -restrictions, but programs should not abuse this freedom, as future -implementations may enforce them or silently change the meaning of the -program.) - -\section{The \keyword{global} statement} \label{global} -\stindex{global} - -\begin{verbatim} -global_stmt: "global" identifier ("," identifier)* -\end{verbatim} - -The \keyword{global} statement is a declaration which holds for the -entire current code block. It means that the listed identifiers are to be -interpreted as globals. While \emph{using} global names is automatic -if they are not defined in the local scope, \emph{assigning} to global -names would be impossible without \keyword{global}. -\indexiii{global}{name}{binding} - -Names listed in a \keyword{global} statement must not be used in the same -code block before that \keyword{global} statement is executed. - -Names listed in a \keyword{global} statement must not be defined as formal -parameters or in a \keyword{for} loop control target, \keyword{class} -definition, function definition, or \keyword{import} statement. - -(The current implementation does not enforce the latter two -restrictions, but programs should not abuse this freedom, as future -implementations may enforce them or silently change the meaning of the -program.) - -Note: the \keyword{global} is a directive to the parser. Therefore, it -applies only to code parsed at the same time as the \keyword{global} -statement. In particular, a \keyword{global} statement contained in an -\keyword{exec} statement does not affect the code block \emph{containing} -the \keyword{exec} statement, and code contained in an \keyword{exec} -statement is unaffected by \keyword{global} statements in the code -containing the \keyword{exec} statement. The same applies to the -\function{eval()}, \function{execfile()} and \function{compile()} functions. -\stindex{exec} -\bifuncindex{eval} -\bifuncindex{execfile} -\bifuncindex{compile} |