Документация по Python

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

В: Документация по Python

Введение

Примеры

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

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

Синтаксис

Параметры

Примечания

Еще от кодкамп
Замечательно! Вы успешно подписались.
Добро пожаловать обратно! Вы успешно вошли
Вы успешно подписались на кодкамп.
Срок действия вашей ссылки истек.
Ура! Проверьте свою электронную почту на наличие волшебной ссылки для входа.
Успех! Ваша платежная информация обновлена.
Ваша платежная информация не была обновлена.