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
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.:
def make_incrementor(increment): return lambda x, n=increment: x+n