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

Логические операции and, or и not в Python.

Синтаксис:

x or y
x and y
not x
x and y and not z
x and (y or z)

Важно! Операторы and и or закорачивают вычисление своих операндов (т.е. используют замыкания): правый операнд вычисляется лишь в том случае, если его значение необходимо для получения истинного значения в операциях and или or. Другими словами, замыкания в логических операциях используются для запуска второй части или последующих частей логического выражения только в том случае, если это актуально!

• or — оценивает второй аргумент, только если первый равен False. Если какой либо операнд в цепочке or является истиной, немедленно возвращается результат — первое истинное значение.
• and — оценивает второй аргумент, только если первый равен True. Если в цепочке and все операнды являются истиной, результатом будет последнее значение. А если какой-либо из операндов является False, результатом будет первое ложное значение.
• not имеет более низкий приоритет, чем операторы сравнения, так not a == b интерпретируется как not (a == b), а выражение a == not b вовсе является синтаксической ошибкой. Единственный логический оператор с одним аргументом. Он принимает один аргумент x и возвращает противоположный результат: False для истинного значения и True для ложного значения.

Операторы and и or не приводят свои результаты принудительно к значениям True или False, а возвращают один из своих операндов. Такой подход позволяет использовать эти операторы в более общих, а не только булевых операциях. Если другие операторы, прежде чем выполнить операцию, вычисляют все свои операнды, то в случае операторов

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

Из булевых операторов, not имеет самый высокий приоритет, а or самый низкий, так что A and not B or C эквивалентно (A and (not B)) or C. Как всегда, скобки могут быть использованы для выражения желаемого приоритета в операциях.

Логические операции, упорядоченные по приоритету выполнения:

1. not x — если x ложно, то возвращается True, иначе False.
2. x and y — если x ложно, то возвращается x, иначе у.
3. x or y — если x ложно, то возвращается у, иначе x

Объяснение работы замыкания c оператором

and:

a = 'a'
b = 'b'
c = 'c'
>>> a and b
# 'b'
>>> '' and b
# ''
>>> a and b and c
# 'c'

Пояснения к примеру выше с оператором and

:

1. Оператор and вычисляет значения в булевом контексте слева направо. Значения 0, '', [], (), {} и None являются ложью, все остальное является истиной. Если у and оба операнда являются истиной, результатом будет последнее значение.
2. Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает это '' — пустая строка, первое значение которое является ложью.
3. Все значения являются истиной, так что в результате мы получаем последнее c.

Объяснение работы замыкания c оператором

or:

a = 'a'
b = 'b'
>>> a or b
# 'a'
>>> '' or b
# 'b'
>>> '' or [] or {}
# {}
>>> def func():
...        return 1
>>> a or func()
# 'a'

Пояснения к примеру выше с оператором or:

1. Оператор or вычисляет значения в булевом контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае a, первое истинное значение.
2. or вычисляет выражение '', которое является ложью, затем b, которое является истиной, и возвращает его значение.
3. Если все значения являются ложью, or возвращает последнее.
4. Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция func() не вызывается, так как для получения результата выражения с оператором or достаточно того, что первый операнд a является истиной.

Другие примеры с and и or:

>>> a = 'one'
>>> b = 'two'
>>> 1 and a or b
# 'one'
>>> 0 and a or b
# 'two'
>>> a = ''
>>> b = 'two'
# 'a' - пустая строка, которую Python считает ложью,
# следовательно 1 and '' дает '', а '' or 'two' дает 'two'.
  
>>> 1 and a or b
# 'two'

Внимание! Замыкания в операциях and и or можно использовать с пользой в вычислениях для экономии ресурсов, сокращения времени выполнения и т.д., только будьте осторожны! Необходимо четко понимать как работают замыкания в операторах and и or.

• Экономия ресурсов и времени выполнения при помощи and;
• Проверка предварительных условий перед выражением;
• Определение значения по умолчанию при помощи or;
• Пример использования замыканий в функциях all() и any().

Экономия ресурсов и времени выполнения при помощи

and.

