##
2.2.3 Comparisons

Comparison operations are supported by all objects. They all have the same priority (which is higher than that of the Boolean operations). Comparisons can be chained arbitrarily; for example, `x < y <= z` is equivalent to `x < y and y <= z`, except that y is evaluated only once (but in both cases z is not evaluated at all when `x < y` is found to be false).

This table summarizes the comparison operations:

Operation | Meaning | Notes
--- | --- | ---
`<` | strictly less than |
`<=` | less than or equal |
`>` | strictly greater than |
`>=` | greater than or equal |
`==` | equal |
`!=` | not equal | (1)
`<>` | not equal | (1)
`is` | object identity |
`is not` | negated object identity |

Notes:

(1)
  `<>` and `!=` are alternate spellings for the same operator. `!=` is the preferred spelling; `<>` is obsolescent.

Objects of different types, except different numeric types and different string types, never compare equal; such objects are ordered consistently but arbitrarily (so that sorting a heterogeneous array yields a consistent result). Furthermore, some types (for example, file objects) support only a degenerate notion of comparison where any two objects of that type are unequal. Again, such objects are ordered arbitrarily but consistently. The `<`, `<=`, `>` and `>=` operators will raise a `TypeError` exception when any operand is a complex number.

Instances of a class normally compare as non-equal unless the class defines the `__cmp__()` method. Refer to the Python Reference Manual for information on the use of this method to effect object comparisons.

Implementation note: Objects of different types except numbers are ordered by their type names; objects of the same types that don't support proper comparison are ordered by their address.

Two more operations with the same syntactic priority, "`in`" and "`not in`" , are supported only by sequence types (below).