Why is '' > 0 True in Python 2?
Question:
In Python 2.x:
>>> '' > 0
True
Why is that?
Answers:
from https://docs.python.org/2.7/tutorial/datastructures.html#id1
Note that comparing objects of different types is legal. The outcome
is deterministic but arbitrary: the types are ordered by their name.
Thus, a list is always smaller than a string, a string is always
smaller than a tuple, etc. [1] Mixed numeric types are compared
according to their numeric value, so 0 equals 0.0, etc.
The original design motivation for allowing order-comparisons of arbitrary objects was to allow sorting of heterogeneous lists — usefully, that would put all strings next to each other in alphabetical order, and all numbers next to each other in numerical order, although which of the two blocks came first was not guaranteed by the language. For example, this allowed getting only unique items in any list (even one with non-hashable items) in O(N log N) worst-case time
Over the years, this pragmatic arrangement eroded. The first crack came when the ability to order-compare complex numbers was taken away, quite a few versions ago. Suddenly, the ability to sort any list disappeared: it did not apply any more if the list contained complex numbers, possibly together with items of other types. Then Guido started disliking heterogeneous lists more generally, and thus started thinking that it didn’t really matter if such lists could be usefully sorted or not… because such lists should not exist in the first place, according to his new thinking. He didn’t do anything to forbid them, but was not inclined to accept any compromises to support them either.
Note that both changes move the balance a little bit away from the “practicality beats purity” item of the Zen of Python (which was written earlier, back when complex numbers still could be order-compared 😉 – a bit more purity, a bit less practicality.
Nevertheless the ability to order-compare two arbitrary objects (as long as neither was a complex number 😉 remained for a long time, because around that same time Guido started really insisting on maintaining strong backwards compatibility (a shift that’s both practical and pure ;-).
So, it’s only in Python 3, which explicitly and deliberately removed the constraint of strong backwards compatibility to allow some long-desired but backwards incompatible enhancements (especially simplifications and removal of obsolete, redundant way to perform certain tasks), that order comparison of instances of different types became an error.
So this historical and philosophical treatise is basically the only way to truly respond to your “why” question…! 🙂
In Python 2.x:
>>> '' > 0
True
Why is that?
from https://docs.python.org/2.7/tutorial/datastructures.html#id1
Note that comparing objects of different types is legal. The outcome
is deterministic but arbitrary: the types are ordered by their name.
Thus, a list is always smaller than a string, a string is always
smaller than a tuple, etc. [1] Mixed numeric types are compared
according to their numeric value, so 0 equals 0.0, etc.
The original design motivation for allowing order-comparisons of arbitrary objects was to allow sorting of heterogeneous lists — usefully, that would put all strings next to each other in alphabetical order, and all numbers next to each other in numerical order, although which of the two blocks came first was not guaranteed by the language. For example, this allowed getting only unique items in any list (even one with non-hashable items) in O(N log N) worst-case time
Over the years, this pragmatic arrangement eroded. The first crack came when the ability to order-compare complex numbers was taken away, quite a few versions ago. Suddenly, the ability to sort any list disappeared: it did not apply any more if the list contained complex numbers, possibly together with items of other types. Then Guido started disliking heterogeneous lists more generally, and thus started thinking that it didn’t really matter if such lists could be usefully sorted or not… because such lists should not exist in the first place, according to his new thinking. He didn’t do anything to forbid them, but was not inclined to accept any compromises to support them either.
Note that both changes move the balance a little bit away from the “practicality beats purity” item of the Zen of Python (which was written earlier, back when complex numbers still could be order-compared 😉 – a bit more purity, a bit less practicality.
Nevertheless the ability to order-compare two arbitrary objects (as long as neither was a complex number 😉 remained for a long time, because around that same time Guido started really insisting on maintaining strong backwards compatibility (a shift that’s both practical and pure ;-).
So, it’s only in Python 3, which explicitly and deliberately removed the constraint of strong backwards compatibility to allow some long-desired but backwards incompatible enhancements (especially simplifications and removal of obsolete, redundant way to perform certain tasks), that order comparison of instances of different types became an error.
So this historical and philosophical treatise is basically the only way to truly respond to your “why” question…! 🙂