GNU Info

(python2.1-ref.info)Boolean operations

---

Next: Expression lists Prev: Comparisons Up: Expressions

---

Enter node , (file) or (file)node

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 Note: Function definitions 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

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