Недавно я заметил часть кода, непосредственно сравнивающую два списка целых чисел:
a = [10,3,5, ...]
b = [5,4,3, ...,]
if a > b:
...
который казался немного странным, но я предположил, что он вернет True, если все элементы list_a больше, чем list_b и False, если каждый элемент равен или list_b больше элементов, чем list_a " s. Поэтому я протестировал его:
>>> a=[3,3,3,3]
>>> b=[4,4,4,4]
>>> a>b
False
>>> b>a
True
Хорошо, что работает. Как это делает:
>>> b = [1,1,1,1]
>>> a = [1,1,1,1]
>>> a>b
False
>>> b>a
False
но когда он становится более нечетким:
>>> a=[1,1,3,1]
>>> b=[1,3,1,1]
>>> a>b
False
>>> b>a
True
или:
>>> a=[1,3,1,1]
>>> b=[1,1,3,3]
>>> a>b
True
>>> b>a
False
результаты немного страннее. Что на самом деле делает python? Кажется, что он возвращает результат в пользу первого списка, в котором самый левый элемент больше, чем соответствующий?
Из сравнения последовательностей и других типов в учебнике Python:
Сравнение использует лексикографическое упорядочение: сначала сравниваются первые два элемента, и если они отличаются друг от друга, это определяет результат сравнения; если они равны, сравниваются следующие два элемента и так далее, пока не будет исчерпана любая последовательность.
См. Также статью в Википедии о лексикографическом порядке.
Так как я не нашел объяснения сравнения списка/кортежа, используя, в первую очередь, "лексикографическое упорядочение", в первую очередь освещающее его, вот попытка объяснить это "своими словами". Во-первых, вот несколько примеров списков, о которых говорится в объяснении ниже:
a = [1, 2, 3]
b = [1, 2, 10]
c = [1, 2, 3, 100]
d = [1, 2, 3]
e = [1, 2, 3, 4, 'a']
f = ['a', 'b', 'c']
Пара элементов по каждому индексу сравнивается по очереди. Таким образом, сравнение a с b приведет к сравнению 1, 2 с 2, а 3 сравнивается с 10.
Сравнение пар остановится, если найдена неравная пара элементов или - если списки имеют разные длины - достигнут конец более короткого списка.
Например, при сравнении a и b сравнения будут останавливаться при сравнении 3 и 10. При сравнении b и c сравнения будут останавливаться при сравнении 10 и 3.
Как только обнаружена неравная пара, общий результат - результат сравнения неравных предметов. Это относится к тому, являются ли списки одинаковой длины или нет - например, список b больше, чем список c, потому что 100 in c никогда не запускается.
Например, при сравнении a с b общий результат будет результатом сравнения 3 с 10. a < b -> True, потому что 3 меньше 10. a > b -> False, потому что 3 не больше 10. a == b -> False, потому что 3 не равно 10.
Если один из списков короче и его N элементов равны первым N элементам более длинного списка, как в случае с a и c, более короткий список будет считаться меньшим, чем более длинный список (поэтому a меньше c).
Два списка будут сравниваться как равные, только если они одинаковой длины, а все пары элементов сравниваются как равные.
Примечание о типах: если элементы в паре не сопоставимы, сравнение будет происходить с использованием TypeError, как обычно. Например, сравнение списка a с f не удастся, если 1 будет сравниваться с 'a'. Но также обратите внимание, что списки d и e можно сравнить, поскольку 'a' in e никогда не сравнивается ни с чем в d.