Как написать на пайтоне не равно

There’s the != (not equal) operator that returns True when two values differ, though be careful with the types because "1" != 1. This will always return True and "1" == 1 will always return False, since the types differ. Python is dynamically, but strongly typed, and other statically typed languages would complain about comparing different types.

There’s also the else clause:

# This will always print either "hi" or "no hi" unless something unforeseen happens.
if hi == "hi":     # The variable hi is being compared to the string "hi", strings are immutable in Python, so you could use the 'is' operator.
    print "hi"     # If indeed it is the string "hi" then print "hi"
else:              # hi and "hi" are not the same
    print "no hi"

The is operator is the object identity operator used to check if two objects in fact are the same:

a = [1, 2]
b = [1, 2]
print a == b # This will print True since they have the same values
print a is b # This will print False since they are different objects.

• Главная

• Инструкции

• Python

• Какие операторы используются в Python: руководство

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

• арифметические,
• сравнения,
• присваивания,
• тождественности,
• принадлежности,
• логические,
• побитовые.

В этой статье-справочнике подробно рассмотрим каждый из них и приведем примеры.

Арифметические

Для сложения, вычитания, умножения и деления используются, соответственно, +, -, * и /.

>>> 24 + 28
52
>>> 24 - 28
-4
>>> 24 * 28
672
>>> 24 / 28
0.8571428571428571

Для возведения в степень — **.

>>> 5 ** 2
25
>>> 5 ** 3
125
>>> 5 ** 4
625

Для целочисленного деления без остатка — //.

>>> 61 // 12
5
>>> 52 // 22
2
>>> 75 // 3
25
>>> 77 // 3
25

% выдает остаток, то есть выполняет деление по модулю:

>>> 62 % 6
2
>>> 65 % 9
2
>>> 48 % 5
3
>>> 48 % 12
0

Сравнения

Таких операторов выражения в Python шесть: >, <, >=, <=, ==, !=. Обратите внимание, что «равно» в Питоне при сравнении записывается так: ==, потому что один знак «равно» означает присвоение значения (об этом в следующей главе). Для выражения «не равно» используется сочетание символов !=. При сравнении значений интерпретатор языка будет выдавать ответы True и False в зависимости от того, являются ли выражения истинными или ложными. Примеры:

>>> 26 > 58
False
>>> 26 < 58
True
>>> 26 >= 26
True
>>> 58 <= 57
False
>>> 50 == 50
True
>>> 50 != 50
False
>>> 50 != 51
True

Присваивания

Для присвоения значений переменным используется один знак «равно»:

>>> b = 5
>>> variants = 20

Также предусмотрены удобные конструкции для совмещения всех арифметических действий с одновременным присваиванием полученного значения: +=, -=, *=, /=, //=, %=. Например:

>>> cars = 5
>>> cars += 7
>>> cars
12

Мы задали переменную сars и присвоили ей значение 5, затем добавили еще 7 с одновременным присвоением нового значения. Конечно, можно вместо cars += 7 написать и так:

>>> cars = cars + 7
>>> cars
12

Ошибки нет, но первый вариант более компактный. Посмотрим, как работают другие действия одновременно с присваиванием:

>>> train = 11
>>> train -= 2
>>> train
9
>>> moto = 3
>>> moto *= 7
>>> moto
21
>>> plain = 8
>>> plain /= 4
>>> plain
2.0

Обратите внимание, что в последнем случае мы получили не целое значение, int, а с запятой, float.

Тождественности

Таких операторов в Python 2: is и is not. Как и в английском, первый означает (это) есть, а второй — это не. Ответами интерпретатора, как и в случае со сравнениями, будут True или False.

>>> 55 is 55
True
>>> 55 is 56
False
>>> 55 is not 55
False
>>> 55 is not 56
True
>>> 55 is '55'
False
>>> '55' is "55"
True

