Операторы в Python

Эта статья объясняет операторы в Python.

YouTube Video

Операторы в Python

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

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

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

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• В дополнение к четырём основным арифметическим операциям Python предоставляет операторы для деления (/), целочисленного деления (//), остатка от деления (%) и возведения в степень (**). Операция деления возвращает число с плавающей запятой даже при делении целых чисел.

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

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

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Операторы присваивания позволяют совмещать стандартное присваивание с различными операциями для присваивания результата.
• Оператор морж (:=) — это выражение присваивания, появившееся в Python 3.8 и более поздних версиях.
• Стандартное присваивание может использоваться только как оператор, тогда как оператор морж позволяет выполнять присваивание внутри выражения.

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

Операторы сравнения сравнивают значения и возвращают True или False.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Операторы сравнения сравнивают два значения по порядку или на равенство и возвращают в результате True или False.
• В Python следует быть осторожным при сравнении разных типов данных. Некоторые типы можно сравнивать друг с другом, но результаты могут быть неочевидны.

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

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

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

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

Приоритет логических операторов

Операторы имеют приоритет. Это правило определяет, какой оператор вычисляется первым в выражении. Логические операторы вычисляются в следующем порядке: not, затем and, затем or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

В первом примере сначала вычисляется and, поэтому False and False становится False, и в результате True or False становится True. Вы также можете изменить порядок вычисления с помощью скобок, как показано во втором примере.

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

Побитовые операторы выполняют операции на уровне битов.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Можно выполнять побитовые операции AND, OR, XOR, NOT, а также операции сдвига битов. Их также можно сочетать с операторами присваивания, такими как &=.

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

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

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• Оператор in используется для определения, содержится ли указанное значение внутри последовательности, такой как список или строка, либо в коллекции, такой как словарь.
• Оператор not in используется для определения, содержится ли указанное значение не внутри последовательности или коллекции.

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

Операторы идентичности проверяют идентичность объектов.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• Оператор is проверяет, являются ли два объекта одним и тем же объектом (то есть указывают ли они на одну и ту же область памяти).
• Оператор is not проверяет, являются ли два объекта разными объектами.
• Например, x is y отличается от x == y тем, что проверяет тождественность объектов, а не равенство значений.

Проверка типа

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

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() — это функция, которая проверяет, является ли объект экземпляром указанного класса или его подкласса.
• type() — это функция, которая возвращает точный тип (класс) объекта. Обычно используется, когда требуется строгое сравнение типов.
• isinstance() учитывает наследование, а type() проверяет только точное совпадение типов.

Резюме

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

Вы можете следовать этой статье, используя Visual Studio Code на нашем YouTube-канале. Пожалуйста, также посмотрите наш YouTube-канал.

YouTube Video