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