Skip to content

Latest commit

 

History

History
551 lines (401 loc) · 33.7 KB

README.md

File metadata and controls

551 lines (401 loc) · 33.7 KB
Raw

4. Операторы в Python

img.png

Добро пожаловать в тему операторов и их магии!

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

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

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

Также обратим внимание на особый моржовый оператор, который предоставляет удобный способ совмещения присваивания и сравнения.

Булевые значения

Булевые значения - это основа логической алгебры, которая позволяет нам работать с высказываниями, их комбинациями и выражениями истинности. Их всего два: True (истина) и False (ложь).

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

is_valid = True
is_greater = False

print(is_valid)  # True
print(is_greater)  # False

Обратите внимание, что True и False без кавычек, поскольку они являются ключевыми словами языка Python.

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

Вот примеры приведения различных типов данных к булевому типу:

print(bool(0))  # False
print(bool(0.0))  # False
print(bool(''))  # False
print(bool(None))  # False

print(bool(-17))  # True
print(bool(39))  # True
print(bool(1.6894))  # True
print(bool("Не пустая строка"))  # True

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

Операторы сравнения позволяют сравнивать значения различных типов данных и получать результат в виде булевого значения. В Python доступны следующие операторы сравнения:

Оператор Название Описание
== равно проверяет, являются ли два значения равными.
!= не равно проверяет, являются ли два значения неравными.
> больше проверяет, является ли первое значение большим, чем второе.
< меньше проверяет, является ли первое значение меньшим, чем второе.
>= больше или равно проверяет, является ли первое значение большим или равным второму.
<= меньше или равно проверяет, является ли первое значение меньшим или равным второму.

Примеры использования этих операторов:

x = 5
y = 10
z = "Hello"
w = "World"

print(x == y)  # False, значение x не равно значению y
print(x != y)  # True, значение x не равно значению y
print(x > y)  # False, значение x не больше значения y
print(x < y)  # True, значение x меньше значения y
print(x >= y)  # False, значение x не больше или равно значению y
print(x <= y)  # True, значение x меньше или равно значению y

print(z == w)  # False, значения z и w не равны
print(z != w)  # True, значения z и w не равны

# сравнение строк осуществляется по лексикографическому порядку
print(z > w)  # False, значение z не больше значения w
print(z < w)  # True, значение z меньше значения w
print(z >= w)  # False, значение z не больше или равно значению w
print(z <= w)  # True, значение z меньше или равно значению w

Обратите внимание, что результатом операторов сравнения является булевое значение True или False, которое можно использовать для принятия решений в программе или для контроля потока выполнения кода.

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

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

Оператор Название Описание
= равно присваивает значение справа от оператора переменной слева от оператора.
+= плюс равно увеличивает значение переменной на указанное значение и присваивает результат переменной.
-= минус равно уменьшает значение переменной на указанное значение и присваивает результат переменной.
*= умножить равно умножает значение переменной на указанное значение и присваивает результат переменной.
/= разделить равно делит значение переменной на указанное значение и присваивает результат переменной.
%= остаток равно присваивает переменной остаток от деления значения переменной на указанное значение.
//= целочисленное деление равно выполняет целочисленное деление значения переменной на указанное значение и присваивает результат переменной.
**= возведение в степень равно возводит значение переменной в указанную степень и присваивает результат переменной.

Примеры использования этих операторов:

x = 5  # присваивание значения 5 переменной x
print(x)  # 5

x += 2  # увеличение значения переменной x на 2
print(x)  # 7

x -= 3  # уменьшение значения переменной x на 3
print(x)  # 4

x *= 2  # умножение значения переменной x на 2
print(x)  # 8

x /= 4  # деление значения переменной x на 4
print(x)  # 2.0

x %= 3  # присваивание остатка от деления значения переменной x на 3
print(x)  # 2.0 (остаток от деления 2.0 на 3)

x //= 1.5  # целочисленное деление значения переменной x на 1.5
print(x)  # 1.0 (результат целочисленного деления 2.0 на 1.5)

x **= 3  # возведение значения переменной x в степень 3
print(x)  # 1.0 (результат возведения 1.0 в степень 3)

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

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

Если в настоящее время побитовые операторы кажутся вам сложными или не вызывают особого интереса, можете временно пропустить этот раздел темы и перейти к изучению следующих разделов. Когда будете чувствовать себя более уверенно в языке Python и приобретете больше опыта, рекомендуется вернуться и изучить раздел Побитовые операторы. Эти операторы предоставляют дополнительные инструменты и возможности, которые могут быть полезными в некоторых конкретных случаях программирования.