Разбираемся, что произошло в последних двух операциях. В первом случае (55 is '55') сравнивалось целое число и строка, поэтому интерпретатор выдал False, а во втором ('55' is "55") оба операнда представляли собой строки, поэтому было выдано True. Заметьте, что Питону не важно, использует ли программа одинарные или двойные кавычки: оба варианта синтаксически допустимы, поэтому результат тождества оказался истинным.

Принадлежности

Этих операторов тоже только два: in и not in. Они проверяют, есть или нет определенное значение в какой-либо последовательности. Например:

>>> wordlist = ('assistant', 'streetcar', 'fraudster', 'dancer', 'heat', 'blank', 'compass', 'commerce', 'judgment', 'approach')
>>> 'house' in wordlist
False
>>> 'assistant' in wordlist
True
>>> 'assistant' and 'streetcar' in wordlist
True

В последнем случае мы задействовали логический оператор (and), к рассмотрению которых и переходим.

Логические

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

>>> wordlist = ('assistant', 'streetcar', 'fraudster', 'dancer', 'heat', 'blank', 'compass', 'commerce', 'judgment', 'approach')
>>> 'assistant' and 'streetcar' in wordlist
True
>>> 'fraudster' and 'dancer' and 'heat' and 'blank' in wordlist
True
>>> 'fraudster' and 'dancer' and 'heat' and 'blank' and 'house' in wordlist
False

Как видим, значения 'house' в строке не оказалось, поэтому интерпретатор выдал False. Те же операции можно производить и над целочисленными значениями:

>>> numbers = 54 > 55 and 22 > 21
>>> print(numbers)
False

Всё верно, потому что одно из выражений ложно, а and требует, чтобы истинными были все условия.

or действует по-другому: выражение признается истинным в том случае, если истинно хотя бы одно из его значений. Поэтому, если в предыдущем примере мы заменим операторы and на or, то получим следующий результат:

>>> numbers = 54 > 55 or 22 > 21
>>> print(numbers)
True

22 больше 21 и при этом для операции or не важно, что первое выражение ложно.

А вот как работает not:

>>> first = True
>>> second = False
>>> print(not first)
False
>>> print(not second)
True

Из примера видно, что not переворачивает логические значения, меняя True на False и наоборот.

Побитовые

Побитовые (или битовые) операторы используются в Python для изменения объектов на уровне битов. Их всего пять (сдвиговые принадлежат к одному типу, поскольку различаются только направлением сдвига):

• & (AND)
• | (OR)
• ^ (XOR)
• ~ (NOT)
• << и >> (сдвиговые)

Битовые операторы основаны на принципах Булевой логики, поэтому действуют следующим образом:

& (AND) возвращает 1, если 1 есть в обоих операндах, в остальных случаях 0:

>>> 1 & 1
1
>>> 1 & 0
0
>>> 0 & 1
0
>>> 0 & 0
0

| (OR) возвращает 1, если 1 есть в одном из операндов, иначе вернет 0:

>>> 1 | 1
1
>>> 1 | 0
1
>>> 0 | 1
1
>>> 0 | 0
0

^ (XOR) возвращает 1, если операнды различаются, и 0, если они одинаковы:

>>> 1 ^ 1
0
>>> 1 ^ 0
1
>>> 0 ^ 1
1
>>> 0 ^ 0
0

~ (NOT) переворачивает биты, преобразуя положительные значения в отрицательные со сдвигом на единицу следующим образом:

>>> ~5
-6
>>> ~-5
4
>>> ~7
-8
>>> ~-7
6
>>> ~9
-10
>>> ~-9
8

<< и >> сдвигают биты на определенное количество, которое указывается справа:

>>> 1 << 1
2
>>> 1 >> 1
0

Для понимания сдвигов давайте разложим значения на биты, добавив, где нужно, разряд для удобства:

0 = 00
1 = 01
2 = 10

Поэтому, сдвигая в единице разряд влево, мы получаем 2, а если вправо, то 0. А если на два разряда?

>>> 1 << 2
4
>>> 1 >> 2
0

1 = 001
2 = 010
4 = 100

