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.:
Python 2.1 introduced nested scopes as an optional feature, and this
work-around has not been necessary when the feature is enabled. The
use of nested scopes is enabled by the statement "from __future__
import nested_scopes"; future versions of Python will 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