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

Введение

Примеры

  • 0

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

     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
    
     

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

  • 0

    Не равно

     x != y  
    
     

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

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

    Равно

     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 .

  • 6

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

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

     x > y > z
    
     

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

     x > y and y > z
    
     

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

    Общая форма

     a OP b OP c OP d ...
    
     

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

    Заметим , что 0 != 1 != 0 имеет значение True , даже если 0 != 0 является False . В отличии от общих математических обозначений , в которых x != y != z означает , что x , y и z имеет разные значения. Цепная == операции имеет естественный смысл в большинстве случаев, так как равенство , как правило , транзитивно.

    Стиль

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

     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 верно.

  • 2

    Сравнение по `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 
  • 0

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

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

Синтаксис

Параметры

Примечания