diff options
Diffstat (limited to 'Doc')
| -rw-r--r-- | Doc/ref/ref5.tex | 452 |
1 files changed, 292 insertions, 160 deletions
diff --git a/Doc/ref/ref5.tex b/Doc/ref/ref5.tex index 6ef2545..d0d57ec 100644 --- a/Doc/ref/ref5.tex +++ b/Doc/ref/ref5.tex @@ -1,28 +1,12 @@ -\chapter{Expressions and conditions} +\chapter{Expressions} \index{expression} -\index{condition} - -\strong{Note:} In this and the following chapters, extended BNF -notation will be used to describe syntax, not lexical analysis. -\index{BNF} - -This chapter explains the meaning of the elements of expressions and -conditions. Conditions are a superset of expressions, and a condition -may be used wherever an expression is required by enclosing it in -parentheses. The only places where expressions are used in the syntax -instead of conditions is in expression statements and on the -right-hand side of assignment statements; this catches some nasty bugs -like accidentally writing \code{x == 1} instead of \code{x = 1}. -\indexii{assignment}{statement} - -The comma plays several roles in Python's syntax. It is usually an -operator with a lower precedence than all others, but occasionally -serves other purposes as well; e.g. it separates function arguments, -is used in list and dictionary constructors, and has special semantics -in \keyword{print} statements. -\index{comma} -When (one alternative of) a syntax rule has the form +This chapter explains the meaning of the elements of expressions in +Python. + +\strong{Syntax Notes:} In this and the following chapters, extended +BNF\index{BNF} notation will be used to describe syntax, not lexical +analysis. When (one alternative of) a syntax rule has the form \begin{verbatim} name: othername @@ -36,28 +20,30 @@ are the same as for \code{othername}. \indexii{arithmetic}{conversion} When a description of an arithmetic operator below uses the phrase -``the numeric arguments are converted to a common type'', -this both means that if either argument is not a number, a -\exception{TypeError} exception is raised, and that otherwise -the following conversions are applied: -\exindex{TypeError} -\indexii{floating point}{number} -\indexii{long}{integer} -\indexii{plain}{integer} +``the numeric arguments are converted to a common type,'' the +arguments are coerced using the coercion rules listed at the end of +chapter 3. If both arguments are standard numeric types, the +following coercions are applied: \begin{itemize} -\item first, if either argument is a floating point number, +\item If either argument is a complex number, the other is converted + to complex; +\item otherwise, if either argument is a floating point number, the other is converted to floating point; -\item else, if either argument is a long integer, +\item otherwise, if either argument is a long integer, the other is converted to long integer; \item otherwise, both must be plain integers and no conversion is necessary. \end{itemize} +Some additional rules apply for certain operators (e.g. a string left +argument to the `\%' operator). Extensions can define their own +coercions. \section{Atoms} \index{atom} -Atoms are the most basic elements of expressions. Forms enclosed in +Atoms are the most basic elements of expressions. The simplest atoms +are identifiers or literals. Forms enclosed in reverse quotes or in parentheses, brackets or braces are also categorized syntactically as atoms. The syntax for atoms is: @@ -89,19 +75,37 @@ that object. When a name is not bound, an attempt to evaluate it raises a \exception{NameError} exception. \exindex{NameError} +\strong{Private name mangling:}% +\indexii{name}{mangling}% +\indexii{private}{names}% +when an identifier that textually occurs in a class definition begins +with two or more underscore characters and does not end in two or more +underscores, it is considered a ``private name'' of that class. +Private names are transformed to a longer form before code is +generated for them. The transformation inserts the class name in +front of the name, with leading underscores removed, and a single +underscore inserted in front of the class name. For example, the +identifier \code{__spam} occurring in a class named \code{Ham} will be +transformed to \code{_Ham__spam}. This transformation is independent +of the syntactical context in which the identifier is used. If the +transformed name is extremely long (longer than 255 characters), +implementation defined truncation may happen. If the class name +consists only of underscores, no transformation is done. + \subsection{Literals} \index{literal} -Python knows string and numeric literals: +Python supports string literals and various numeric literals: \begin{verbatim} -literal: stringliteral | integer | longinteger | floatnumber +literal: stringliteral | integer | longinteger | floatnumber | imagnumber \end{verbatim} Evaluation of a literal yields an object of the given type (string, -integer, long integer, floating point number) with the given value. -The value may be approximated in the case of floating point literals. -See section \ref{literals} for details. +integer, long integer, floating point number, complex number) with the +given value. The value may be approximated in the case of floating +point and imaginary (complex) literals. See section \ref{literals} +for details. All literals correspond to immutable data types, and hence the object's identity is less important than its value. Multiple @@ -109,51 +113,51 @@ evaluations of literals with the same value (either the same occurrence in the program text or a different occurrence) may obtain the same object or a different object with the same value. \indexiii{immutable}{data}{type} - -(In the original implementation, all literals in the same code block -with the same type and value yield the same object.) +\indexii{immutable}{objects} \subsection{Parenthesized forms} \index{parenthesized form} -A parenthesized form is an optional condition list enclosed in +A parenthesized form is an optional expression list enclosed in parentheses: \begin{verbatim} -parenth_form: "(" [condition_list] ")" +parenth_form: "(" [expression_list] ")" \end{verbatim} -A parenthesized condition list yields whatever that condition list -yields. +A parenthesized expression list yields whatever that expression list +yields: if the list contains at least one comma, it yields a tuple; +otherwise, it yields the single expression that makes up the +expression list. An empty pair of parentheses yields an empty tuple object. Since -tuples are immutable, the rules for literals apply here. +tuples are immutable, the rules for literals apply (i.e., two +occurrences of the empty tuple may or may not yield the same object). \indexii{empty}{tuple} -(Note that tuples are not formed by the parentheses, but rather by use +Note that tuples are not formed by the parentheses, but rather by use of the comma operator. The exception is the empty tuple, for which parentheses {\em are} required --- allowing unparenthesized ``nothing'' in expressions would cause ambiguities and allow common typos to -pass uncaught.) +pass uncaught. \index{comma} \indexii{tuple}{display} \subsection{List displays} \indexii{list}{display} -A list display is a possibly empty series of conditions enclosed in +A list display is a possibly empty series of expressions enclosed in square brackets: \begin{verbatim} -list_display: "[" [condition_list] "]" +list_display: "[" [expression_list] "]" \end{verbatim} -A list display yields a new list object. +A list display yields a new list object. If it has no expression +list, the list object has no items. Otherwise, the elements of the +expression list are evaluated from left to right and inserted in the +list object in that order. \obindex{list} - -If it has no condition list, the list object has no items. Otherwise, -the elements of the condition list are evaluated from left to right -and inserted in the list object in that order. \indexii{empty}{list} \subsection{Dictionary displays} \label{dict} @@ -168,7 +172,7 @@ enclosed in curly braces: \begin{verbatim} dict_display: "{" [key_datum_list] "}" key_datum_list: key_datum ("," key_datum)* [","] -key_datum: condition ":" condition +key_datum: expression ":" expression \end{verbatim} A dictionary display yields a new dictionary object. @@ -179,11 +183,11 @@ entries of the dictionary: each key object is used as a key into the dictionary to store the corresponding datum. Restrictions on the types of the key values are listed earlier in -section \ref{types}. -Clashes between duplicate keys are not detected; the last -datum (textually rightmost in the display) stored for a given key -value prevails. -\exindex{TypeError} +section \ref{types}. (To summarize,the key type should be hashable, +which excludes all mutable objects.) Clashes between duplicate keys +are not detected; the last datum (textually rightmost in the display) +stored for a given key value prevails. +\indexii{immutable}{objects} \subsection{String conversions} \indexii{string}{conversion} @@ -191,14 +195,14 @@ value prevails. \indexii{backward}{quotes} \index{back-quotes} -A string conversion is a condition list enclosed in reverse (or +A string conversion is an expression list enclosed in reverse (a.k.a. backward) quotes: \begin{verbatim} -string_conversion: "`" condition_list "`" +string_conversion: "`" expression_list "`" \end{verbatim} -A string conversion evaluates the contained condition list and +A string conversion evaluates the contained expression list and converts the resulting object into a string according to rules specific to its type. @@ -218,9 +222,9 @@ indirectly.) \obindex{recursive} The built-in function \function{repr()} performs exactly the same -conversion in its argument as enclosing it it reverse quotes does. -The built-in function \function{str()} performs a similar but more -user-friendly conversion. +conversion in its argument as enclosing it in parentheses and reverse +quotes does. The built-in function \function{str()} performs a +similar but more user-friendly conversion. \bifuncindex{repr} \bifuncindex{str} @@ -268,21 +272,23 @@ or mapping (dictionary) object: \indexii{sequence}{item} \begin{verbatim} -subscription: primary "[" condition "]" +subscription: primary "[" expression_list "]" \end{verbatim} The primary must evaluate to an object of a sequence or mapping type. -If it is a mapping, the condition must evaluate to an object whose -value is one of the keys of the mapping, and the subscription selects -the value in the mapping that corresponds to that key. +If the primary is a mapping, the expression list must evaluate to an +object whose value is one of the keys of the mapping, and the +subscription selects the value in the mapping that corresponds to that +key. (The expression list is a tuple except if it has exactly one +item.) -If it is a sequence, the condition must evaluate to a plain integer. -If this value is negative, the length of the sequence is added to it -(so that, e.g. \code{x[-1]} selects the last item of \code{x}.) -The resulting value must be a nonnegative integer smaller than the -number of items in the sequence, and the subscription selects the item -whose index is that value (counting from zero). +If the primary is a sequence, the expression (list) must evaluate to a +plain integer. If this value is negative, the length of the sequence +is added to it (so that, e.g., \code{x[-1]} selects the last item of +\code{x}.) The resulting value must be a nonnegative integer less +than the number of items in the sequence, and the subscription selects +the item whose index is that value (counting from zero). A string's items are characters. A character is not a separate data type but a string of exactly one character. @@ -293,53 +299,144 @@ type but a string of exactly one character. \index{slicing} \index{slice} -A slicing (or slice) selects a range of items in a sequence (string, -tuple or list) object: +A slicing selects a range of items in a sequence object (e.g., a +string, tuple or list). Slicings may be used as expressions or as +targets in assignment or del statements. The syntax for a slicing: \obindex{sequence} \obindex{string} \obindex{tuple} \obindex{list} \begin{verbatim} -slicing: primary "[" [condition] ":" [condition] "]" +slicing: simple_slicing | extended_slicing +simple_slicing: primary "[" short_slice "]" +extended_slicing: primary "[" slice_list "]" +slice_list: slice_item ("," slice_item)* [","] +slice_item: expression | proper_slice | ellipsis +proper_slice: short_slice | long_slice +short_slice: [lower_bound] ":" [upper_bound] +long_slice: short_slice ":" [stride] +lower_bound: expression +upper_bound: expression +stride: expression +ellipsis: "..." \end{verbatim} -The primary must evaluate to a sequence object. The lower and upper -bound expressions, if present, must evaluate to plain integers; -defaults are zero and the sequence's length, respectively. If either -bound is negative, the sequence's length is added to it. The slicing -now selects all items with index \var{k} such that +There is ambiguity in the formal syntax here: anything that looks like +an expression list also looks like a slice list, so any subscription +can be interpreted as a slicing. Rather than further complicating the +syntax, this is disambiguated by defining that in this case the +interpretation as a subscription takes priority over the +interpretation as a slicing (this is the case if the slice list +contains no proper slice nor ellipses). Similarly, when the slice +list has exactly one short slice and no trailing comma, the +interpretation as a simple slicing takes priority over that as an +extended slicing.\indexii{extended}{slicing} + +The semantics for a simple slicing are as follows. The primary must +evaluate to a sequence object. The lower and upper bound expressions, +if present, must evaluate to plain integers; defaults are zero and the +sequence's length, respectively. If either bound is negative, the +sequence's length is added to it. The slicing now selects all items +with index \var{k} such that \code{\var{i} <= \var{k} < \var{j}} where \var{i} and \var{j} are the specified lower and upper bounds. This may be an empty sequence. It is not an error if \var{i} or \var{j} lie outside the range of valid indexes (such items don't exist so they aren't selected). +The semantics for an extended slicing are as follows. The primary +must evaluate to a mapping object, and it is indexed with a key that +is constructed from the slice list, as follows. If the slice list +contains at least one comma, the key is a tuple containing the +conversion of the slice items; otherwise, the conversion of the lone +slice item is the key. The conversion of a slice item that is an +expression is that expression. The conversion of an ellipsis slice +item is the built-in \code{Ellipsis} object. The conversion of a +proper slice is a slice object (see section \ref{types}) whose +\code{start}, \code{stop} and \code{step} attributes are the values of +the expressions given as lower bound, upper bound and stride, +respectively, substituting \code{None} for missing expressions. + \subsection{Calls} \label{calls} \index{call} A call calls a callable object (e.g. a function) with a possibly empty -series of arguments:\footnote{The new syntax for keyword arguments is -not yet documented in this manual. See chapter 12 of the Tutorial.} +series of arguments: \obindex{callable} \begin{verbatim} -call: primary "(" [condition_list] ")" +call: primary "(" [argument_list [","]] ")" +argument_list: positional_arguments ["," keyword_arguments] + | keyword_arguments +positional_arguments: expression ("," expression)* +keyword_arguments: keyword_item ("," keyword_item)* +keyword_item: identifier "=" expression \end{verbatim} +A trailing comma may be present after an argument list but does not +affect the semantics. + The primary must evaluate to a callable object (user-defined functions, built-in functions, methods of built-in objects, class -objects, and methods of class instances are callable). If it is a -class, the argument list must be empty; otherwise, the arguments are -evaluated. +objects, methods of class instances, and certain class instances +themselves are callable; extensions may define additional callable +object types). All argument expressions are evaluated before the call +is attempted. Please refer to section \ref{function} for the syntax +of formal parameter lists. + +If keyword arguments are present, they are first converted to +positional arguments, as follows. First, a list of unfilled slots is +created for the formal parameters. If there are N positional +arguments, they are placed in the first N slots. Next, for each +keyword argument, the identifier is used to determine the +corresponding slot (if the identifier is the same as the first formal +parameter name, the first slot is used, and so on). If the slot is +already filled, a \exception{TypeError} exception is raised. +Otherwise, the value of the argument is placed in the slot, filling it +(even if the expression is \code{None}, it fills the slot). When all +arguments have been processed, the slots that are still unfilled are +filled with the corresponding default value from the function +definition. (Default values are calculated, once, when the function +is defined; thus, a mutable object such as a list or dictionary used +as default value will be shared by all calls that don't specify an +argument value for the corresponding slot; this should usually be +avoided.) If there are any unfilled slots for which no default value +is specified, a \exception{TypeError} exception is raised. Otherwise, +the list of filled slots is used as the argument list for the call. + +If there are more positional arguments than there are formal parameter +slots, a \exception{TypeError} exception is raised, unless a formal +parameter using the syntax ``\code{*identifier}'' is present; in this +case, that formal parameter receives a tuple containing the excess +positional arguments (or an empty tuple if there were no excess +positional arguments). + +If any keyword argument does not correspond to a formal parameter +name, a \exception{TypeError} exception is raised, unless a formal +parameter using the syntax ``\code{**identifier}'' is present; in this +case, that formal parameter receives a dictionary containing the +excess keyword arguments (using the keywords as keys and the argument +values as corresponding values), or a (new) empty dictionary if there +were no excess keyword arguments. + +Formal parameters using the syntax ``\code{*identifier}'' or +``\code{**identifier}'' cannot be used as positional argument slots or +as keyword argument names. Formal parameters using the syntax +``\code{(sublist)}'' cannot be used as keyword argument names; the +outermost sublist corresponds to a single unnamed argument slot, and +the argument value is assigned to the sublist using the usual tuple +assignment rules after all other parameter processing is done. A call always returns some value, possibly \code{None}, unless it raises an exception. How this value is computed depends on the type -of the callable object. If it is: +of the callable object. + +If it is--- \begin{description} -\item[a user-defined function:] the code block for the function is +\item[a user-defined function:] The code block for the function is executed, passing it the argument list. The first thing the code block will do is bind the formal parameters to the arguments; this is described in section \ref{function}. When the code block executes a @@ -350,7 +447,7 @@ function call. \obindex{user-defined function} \obindex{function} -\item[a built-in function or method:] the result is up to the +\item[a built-in function or method:] The result is up to the interpreter; see the library reference manual for the descriptions of built-in functions and methods. \indexii{function}{call} @@ -362,20 +459,49 @@ built-in functions and methods. \obindex{method} \obindex{function} -\item[a class object:] a new instance of that class is returned. +\item[a class object:] A new instance of that class is returned. \obindex{class} \indexii{class object}{call} -\item[a class instance method:] the corresponding user-defined +\item[a class instance method:] The corresponding user-defined function is called, with an argument list that is one longer than the argument list of the call: the instance becomes the first argument. \obindex{class instance} \obindex{instance} -\indexii{instance}{call} \indexii{class instance}{call} +\item[a class instance:] The class must define a \method{__call__()} +method; the effect is then the same as if that method was called. +\indexii{instance}{call} +\ttindex{__call__} + \end{description} + +\section{The power operator} + +The power operator binds more tightly than unary operators on its +left; it binds less tightly than unary operators on its right. The +syntax is: + +\begin{verbatim} +power: primary ["**" u_expr] +\end{verbatim} + +Thus, in an unparenthesized sequence of power and unary operators, the +operators are evaluated from right to left (this does not constrain +the evaluation order for the operands). + +The power operator has the same semantics as the built-in +\function{pow()} function, when called with two arguments: it yields +its left argument raised to the power of its right argument. The +numeric arguments are first converted to a common type. The result +type is that of the arguments after coercion; if the result is not +expressible in that type (as in raising an integer to a negative +power, or a negative floating point number to a broken power), a +\exception{TypeError} exception is raised. + + \section{Unary arithmetic operations} \indexiii{unary}{arithmetic}{operation} \indexiii{unary}{bit-wise}{operation} @@ -383,7 +509,7 @@ argument list of the call: the instance becomes the first argument. All unary arithmetic (and bit-wise) operations have the same priority: \begin{verbatim} -u_expr: primary | "-" u_expr | "+" u_expr | "~" u_expr +u_expr: power | "-" u_expr | "+" u_expr | "~" u_expr \end{verbatim} The unary \code{-} (minus) operator yields the negation of its @@ -397,7 +523,8 @@ unchanged. The unary \code{~} (invert) operator yields the bit-wise inversion of its plain or long integer argument. The bit-wise inversion of -\code{x} is defined as \code{-(x+1)}. +\code{x} is defined as \code{-(x+1)}. It only applies to integral +numbers. \index{inversion} In all three cases, if the argument does not have the proper type, @@ -409,8 +536,8 @@ a \exception{TypeError} exception is raised. The binary arithmetic operations have the conventional priority levels. Note that some of these operations also apply to certain -non-numeric types. There is no ``power'' operator, so there are only -two levels, one for multiplicative operators and one for additive +non-numeric types. Apart from the power operator, there are only two +levels, one for multiplicative operators and one for additive operators: \begin{verbatim} @@ -440,21 +567,23 @@ The \code{\%} (modulo) operator yields the remainder from the division of the first argument by the second. The numeric arguments are first converted to a common type. A zero right argument raises the \exception{ZeroDivisionError} exception. The arguments may be floating -point numbers, e.g. \code{3.14 \% 0.7} equals \code{0.34}. The modulo -operator always yields a result with the same sign as its second -operand (or zero); the absolute value of the result is strictly -smaller than the second operand. +point numbers, e.g. \code{3.14\%0.7} equals \code{0.34} (since +\code{3.14} equals \code{4*0.7 + 0.34}.) The modulo operator always +yields a result with the same sign as its second operand (or zero); +the absolute value of the result is strictly smaller than the second +operand. \index{modulo} The integer division and modulo operators are connected by the following identity: \code{x == (x/y)*y + (x\%y)}. Integer division and modulo are also connected with the built-in function \function{divmod()}: \code{divmod(x, y) == (x/y, x\%y)}. These identities don't hold for -floating point numbers; there a similar identity holds where -\code{x/y} is replaced by \code{floor(x/y)}). +floating point and complex numbers; there a similar identity holds where +\code{x/y} is replaced by \code{floor(x/y)}) or +\code{floor((x/y).real)}, respectively. The \code{+} (addition) operator yields the sum of its arguments. -The arguments must either both be numbers, or both sequences of the +The arguments must either both be numbers or both sequences of the same type. In the former case, the numbers are converted to a common type and then added together. In the latter case, the sequences are concatenated. @@ -483,10 +612,10 @@ second argument. A right shift by \var{n} bits is defined as division by \code{pow(2,\var{n})}. A left shift by \var{n} bits is defined as multiplication with \code{pow(2,\var{n})}; for plain integers there is -no overflow check so this drops bits and flips the sign if the result -is not less than \code{pow(2,31)} in absolute value. - -Negative shift counts raise a \exception{ValueError} exception. +no overflow check so in that case the operation drops bits and flips +the sign if the result is not less than \code{pow(2,31)} in absolute +value. Negative shift counts raise a \exception{ValueError} +exception. \exindex{ValueError} \section{Binary bit-wise operations} @@ -543,16 +672,17 @@ when \code{x < y} is found to be false). Formally, if \var{a}, \var{b}, \var{c}, \ldots, \var{y}, \var{z} are expressions and \var{opa}, \var{opb}, \ldots, \var{opy} are comparison operators, then \var{a opa b opb c} \ldots \var{y opy z} is equivalent -to \var{a opa b} \keyword{and} \var{b opb c} \keyword{and} \ldots \keyword{and} +to \var{a opa b} \keyword{and} \var{b opb c} \keyword{and} \ldots \var{y opy z}, except that each expression is evaluated at most once. Note that \var{a opa b opb c} doesn't imply any kind of comparison -between \var{a} and \var{c}, so that e.g.\ \code{x < y > z} is +between \var{a} and \var{c}, so that, e.g., \code{x < y > z} is perfectly legal (though perhaps not pretty). The forms \code{<>} and \code{!=} are equivalent; for consistency with C, \code{!=} is preferred; where \code{!=} is mentioned below -\code{<>} is also implied. +\code{<>} is also acceptable. At some point in the (far) future, +\code{<>} may become obsolete. The operators {\tt "<", ">", "==", ">=", "<="}, and {\tt "!="} compare the values of two objects. The objects needn't have the same type. @@ -560,9 +690,10 @@ If both are numbers, they are coverted to a common type. Otherwise, objects of different types {\em always} compare unequal, and are ordered consistently but arbitrarily. -(This unusual definition of comparison is done to simplify the +(This unusual definition of comparison was used to simplify the definition of operations like sorting and the \keyword{in} and -\keyword{not in} operators.) +\keyword{not in} operators. In the future, the comparison rules for +objects of different types are likely to change.) Comparison of objects of the same type depends on the type: @@ -584,10 +715,10 @@ corresponding items. Mappings (dictionaries) are compared through lexicographic comparison of their sorted (key, value) lists.% \footnote{This is expensive since it requires sorting the keys first, -but about the only sensible definition. An earlier version of Python -compared dictionaries by identity only, but this caused surprises -because people expected to be able to test a dictionary for emptiness -by comparing it to \code{\{\}}.} +but it is about the only sensible definition. An earlier version of +Python compared dictionaries by identity only, but this caused +surprises because people expected to be able to test a dictionary for +emptiness by comparing it to \code{\{\}}.} \item Most other types compare unequal unless they are the same object; @@ -624,14 +755,14 @@ truth value. Boolean operations have the lowest priority of all Python operations: \begin{verbatim} -condition: or_test | lambda_form +expression: or_test | lambda_form or_test: and_test | or_test "or" and_test and_test: not_test | and_test "and" not_test not_test: comparison | "not" not_test -lambda_form: "lambda" [parameter_list]: condition +lambda_form: "lambda" [parameter_list]: expression \end{verbatim} -In the context of Boolean operations, and also when conditions are +In the context of Boolean operations, and also when expressions are used by control flow statements, the following values are interpreted as false: \code{None}, numeric zero of all types, empty sequences (strings, tuples and lists), and empty mappings (dictionaries). All @@ -641,20 +772,20 @@ The operator \keyword{not} yields \code{1} if its argument is false, \code{0} otherwise. \opindex{not} -The condition \code{\var{x} and \var{y}} first evaluates \var{x}; if +The expression \code{\var{x} and \var{y}} first evaluates \var{x}; if \var{x} is false, its value is returned; otherwise, \var{y} is evaluated and the resulting value is returned. \opindex{and} -The condition \code{\var{x} or \var{y}} first evaluates \var{x}; if +The expression \code{\var{x} or \var{y}} first evaluates \var{x}; if \var{x} is true, its value is returned; otherwise, \var{y} is evaluated and the resulting value is returned. \opindex{or} -(Note that \keyword{and} and \keyword{or} do not restrict the value +(Note that neither \keyword{and} nor \keyword{or} restrict the value and type they return to \code{0} and \code{1}, but rather return the last evaluated argument. -This is sometimes useful, e.g.\ if \code{s} is a string that should be +This is sometimes useful, e.g., if \code{s} is a string that should be replaced by a default value if it is empty, the expression \code{s or 'foo'} yields the desired value. Because \keyword{not} has to invent a value anyway, it does not bother to return a value of the @@ -662,54 +793,53 @@ same type as its argument, so e.g. \code{not 'foo'} yields \code{0}, not \code{''}.) Lambda forms (lambda expressions) have the same syntactic position as -conditions. They are a shorthand to create anonymous functions; the -expression \code{lambda \var{arguments}: \var{condition}} +expressions. They are a shorthand to create anonymous functions; the +expression \code{lambda \var{arguments}: \var{expression}} yields a function object that behaves virtually identical to one defined with -\code{def \var{name}(\var{arguments}): return \var{condition}}. -See section \ref{function} for the syntax of -parameter lists. Note that functions created with lambda forms cannot -contain statements. + +\begin{verbatim} +def name(arguments): + return expression +\end{verbatim} + +See section \ref{function} for the syntax of parameter lists. Note +that functions created with lambda forms cannot contain statements. \label{lambda} \indexii{lambda}{expression} \indexii{lambda}{form} \indexii{anonmymous}{function} -\section{Expression lists and condition lists} +\strong{Programmer's note:} a lambda form defined inside a function +has no access to names defined in the function's namespace. This is +because Python has only two scopes: local and global. A common +work-around is to use default argument values to pass selected +variables into the lambda's namespace, e.g.: + +\begin{verbatim} +def make_incrementor(increment): + return lambda x, n=increment: x+n +\end{verbatim} + +\section{Expression lists and expression lists} \indexii{expression}{list} -\indexii{condition}{list} \begin{verbatim} -expression_list: or_expr ("," or_expr)* [","] -condintion_list: condition ("," condition)* [","] +expression_list: expression ("," expression)* [","] \end{verbatim} -The only difference between expression lists and condition lists is -the lowest priority of operators that can be used in them without -being enclosed in parentheses; condition lists allow all operators, -while expression lists don't allow comparisons and Boolean operators -(they do allow bitwise and shift operators though). - -Expression lists are used in expression statements and assignments; -condition lists are used everywhere else where a list of -comma-separated values is required. - -An expression (condition) list containing at least one comma yields a -tuple. The length of the tuple is the number of expressions -(conditions) in the list. The expressions (conditions) are evaluated -from left to right. (Condition lists are used syntactically is a few -places where no tuple is constructed but a list of values is needed -nevertheless.) +An expression (expression) list containing at least one comma yields a +tuple. The length of the tuple is the number of expressions in the +list. The expressions are evaluated from left to right. \obindex{tuple} The trailing comma is required only to create a single tuple (a.k.a. a {\em singleton}); it is optional in all other cases. A single -expression (condition) without a trailing comma doesn't create a -tuple, but rather yields the value of that expression (condition). -\indexii{trailing}{comma} - +expression (expression) without a trailing comma doesn't create a +tuple, but rather yields the value of that expression (expression). (To create an empty tuple, use an empty pair of parentheses: \code{()}.) +\indexii{trailing}{comma} \section{Summary} @@ -746,6 +876,8 @@ chain from left to right --- see above). \hline \code{*}, \code{/}, \code{\%} & Multiplication, division, remainder \\ \hline +\code{**} & Power \\ +\hline \code{+\var{x}}, \code{-\var{x}} & Positive, negative \\ \code{\~\var{x}} & Bitwise not \\ \hline @@ -757,7 +889,7 @@ chain from left to right --- see above). \code{(\var{expressions}\ldots)} & Binding or tuple display \\ \code{[\var{expressions}\ldots]} & List display \\ \code{\{\var{key}:\var{datum}\ldots\}} & Dictionary display \\ -\code{`\var{expression}\ldots`} & String conversion \\ +\code{`\var{expressions}\ldots`} & String conversion \\ \hline \end{tabular} \end{center} |