Не забывайте, что процесс обучения - это непрерывный и постоянный процесс, и важно гибко подстраиваться под свои потребности и интересы.

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

Оператор Название Описание
& побитовое И возвращает результат побитового И для каждой пары битов операндов.
| побитовое ИЛИ возвращает результат побитового ИЛИ для каждой пары битов операндов.
^ побитовое исключающее ИЛИ возвращает результат побитового исключающего ИЛИ для каждой пары битов операндов.
~ побитовое отрицание возвращает результат побитового отрицания операнда.
<< побитовый сдвиг влево сдвигает биты операнда влево на указанное количество позиций.
>> побитовый сдвиг вправо сдвигает биты операнда вправо на указанное количество позиций.

Примеры использования побитовых операторов:

x = 5  # бинарное представление: '0b101'
y = 3  # бинарное представление: '0b11'

result_and = x & y  # побитовое И
print(result_and)  # 1 (бинарное представление: '0b1')

result_or = x | y  # побитовое ИЛИ
print(result_or)  # 7 (бинарное представление: '0b111')

result_xor = x ^ y  # побитовое исключающее ИЛИ
print(result_xor)  # 6 (бинарное представление: '0b110')

result_not_x = ~x  # побитовое отрицание
print(result_not_x)  # -6 (бинарное представление: '-0b110')

result_left_shift = x << 2  # побитовый сдвиг влево на 2 позиции
print(result_left_shift)  # 20 (бинарное представление: `0b10100`)

result_right_shift = x >> 1  # побитовый сдвиг вправо на 1 позицию
print(result_right_shift)  # 2 (бинарное представление: `0b10`)

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

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

Логические операторы позволяют комбинировать булевы значения и получать новые логические результаты. В Python доступны следующие логические операторы:

Оператор Название Описание
and логическое И возвращает True, если оба операнда являются истинными, и False в противном случае.
or логическое ИЛИ возвращает True, если хотя бы один из операндов является истинным, и False в противном случае.
not логическое НЕ возвращает True, если операнд является ложным, и False, если операнд является истинным.

Примеры использования логических операторов:

x = 5
y = 10
z = 7

result_and = (x < y) and (y < z)  # логическое И
print(result_and)  # True

result_or = (x < y) or (y > z)  # логическое ИЛИ
print(result_or)  # True

result_not = not (x < y)  # логическое НЕ
print(result_not)  # False

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

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

Вот таблица истинности для логических операторов and, or и not:

A B A and B A or B not A
True True True True False
True False False True False
False True False True True
False False False False True

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

Операторы in и not in

Операторы in и not in предоставляют удобные способы проверки принадлежности элемента к последовательности (строке, списку и др.).

Для примера, рассмотрим использование этих операторов со строками:

sentence = "Python is a powerful programming language"

# Проверяем, содержит ли строка "Python" в себе
print("Python" in sentence)  # True

# Проверяем, содержит ли строка "Java" в себе
print("Java" in sentence)  # False

# Проверяем, что строка не содержит "programming"
print("programming" not in sentence)  # False

# Проверяем, что строка не содержит "JavaScript"
print("JavaScript" not in sentence)  # True

Также можем использовать эти операторы для проверки принадлежности элемента к списку:

numbers = [1, 2, 3, 4, 5]

# Проверяем, содержится ли число 3 в списке
print(3 in numbers)  # True

# Проверяем, содержится ли число 6 в списке
print(6 in numbers)  # False

# Проверяем, что список не содержит число 0
print(0 not in numbers)  # True

# Проверяем, что список не содержит число 2
print(2 not in numbers)  # False

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

Операторы is и is not

Операторы is и is not предоставляют способ сравнения объектов на идентичность, то есть проверку, указывают ли они на один и тот же объект в памяти. Эти операторы используются для сравнения объектов, а не их значений.

Простыми словами, эти операторы используются для сравнения идентификаторов объектов (вспомните функцию id()).

Рассмотрим примеры использования операторов is и is not:

# Сравниваем два булевых значения
print(True is True)  # True
print(True is False)  # False

# Сравниваем две строки
print("Hello" is "Hello")  # True
print("Hello" is "World")  # False

# Сравниваем два числа
print(10 is 10)  # True
print(10 is 20)  # False

