Not equal check in python

Python Not Equal – Does Not Equal Operator Tutorial

Ihechikara Vincent Abba

When you’re learning the basics of most programming languages, you are bound to come across operators.

In this tutorial, we will talk about the not equal operator in Python and also see a few examples of how it works.

Operators and Operands in Python

Before talking about the not equal operator, let’s understand what operators and operands are in general.

Operators are symbols that denote a certain type of action or process. They carry out specific operations on certain values or variables. These values or variables are known as the operands of the the operator so the operator performs its operation on them and returns a value.

Here are a few examples of operators and how they interact with operands:

Addition operator ( + )

a = 10 b = 10 print(a + b) # returns 20 

The operator here is the + symbol which adds the value of a and b which are the operands.

Multiplication operator ( * )

c = 10 d = 10 print(a * b) # returns 100

Similar to the last example, * is the operator while c and d are the operands.

Not equal operator ( != )

firstNumber = 10 secondNumber = 20 print(firstNumber != secondNumber) # returns True

Again, the operator is the != symbol and the operands are firstNumber and secondNumber .

There are many other operators in Python which are divided into groups but in this tutorial we will be focusing on the not equal operator ( != ).

Not Equal Operator in Python

The not equal operator is a relational or comparison operator that compares two or more values (operands). It returns either true or false depending on the result of the operation.

If the values compared are equal, then a value of true is returned. If the values compared are not equal, then a value of false is returned.

!= is the symbol we use for the not equal operator.

Let’s see a few examples of how it works.

How to compare numeric values using the != operator in Python

Here, we will define two variables and then compare their values.

a = 600 b = 300 print(a != b) # True 

As expected, the above operation returns true because the value of a is not equal to the value of b . If you still find this hard to grasp, then I will represent the code above using plain English to rewrite each line below:

a is equal to 600 b is equal to 300 print(the value of a does not equal the value of b) # True, the value of a is not equal to the value of b

That should probably simplify it.

Next, we will compare more than two values.

a = 600 b = 300 c = 300 print(a != b & c) # True

If you were expecting a value of false then you were probably trying to add some of the values during the comparison.

To make this simpler to understand, the operator is only going look at the values of each operand and then compare all of them without adding one operand to the other.

Imagine a , b and c as triplets and each baby’s face was represented by a number. Now the != operator is saying, «I have made my observations and concluded that the three babies are not identical facially» and that is completely True .

When all the operands are the same and the != is used, then the value returned will be false. That is:

a = 600 b = 600 c = 600 print(a != b & c) # False

Here, the triplets all have the same face but != is saying, «All the babies do not have the same face» and that is false because their faces, represented by numbers, are the same – 600.

How to compare lists in Python using the != operator

In the previous section, we compared the values of numbers. In this section, we will be comparing lists. Lists are used to store more than one item in a single variable.

a = [2, 3] b = [2, 3] print(a != b) # False

Just like we saw in the previous section, the value is False because the two lists are the same. It would be True if both operands were not the same.

To further grasp the idea of True or False being returned when using the != operator, you should always have in mind that the value will be True if the operands are not the same and False if the operands are the same.

The != operator can also be used to compare Strings, Dictionaries, Tuples and Sets.

How to use an if statement with the != operator in Python

In some cases, you might prefer to carry out a certain command only after evaluating two variables. Consider the example below:

a = 21 b = 10 if ( a != b ): print ("True. a is not equal to b") else: print ("False. a is equal to b") # True. a is not equal to b

The if statement checks whether the values of the operands are not the same and then prints a message based on the value returned.

This is a very basic example. As you advance as a Python developer, you’ll find yourself crafting more complex (but not necessarily hard) logic to execute various commands.

Conclusion

This article served as an introduction to using the not equal ( != ) operator in Python and highlighted a few examples to help you understand its application.

If you are a beginner interested in learning Python, freeCodeCamp has a Scientific Computing with Python certificate which is a good place to start.

Источник

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

Источник