Сдвинув единицу на два разряда влево, мы получили 4, потому что 4 в битовом представлении будет 100. Сдвиг вправо на любое число разрядов всё равно дает нам ноль, так как бит «обнуляется» в любом случае.

Больше информации о битовых операторах можно найти в нашей статье о них. 

В завершение проясним один важный момент и разграничим похожие по способу действия языковые инструменты.

Чем отличаются операторы от функций

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

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

В этом уроке вы узнаете:

• синтаксис оператора не равно (!=) и варианты использования,
• синтаксис оператора равенства (==) с примерами и
• использование операторов is и not для проверки идентичности любых двух объектов Python.

Давайте начнем.

Для любых двух объектов Python obj1 и obj2 общий синтаксис использования оператора не равно:

<obj1> != <obj2>

• возвращает True, когда значения obj1 и obj2 не равны, и
• возвращает False в противном случае.

Примечание. Как упоминалось выше, obj1 и obj2 могут быть целыми числами, числами с плавающей запятой, строками, списками и т.д.

Примеры кода оператора Python Not Equal

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

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

Вот наш первый пример.

num1 = 27
num2 = 3*9

num1 != num2

# Output: False

Вы можете запускать примеры кода в интегрированной среде разработки Python для toadmin.ru — прямо из браузера. Или вы можете запустить на своей локальной машине.

Поскольку num1 = 27, а num2 также равно 27 (3*9 = 27), значения num1 и num2 равны. Таким образом, оператор != возвращает False.

Возьмем другой пример.

В приведенном ниже коде для num1 установлено значение 7. А для num2 установлено значение 7. Поскольку они относятся к разным типам данных, оператор не равно возвращает True.

num1 = 7 
num2 = "7" 
num1 != num2 

# Output: True

Вы приводите строку к целому числу, как показано ниже:

num1 = 7
num2 = int("7")

num1 != num2

# Output: False

В этом случае вы можете видеть, что возвращаемый результат равен False, так как num1 и num2 теперь равны целому числу 7.

Вы также можете использовать оператор не равно с коллекциями Python, такими как списки, кортежи и наборы.

Примечание. Для наборов данных, таких как списки, оператор не равно работает путем проверки значений отдельных элементов. Например, два списка list1 и list2 — каждый длиной n — равны, только если list1[i] == список2[i] для i в {0,1,2,3,..n-1}.

Вот пример:

list1 = [2,4,6,8]
list2 = [2,4,6,9]

list1 != list2

# Output: True

В приведенном выше примере список1 и список2 отличаются только одним элементом. И оператор not equal != возвращает True, как и ожидалось.

Использование оператора Python Not Equal в условных выражениях

Вы часто будете использовать оператор «не равно» как часть условных выражений Python.

Например, фрагмент кода ниже показывает, как вы можете проверить, является ли число нечетным.

Число, которое не делится без остатка на 2, является нечетным. А это сводится к условию num%2 != 0.

num = 7
if(num%2 != 0):
  print("The number is odd.")
else:
  print("The number is even.")

# Output: The number is odd.

Вы также можете использовать условные операторы в понимание списка когда вы хотите сохранить только те элементы списка, которые соответствуют определенному условию. В приведенном ниже примере нечетные_10 — это список всех нечетных чисел меньше 10.

odd = [num for num in range(10) if num%2 != 0]
print(odd)

# Output: [1, 3, 5, 7, 9]

На этом мы завершаем обсуждение оператора «не равно» (!=).✅

Как вы уже могли догадаться, оператор «равно» производит эффект, противоположный оператору «не равно».

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

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

Вот синтаксис для использования оператора равенства Python:

<obj1> == <obj2>  #where <obj1> and <obj2> are valid Python objects

• возвращает True, когда значения obj1 и obj2 равны, и
• возвращает False в противном случае.

Примеры кода оператора равенства Python

Оператор равенства (==) можно использовать очень похоже на оператор не равно.

Давайте закодируем следующие примеры:

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

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

