Changes copied from the FrameMaker version, and some new stuff
(complex numbers, power operator).
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 in
+Python.
-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
+\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 @@
\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 @@
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 @@
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 @@
\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 @@
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 @@
\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 @@
\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 @@
\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 @@
\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 @@
\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 @@
\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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
\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 @@
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}
-\indexii{expression}{list}
-\indexii{condition}{list}
+\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}
-expression_list: or_expr ("," or_expr)* [","]
-condintion_list: condition ("," condition)* [","]
+def make_incrementor(increment):
+ return lambda x, n=increment: x+n
\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).
+\section{Expression lists and expression lists}
+\indexii{expression}{list}
-Expression lists are used in expression statements and assignments;
-condition lists are used everywhere else where a list of
-comma-separated values is required.
+\begin{verbatim}
+expression_list: expression ("," expression)* [","]
+\end{verbatim}
-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 @@
\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 @@
\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}