5.10 Boolean operations

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

See About this document... for information on suggesting changes.