Не равно в питоне: Оператор неравенства != в Python

Оператор неравенства != в Python

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

Что значит //, %, not in, == и другие операторы Python

Автор Амина С. На чтение 8 мин Опубликовано 09.06.2021

Операторы – это специальные знаки, которые являются командой для интерпретатора Python по выполнению определенных задач. Они бывают абсолютно разными: арифметическими, операторами сравнения, тождественности, принадлежности и так далее. Все они имеют различные особенности, которые сегодня мы рассмотрим более подробно.

Содержание

1. Арифметические операторы Python
2. Операторы присваивания Python
3. Операторы сравнения Python
4. Логические операторы Python
5. Операторы тождественности Python
6. Операторы принадлежности Python
7. Побитовые операторы Python

Арифметические операторы Python

Как можно догадаться из названия, арифметические операторы нужны для того, чтобы совершать несложные арифметические операции. К таковым относятся:

1. Сложение. Для этого используется оператор +, который является таким же, как и известный математический знак, выполняющий эту функцию.
2. Вычитание. Эта операция осуществляется с использованием знака «–».
3. Умножение. В большинстве компьютерных программ данная арифметическая операция выполняется с использованием знака звездочки *. Python – не исключение.
4. Деление. Для этого используется знак слэша /. Внимание! Он должен быть направлен именно в эту сторону.
5. Остаток от деления. Выглядит так, как математический знак процента (%), но имеет другую функцию.
6. Возведение в степень. Отличается от аналогичного знака в арифметике. Выглядит, как две звездочки, расположенные по горизонтали (**).
7. Деление без остатка. Этот оператор получает исключительно целое число, округленное в меньшую сторону (так, чтобы оставался остаток). При этом он не возвращает остатка.

Теперь перейдем к описанию принципа работы этих операторов (равно, как и других). Сначала необходимо разобраться в значении слова «операнд». Это те фрагменты информации, над которыми осуществляется операция. В нашем случае – арифметическая.

Любые операнды размещаются по разные стороны оператора. В случае с математическими операторами, в большинстве случаев это будет стандартное арифметическое выражение типа a + b = c или n = a+3.

Но оператор деления по модулю, например, будет использоваться таким образом.

с = 10 % 3.

То есть, каждый из описанных выше знаков ставится между операндами. А получившееся выражение может присваиваться другой переменной или же использоваться в качестве аргумента функции.

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

Присваивание значения переменной – одна из самых распространенных операций. С ее помощью можно передавать ей необходимую информацию, которая в дальнейшем может использоваться программой. Без нее невозможно представить программирования. А для большего удобства использования количество операторов присваивания в Python очень большое. 

Рассмотрим наиболее распространенные из них.

Оператор =. Это классический оператор присваивания. Обратите внимание, он не проверяет равенство операндов, за это отвечает другой оператор. Он именно используется для присваивания значений или объектов переменным.

Тем не менее, в некоторых случаях он может читаться, как знак «равно», но только если речь не идет о сравнении операндов.

Пример.

x = 5. 

Эта простая строчка кода присваивает переменной x значение 5. То есть, она может читаться, как «x равно 5». Но при этом осуществляется не констатация факта, а действие, после которого переменная x становится равной 5. А до этого действия она может как вовсе отсутствовать, так и содержать любое другое значение. 

Это единственный оператор этой категории, который выполняет одно действие. Остальные же совершают сразу 2.

Оператор +=. Этот оператор сначала добавляет к переменной то число, которое находится во втором операнде, а потом делает так, чтобы эта переменная имела соответствующее значение. 

x += 3

Это то же самое, что x = x + 3.

В целом, любой из операторов может быть заменен на аналогичное выражение, где переменная равно переменная, оператор, операнд 2. Дальше мы приведем еще несколько таких примеров для наглядности, и такая же логика будет действовать для всех операторов присваивания.

Оператор –=. Выполняет похожую операцию на ту, что делает предыдущий оператор, но при этом со знаком «минус». Он сначала берет переменную, которая стоит в первом операнде, отнимает от содержащегося в ней числе значение, расположенное в правом операнде, а потом результат присваивает этой же переменной, которая стоит в левом операнде. 

На практике все значительно проще, чем может показаться, когда вы читали это правило. Оператор –= аналогичен выражению x = x-y. Просто оно более сокращенное. 

Приведем пример.

x -= 3

Если вместо x подставить значение 2, то получится число -1, поскольку если от двух отнять 3, выйдет именно -1.