Рассмотрим реальный пример из модуля base64 стандартной библиотеки Python, который использует замыкание в оператора if. Исследуем функцию b64decode, которая берет строку (или объект, подобный байтам) и декодирует ее:

# взято из Lib/base64.  py
def b64decode(s, altchars=None, validate=False):
    """Decode the Base64 encoded bytes-like object or ASCII string s.
    [docstring cut for brevity]
    """
    s = _bytes_from_decode_data(s)
    if altchars is not None:
        altchars = _bytes_from_decode_data(altchars)
        assert len(altchars) == 2, repr(altchars)
        s = s.translate(bytes.maketrans(altchars, b'+/'))
    # использование замыкания с оператором `and`
    if validate and not re.fullmatch(b'[A-Za-z0-9+/]*={0,2}', s):
        raise binascii.Error('Non-base64 digit found')
    return binascii.a2b_base64(s)

Смотрим на оператор if, который помечен комментарием. В условии сначала проверяется аргумент

validate, а только потом результат работы функции re.fullmatch(). Аргумент validate сообщает функции, хочет ли пользователь вообще проверять строку, которую нужно декодировать. Обратите внимание, что если validate=False то сопоставление регулярного выражения не запускается (срабатывает замыкание). Если порядок операндов поменять, то результат остался такой же, но было бы потрачено гораздо больше времени.

Проверка предварительных условий перед выражением.

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

Допустим есть последовательность и нужно взять элемент по индексу, но последовательность может оказаться пустой или ее длина может быть меньше индекса. Например:

>>> lst = [0, 1, 2]
>>> lst[3]
# Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
# IndexError: list index out of range

Используем проверку предварительных условий:

>>> lst = [0, 1, 2]
>>> if lst and len(lst) >=3:
...     lst[3]

Здесь, в условии сначала проверяется что список НЕ пустой и только после этого вычисляется длинна этого списка. Если список пустой, то его длина проверяться не будет и условие if завершиться.

Еще один пример из модуля enum:

# взято из Lib/enum.py
def _create_(cls, class_name, names, *, module=None, qualname=None, type=None, start=1):
    """
    Convenience method to create a new Enum class.
    """
    # [сокращено для краткости]
    # special processing needed for names?
    if isinstance(names, str):
        names = names.replace(',', ' ').split()
    # смотрим на следующие условие 
    if isinstance(names, (tuple, list)) and names and isinstance(names[0], str):
        original_names, names = names, []
        last_values = []
    # [сокращено для краткости]

Более длинный оператор if содержит три выражения, разделенных операторами and, и первые два выражения нужны для того, чтобы убедиться, можно ли безопасно выполнить последнее.

• isinstance(names, (tuple, list)) — проверяет, является ли names кортежем или списком. Если не является то условие завершается.
• далее names проверяется пусто оно или нет. Если элементов нет то условие завершается.
• если names не пустой, то можно безопасно выполнить последнюю проверку, связанную с индексацией names[0], а именно isinstance(names[0], str).

Определение значения по умолчанию при помощи

or.

Замыкание с помощью логического оператора or может использоваться для присвоения переменным значений по умолчанию. Вот пример:

# test.py
greet = input("Ваше имя >> ") or "незнакомец"
print(f"Привет, {greet}!")
# $python3 -i test.py
# Ваше имя >>
# Привет, незнакомец!

Если запустить этот пример и ничего не вводя нажать Enter, то получим вывод «Привет, незнакомец!». Что тут происходит? Если ничего не вводить и нажать Enter, то функция input() вернет пустую строку '', что является False. Следовательно, оператор or видит ложное значение слева и должен оценить правый операнд. Для определения окончательное значение выражения or оценивает правый операнд и если он True, то возвращает его значение.

Еще пример присвоения значение по умолчанию (используя or) для изменяемого аргумента из стандартной библиотеки Python.

# взято из Lib/cgitb.py 
class Hook:
    """A hook to replace sys.excepthook that shows tracebacks in HTML."""
    def __init__(self, display=1, logdir=None, context=5, file=None,
                 format="html"):
        self.display = display          # send tracebacks to browser if true
        self.logdir = logdir            # log tracebacks to files if not None
        self.context = context          # number of source code lines per frame
        self.file = file or sys.stdout  # <= смотрите сюда
        self.format = format

