Операторы равенства: == и !=
Бинарные операторы равенства сравнивают операнды для строгого равенства или неравенства.
Операторы равенства, то есть равно ( == ) и не равно ( != ), имеют более низкий приоритет, чем операторы отношения, но их поведение аналогично. Тип результата для этих операторов . bool
== Оператор равного () возвращает true , если оба операнда имеют одно и то же значение; в противном случае возвращается false . Оператор not-equal-to ( != ) возвращает true , если операнды не имеют того же значения; в противном случае возвращается false .
Оператор ключевое слово для !=
C++ указывает not_eq в качестве альтернативной орфографии для != . (Нет альтернативной орфографии для == .) В C альтернативная орфография предоставляется в виде макроса в заголовке . В C++альтернативная орфография является ключевое слово; или эквивалентное
Пример
// expre_Equality_Operators.cpp // compile with: /EHsc #include using namespace std; int main()
Операторы равенства могут сравнивать указатели на члены одного типа. В таком сравнении выполняются преобразования указателя на члены. Указатели на члены также можно сравнить с константным выражением, результатом которого является значение 0.
Операторы равенства — проверка того, равны ли два объекта или нет
Операторы == (равенство) и != (неравенство) проверяют равенство или неравенство своих операндов. Типы значений равны, если их содержимое равно. Ссылочные типы равны, если две переменные ссылаются на одно хранилище.
Оператор равенства ==
Оператор равенства == возвращает значение true , если его операнды равны. В противном случае возвращается значение false .
Равенство типов значений
Операнды встроенных типов значений равны, если равны их значения.
int a = 1 + 2 + 3; int b = 6; Console.WriteLine(a == b); // output: True char c1 = 'a'; char c2 = 'A'; Console.WriteLine(c1 == c2); // output: False Console.WriteLine(c1 == char.ToLower(c2)); // output: True У операторов == , < , >, = , если какой-то из операндов не является числом (Double.NaN или Single.NaN), результатом операции является false . Это означает, что значение NaN не больше, не меньше и не равно любому другому значению double (или float ), включая NaN . Дополнительные сведения и примеры см. в справочных статьях по Double.NaN или Single.NaN.
Два операнда одного типа enum равны, если равны соответствующие значения базового целочисленного типа.
По умолчанию пользовательские типы struct не поддерживают оператор == . Чтобы поддерживать оператор == , пользовательская структура должна перегружать его.
Равенство ссылочных типов
По умолчанию два операнда ссылочного типа, отличные от записи, являются равными, если они ссылаются на один и тот же объект.
public class ReferenceTypesEquality < public class MyClass < private int id; public MyClass(int id) =>this.id = id; > public static void Main() < var a = new MyClass(1); var b = new MyClass(1); var c = a; Console.WriteLine(a == b); // output: False Console.WriteLine(a == c); // output: True >> Как показано в примере, определяемые пользователем ссылочные типы поддерживают оператор == по умолчанию. Однако ссылочный тип может перегружать оператор == . Если ссылочный тип перегружает оператор == , воспользуйтесь методом Object.ReferenceEquals, чтобы проверить, что две ссылки этого типа указывают на один и тот же объект.
Равенство типов записей
Типы записей поддерживают == операторы != , которые по умолчанию предоставляют семантику равенства значений. То есть два операнда записи равны, когда оба они равны null или равны соответствующие значения всех полей и автоматически реализуемых свойств.
public class RecordTypesEquality < public record Point(int X, int Y, string Name); public record TaggedNumber(int Number, ListTags); public static void Main() < var p1 = new Point(2, 3, "A"); var p2 = new Point(1, 3, "B"); var p3 = new Point(2, 3, "A"); Console.WriteLine(p1 == p2); // output: False Console.WriteLine(p1 == p3); // output: True var n1 = new TaggedNumber(2, new List() < "A" >); var n2 = new TaggedNumber(2, new List() < "A" >); Console.WriteLine(n1 == n2); // output: False > > Как показано в предыдущем примере, для элементов ссылочного типа, не относящихся к записи, сравниваются их ссылочные значения, а не для ссылочных экземпляров.
Равенство строк
Два операнда string равны, если они оба имеют значение null или оба экземпляра строки имеют одинаковую длину и идентичные символы в каждой позиции символа.
string s1 = "hello!"; string s2 = "HeLLo!"; Console.WriteLine(s1 == s2.ToLower()); // output: True string s3 = "Hello!"; Console.WriteLine(s1 == s3); // output: False Сравнение равенства строк — это порядковые сравнения с учетом регистра. Дополнительные сведения о том, как сравнивать строки, см. в статье Сравнение строк в C#.
Равенство делегатов
Два операнда делегатов одного типа среды выполнения равны, если оба из них имеют значение null или их списки вызовов имеют одинаковую длину и содержат одинаковые записи в каждой позиции:
Action a = () => Console.WriteLine("a"); Action b = a + a; Action c = a + a; Console.WriteLine(object.ReferenceEquals(b, c)); // output: False Console.WriteLine(b == c); // output: True Подробные сведения см. в разделе Delegate equality operators (Операторы равенства делегатов) в спецификации языка C#.
Делегаты, созданные из оценки семантических лямбда-выражений , не равны, как показано в следующем примере:
Action a = () => Console.WriteLine("a"); Action b = () => Console.WriteLine("a"); Console.WriteLine(a == b); // output: False Console.WriteLine(a + b == a + b); // output: True Console.WriteLine(b + a == a + b); // output: False Оператор неравенства !=
Оператор неравенства != возвращается true , если его операнды не равны, false в противном случае. Для операндов встроенных типов выражение x != y дает тот же результат, что и выражение !(x == y) . Дополнительные сведения о равенстве типов см. в разделе Оператор равенства.
В следующем примере иллюстрируется использование оператора != .
int a = 1 + 1 + 2 + 3; int b = 6; Console.WriteLine(a != b); // output: True string s1 = "Hello"; string s2 = "Hello"; Console.WriteLine(s1 != s2); // output: False object o1 = 1; object o2 = 1; Console.WriteLine(o1 != o2); // output: True Возможность перегрузки оператора
Определяемый пользователем тип может перегружать операторы == и != . Если тип перегружает один из двух операторов, он должен также перегружать и другой.
Тип записи не может явно перегружать == операторы и != операторы. Если необходимо изменить поведение операторов == и != для типа записи T , реализуйте метод IEquatable.Equals со следующей сигнатурой.
public virtual bool Equals(T? other); Спецификация языка C#
Дополнительные сведения о равенстве типов записей см. в разделе Элементы равенствапредложения функции записей.
См. также
- справочник по C#
- Операторы и выражения C#
- System.IEquatable
- Object.Equals
- Object.ReferenceEquals
- Сравнения на равенство
- Операторы сравнения
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Оператор неравенства != в 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. С помощью различных примеров и сценариев мы узнали, как работает оператор != и как его применять для проверки неидентичности двух переменных.
PHP: Операторы сравнения
В этой главе описаны операторы сравнения. Эти операторы проверяют равенство (такое как равно, меньше, тождественно равно и т.д.) между двумя значениями и возвращают true или false в зависимости от того, как соотносятся операнды. Операторы сравнения всегда возвращают логические значения, и эти значения чаще всего применяются в таких операторах как if, while или for для управления ходом исполнения программы.
| Пример | Название | Результат |
|---|---|---|
| $i == $y | Равно | TRUE если $i равно $y после преобразования типов данных. |
| $i === $y | Идентично | TRUE если $i равно $y и имеет тот же тип данных. |
| $i != $y | Не равно | TRUE если $i не равно $y после преобразования типов данных. |
| $i <> $y | Не равно | TRUE если $i не равно $y после преобразования типов данных. |
| $i !== $y | Не идентично | TRUE если $i не равно $y или они разных типов. |
| $i < $y | Меньше | TRUE если $i строго меньше $y. |
| $i > $y | Больше | TRUE если $i строго больше $y. |
| $i | Меньше или равно | TRUE если $i меньше или равно $y. |
| $i >= $y | Больше или равно | TRUE если $i больше или равно $y. |
Примечание: если попытаться вывести результат операции сравнения на экран, значение true отобразится в окне браузера как 1. Значение false соответствует числу 0 и не отображается на экран (в принципе это вы должны помнить из описания типа boolean ). Если вы хотите увидеть результат в виде true или false используйте функцию var_dump() .
Так же стоит отметить: если сравнивается строка с числом или две строки, которые содержат числа, каждая строка будет преобразована в число, и сравниваться они будут как числа.
Оператор == (равенства)
Оператор == ( равенства ) принимает операнды любого типа, если два операнда равны, возвращается значение true , в противном случае — false .
Если операнды имеют разные типы данных, PHP попытается преобразовать их перед сравнением к одному типу, например такое выражение ‘4’ == 4 вернёт значение true , так как PHP автоматически приведет сравниваемые значения к одному типу данных. Аналогично, выражение $a == 1 вернёт значение true , если переменная $a содержит значение 1. Если требуется избежать неявного преобразования типов при сравнении, то следует использовать оператор идентичности, который будет рассмотрен далее.
Оператор === (идентичности)
Оператор === ( идентичности ) принимает операнды любого типа и возвращает true , если их значения совпадают (равны), и false , если они различны. Чем же он отличается от оператора равенства? Оператор идентичности проверяет два операнда на «идентичность», руководствуясь строгим определением совпадения, это означает, что помимо равенства самих значений операндов, они также должны относиться к одному и тому же типу данных. В качестве примера рассмотрим такое выражение, как 5 === ‘5’ , результатом этого выражения будет значение false , так как значение слева является числом, а значение справа — строкой, то есть у этих значений разные типы данных. Запомните, что операторы == и === означают «равно» и «идентично/тождественно равно» .
Оператор != или <> (неравенства)
Оператор неравенства имеет два вида: != и <> . Он является противоположностью оператора == и возвращает true , в том случае, если значения операндов не равны. Оператор неравенства возвращает false только в том случае, если значения по обе стороны от него равны друг другу.
$var2); // вернет false var_dump('Home' <> 'home'); // вернет true ?>
Оператор !== (неидентичности)
Оператор !== ( неидентичности ) выполняет проверку, в точности противоположную оператору === . Он возвращает true , если значения операндов не равны друг другу или не относиться к одному и тому же типу данных. В качестве примера рассмотрим следующее выражение: 7 !== ‘7’ , оператор «неидентичности» вернет true , потому что значение слева является числом, а значение справа строкой, то есть они относятся к разным типам данных. Отсюда легко будет запомнить, что операторы != и !== означают «не равно» и «не идентично/тождественно не равно».
Оператор > (больше)
При использовании оператора > ( больше ) сравнение возвращает true только в том случае, если значение слева от оператора больше значения справа от него. Как и другие операторы, оператор > работает не только с числовыми значениями, но и со строковыми. Но как одна строка может быть больше другой?
При работе со строками буква в нижнем регистре больше буквы в верхнем регистре. При сравнении строк PHP сначала проверяет на несовпадение первую букву строки. Если разницы не обнаруживается, происходит переход к следующему символу и т.д., пока не будет найдено различие или не будет достигнут конец строки. Если два значения с каждой из сторон оператора > будут равны, оператор также вернет false .
3); // вернет true var_dump('Hi' > 'hi'); // вернет false var_dump(1 > 1); // вернет false ?>
Оператор < (меньше)
Оператор >= (больше или равно)
Оператор >= ( больше или равно ) немного отличается от тех операторов сравнения, которые рассматривались ранее. Он добавляет возможность равенства двух значений по обе стороны от него, то есть, чтобы было возвращено true , значение слева от оператора должно быть больше или равно значению справа от него. Оператор «больше или равно» возвращает false , только если значение слева от него меньше, чем значение справа.
= 5); // вернет true var_dump('hi' >= 'hi'); // вернет true var_dump(1 >= 2); // вернет false ?>
Оператор
С этой темой смотрят:
- Выражения и операторы
- Арифметические операторы
- Логические операторы
- Побитовые операторы