Оператор *=. Аналог предыдущих двух операторов присваивания, только выполняющий операцию умножения. Соответственно, принцип его работы аналогичный. 

В целом, по такому же принципу работают все остальные операторы. Например, есть оператор деления, который также ставится перед знаком равно, а также деление по модулю, остаток от деления и так далее. Давайте приведем таблицу с описанием всех имеющихся операторов сравнения при их соединении с другими.

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

Они используются, чтобы сопоставить операнды друг с другом и понять, они равны, или какое-то из них большее, или меньшее. 

Рассмотрим существующие операторы сравнения.

Равно (==). Как и говорилось выше, этот оператор выглядит несколько иначе, чем оператор присваивания. Выглядит он, как два математических знака «равно», стоящих вместе. Он проверяет равенство двух операндов, и в случае соблюдения этого критерия возвращает значение «истина».

Не равно (!=). Также отличается от аналогичного арифметического знака в математике. Противоположный по значению оператор. Возвращает истину, если указанный выше критерий не соблюдается. 

Больше, чем (>) и меньше, чем (<). Операторы, аналогичные таковым в математике. 

Больше или равно (>=) и меньше или равно (<=). Аналоги соответствующих операторов в математике с несколько иным описанием.

Приведем сводную таблицу со значениями и примерами использования этих операторов.

Логические операторы Python

Предназначены для связывания объектов между собой. Используются для задания условия, при котором выполняются определенные действия или для указания критерия, при котором выполняется цикл или осуществляется выход из него. Всего существует три логических оператора в этом языке программирования

И (and). Объединяет условия между собой. Если оба критерия оказываются верными, оператор возвращает значение «истина». Если же нет, то «ложь». 

ИЛИ (or). Проверяет истинность хотя бы одного из указанных операндов. Если из них есть один, который соответствует действительности, то возвращается значение «истина». Если же нет, то «ложь». 

НЕ (not). Выполняет инверсию результата вывода логического оператора или функции. То есть, истина становится ложью и наоборот. 

Приведем сводную таблицу с примерами использования этих операторов, а также их значениями.

Операторы тождественности Python

Если требуется сравнить несколько объектов между собой, используются операторы тождественности. При этом они отличаются по принципу действия от операторов сравнения с тем, поскольку критерием для тождественности является нахождение операндов в одной и той же части памяти. 

Есть всего два оператора тождественности: 

1. Выполняет сравнение, операндов, и если они являются идентичными, то возвращается значение true. Соответственно, если этот критерий не соблюдается, возвращается значение false. 

is not. Противоположный по принципу работы оператор. В случае тождественности операндов друг другу возвращает false.

Приведем наглядную таблицу с описанием использования операторов тождественности в Python.

Операторы принадлежности Python

Python также умеет раскладывать объекты на составляющие и проверять, является ли один объект составной частью другого. Типичный пример использования – строки. Например, с их помощью можно проверять, является ли одна подстрока составной частью другой подстроки. Соответственно, возвращается логический результат, предусмотренный подходящим оператором. 

В Python есть два оператора принадлежности – in и not in. По синтаксису они напоминают все остальные. Сначала ставится операнд 1, после этого оператор, а потом – операнд 2. И выполняют они похожие действия. Просто если строка является составной частью большей строки (или меньший объект – составляющей большего), то оператор in возвращает значение True. Если же здесь бы использовался оператор not in, то возвращаемое значение было бы False.

Приведем небольшую таблицу с примерами использования этих операторов (вернее, шаблонами), а также – их значениями.

Побитовые операторы Python

Самая сложная для понимания категория операторов. Настолько сложная, что для этого нужно отдельно рассматривать принцип работы каждого из них. Ведь каждый работает по определенным формулам. Они поддаются логике, она будет указана в таблице ниже. Тем не менее, это все равно довольно сложно. 

Начнем с того, что они работают с битами. То есть, с нулями и единицами, а не привычными значениями. Например, оператор & каждый бит делает единицей лишь при условии, что каждый бит операндов на соответствующих позициях равен единице.

Вот более подробная таблица с использованием этих операторов.

Мы разобрались с самыми часто используемыми операторами в Python, а также рядом других, сфера применения которых более ограниченная. Следует отметить, что операторы – это одна из самых простых тем в программировании. Они почти не отличаются от привычных нам математических знаков, просто список символов, которые используются, несколько больше. При этом принцип их работы доступен для понимания каждому новичку. Единственное исключение – побитовые операторы, которые заслуживают отдельного рассмотрения.

