#
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 for the syntax of parameter lists. Note that functions created with lambda forms cannot contain statements.

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