diff options
Diffstat (limited to 'Doc/ref6.tex')
| -rw-r--r-- | Doc/ref6.tex | 512 |
1 files changed, 0 insertions, 512 deletions
diff --git a/Doc/ref6.tex b/Doc/ref6.tex deleted file mode 100644 index 5bd468c..0000000 --- a/Doc/ref6.tex +++ /dev/null @@ -1,512 +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 -\verb@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 \verb@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 \verb@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 \verb@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, \verb@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 \verb@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, \verb@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. -\verb@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 {\tt pass} statement} -\stindex{pass} - -\begin{verbatim} -pass_stmt: "pass" -\end{verbatim} - -\verb@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 {\tt 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 \verb@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 {\tt print} statement} \label{print} -\stindex{print} - -\begin{verbatim} -print_stmt: "print" [ condition ("," condition)* [","] ] -\end{verbatim} - -\verb@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 \verb/\n/; or (3) when the last write operation on standard -output was not a \verb@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 \verb/"\n"/ character is written at the end, unless the \verb@print@ -statement ends with a comma. This is the only action if the statement -contains just the keyword \verb@print@. -\indexii{trailing}{comma} -\indexii{newline}{suppression} - -Standard output is defined as the file object named \verb@stdout@ -in the built-in module \verb@sys@. If no such object exists, -or if it is not a writable file, a \verb@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} -\bimodindex{sys} -\ttindex{stdout} -\exindex{RuntimeError} - -\section{The {\tt return} statement} -\stindex{return} - -\begin{verbatim} -return_stmt: "return" [condition_list] -\end{verbatim} - -\verb@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 \verb@None@ -is substituted. - -\verb@return@ leaves the current function call with the condition -list (or \verb@None@) as return value. - -When \verb@return@ passes control out of a \verb@try@ statement -with a \verb@finally@ clause, that finally clause is executed -before really leaving the function. -\kwindex{finally} - -\section{The {\tt raise} statement} -\stindex{raise} - -\begin{verbatim} -raise_stmt: "raise" condition ["," condition ["," condition]] -\end{verbatim} - -\verb@raise@ evaluates its first condition, which must yield -a string, class, or instance object. If there is a second condition, -this is evaluated, else \verb@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 -\verb@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 \verb@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 \verb@None@). - -If a third object is present, and it it not \verb@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 {\tt break} statement} -\stindex{break} - -\begin{verbatim} -break_stmt: "break" -\end{verbatim} - -\verb@break@ may only occur syntactically nested in a \verb@for@ -or \verb@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 -\verb@else@ clause if the loop has one. -\kwindex{else} - -If a \verb@for@ loop is terminated by \verb@break@, the loop control -target keeps its current value. -\indexii{loop control}{target} - -When \verb@break@ passes control out of a \verb@try@ statement -with a \verb@finally@ clause, that finally clause is executed -before really leaving the loop. -\kwindex{finally} - -\section{The {\tt continue} statement} -\stindex{continue} - -\begin{verbatim} -continue_stmt: "continue" -\end{verbatim} - -\verb@continue@ may only occur syntactically nested in a \verb@for@ or -\verb@while@ loop, but not nested in a function or class definition or -\verb@try@ statement within that loop.\footnote{Except that it may -currently occur within an {\tt except} clause.} -\stindex{for} -\stindex{while} -\indexii{loop}{statement} -\kwindex{finally} - -It continues with the next cycle of the nearest enclosing loop. - -\section{The {\tt 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 \verb@import@ statement occurs). -The first form (without \verb@from@) repeats these steps for each -identifier in the list, the \verb@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 \verb@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 \verb@".py"@. (The current -implementation uses the list of strings \verb@sys.path@ as the search -path; it is initialized from the shell environment variable -\verb@$PYTHONPATH@, with an installation-dependent default.) -\ttindex{modules} -\ttindex{sys.modules} -\indexii{module}{name} -\indexii{built-in}{module} -\indexii{user-defined}{module} -\bimodindex{sys} -\ttindex{path} -\ttindex{sys.path} -\indexii{filename}{extension} - -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, -\verb@ImportError@ is raised. If a file is found, it is parsed, -yielding an executable code block. If a syntax error occurs, -\verb@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 \verb@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 \verb@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, -\verb@ImportError@ is raised. If the list of identifiers is replaced -by a star (\verb@*@), all names defined in the module are bound, -except those beginning with an underscore(\verb@_@). -\indexii{name}{binding} -\exindex{ImportError} - -Names bound by import statements may not occur in \verb@global@ -statements in the same scope. -\stindex{global} - -The \verb@from@ form with \verb@*@ 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 {\tt global} statement} \label{global} -\stindex{global} - -\begin{verbatim} -global_stmt: "global" identifier ("," identifier)* -\end{verbatim} - -The \verb@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 {\em using} global names is automatic -if they are not defined in the local scope, {\em assigning} to global -names would be impossible without \verb@global@. -\indexiii{global}{name}{binding} - -Names listed in a \verb@global@ statement must not be used in the same -code block before that \verb@global@ statement is executed. - -Names listed in a \verb@global@ statement must not be defined as formal -parameters or in a \verb@for@ loop control target, \verb@class@ -definition, function definition, or \verb@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 \verb@global@ is a directive to the parser. Therefore, it -applies only to code parsed at the same time as the \verb@global@ -statement. In particular, a \verb@global@ statement contained in an -\verb@exec@ statement does not affect the code block {\em containing} -the \verb@exec@ statement, and code contained in an \verb@exec@ -statement is unaffected by \verb@global@ statements in the code -containing the \verb@exec@ statement. The same applies to the -\verb@eval()@, \verb@execfie()@ and \verb@compile()@ functions. -\stindex{exec} -\ttindex{eval} -\ttindex{execfile} -\ttindex{compile} |