В приведенном ниже фрагменте кода str1 и str2 равны по значению. Таким образом, оператор равенства (==) возвращает True.

str1 = "coding"
str2 = "coding"

str1 == str2

# Output: True

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

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

Примечание: число, которое без остатка делится на 2, является четным. А в коде это сводится к условию num%2 == 0

num = 10
if(num%2 == 0):
  print("The number is even.")
else:
  print("The number is odd.")

# Output: The number is even.

Давайте теперь возьмем этот пример и воспользуемся распознаванием списков Python, чтобы получить все четные числа меньше 10.

even_10 = [num for num in range(10) if num%2 == 0]
print(even_10)

# Output: [0, 2, 4, 6, 8]

В приведенном выше примере

• range(10) возвращает объект диапазона, который можно пройти в цикле, чтобы получить все целые числа от 0 до 9.
• Условие num%2 == 0 истинно только для четных чисел.
• Итак, even_10 — это список всех четных чисел меньше 10.

Итак, вы узнали, как проверять равенство с помощью операторов не равно (!=) и равно (==).

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

Как использовать операторы Python is и not is

Если вы новичок в программировании на Python, возможно, вы запутались между операторами == и is. Поясним это в этом разделе.

В предыдущем разделе у нас был пример, где str1 и str2 равны, а оператор == возвращает True.

Теперь запустите следующий фрагмент кода.

str1 = "coding" 
str2 = "coding" 

str1 is str2 

# Output: False

Вы можете видеть, что str1 является str2 возвращает False.

Давайте сделаем шаг назад и поймем, что делает оператор is в Python.

Оператор is работает с любыми двумя объектами Python.
И возвращает True только в том случае, если два объекта идентичны, то есть они ссылаются на один и тот же объект в памяти.

Несмотря на то, что str1 равен str2, str1 не является str2, поскольку они указывают на два разных объекта в памяти. И поэтому у них разные личности.

== и это НЕ одно и то же

В Python вы можете использовать я бы() функция для получения идентификатора объекта.

▶ Запустите следующую ячейку кода, чтобы получить идентификаторы str1 и str2.

id(str1)

# Sample output: 139935398870320

id(str2)

# Sample output: 139935398871344

Как видите, str1 и str2 имеют разные идентификаторы. И str1 is str2 возвращает False, как и ожидалось.

Собрав это вместе,

<obj1> is <obj2> # returns True if and only if
id(<obj1>) == id(<obj2>) # returns True

Давайте быстро проверим это, как показано:

str1 = "coding"
str2 = str1

print(str1 is str2)
print(id(str1) == id(str2))

# Output
True
True

Интуитивно оператор is not делает противоположное оператору is.

Оператор is not работает с любыми двумя объектами Python.
И возвращает False только в том случае, если два объекта идентичны, то есть они ссылаются на один и тот же объект в памяти. В противном случае он возвращает True.

В приведенных выше примерах кода попробуйте заменить is на is not и проверьте результат.

Вывод 👩‍💻

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

Подводя итог, вы узнали:

• как использовать операторы «равно» (==) и «не равно» (!=), чтобы проверить, имеют ли два объекта Python одинаковое значение,
• разница между равенством и идентичностью объектов Python и
• как операторы Python есть и не помогают в проверке идентичности двух объектов Python.

Узнайте, как рассчитать разницу во времени или сделать игру в змейку на питоне, здесь.

Увидимся в следующем уроке. А пока удачного обучения и кодирования!🎉

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

Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами.
Операндом выступает переменная или значение, над которыми проводится операция.

Операторы Python бывают 7 типов:

• Арифметические операторы
• Операторы сравнения
• Операторы присваивания
• Логические операторы
• Операторы принадлежности
• Операторы тождественности
• Битовые операторы

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

Этот тип включает операторы для проведения базовых арифметических операций.

Сложение (+)

Складывает значение по обе стороны оператора.
Пример:

>>> 3+4

7  

Вычитание (-)

