Введение

Примеры

Больше или меньше чем

x > y
x < y

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

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

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

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

В этих сравнениях, строчные буквы считаются «больше чем» верхний регистр, поэтому "gamma" < "OMEGA" является ложным. Если бы все они были в верхнем регистре, он вернул бы ожидаемый результат в алфавитном порядке:

"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__ ( <= ), __gt__ ( > ), и __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() или аналогичный поможет предотвратить это (если это необходимо).

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