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

Что такое оператор в Python

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

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

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

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

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

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

Эти операторы знакомы каждому, так как повторяют привычные действия из математики, но в Python у них есть особенности, которые важно учитывать:

Сложение (+)

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

print(7 + 3)          # 10

print(4.5 + 2.5)      # 7.0

print("Py" + "thon")  # Python

print([1, 2] + [3])   # [1, 2, 3]

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

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

print(10 - 4)     # 6

print(5.5 - 2)    # 3.5

print(-7)         # -7

print(-(3 + 2))   # -5

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

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

print(6 * 3)     # 18

print("Hi" * 3)  # HiHiHi

print([1] * 4)   # [1, 1, 1, 1]

Деление (/)

Выполняет деление и всегда возвращает число с плавающей точкой, даже если делится без остатка:

print(10 / 2)    # 5.0

print(7 / 2)     # 3.5

Целочисленное деление (//)

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

print(7 // 2)    # 3

print(-7 // 2)   # -4

Остаток от деления (%)

Дает остаток от деления одного числа на другое. Знак результата всегда совпадает со знаком делителя:

print(10 % 3)    # 1

print(-7 % 3)    # 2

print(7 % -3)    # -2

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

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

print(2 ** 3)     # 8

print(9 ** 0.5)   # 3.0

print(2 ** -2)    # 0.25

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

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

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

Давайте разберем основные операторы сравнения и посмотрим, как они работают на примерах.

Равно (==)

Проверяет, равны ли два значения:

print(5 == 5)      # True

print(5 == 3)      # False

print("hi" == "hi")  # True

Не равно (!=)

Возвращает True, если значения различаются:

print(5 != 3)      # True

print(5 != 5)      # False

Больше (>)

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

print(7 > 3)   # True

print(2 > 5)   # False

Меньше (<)

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

print(3 < 7)   # True

print(5 < 2)   # False

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

Возвращает True, если левое значение больше или равно правому:

print(5 >= 5)   # True

print(7 >= 5)   # True

print(3 >= 5)   # False

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

Возвращает True, если левое значение меньше или равно правому:

print(3 <= 5)   # True

print(5 <= 5)   # True

print(7 <= 5)   # False

В Python можно сравнивать не только числа, но и строки. Сравнение выполняется по порядку символов в таблице Unicode. Фактически строки сравниваются посимвольно: сначала первые символы, затем вторые и так далее:

print("apple" < "banana")  # True (буква "a" идет раньше "b")

print("abc" == "ABC")      # False (строчные и прописные буквы разные)

Например, "Zoo" > "apple", так как заглавная буква "Z" имеет меньший код в Unicode, чем строчная "a".

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

В программировании редко ограничиваются одной простой проверкой. Чаще всего нужно проверить сразу несколько условий: например, что число положительное и при этом меньше 100, или что строка пуста или равна определенному значению. Для таких случаев в Python используются логические операторы.

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

В Python есть три логических оператора: and, or и not. Каждый из них возвращает результат проверки в виде логического значения True или False. 

and (логическое «и»)

Оператор возвращает True, если оба условия истинны. Если хотя бы одно условие ложно — результат будет False:

x = 5

print(x > 0 and x < 10)   # True

print(x > 0 and x > 10)   # False

Таблица истинности:

• True and True → True
• True and False → False
• False and True → False
• False and False → False

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

or (логическое «или»)

Возвращает True, если хотя бы одно условие истинно. Результат будет False только в том случае, если оба условия ложны:

x = 5

print(x < 0 or x > 10)    # False

print(x < 0 or x == 5)    # True

Таблица истинности:

• True or True → True
• True or False → True
• False or True → True
• False or False → False

У or тоже есть короткое замыкание: если первое условие уже истинно, второе не проверяется.

not (логическое «не»)

Оператор меняет логическое значение на противоположное: из True делает False, и наоборот:

x = 5

print(not x > 0)    # False (так как x > 0 → True, но not меняет результат)

print(not x < 0)    # True

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

Порядок выполнения логических операторов следующий:

1. not
2. and
3. or

Например:

x = True

y = False

print(not x or y)   # False (сначала not x → False, потом False or False → False)

Чтобы избежать ошибок, сложные выражения лучше заключать в скобки.

Условные операторы

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

Для этого и нужны условные операторы. С их помощью можно задать проверку — если условие выполняется, программа делает одно, если нет — другое. 

В Python это реализовано с помощью ключевых слов if, elif и else. Они образуют основу управления потоком кода и встречаются практически в любом современно проекте. 

if — проверка условия

Оператор if выполняет блок кода только тогда, когда условие истинно (True):

x = 10

if x > 5:

    print("x больше 5")

Если условие ложно (False), блок просто пропускается.

else — альтернативный вариант

Ключевое слово else задает блок кода, который выполнится, если условие в if оказалось ложным:

x = 3

if x > 5:

    print("x больше 5")

else:

    print("x не больше 5")

elif — проверка дополнительных условий

Когда условий несколько, используется elif («else if»). Он проверяет новое условие, если предыдущие оказались ложными:

x = 5

if x > 5:

    print("x больше 5")

elif x == 5:

    print("x равно 5")

else:

    print("x меньше 5")

Вложенные условия

Внутри одного условия можно использовать другое:

x = 10

if x > 0:

    if x % 2 == 0:

        print("x положительное и четное")

    else:

        print("x положительное и нечетное")

Тернарный оператор (короткая форма if)

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

x = 7

result = "четное" if x % 2 == 0 else "нечетное"

print(result)  # нечетное

Операторы циклов

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

В Python есть два основных оператора циклов: for и while. Оба они позволяют организовать повторение действий, но работают немного по-разному.

Цикл for

Цикл for перебирает элементы последовательности (списка, строки, словаря, множества) или любого объекта-итератора:

for i in [1, 2, 3]:

    print(i)

# Вывод:

# 1

# 2

# 3

Чаще всего for используют вместе с функцией range(), которая генерирует последовательность чисел:

for i in range(5):

    print(i)

# Вывод: 0 1 2 3 4

Можно задавать начало, конец и шаг:

for i in range(2, 10, 2):

    print(i)

# Вывод: 2 4 6 8

Цикл while

Цикл while повторяет блок кода до тех пор, пока условие остается истинным.

x = 0

while x < 5:

    print(x)

    x += 1

Здесь цикл остановится, когда x станет равен 5. 

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

Операторы break и continue

Внутри циклов можно управлять их выполнением с помощью специальных операторов:

break — прерывает выполнение цикла полностью:

for i in range(10):

    if i == 5:

        break

    print(i)

# Вывод: 0 1 2 3 4

continue — пропускает текущую итерацию и переходит к следующей:

for i in range(5):

    if i == 2:

        continue

    print(i)

# Вывод: 0 1 3 4

Блок else в циклах

В Python у циклов есть особенность: к ним можно добавлять блок else. Он выполняется только в том случае, если цикл завершился естественным образом (без break):

for i in range(3):

    print(i)

else:

    print("Цикл завершен без break")

Если же цикл прервали через break, блок else не выполнится.

Вложенные циклы

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

for i in range(3):

    for j in range(2):

        print(i, j)

Операторы работы с функциями

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

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

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

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

def — определение функции

С помощью def создается функция с заданным именем и параметрами:

def greet(name):

    print(f"Привет, {name}!")

Где greet — это имя функции, а name — ее параметр.

return — возврат значения

Функция может не только выполнять действия, но и возвращать результат. Для этого используется оператор return:

def add(a, b):

    return a + b

print(add(3, 4))  # 7

Если return не указан, функция возвращает None.

lambda — анонимные функции

Порой удобно создать небольшую функцию прямо в месте использования. Для этого применяется ключевое слово lambda:

square = lambda x: x ** 2

print(square(5))  # 25

Такие функции часто используют в сочетании с map(), filter() и другими встроенными инструментами.

global и nonlocal

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

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

count = 0

def increment():

    global count

    count += 1

nonlocal — используется во вложенных функциях, чтобы работать с переменными из внешней функции:

def outer():

    x = 10

    def inner():

        nonlocal x

        x += 1

        return x

    return inner()

print(outer())  # 11

yield — генераторы

Оператор yield превращает функцию в генератор, который возвращает значения по одному, сохраняя свое состояние между вызовами:

def counter():

    for i in range(3):

        yield i

for num in counter():

    print(num)

# Вывод: 0 1 2

В отличие от return, yield не завершает функцию окончательно.

Другие полезные операторы

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

К ним относятся:

Оператор присваивания (=)

Используется для записи значения в переменную:

x = 10

name = "Python"

В Python присваивание не копирует значение, а связывает переменную с объектом.

Составные операторы присваивания (+=, -=, *=, /=, //=, %= и другие)

Позволяют изменить значение переменной и сразу записать результат обратно:

x = 5

x += 3   # эквивалентно x = x + 3

print(x)  # 8

Составные операторы делают код компактнее.

Операторы принадлежности (in, not in)

Проверяют, содержится ли элемент в последовательности (строке, списке, кортеже, множестве или словаре):

print("a" in "cat")        # True

print(3 in [1, 2, 3])      # True

print("x" not in "text")   # False

Операторы идентичности (is, is not)

Сравнивают не значения, а ссылки на объекты. Полезны при проверке на None или когда важно, чтобы это был именно тот же объект:

x = [1, 2, 3]

y = x

z = [1, 2, 3]

print(x is y)      # True (ссылаются на один объект)

print(x is z)      # False (разные объекты, даже если содержимое одинаковое)

print(z is not y)  # True

Оператор del

Удаляет переменные или элементы коллекций:

x = [1, 2, 3]

del x[1]

print(x)  # [1, 3]

name = "Python"

del name

# теперь переменной name не существует

Оператор pass

Используется как заглушка. Ничего не делает, но позволяет сохранить правильную структуру кода.

def todo_function():

    pass

Оператор with (контекстный менеджер)

Автоматизирует работу с ресурсами (например, файлами), гарантируя их корректное закрытие:

with open("data.txt", "r") as file:

    content = file.read()

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

Оператор assert

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

x = 5

assert x > 0  # все в порядке

assert x < 0  # вызовет ошибку AssertionError

Заключение

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

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

FAQ

Какой оператор используется для условий в Python?

Для условий в Python используется оператор if. Он проверяет логическое выражение и выполняет блок кода, только если условие истинно (True). 

В связке с ним часто применяются elif (для дополнительных условий) и else (для варианта «иначе»).

Какой оператор цикла чаще применяют — for или while?

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

Какие логические операторы поддерживает Python?

В Python используются три логических оператора: and для логического «и», or для логического «или» и not для логического «не».

Чем отличаются операторы is и ==?

Оператор == сравнивает значения объектов — то есть проверяет, одинаково ли их содержимое. Например, два списка с одинаковыми элементами считаются равными по значению.

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