Вычитает значение правой стороны из значения в левой.
Пример:

>>> 3-4

-1  

Умножение (*)

Перемножает значения с обеих сторон оператора.
Пример:

>>> 3*4

12  

Деление (/)

Делит значение левой стороны на значение правой. Тип данных результата деления — число с плавающей точкой.
Пример:

>>> 3/4

0.75 

Возведение в степень (**)

Возводит первое число в степень второго.
Пример:

>>> 3**4

81

Деление без остатка (//)

Выполняет деление и возвращает целочисленное значение частного, убирая цифры после десятичной точки.
Пример:

>>> 4//3

1

>>> 10//3

3

Деление по модулю (остаток от деления) (%)

Выполняет деление и возвращает значение остатка.
Пример:

>>> 3%4

3

>>> 4%3

1

>>> 10%3

1

>>> 10.5%3

1.5

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

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

Меньше (<)

Этот оператор проверяет, является ли значение слева меньше, чем правое.
Пример:

>>> 4<3

False

Больше (>)

Проверяет, является ли значение слева больше правого.

Пример:

>>> 4>3

True

Меньше или равно (<=)

Проверяет, является ли левая часть меньше или равной правой.
Пример:

>>> 7<=7

True

Больше или равно (>=)

Проверяет, является ли левая часть больше или равной правой.
Пример:

>>> 0>=0

True

Равно (==)

Этот оператор проверяет, равно ли значение слева правому. 1 равна булевому True, а 2 (двойка) — нет. 0 равен False.
Пример:

>>> 3==3.0

True

>>> 1==True

True

>>> 7==True

False

>>> 0==False

True

>>> 0.5==True

False

Не равно (!=)

Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.

Когда условие выполнено, возвращается True. В противном случае — False. Это возвращаемое значение можно использовать в последующих инструкциях и выражениях.
Пример:

>>> 1!=1.0

False

>>> 1==True  # Это вызывает SyntaxError

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

Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.

Присваивание (=)

Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания.
Пример:

>>> a = 7
>>> print(a)

7

Сложение и присваивание (+=)

Суммирует значение обеих сторон и присваивает его выражению слева. a += 10 — это то же самое, что и a = a + 10.

То же касается и все остальных операторов присваивания.
Пример:

>>> a += 2
>>> print(a)

9 

Вычитание и присваивание (-=)

Вычитает значение справа из левого и присваивает его выражению слева.
Пример:

>>> a -= 2
>>> print(a)

7

Деление и присваивание (/=)

Делит значение слева на правое. Затем присваивает его выражению слева.
Пример:

>>> a /= 7
>>> print(a)

1.0

Умножение и присваивание (*=)

Перемножает значения обеих сторон. Затем присваивает правое левому.
Пример:

>>> a *= 8
>>> print(a)

8.0

Деление по модулю и присваивание (%=)

Выполняет деление по модулю для обеих частей. Результат присваивает левой части.
Пример:

>>> a %= 3
>>> print(a)

2.0

Возведение в степень и присваивание (**=)

Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части.
Пример:

>>> a **= 5
>>> print(a)

32.0

Деление с остатком и присваивание (//=)

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

>>> a //= 3
>>> print(a)

10.0

Это один из важных операторов Python

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

Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).

И (and)

Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным.
Пример:

>>> a = 7 > 7 and 2 > -1
>>> print(a)

False

Или (or)

Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно.
Пример:

>>> a = 7 > 7 or 2 > -1
>>> print(a)

True

Не (not)

Этот оператор инвертирует булевые значения выражения. True превращается в False и наоборот. В примере внизу булево значение 0 — False. Поэтому оно превращается в True.
Пример:

>>> a = not(0)
>>> print(a)

True

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

Эти операторы проверяют, является ли значение частью последовательности. Последовательность может быть списком, строкой или кортежем. Есть всего два таких оператора: in и not in.

В (in)

Проверяет, является ли значение членом последовательности. В этом примере видно, что строки fox нет в списке питомцев. Но cat — есть, поэтому она возвращает True. Также строка me является подстрокой disappointment. Поэтому она вернет True.
Пример:

>>> pets=['dog','cat', 'ferret']
>>> 'fox' in pets

False

>>> 'cat' in pets

True

>>> 'me' in 'disappointment'

True

Нет в (not in)

Этот оператор проверяет, НЕ является ли значение членом последовательности.
Пример:

>>> 'pot' not in 'disappointment'

True

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

Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).

