在Python中如何对字典，列表和元组进行逐元素比较？

Question

[1,3] > [1,2]
True

OK, sounds reasonable, on an intuitive level if nothing else.

(3,2) <= (3,2)
True

Ditto.

But what makes:

(4,3) >= (1,1,1)
True

And if we are comparing values() here:

{'a':1, 'b':2} < {'a':1, 'b':3}
True

Then why are we comparing keys() here:

{'a':1, 'b':2} < {'x':1, 'y':2}
True

I don't find documentation on these phenomena anywhere.

Answer 1

(4,3) is larger than (1,1,1) for the exact same reason that "mouse" is larger than "elephant" . Lexicographical order . With strings you're probably very familiar with it. You'd expect "elephant" to appear before "mouse" in a dictionary, right?

Answer 2

All this is very clearly documented in Python Language Reference 5.9 Comparisons .

Especially:

• 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. [1] Outcomes other than equality
  are resolved consistently, but are not otherwise defined. [2]

where the footnotes are

1. The implementation computes this efficiently, without constructing lists or sorting.

2. Earlier versions of Python used lexicographic comparison of the sorted (key, value) lists, but this was very expensive for the common case of comparing for equality. An even earlier version of Python compared dictionaries by identity only, but this caused surprises because people expected to be able to test a dictionary for emptiness by comparing it to {} .

---

Comparing dictionaries in Python 3 raises TypeError . Likewise sequences having incompatible elements:

>>> {} < {1:2}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: dict() < dict()
>>> ['a'] < [1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()