Оцените качество статьи. Нам важно ваше мнение:

Python оператор NOT EQUAL В Python

!= определяется как оператор , не равный оператору . Он возвращает True , если операнды с обеих сторон не равны друг другу, и возвращает False , если они равны.

Операторы NOT EQUAL Python Синтаксис

Оператор не равен в описании Python:

• != Оператор Not Equal , работает как в Python 2, так и в Python 3.
• <> Оператор Not equal в Python 2 , устарел в Python 3.

Синтаксис: Значение A != Значение B

9000 2 Тип возврата:

• Возвращает True или False

Примечание. Важно помнить, что этот оператор сравнения вернет True, если значения совпадают, но относятся к разным типам данных.

Примеры оператора NOT EQUAL в Python

Вот несколько примеров операторов NOT EQUAL Python.

Пример 1: оператор NOT EQUAL с одинаковым типом данных

В этом примере мы сравниваем разные значения одного и того же типа данных, то есть целые числа, чтобы увидеть, как работает оператор NOT EQUAL.

Python3

A = 1 B = 2 С = 2   печать (A! = B) печать 90 061 (Б! = С)

Выход:

 Верно
False 

Пример 2: оператор NOT EQUAL с разными типами данных

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

Python3

A = 1 B = 1.0 C = "1"   печать (A! = B) печать (B! = C) печать (А! = С)

Вывод:

 Ложь
Истинный
True 

Сравнение списков в Python с использованием оператора Not Equal

Оператор NOT EQUAL в Python также можно использовать для сравнения двух списков. Давайте посмотрим, как это можно сделать.

В этом примере мы берем 3 списка Python, два из которых — целые числа, а один — список строк. Затем мы сравнили их с помощью оператора NOT EQUAL.

Python3

список1 = [ 10 , 20 , 30 ] 900 60 список2 = [ 10 , 20 , 30 ] список3 = [ "выродки" , "для" , 9 0062 "гики" ]   печать (список1 ! = список2) печать (список1 ! = список3) 9 0106

Вывод:

 Ложь
True 

Использование оператора if с оператором Not Equal  в Python

Оператор NOT EQUAL также можно использовать с оператором Python if else. Давайте посмотрим на простой пример этого.

В этом примере мы сравниваем две строки, а затем печатаем сообщение на основе вывода оператора NOT EQUAL.

Python3

стр1 = «Гики» стр2 9 0061 = 'GeeksforGeeks'   if str1 ! = стр2:      печать ( "Строки не равны" ) 9006 2 еще :      печать ( "Строки равны" )

Вывод:

 Числа не равны 90 115 
 Оператор NOT EQUAL Python с пользовательским объектом 
 
 Мы также можем использовать оператор NOT EQUAL с пользовательские объекты в Python. Вот пример того, как оператор NOT EQUAL работает с пользовательскими объектами.  
 
 Декоратор Python  __ne__()  вызывается всякий раз, когда используется оператор не равно в Python. Мы можем переопределить эту функцию, чтобы изменить природу оператора «не равно». 
  
 Python3 
  
 
 
 
   класс   Студент:  
 
   
         90 061 def   __init__(   self   , name):  
              self   .student_name   =   имя  
 
   
          def   __ne__(   self   , x): 900 62 
             
             
              если   введите   (x) !   =   тип   (   сам   ):  
                  возврат   True  
                
             
              если   сам   . имя_студента !   =   x.имя_ученика:  
                 return   True  
              else   :  
                 return   False  
 
   
   s1   =  900 61 Студент(   "Шьям"   )  
   s2   =   Студент(   "Раджу"   )  
   s3  90 061 =   Студент(   "бабу рао"   )  
 
   
   печать   (s1 !   =   s2) 9006 2 
   печать   (s2 !   =   s3)  
 
 
 
 
 
  Вывод:  
 
 Истинно
True 

 Python Not Equal Operator (!=) 
 АвторSteve Campbell
 Часы  Обновлено  22 апреля 2023 г. 
 Что Python не равно оператору? 
 Python определяется как очень динамичный язык программирования и обычно считается строго типизированным языком. Это утверждение можно объяснить, поняв значение оператора not equal. В операторе  не равно , если значения двух операндов по обе стороны от оператора не равны, то оператор предоставляет истинное значение, в противном случае он предоставляет ложное.
 В операторе  не равно , если две переменные имеют разные типы, но содержат одинаковые значения сами по себе, то оператор не равно возвращает истину. Не многие языки программирования могут классифицировать его как истинный, если тип переменной имеет другой тип, что делает python очень динамичным языком. В python операторы не равных могут быть классифицированы как один из операторов сравнения.
 Типы операторов Not equal to с синтаксисом в Python 
 Синтаксис обоих типов показан ниже: –
 X<>Y
