Unlike C, all comparison and test operations in Python have the
same priority, which is lower than that of any arithmetic, shifting
or bitwise operation. Also unlike C, expressions like a <
b < c have the interpretation that is conventional in
mathematics.
Syntax:
expression operator expression
expression [ operator expression ]...
where operator is one of:
"<" | ">" | "==" | ">=" | "<=" | "<>" | "!=" | "is" ["not"] | ["not"] "in"`
Comparisons yield boolean values: True or False.
Comparisons can be chained arbitrarily, e.g., 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).
Formally, if a, b, c, ..., y, z are expressions and
opa, opb, ..., opy are comparison operators, then
a opa b opb c ...y opy z is equivalent to a opa
b and b opb c and ... y opy z, except that each expression
is evaluated at most once.
Note that a opa b opb c doesn't imply any kind of
comparison between a and c, so that, e.g., x < y >
z is perfectly legal (though perhaps not pretty).
The forms <> and != are
equivalent; for consistency with C, != is preferred;
where != is mentioned below <> is
also accepted. The <> spelling is considered
obsolescent.
The operators <, >,
==, >=, <=, and
!= compare the values of two objects. The objects need not
have the same type. If both are numbers, they are converted to a
common type. Otherwise, objects of different types always
compare unequal, and are ordered consistently but
arbitrarily.
(This unusual definition of comparison was used to simplify the definition of operations like sorting and the in and not in operators. In the future, the comparison rules for objects of different types are likely to change.)
Comparison of objects of the same type depends on the type:
Numbers are compared arithmetically.
Strings are compared lexicographically using the numeric equivalents (the result of the built-in function ord()) of their characters. Unicode and 8-bit strings are fully interoperable in this behavior.
Tuples and lists are compared lexicographically using comparison of corresponding elements. This means that to compare equal, each element must compare equal and the two sequences must be of the same type and have the same length.
If not equal, the sequences are ordered the same as their first
differing elements. For example, cmp([1,2,x], [1,2,y])
returns the same as cmp(x,y). If the corresponding
element does not exist, the shorter sequence is ordered first (for
example, [1,2] < [1,2,3]).
Mappings (dictionaries) compare equal if and only if their sorted (key, value) lists compare equal. The implementation computes this efficiently, without constructing lists or sorting. Outcomes other than equality are resolved consistently, but are not otherwise defined.
Most other types compare unequal unless they are the same object; the choice whether one object is considered smaller or larger than another one is made arbitrarily but consistently within one execution of a program.
The operators in and not in test for set membership. See in for details.
The operators is and is not test for object identity. See is for details.