Python условие не равен

Оператор неравенства != в 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 is not equal to b = False f = a != c print(f"a is not equal to c = ") # a is not equal to c = True q = '3' print(f'a is not equal to 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. С помощью различных примеров и сценариев мы узнали, как работает оператор != и как его применять для проверки неидентичности двух переменных.

Источник

Операторы Equal и Not Equal в Python

Not Equal в Python – это оператор сравнения в Python, используемый для проверки, не равны ли два значения.

Для оператора Not Equal используется символ !=. Между восклицательным знаком и знаком равенства не должно быть разделителя.

Not Equal в основном используется в логических выражениях условных операторов, таких как If, If-Else, Elif, While и т.д.

Синтаксис

Ниже приведен синтаксис оператора сравнения:

result = operand_1 != operand_2

Где, операнд_1 и операнд_2 – значения любого типа данных.

Оператор возвращает логическое значение, True – если операнд_1 и операнд_2 не равны, в противном случае он возвращает false.

Пример применения !=

В этом примере мы возьмем два целых числа и проверим, не равны ли они, используя !=.

a = 10 b = 12 c = 12 print(a != b) print(b != c)

a и b не равны, поэтому a != b вернул True.

a и c равны, поэтому a != b вернул False.

Пример 2: с оператором if

Мы уже знаем, что команда not equal возвращает логическое значение. Следовательно, это можно использовать в условиях принятия решений.

В следующем примере мы будем использовать оператор не равно в условии оператора IF.

a = 11 if a%2 != 0 : print(a, "is not even number.")

a% 2 != 0 возвращает True для a = 11, поэтому, если блок выполняется.

Пример 3: со строками

В этом примере мы будем использовать Not Equal, чтобы проверить, не равны ли две строки.

a = "python" b = "javascript" if a != b : print(a, 'and', b, 'are different.')

Ясно, что две строки не равны, и результат a != b true. Итак, в Python выполняет код блока if.

Пример 4: в условии while

Вы можете использовать команду not equal в условии цикла while в Python.

a = 4 while a != 0 : print("hello") a -= 1

Пример 5: в сложном условии

Команда может использоваться для объединения простых условий и формирования сложных условий или логических выражений.

a = 4 b = 5 if (a == 1) != (b == 5): print('Hello')

(a == 1) и (b == 5) два простых условия, и мы должны использовать оператор неравенства, чтобы объединить их и сформировать составное условие.

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

Equal в Python – это оператор сравнения, используемый для проверки равенства двух значений.

Символ, используемый для оператора равенства Python, – ==. Оператор равенства в основном используется в логических выражениях условных операторов, таких как If, If-Else, Elif, While и т.д.

Синтаксис

result = operand_1 == operand_2

Где, операнд_1 и операнд_2 – значения любого типа данных. Оператор равенства возвращает true, если операнд_1 и операнд_2 равны, иначе возвращает false.

Пример 1

В этом примере мы возьмем два целых числа и проверим, равны ли они, используя ==.

a = 10 b = 12 c = 12 print(a == b) print(b == c)

Пример 2: с оператором IF

В следующем примере мы будем использовать оператор равенства в условии IF.

a = 10 if a%2 == 0 : print(a, "is even number.")

a% 2 == 0 возвращает true для a = 10.

Пример 3: со строками

В этом примере мы будем использовать оператор равенства, чтобы проверить, равны ли две строки.

a = "python" b = "python" if a == b : print("a and b have same value.")

Пример 4: в условии while

Вы можете использовать оператор равенства в условии while.

a = 20 while int(a/6) == 3: print("hello") a += 1

Заключение

В этом руководстве Python мы узнали, что такое операторы сравнения Equal и Not Equal в Python, как использовать их, чтобы определить, равны или не равны два значения, с помощью подробных примеров программ.

Источник