X!=Y 
 В python есть два типа неравных операторов: -
  != 
  <> 
 Первый тип,  != , используется в Python версии 2 и 3.
 Второй тип,  <> , используется в Python версии 2, а в версии 3 этот оператор устарел.
 Пример оператора Not Equal в Python 
 Давайте рассмотрим два сценария, чтобы проиллюстрировать не равенство в Python. Ниже приведен пример неравного оператора для одного и того же типа данных, но разных значений: -
 A = 44
В = 284
С = 284
распечатать (В! = А)
печать (В! = С)
 
  Вывод: 
 Истинно
ЛОЖЬ
 
 Ниже приведен пример не равенства в python для разных типов данных, но с одинаковыми значениями
 C = 12222
Х = 12222,0
Г = "12222"
распечатать (С! = Х)
распечатать (Х! = Y)
печать (С! = Y)
 
  Вывод: 
 Ложь
Истинный
Истинный
 
 Как использовать оператор Not Equal с оператором IF 
 В python оператор if можно описать как оператор, который проверяет условие начального уровня и выполняется, когда оно истинно.
 Возьмем базовый пример использования оператора if и не равно оператору, как показано ниже: –
 X = 5
Y = 5
если ( Х != Y ):
  print("Х не равно Y")
еще:
  print("Х равно Y")
 
  Выход: 
 X равно Y
 
 Здесь не равно  !=  используется вместе с оператором if.
 Как использовать оператор равенства (==) с циклом while 
 В python цикл while повторяет блок кода до тех пор, пока условие истинно или ложно. Давайте возьмем случай печати нечетных чисел с использованием цикла while и оператора равенства, как показано ниже: –
 м = 300
пока м <= 305:
   м = м + 1
  если м%2 == 0:
     продолжать
   печать (м)
 
 Выход:
 301
303
305 
 Здесь равно  ==  используется вместе с оператором if.
 Пример: поиск четных чисел с помощью оператора «не равно» 
 В python цикл while также можно использовать с оператором «не равно». Давайте возьмем случай печати четных чисел с использованием цикла while и оператора не равно, как показано ниже: –
 м = 300
пока м <= 305:
  м = м + 1
  если m%2 != 0:
    продолжать
  печать (м) 
  Вывод: 
 302
304
306
 
 Здесь не равно  !=  используется вместе с оператором if.
 Как использовать оператор Python not equal с пользовательским объектом 
 Пользовательские объекты позволяют пользователю или разработчику создавать собственные реализации. Это позволяет разработчикам изменить фактический вывод, чем обычно ожидается.
 Рассмотрим пример пользовательского объекта, в котором используется оператор «не равно», как показано ниже: –
  Пример: 
 класс G9Пример:
   s_n=''
def __init__(я, имя):
   self.s_n = имя
защита __ne__(я, х):
если тип(х) != тип(я):
  вернуть Истина
# возвращаем True для разных значений
если self.s_n != x.s_n:
  вернуть Истина
еще:
  вернуть ложь
G1 = G9Пример("Гуру99")
G2 = G9Пример("Хип-Хоп99")
G3 = G9Пример("Гуру99")
печать (G1! = G2)
печать (G2! = G3)
печать (G1! = G3)
 
 Выход
 Истинно
Истинный
False 
 Операторы сравнения в Python 
 В следующей таблице приводится список операторов сравнения в Python: –
  Оператор 
  Значение 
  Пример 
  != 
 Не равно — дает истину, если операнды не имеют одинаковых значений
 А!=В
  == 
 Равно — Дает истину, если операнды имеют одинаковые значения
 А==В
  >= 
 Больше или равно — дает значение true, если первый операнд больше или равен второму операнду
 А>=В
  <= 
 Меньше или равно - дает значение true, если первый операнд меньше или равен второму операнду
 А<=В
  > 
 Больше, чем — дает истинное значение, если первый операнд больше второго операнда
 А>В
  < 
 Меньше чем — дает значение true, если первый операнд меньше второго операнда
 А<В
 Полезные советы по использованию оператора не равно 
 Вот несколько полезных советов
 Оператор не равно можно использовать в форматированных строках.
No related posts.