Это (is)

Если операнды тождественны, то вернется True. В противном случае — False. Здесь 2 не является 20, поэтому вернется False. Но '2' — это то же самое, что и "2". Разные кавычки не меняют сами объекты, поэтому вернется True.
Пример:

>>> 2 is 20

False

>>> '2' is "2"

True

Это не (is not)

2 — это число, а '2' — строка. Поэтому вернется True.
Пример:

>>> 2 is not '2'

True

Битовые операторы Python

Эти операторы работают над операндами бит за битом.

Бинарное И (&)

Проводит побитовую операцию and над двумя значением. Здесь бинарная 2 — это 10, а 3 — 11. Результатом побитового and является 10 — бинарная 2. Побитовое and над 011(3) и 100(4) выдает результат 000(0).
Пример:

>>> 2&3

2

>>> 3&4

0

Бинарное ИЛИ (|)

Проводит побитовую операцию or на двух значениях. Здесь or для 10(2) и 11(3) возвращает 11(3).
Пример:

>>> 2|3

3

Бинарное ИЛИ НЕТ (^)

Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10(2) и 11(3) будет 01(1).
Пример:

>>> 2^3

1

Инвертирующий оператор (~)

Он возвращает инвертированные двоичные числа. Другими словами, переворачивает биты. Битовая 2 — это 00000010. Ее инвертированная версия — 11111101. Это бинарная -3. Поэтому результат -3. Похожим образом ~1 равняется -2.
Пример:

>>> ~-3

2

Еще раз, инвертированная -3 — это 2.

Бинарный сдвиг влево (<<)

Он сдвигает значение левого операнда на позицию, которая указана справа. Так, бинарная 2 — это 10. 2 << 2 сдвинет значение на две позиции влево и выйдет 1000 — это бинарная 8.
Пример:

>>> 2<<2

8

Бинарный сдвиг вправо (>>)

Сдвигает значение левого оператора на позицию, указанную справа. Так, бинарная 3 — это 11. 3 >> 2 сдвинет значение на два положение вправо. Результат — 00, то есть 0. 3 >> 1 сдвинет на одну позицию вправо, а результатом будет 01 — бинарная 1.
Пример:

>>> 3>>2
>>> 3>>1

1

Выводы

В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.

Python – весьма перспективный язык программирования, который набирает популярность. Он позволяет создавать функциональный контент совершенно разного направления: от бизнес-софта до развлекательных утилит. Достаточно прост в изучении и освоении с нуля.

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

Немного терминологии

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

1. Алгоритм – своеобразный набор правил и инструкций. Он необходим для обработки функций и выполнения тех или иных задач.
2. API – интерфейс прикладного программирования. Включает в себя структурные данные, протоколы и правила, позволяющие быстро разрабатывать ПО, а также налаживать его взаимодействие с разного рода службами.
3. Переменные – именованные ячейки памяти. Они резервируются системой с учетом типа используемых данных в исходном коде.
4. Константа – постоянное значение. Оно не подлежит никаким корректировкам на протяжении всего жизненного цикла софта.
5. Аргумент – значение, которое передается в команду или функцию.
6. Объекты – наборы связанных между собой переменных, констант и иных структурных данных, выбираемых и обрабатываемых совместно.
7. Классы – перечни связанных объектов. Наделяются общими свойствами.
8. Итерация – один проход через команду или функцию в коде.

Отдельно стоит выделить такие понятия как «оператор» и «операнд». Первый термин указывает на объект, умеющий управлять операндами. Для этого задействуются специальные символы и записи (функции). Операнд – объект, которым можно манипулировать через так называемые операторы.

