Перевод статьи «Python Not Equal Operator».

В 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. С помощью различных примеров и сценариев мы узнали, как работает оператор != и как его применять для проверки неидентичности двух переменных.