# Сравниваем переменные с одинаковыми значениями
x = [1, 2, 3]
y = [1, 2, 3]
print(x is y)  # False

# Сравниваем переменные, указывающие на один и тот же объект
a = [1, 2, 3]
b = a
print(a is b)  # True

# Сравниваем переменные с разными типами данных
print("Hello" is 10)  # False
print(True is 1)  # False

Важно понимать отличия между операторами равенства и is , что операторы равенства == и неравенства != сравнивают значения объектов, в то время как операторы is и is not сравнивают идентичность объектов в памяти. Выбор между этими операторами зависит от контекста и требований конкретной задачи.

None - специальное значение отсутствия значения

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

Пример использования None:

# Инициализация переменной без присвоения значения
some_variable = None

print(some_variable)  # None

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

Однако, не волнуйтесь! Значение None будет более подробно рассмотрено в последующих темах, где мы сможем предоставить более понятные и обстоятельные примеры использования и сравнения значения None с другими типами данных.

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

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

Рассмотрим несколько простых примеров:

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

result = 2 + 3 * 4
print(result)  # Результат: 14
  • В данном случае оператор умножения * имеет более высокий приоритет, чем оператор сложения +, поэтому он выполняется первым. Результат будет равен 2 + (3 * 4) = 2 + 12 = 14.

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

result = 5 < 3 == True
print(result)  # Результат: False
  • Оператор сравнения < (меньше) имеет более высокий приоритет, чем оператор сравнения == (равно). Поэтому выражение сначала сравнивает 5 < 3, что дает False, а затем сравнивает False == True, что дает False.

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

  • Операторы not, and и or имеют следующий порядок приоритета (от наивысшего к наименьшему):

    • not
    • and
    • or
result = not True or False and True
print(result)  # Результат: False

Сначала выполнится операция not True, которая даст результат False. Затем будет выполнена операция False or False and True, где сначала выполнится False and True, результат False, а затем False or False, конечный результат False.

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

result = (2 + 3) * 4
print(result)  # Результат: 20

В данном случае операторы в скобках выполняются первыми, а затем результат умножается на 4. Результат будет равен (2 + 3) * 4 = 5 * 4 = 20.

Это лишь некоторые примеры для демонстрации приоритета операторов. При работе с более сложными выражениями всегда полезно обращаться к таблице приоритетов операторов для точного определения порядка их выполнения.

Таблица приоритетов операторов, операторы расположены по убыванию приоритета:

Оператор Описание
() Группировка
x[index], x[index:index] Обращение к элементу или срезу в списке или строке
f(args...), x.attr Вызов функции или метода
** Возведение в степень
+x, -x, ~x Унарные плюс, минус, инверсия
*, /, //, % Умножение, деление, целочисленное деление, остаток
+, - Сложение, вычитание
<<, >> Побитовый сдвиг влево, вправо
& Побитовое И
^ Побитовое исключающее ИЛИ
| Побитовое ИЛИ
<, <=, >, >=, ==, != Сравнение
not Логическое НЕ
and Логическое И
or Логическое ИЛИ
if else Условный оператор if else
lambda Лямбда-выражение
=, +=, -=, *=, /=, //=, %= Присваивание и составные операторы присваивания
:= Моржовый оператор

Моржовый оператор

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

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

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

Пример 1: Проверка и присвоение значения

# Пример с использованием моржового оператора
if (n := len(my_list)) > 0:
    print("Длина списка:", n)
else:
    print("Список пуст")

# Эквивалентный код без использования моржового оператора
n = len(my_list)
if n > 0:
    print("Длина списка:", n)
else:
    print("Список пуст")

Пример 2: Присвоение значения

# Пример с использованием моржового оператора
if (value := 10) > 0:
    result = "Положительное число"
else:
    result = "Отрицательное число или ноль"
print(result)

# Эквивалентный код без использования моржового оператора
value = 10
if value > 0:
    result = "Положительное число"
else:
    result = "Отрицательное число или ноль"
print(result)

Пример 3: Проверка и присвоение значения

# Пример с использованием моржового оператора
a = 5
b = 10
if (c := a + b) > 0:
    print("Сумма a и b:", c)
else:
    print("Сумма a и b меньше или равна нулю")

# Эквивалентный код без использования моржового оператора
a = 5
b = 10
c = a + b
if c > 0:
    print("Сумма a и b:", c)
else:
    print("Сумма a и b меньше или равна нулю")

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

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

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

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

Задания