 |
 |
 |
Python Reference Manual |  |
 |
 |
Boolean operations have the lowest priority of all Python operations:
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]: expression |
In the context of Boolean operations, and also when expressions are
used by control flow statements, the following values are interpreted
as false: None, numeric zero of all types, empty sequences
(strings, tuples and lists), and empty mappings (dictionaries). All
other values are interpreted as true.
The operator not yields 1 if its argument is false,
0 otherwise.
The expression x and y first evaluates x; if
x is false, its value is returned; otherwise, y is
evaluated and the resulting value is returned.
The expression x or y first evaluates x; if
x is true, its value is returned; otherwise, y is
evaluated and the resulting value is returned.
(Note that neither and nor or restrict the value
and type they return to 0 and 1, but rather return the
last evaluated argument.
This is sometimes useful, e.g., if s is a string that should be
replaced by a default value if it is empty, the expression
s or 'foo' yields the desired value. Because not has to
invent a value anyway, it does not bother to return a value of the
same type as its argument, so e.g., not 'foo' yields 0,
not ''.)
Lambda forms (lambda expressions) have the same syntactic position as
expressions. They are a shorthand to create anonymous functions; the
expression lambda arguments: expression
yields a function object that behaves virtually identical to one
defined with
def name(arguments):
return expression
See section 7.5 for the syntax of parameter lists. Note that functions created with lambda forms cannot contain statements.
Programmer's note: Prior to Python 2.1, a lambda form defined inside a function has no access to names defined in the function's namespace. This is because Python had only two scopes: local and global. A common work-around was to use default argument values to pass selected variables into the lambda's namespace, e.g.:
def make_incrementor(increment):
return lambda x, n=increment: x+n
As of Python 2.1, nested scopes were introduced, and this work-around has not been necessary. Python 2.1 supports nested scopes in modules which include the statement "from __future__ import nested_scopes", and more recent versions of Python enable nested scopes by default. This version works starting with Python 2.1:
from __future__ import nested_scopes
def make_incrementor(increment):
return lambda x: x+increment
|
|
|
Python Reference Manual | |
|
|