Этот код взят из модуля cgitb и определяет sys.stdout как значение по умолчанию для переменной self.file. Определение функции __init__ имеет file=None в качестве ключевого аргумента, так почему бы просто не написать file=sys.stdout?

Проблема в том, что sys. stdout может быть изменяемым объектом, поэтому использование file=sys.stdout в качестве ключевого аргумента со значением по умолчанию не будет работать так, как ожидается. Это легче продемонстрировать со списком в качестве аргумента по умолчанию, хотя принцип тот же:

>>> def addend(val, l=[]):
...   l.append(val)
...   print(l)
>>> addend(3, [1, 2])
# [1, 2, 3]
>>> addend(5)
# [5]
>>> addend(5)
# [5, 5]
>>> addend(5)
# [5, 5, 5]

Обратите внимание на три последовательных вызова addend(5). Ожидается, что вызов addend(5) со значением по умолчанию l=[] будет вести себя одинаково, но т.к. список является изменяемым объектом, то вызовы добавляют значения val к значению по умолчанию [], при этом список растет! Дополнительно смотрите материал «Список Python как аргумент по умолчанию».

Пример использования замыканий

or и and в функциях all() и any().

Если в выражении генератора использовать оператор моржа :=, и принимать во внимание тот факт, что функции all() и any() также используют замыкания, то можно использовать следующую конструкцию для извлечения первого истинного элемента.

any(predicate(witness := item) for item in items)

Другими словами, если какой-либо элемент item удовлетворяет условию в функции predicate(), то переменная witness сохранит его значение!

Например, если последовательность содержит много целых чисел, как выяснить, есть ли там какие-либо нечетные числа, и как вывести первое из них?

items = [14, 16, 18, 20, 35, 41, 100]
any_found = False
for item in items:
    any_found = item % 2
    if any_found:
        print(f"Найдено нечетное число {item}.")
        break

Теперь все это сравним со следующим кодом:

>>> items = [14, 16, 18, 20, 35, 41, 100]
>>> is_odd = lambda x: x % 2
>>> if any(is_odd(witness := item) for item in items):
. ..     print(f"Найдено нечетное число {witness}.")
# Найдено нечетное число 35.

