Перевод статьи «Python Not Equal Operator».
Друзья, подписывайтесь на наш телеграм канал Pythonist. Там еще больше туториалов, задач и книг по Python.
В Python для проверки верности неравенства используется !=
или is not
. Когда значения любых двух переменных Python или операндов, предоставленных по обе стороны от оператора неравенства, не равны, он должен возвращать True
, в противном случае — False
.
Выполняя сравнение, следует иметь в виду тип переменных. Многие языки структурированных запросов «ругаются» по поводу сопоставления различных типов. А вот Python гибок, хотя и жестко типизирован. Если значения двух переменных совпадают, но принадлежат к разным типам, оператор неравенства должен возвращать True
.
Ниже мы приведем несколько примеров, чтобы показать, как работают операторы неравенства Python.
Сравнение при помощи оператора != переменных одного и двух типов
Наш первый пример будет содержать различные способы сравнения двух или более значений переменных разных типов с помощью оператора неравенства.
Мы инициализируем две целочисленные переменные, x
и y
. После этого используем знак !=
для сравнения их значений. Результат в виде булева значения будет сохранен в новой переменной c
. После этого мы выводим значение этой переменной.
x = 5 y = 5 c = x != y print(c) # False
При выполнении этого кода мы получим результат False
, потому что значения переменных x
и y
были равны и имели одинаковый тип данных.
Теперь давайте обновим наш код. Мы объявим три разные переменные, причем только две из них будут иметь одинаковое значение.
После этого мы воспользуемся оператором неравенства !=
, чтобы получить результат сравнения переменных a
и b
. В этом случае мы используем оператор неравенства прямо в предложении print
.
Затем мы сравним переменные a
и c
вне предложения print и запишем результат в переменную f
. После этого используем значение этой переменной в print.
Наконец, мы объявим переменную строкового типа q
и сравним ее с целочисленной переменной a в предложении print.
a = 3 b = 3 c = 2 print(f'a is not equal to b = {a!= b}') # a is not equal to b = False f = a != c print(f"a is not equal to c = {f}") # a is not equal to c = True q = '3' print(f'a is not equal to q = {a!= q}') # a is not equal to q = True
В выводе мы видим одно ложное и два истинных значения. Первые два результата мы получили, сравнивая переменные целочисленного типа. Однако последнее сравнение было между переменными целочисленного и строкового типов. И хотя обе переменные были равны 3, одна из них была строковой, а вторая – целочисленной. Поэтому мы получили True
, значения не равны.
Использование оператора неравенства в if-блоках
Давайте посмотрим, как оператор неравенства используется в условии if
.
У нас есть две переменные: переменная x
– целочисленного типа, а y
– строкового. Мы инициализируем предложение if
и используем в нем оператор !=
, чтобы проверить наши переменные на неравенство. Если условие будет выполняться, то в выводе мы увидим фразу о том, что переменные не равны.
x = 5 y = '5' if (x != y): print('x is not equal to y') # x is not equal to y
После выполнения кода в выводе мы получили желаемую строку.
Рассмотрим другой пример. На этот раз мы используем обе переменные строкового типа и сравним их в операторе if
. Также мы используем print()
, чтобы вывести значения обеих переменных.
x = 'Aqsa' y = 'Yasin' if x != y: print(x, 'and', y, 'are different') # Aqsa and Yasin are different
При запуске кода мы не получаем никаких ошибок (т.е. наши переменные действительно не равны).
А теперь давайте рассмотрим пример посложнее.
Используем целочисленную переменную z
, имеющую значение 21. Сначала мы вычислим остаток от деления z
на 2. После этого, при помощи if
, зададим условие с !=
, чтобы сравнить вычисленное значение с 0. Таким образом мы проверим, является ли значение z
четным. Если полученное значение не равно 0 (т.е. остаток от деления на 2 равен единице), в выводе мы получим значение переменной z
и сообщение о том, что оно не является четным.
z = 21 if z % 2 != 0: print(z, 'is not even!') # 21 is not even!
В результате выполнения кода переменная z
была выведена на экран вместе со строкой is not even
!.
Использование оператора != в блоках if-else
В приведенных выше примерах мы использовали оператор if
. На этот раз давайте воспользуемся оператором if-else
.
Напишем следующий код. Прежде всего, инициализируем переменную целочисленного типа a
, значение которой равно 10. После этого мы запускаем условие if-else
.
Условие if
использует оператор неравенства is not
для сравнения переменной a
со значением 20. Если условие удовлетворяется, мы получим результат «Values are not Equal». В противном случае программа перейдет к else
и выведет «Values are Equal».
a = 10 if a is not 20: print('Values are not Equal') else: print('Values are Equal')
Запустим наш код. Вы можете видеть, что условие в операторе if
выполнено и в выводе мы получаем сообщение о том, что значения не равны – «Values are not Equal».
Давайте взглянем на другой пример. Объявим строку str
, имеющую значение Aqsa
. Если наша str
равна Aqsa
, то нам выведется на экран Hy Aqsa
. Если же условие оператора if
не выполняется, программа переходит на следующую строчку кода – оператор elif
. В таком случае мы получим сообщение Bye
.
str = 'Aqsa' if str == 'Aqsa': print('Hy Aqsa') elif str != 'Aqsa': print('Bye')
Поскольку условие в операторе if
выполняется, на выходе мы получим результат первого print()
, и к условию elif
программа не перейдет .
Давайте изменим значение переменной str
на Yasin
. На этот раз условие в операторе if
не соблюдается, и программа переходит к условию elif
. Следовательно, на экран будет выведен результат второго print()
.
str = 'Yasin' if str == 'Aqsa': print('Hy Aqsa') elif str != 'Aqsa': print('Bye')
Запустив код теперь, мы получим результат работы print() в блоке elif
– Bye
.
Более сложный пример использования != в Python
Наконец, протестируем оператор сравнения !=
на сложном примере.
Мы инициализировали класс с именем Test
. Внутри этого класса мы инициализировали переменную i
, имеющую значение 0. Другая переменная — data
— была инициализирована со значением None
.
После этого мы инициализировали конструктор нашего класса, чтобы получить значения этих переменных для каждого экземпляра класса.
Затем мы инициализировали встроенный метод, использующий оператор неравенства, и применили в нем конструкцию if-else
.
Далее были созданы три объекта для отправки значений конструктору.
После этого мы сравнили объекты друг с другом и вывели на экран результат сравнения. Сохраним код и запустим его.
class Test: i = 0 data = '' def __init__(self, i, s): self.i = i self.data = s def __ne__(self, other): if type(other) != type(self): return True if self.data != other.data: return True else: return False t1 = Test(1, 'Aqsa') t2 = Test(2, 'Aqsa') t3 = Test(3, 'Yasin') print(t1 != t2) print(t2 != t3)
На выходе получим значение False
как возврат первого оператора print()
, поскольку значения, проанализированные для обоих объектов, были одинаковыми. Напротив, второй print()
возвращает True, потому что t2
и t3
имеют разные значения и, следовательно, они не равны.
Вывод
Сегодня мы поговорили об операторе неравенства в Python. С помощью различных примеров и сценариев мы узнали, как работает оператор != и как его применять для проверки неидентичности двух переменных.