Как сравнить несколько чисел в python

И я решил что могу эту задачу решить отнимая числа друг от друга. Но выглядит это так себе.. Может есть метод покрасивее/получше?

Операции сравнения в Python, цепочки сравнений

В Python есть шесть операций сравнения. Все они имеют одинаковый приоритет, который выше, чем у логических операций.

Разрешенные операции сравнения:

• x < y - строго x меньше y ,
• x
• x > y - строго x больше y ,
• x >= y - x больше или равно y ,
• x == y - x равно y ,
• x != y - x не равно y .

Сравнения могут быть связаны произвольно и записаны в цепочки сравнений, в которых для соединения сравнений используются неявные логические операторы and .

x  y  z # эквивалентно x  y and y  z 

a  b  c  d # эквивалентно a  b and b  c and c  d 

В такой форме сравнения легче читаются, и каждое подвыражение вычисляется по крайней мере один раз.

Объекты разных типов, за исключением различных числовых типов, никогда не будут равными.

Оператор == всегда определен, но для некоторых типов объектов, например объектов класса, эквивалентен оператору идентичности is .

Операторы < , и >= применяются только там, где они имеют смысл, например они вызывают исключение TypeError , когда один из аргументов является комплексным числом.

Неидентичные экземпляры класса обычно при сравнении будут неравны, если только класс не определяет метод __eq__() .

Экземпляры класса не могут быть упорядочены относительно других экземпляров того же класса или других типов объектов, если класс не определяет достаточное количество методов __lt__() , __le__() , __gt__() и __ge__() . В общем случае определение методов __lt__() и __eq__() для этих целей бывает достаточно.

Важно! Числа типа float не являются десятичными дробями (decimal.Decimal) и используют двоичную арифметику, поэтому иногда выражения могут вычисляться с ничтожно малыми погрешностями. Из-за этих погрешностей операции сравнения работают не так как ожидается.

>>> 0.8 - 0.5 == 0.3 # False >>> 0.8 - 0.5 - 0.3 == 0 # False >>> 0.8 - 0.5 - 0.3 # 5.551115123125783e-17 >>> from decimal import Decimal >>> Decimal('0.8') - Decimal('0.5') - Decimal('0.3') == 0 # True >>> Decimal('0.8') - Decimal('0.5') - Decimal('0.3') # Decimal('0.0') 

Поведение встроенных типов в операциях сравнения:

• Числа встроенных числовых типов int , float , complex и стандартных библиотечных типов fractions.Fraction и decimal.Decimal можно сравнивать внутри и между их типами, с ограничением, что комплексные числа не поддерживают сравнение порядка. В пределах задействованных типов они сравнивают математически (алгоритмически) правильно без потери точности. Нечисловые значения float('NaN') и decimal.Decimal('NaN') являются особыми. Любое упорядоченное сравнение числа с нечисловым значением неверно. Нечисловые значения не равны самим себе. Например, если x = float('NaN') , 3 < x , x < 3 и x == x все ложны, а x! = X истинно. Это поведение соответствует стандарту IEEE 754.
• None и NotImplemented являются одиночными. PEP 8 советует, что сравнения для одиночных экземпляров всегда должны выполняться с использованием или нет, а не с операторами равенства.
• Двоичные последовательности (экземпляры bytes или bytearray ) можно сравнивать внутри и между их типами. Они сравнивают лексикографически, используя числовые значения своих элементов.
• Строки (экземпляры str ) сравниваются лексикографически с использованием числовых кодовых точек Unicode (результат встроенной функции ord() ) их символов.

Строки и двоичные последовательности напрямую сравнивать нельзя.

• Чтобы две коллекции были равными, они должны быть одного типа, иметь одинаковую длину и каждая пара соответствующих элементов должна быть равной. Например [1,2] == (1,2) ложно, потому что типы последовательностей разные.
• Коллекции, поддерживающие сравнение порядка (сортировку), упорядочиваются также, как их первые неравные элементы, например [1,2, x]

Подводные камни (ловушки цепочек сравнения).