Основные операторы

Оператор в Питоне – символ, который будет отвечать за выполнение операции над одним или сразу несколькими операндами. Последним компонентом будет выступать переменная или значение, с которой требуется проводить дальнейшую работу.

Всего в рассматриваемом ЯП несколько типов операторов:

• арифметические;
• сравнения;
• присваивания;
• логические;
• принадлежности;
• битовые;
• тождественные.

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

Арифметические

Арифметические операторы в Python – самые простые. Данная категория «команд» встречается даже новичкам. С ними знакомятся еще в школьной программе. Они отвечают за элементарные математические действия.

Сюда относят:

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

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

Сравнение

Операторы сравнения отвечают за проверку заданного в приложении равенства. Они указывают, каким является один из операндов:

1. Меньше (<). True присваивается, если показатель слева меньше, чем справа.
2. Больше (>). True на выходе будет получено, когда «условия» слева больше правого.
3. Меньше или равно (<=). Выдает на выходе истину, если левая часть меньше или такая же, как правая.
4. Больше или равно (>=). True устанавливается, если левая часть записи окажется больше или аналогичной правой.
5. Равно (==). В данном случае происходит проверка на непосредственное равенство. Если параметр слева такой же, как справа, на выходе получится true. В противном случае – False.
6. Не равно (!=). Оператор, который убран в Питоне 3. Он проверяет, не равен ли параметр слева правому. При успешном выполнении условия приложение выдаст True.

Здесь в основном придется учитывать результат в виде True и False. Перечисленные манипуляции тоже достаточно активно используются в разработке софта.

Присваивание

Операторы присваивания будут отвечать за передачу переменной того или иного значения. Тут нет true или false. Данная категория включает в себя:

1. Обычное присваивание (=). Параметр справа передается левой части.
2. Сложение и присваивание (+=). Суммирует параметры с обеих сторон и передает результат левой части.
3. Вычитание и присваивание (-=). Из правого вычитается «левое». Далее последнему передается соответствующий результат.
4. Деление и присваивание (/=).
5. Умножение и присваивание (*=).
6. Деление по модулю и присваивание (%=).
7. Возведение в степень и присваивание (**=).
8. Деление с остатком и присваивание (//=).

Последний является одним из самых важных в Питоне.

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

Логические операторы выполняют роль своеобразных союзов. Они будут выдавать на выходе True или False. Дают возможность объединения нескольких условий в единое целое:

1. И (and). Если написанное с двух сторон оператора – это true, то и все выражение окажется true.
2. Или (or). Результат «ложь» выводится тогда, когда два операнда false. В противном случае – true.
3. Не (not). Работает с булевыми значениями. True становится False. Обратное соотношение тоже действует.

Других логических операторов в рассматриваемом языке программирования нет.

Принадлежность

Зато есть операторы принадлежности. Они проверяют, является ли значение частью заданной последовательности: списка, кортежа, строки:

1. В (in). Осуществляет проверку на принадлежность к последовательности. Возвращает True при соответствии указанному условию.
2. Нет в (not in). Проводит проверку на НЕ принадлежность к последовательности.

Других операторов в данной категории нет.

Тождественность

Операторы тождественности проверяют, являются ли операнды одинаковыми. На практике встречаются не слишком часто:

1. Это (is). Если тождественность есть, осуществляется возврат True.
2. Это нет (is not).

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

Битовые операторы

Осуществляют работу над операндами побитово. Здесь можно увидеть:

1. Бинарное И (&). Отвечает за побитовую операцию and.
2. Или (|). Побитово проводит or.
3. Или нет (^). Это – исключающее или (XOR).
4. Инвертирующий оператор (~). Возвращает инвертированные двоичные числа. Будет переворачивать биты.
5. Сдвиг влево (<<). Сдвигает на позицию, указанную справа, левого операнда.
6. Сдвиг вправо (>>).

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