Операторы меньше, больше или равно(>

Оператор «Меньше или равно» в Python используется для сравнения, если операнд меньше или равен другому операнду.

Синтаксис:

operand_1 <= operand_2

Оператор <= возвращает логическое значение true, если значение операнда_1 меньше или равно значению операнда_2. В противном случае возвращается False. Если операнды представляют собой последовательности, такие как строки, списки, кортежи и т.д., соответствующие элементы объектов сравниваются для вычисления результата.

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

Меньше или Равно можно рассматривать как составное выражение, образованное операторами, как показано ниже.

(operand_1 < operand_2) or (operand_1 == operand_2)

Пример 1

В этом примере мы сравним два целых числа, x и y, и проверим, x меньше или равно y.

x = 5
y = 12
result = x <= y
print(result) #True

x = 8
y = 8
result = x <= y
print(result) #True

x = 78
y = 8
result = x <= y
print(result) #False

Вывод:

True
True
False

Пример 2: с последовательностями

Последовательность может быть строкой, списком, кортежем и т.д. Вы можете сравнить две последовательности, используя оператор сравнения «меньше или равно».

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

В следующей программе мы сравним два списка, x и y, и проверим, x меньше или равно y.

x = [41, 54, 21]
y = [98, 8]
z = [41, 54, 4, 6]
k = [41, 54, 21]
print(x <= y) #True
print(x <= z) #False
print(x <= k) #True

Вывод:

True
False
True

Проверка x <= y означает проверку, если [41, 54, 21] <= [98, 8]. При сравнении первого элемента в списках оператор «меньше или равно» возвращает True.

Для x <= z означает проверку, если [41, 54, 21] <= [41, 54, 4, 6]. При сравнении первых двух элементов в списках оператор <= возвращает True. Итак, оператор исследует, пока не достигнет конца списка с True для всех элементов или False в середине. Для третьего элемента оператор возвращает False. Теперь оператор останавливает сравнение и возвращает False.

А для x <= k из данных ясно, что оператор возвращает True.

Оператор “Больше или равно”

Оператор «Больше чем» или «Равно» в Python используется для сравнения, если операнд больше или равен другому операнду.

Синтаксис:

operand_1 ><= operand_2

Оператор Больше или равно возвращает логическое значение. true, если значение операнда_1 больше или равно значению операнда_2. В противном случае возвращается False. Если операнды представляют собой последовательности, такие как строки, списки, кортежи и т.д., соответствующие элементы объектов сравниваются для вычисления результата.

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

«Больше» или «Равно» можно рассматривать как составное выражение, образованное операторами «Больше чем» и «Равно», как показано ниже.

(operand_1 > operand_2) or (operand_1 == operand_2)

Пример

В этом примере мы сравним два целых числа, x и y, и проверим, x больше или равно y.

x = 57
y = 12
result = x >= y
print(result) #True

x = 8
y = 8
result = x >= y
print(result) #True

x = 78
y = 89
result = x >= y
print(result) #False

Вывод:

True
True
False

Пример 2: с последовательностями

Последовательность может быть строкой, списком, кортежем и т.д. Вы можете сравнить две последовательности, используя оператор сравнения больше или равно.

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

В следующей программе мы сравним два списка, x и y, и проверим, x больше или равно y.

x = [41, 54, 21]
y = [9, 8]
z = [41, 54, 74, 6]
k = [41, 54, 21]
print(x >= y) #True
print(x >= z) #False
print(x >= k) #True

Вывод:

True
False
True

Проверка x> = y означает проверку, если [41, 54, 21]> = [9, 8]. При сравнении первого элемента в списках оператор больше или равно возвращает True.

Для x> = z означает проверку, если [41, 54, 21]> = [41, 54, 74, 6]. При сравнении первых двух элементов в списках оператор больше или равно возвращает True. Итак, оператор исследует, пока не достигнет конца списка с True для всех элементов или False в середине.

Для третьего элемента оператор возвращает False. Теперь оператор останавливает сравнение и возвращает False для общего сравнения двух списков. А для x> = k из данных ясно, что оператор возвращает True.

Как использовать не равный оператор в Python?

Нанять? Flexiple поможет вам создать команду вашей мечты из разработчиков и дизайнеров.

Hire Talent

В этом уроке мы узнаем, как использовать оператор «не равно» в Python. Это один из многих операторов сравнения в Python, таких как больше, меньше, равно и т. д. Мы можем использовать их с условными операторами, такими как если, если-иначе, пока, делать-пока и т. д.

Содержание

1. Что делает оператор не равно в Python?
2. Синтаксис оператора не равно в Python
3. Использование оператора не равно
4. Использование оператора не равно для сравнения
5. Использование оператора не равно с оператором if
6. Использование оператора не равно с циклом while
7. Заключительные мысли

Что делает оператор не равно в python?

Не равно — это оператор сравнения, используемый для проверки того, не равна ли первая переменная второй переменной.

Имеет два возвращаемых значения. Если переменные не равны, возвращается TRUE, иначе FALSE. При возврате TRUE или FALSE учитываются как значение, так и тип данных переменных.

Синтаксис оператора не равно

Оператор не равно может быть записан двумя способами:

<> Удален в Python 3, но широко использовался в Python 2. Он был взят из языка программирования ABC, предшественника Python. Он вызывал много синтаксических ошибок и поэтому был удален.

Синтаксис:

 а <> б 

!=

Чаще используется, поскольку поддерживается как в Python 2, так и в Python 3.

Синтаксис:

 a != b 

Некоторые шрифты могут измениться != на ≠, на самом деле ничего не значит.

Использование оператора не равно

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

Например, ниже вы видите две переменные с целочисленным значением 2.

Ввод:

 а = 2
б = 2
если (а != б):
  print("а не равно b")
еще
  print("a равно b") 

Так как «a» и «b» равны, условие FALSE и блок кода будет пропущен, а блок кода else будет выполнен.

Выход:

 а равно b 

Теперь в другом случае, если обе переменные имеют значение 2, но имеют разные типы данных. Один из них — целое число, а другой — строка.

 а = 2
б = "2"
если (а != б):
  print("а не равно b")
еще
  print("а равно b") 

На этот раз «a» имеет целочисленное значение 2, а «b» имеет строковое значение 2. Обе переменные не равны, поэтому удовлетворяют условию. Следовательно, блок кода выполняется.

Выход:

 a равно b 

Использование оператора не равно для сравнения

Оператор не равно может использоваться для сравнения переменных. Если переменные не равны, будет напечатано TRUE, а если переменные равны, будет напечатано FALSE.

Ввод:

 а = 5
б = 5
с = 7
напечатать (а! = б)
напечатать (а != с) 

Выход:

 ЛОЖЬ
ИСТИНА 

? Поскольку «a» и «b» равны, a != b — ЛОЖЬ, а «a» и «c» не равны, a != c — ИСТИНА.

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

Ввод:

 а = 3
б = 4
с = 5
если (а != б и с):
  print("a не равно b и c") 

Блок кода будет выполнен, так как «a» не равно и «b», и «c». Если бы «a» было равно либо «b», либо «c», то блок кода не запустился бы.

Вывод:

 a не равно b и c 

Другой пример:

 а = 3
б = 4
с = 5
если (a != b или c) :
  print("все три переменные не равны") 

Здесь блок кода будет выполнен, если либо «b», либо «c» не равно «a».

Выход:

 все три переменные не равны 

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

Оператор не равно используется с оператором IF в качестве условия. Если условие выполняется, блок кода выполняется, в противном случае блок кода пропускается.

Ввод:

 а = 15
если (а%2 != 0):
  print(a, "является нечетным числом") 

Поскольку остаток переменной при делении на 2 не равен 0, она удовлетворяет условию if и выполняется блок кода.

Выход:

 15 — нечетное число 

Использование оператора не равно с циклом while

Оператор not equal используется с циклом while в качестве условия. Блок кода будет выполняться до тех пор, пока условие не станет ИСТИННЫМ.

Ввод:

 а = 1
пока (а != 5):
  печать (а)
  а += 1 

Поскольку переменная не равна 5, цикл будет продолжаться до тех пор, пока «а» не станет равным «5».

Выход:

 1
2
3
4 

Заключительные мысли

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

Другие руководства

Как использовать экспоненты в Python? Различные способы суммирования чисел в PythonКак проверить, существует ли файл в Python?

Другие связанные концепции

Как представить бесконечное число в Python? 4 способа реализации Python Switch Case StatementКак получить метку времени в Python?

Понравился этот блог?

Работайте с лучшими

стартапами и компаниями. Получайте оплату вовремя. Подать заявку сейчас

Попробуйте высококачественный разработчик

в течение 7 дней. Платите, только если удовлетворены. View Talent

Copyright @2023 Flexiple Inc

Python не равен | Работа оператора не равно в Python с примерами

В этой статье мы обсудим оператор не равно в Python. В общем, понятие оператора в любом языке программирования используется для выполнения любых логических или арифметических операций над определенными переменными и их значениями, и этот оператор известен как оператор сравнения. Это не равно оператору — это специальный символ в Python, который может оценивать логические или арифметические выражения. Обычно это представляется как « != » и « is not » для работы с оператором «не равно». В Python значения, с которыми работает оператор this not equal to, называются операндами. Это не равно оператору в точности противоположно равно оператору. Это возвращает true, когда значения операндов на каждой стороне не совпадают или не равны; в противном случае он вернет false.

Работа оператора «не равно» в Python с синтаксисом

В этом разделе мы увидим синтаксис и примеры оператора «не равно» в Python. Этот оператор используется для сравнения двух значений, который возвращает истину, если оба значения операнда не равны с обеих сторон оператора, но имеют один и тот же тип, в противном случае он возвращает ложь. Следовательно, оператор не равно является оператором сравнения и обозначается как «!=». Теперь давайте подробно в следующем разделе.

Синтаксис:

 opr1 != opr2 

или

 if…else (opr1 не равно opr2) 

opr1: Любой допустимый операнд или объект.

opr2: Любой действительный операнд или объект.

Этот оператор или выражение будет возвращать логические значения, такие как «Истина» или «Ложь».

В приведенном выше синтаксисе мы видели, что мы можем определить «не равно» двумя способами в Python, используя «!=» или «не является» в выражениях или условиях и возвращая логическое значение «Истина» или «Ложь». наличие операндов одного типа с обеих сторон оператора.

Примеры Python not equal

Теперь давайте посмотрим пример, демонстрирующий не равно оператору (!=).

Пример #1

Код:

 print("Программа для демонстрации оператора не равно (!=) выглядит следующим образом:")
х = 5
print("Первый операнд со своим значением выглядит следующим образом:")
печать (х)
у = 3
print("Второй операнд со своим значением выглядит следующим образом:")
печать (у)
print("Действие после применения оператора не равно к вышеприведенным операндам выглядит следующим образом:")
напечатать(х != у) 

Вывод:

В приведенной выше программе мы видим, что мы объявили две переменные, x и y, которые рассматриваются как операнды со значениями 5 и 3. Мы видим, что пытаемся напечатать результат выражение x != y, которое напечатает «True», поскольку оба заданных операнда не равны.

Чтобы увидеть, что вышеприведенная программа имеет вывод «Ложь», нам нужно определить значения двух операндов x и y с одинаковым значением. Итак, мы видим скриншот ниже.

В Python, когда мы используем оператор «не равно», мы должны отметить, что два объявленных операнда должны иметь один и тот же тип данных; иначе в Python, если оба операнда имеют разные типы данных, он вернет не равное значение. Продемонстрируем ниже на примере.

Пример #2

Код:

 print("Программа для демонстрации не равно оператору с разными типами данных операндов:")
х = 5
у = "5"
если ( х != у ):
print("x не равно y") 

Вывод:

В приведенной выше программе мы видим, что мы объявили две переменные: x как тип данных int со значением 5 и y как тип данных string со значением «5». Следовательно, оператор not equal to печатает, операнды имеют разные значения, хотя значение равно 5 для обоих операндов, где один имеет тип int, а другой — строковый.

Теперь давайте рассмотрим пример, в котором оператор not equal to может быть определен как «is not» при использовании условных циклов, таких как if … else. Продемонстрируем это на приведенном ниже примере.

Пример #3

Код:

 print("Программа для демонстрации оператора не равно (не равно) выглядит следующим образом:")
х = 5
print("Первый операнд со своим значением выглядит следующим образом:")
печать (х)
если х не 7:
распечатать("не равно")
еще:
print("equal") 

Вывод:

В приведенной выше программе мы видим, что мы объявили только один операнд x со значением 5. Затем мы пытаемся проверить, не является ли значение x «не » равно 7. В программе мы можем видеть выражение, данное в условии «если», используя «не является» для сравнения значений данного операнда со значением, указанным в выражении внутри цикла if. Итак, если это выражение удовлетворяет требованиям, то оно напечатает «не равно»; иначе, если выражение не удовлетворяет, то будет напечатано «равно». Этот результат можно увидеть на скриншоте выше.

В Python оператор «не равно» обозначается (!=) и более рекомендуется разработчиками и поддерживается версиями Python 2 и 3. В более старых версиях Python был еще один оператор сравнения не равно оператору, который обозначается как ( < > ). Но этот оператор не поддерживается в последней версии, а также в Python 3, и вышеприведенная версия также его не поддерживает. Теперь давайте посмотрим демонстрацию в приведенном ниже примере с ошибкой, которая отображается, когда < > не равно оператору в программе вместо ( != ).

Пример #4

Код:

 print("Программа с не равным оператором <> в версии Python 2.7")
печать("\n")
х = 4
у = 5
print(x<>y) 

Вывод:

В приведенной выше программе мы видим, что мы используем <> not equal to оператор, который работает только в версиях Python 3.