Несмотря на то, что цепочки сравнения выглядят очень разумно, есть пара подводных камней, на которые необходимо обратить внимание.

Нетранзитивные операторы.

Чтобы проверить, совпадают ли a , b и c , можно использовать цепочку сравнения a == b == c . А как проверить, ВСЕ ли они разные? Первое, что приходит в голову - это a != b != c , и попадаем в первую ловушку!

>>> a = c = 1 >>> b = 2 >>> a != b != c # True 

Но это не так. Они не все разные, ведь a == c . Проблема здесь в том, что a != b != c - это a != b and b != c , т.е. проверяет, что b отличается от a и от c , но ничего не говорит о том, как связаны a и c .

С математической точки зрения, != не является транзитивным, т. е. знание того, как a относится к b , и знание того, как b относится к c , не говорит о том, как a относится к c . Что касается транзитивного примера, можно взять оператор равенства == . Если a == b and b == c , то также верно, что a == c .

Непостоянное значение в выражении.

Если b содержит что-то непостоянное или выражение с побочными эффектами, то эти два выражения не эквивалентны.

Этот пример показывает разницу в количестве оценок значения в середине выражения:

def f(): print("run") return 3 >>> 1  f()  5 # run # True >>> 1  f() and f()  5 # run # run # True 

lst = [-2, 2] def f(): global lst lst = lst[::-1] return lst[0] >>> 1  f() and f()  0 # True >>> 1  f()  0 # False 

Синтаксис lst[::-1] - это срез, который переворачивает список.

Плохо читаемые цепочки сравнения.

Цепочки сравнения выглядят действительно естественно, но в некоторых конкретных случаях она не так хороша. Это довольно субъективный вопрос, но лучше избегать цепочки, в которых операторы не "выровнены", например:

Можно утверждать, например, что a < b >c читается как "проверим, b больше, чем a и c ?", но лучше эту цепочку записать так max(a, c) < b или b >max(a, c) .

Есть некоторые другие цепочки, которые просто сбивают с толку:

В Python операторы is , is not , in и not in являются операторами сравнения, следовательно их также можно связать с другими операторами. Это создает странные ситуации, такие как:

>>> a = 3 >>> lst = [3, 5] >>> a in lst == True # False 

Примеры использования цепочек сравнения.

>>> a = 1 >>> b = 2 >>> c = 3 >>> a  b  c # True 

Другой пример использования - когда необходимо убедиться, что все три значения одинаковы:

>>> a = b = 1 >>> c = 2 >>> if a == b == c: . print("все равны") . else: . print("некоторые отличаются") # некоторые отличаются >>> c = 1 >>> if a == b == c: . print("все равны") . else: . print("некоторые отличаются") # все равны 

На самом деле можно связать произвольное количество операторов сравнения в цепочку? Например, a == b == c == d == e проверяет, совпадают ли все пять переменных, в то время как a < b < c < d < e проверяет, есть ли строго возрастающая последовательность.

Операторы сравнения

Эти операторы сравнивают два типа значений, они меньше и больше чем операторы. Для чисел это просто сравнивает числовые значения, чтобы увидеть, что больше:

12 > 4 # True 12 < 4 # False 1 < 4 # True 

Для строк они будут сравниваться лексикографически, что похоже на алфавитный порядок, но не совсем то же самое.

"alpha" < "beta" # True "gamma" >"beta" # True "gamma" < "OMEGA" # False 

"GAMMA" < "OMEGA" # True 

Каждый тип определяет это расчет с < и >операторы по- разному, так что вы должны исследовать , что операторы означают с данным типом перед его использованием.

Не равно

x != y 

Это возвращает True , если x и y не равны и в противном случае возвращает значение False .

12 != 1 # True 12 != '12' # True '12' != '12' # False 

Равно

x == y 

Это выражение , если x и y имеют одинаковое значение и возвращает результат как логическое значение. В целом как тип и значение должны совпадать, так что ИНТ 12 не то же самое , как строка '12' .

12 == 12 # True 12 == 1 # False '12' == '12' # True 'spam' == 'spam' # True 'spam' == 'spam ' # False '12' == 12 # False 

Обратите внимание, что каждый тип должен определять функцию, которая будет использоваться для оценки, если два значения одинаковы. Для встроенных типов эти функции ведут себя так, как вы ожидаете, и просто оценивают вещи, основываясь на том же значении. Однако пользовательские типы можно определить тестирование равенства , как бы они ни хотели, в том числе всегда возвращаются True или всегда возвращаются False .

Сравнение цепей

Вы можете сравнить несколько элементов с несколькими операторами сравнения с помощью цепочки сравнения. Например

x > y > z 

это просто краткая форма:

x > y and y > z 

Это позволит оценить, True , только если оба сравнения True .

a OP b OP c OP d . 

Где OP представляет один из нескольких операций сравнения , которые можно использовать, а буквы представляют собой произвольные действительные выражения.

Стиль

Нет теоретического ограничения на количество элементов и операций сравнения, если вы используете правильный синтаксис:

1 > -1 < 2 >0.5 < 100 != 24 

Вышеприведенные возвращает True , если каждое сравнение возвращает True .Тем не менее, использование замысловатой цепочки не очень хороший стиль. Хорошая цепочка будет «направленной», не более сложной, чем

1 > x > -4 > y != 8 

Побочные эффекты

Как только одно сравнение возвращает значение False , выражение сразу вычисляет значение False , пропуская все остальные сравнения.

Отметим , что выражение exp в a > exp > b будет оцениваться только один раз, в то время как в случае

a > exp and exp > b 

exp будет вычисляться дважды , если a > exp верно.

Сравнение по `is` vs` == `

Типичная ошибка является запутанными операторы сравнения равенства is и == .

a == b сравнивает значение и a b .

a is b сравнит тождества и a b .

a = 'Python is fun!' b = 'Python is fun!' a == b # returns True a is b # returns False a = [1, 2, 3, 4, 5] b = a # b references a a == b # True a is b # True b = a[:] # b now references a copy of a a == b # True a is b # False [!!] 

В принципе, is можно рассматривать как сокращение для id(a) == id(b) .

Помимо этого, существуют особенности среды выполнения, которые еще больше усложняют ситуацию. Короткие строки и небольшие целые числа будут возвращать True , по сравнению с is , из - за машины Python пытается использовать меньше памяти для одинаковых объектов.

a = 'short' b = 'short' c = 5 d = 5 a is b # True c is d # True 

Но более длинные строки и большие целые числа будут храниться отдельно.

a = 'not so short' b = 'not so short' c = 1000 d = 1000 a is b # False c is d # False 

Вы должны использовать is , чтобы проверить на None :

if myvar is not None: # not None pass if myvar is None: # None pass 

Применение по is является проверка на «дозорных» (то есть уникальный объект).

sentinel = object() def myfunc(var=sentinel): if var is sentinel: # value wasn’t provided pass else: # value was provided pass 

Сравнение объектов

Для сравнения равенства пользовательских классов, вы можете переопределить == и != Определяя __eq__ и __ne__ методу. Вы также можете переопределить __lt__ ( < ), __le__ ( ), и __ge__ ( > ). Обратите внимание , что вам нужно только переопределить два метода сравнения, и Python может справиться с остальным ( == таким же , как not < и not >, и т.д.)

class Foo(object): def __init__(self, item): self.my_item = item def __eq__(self, other): return self.my_item == other.my_item a = Foo(5) b = Foo(5) a == b # True a != b # False a is b # False 

Заметим , что это простое сравнение предполагает , что other объект (объект сравнивается с) имеет тот же тип объекта. Сравнение с другим типом приведет к ошибке:

class Bar(object): def __init__(self, item): self.other_item = item def __eq__(self, other): return self.other_item == other.other_item def __ne__(self, other): return self.other_item != other.other_item c = Bar(5) a == c # throws AttributeError: 'Foo' object has no attribute 'other_item' 

Проверка isinstance() или аналогичный поможет предотвратить это (если это необходимо).