Что делает оператор // в Python?

Оператор // (целочисленное деление)

Оператор // в Python выполняет целочисленное деление (floor division) — деление с округлением вниз до ближайшего целого числа.

Основное поведение

# Базовые примеры
print(7 // 2)      # 3 (не 3.5)
print(10 // 3)     # 3
print(20 // 4)     # 5
print(-7 // 2)     # -4 (не -3!)
print(-10 // 3)    # -4

Отличие от обычного деления /

# Обычное деление / возвращает float
print(7 / 2)       # 3.5 (результат float)
print(type(7 / 2)) # <class 'float'>

# Целочисленное деление // округляет вниз
print(7 // 2)      # 3 (результат int)
print(type(7 // 2))# <class 'int'>

# Для положительных чисел это просто отбрасывание дробной части
print(9 / 4)       # 2.25
print(9 // 4)      # 2

ВАЖНО: Округление ВНИЗ (floor), не к нулю!

Это самая частая ошибка!

# Положительные числа
print(7 // 2)      # 3 (floor от 3.5)
print(8 // 2)      # 4

# Отрицательные числа — округляет ВНИЗ!
print(-7 // 2)     # -4 (floor от -3.5 это -4, не -3)
print(-10 // 3)    # -4 (floor от -3.333... это -4)
print(-1 // 2)     # -1 (floor от -0.5 это -1)

# Математически это правильно
import math
print(math.floor(-3.5))  # -4
print(-7 // 2)           # -4

Сравнение операций деления

print(7 / 2)       # 3.5 — обычное деление
print(7 // 2)      # 3 — целочисленное деление
print(int(7 / 2))  # 3 — результат тот же, но медленнее
print(7 % 2)       # 1 — остаток от деления

# Связь между ними
a, b = 7, 2
print(a // b * b + a % b)  # 3 * 2 + 1 = 7 (всегда верно)
print(a / b)               # 3.5

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

# С целыми числами (int)
print(10 // 3)             # 3

# С дробными числами (float)
print(10.0 // 3.0)         # 3.0 (результат float)
print(10 // 3.0)           # 3.0
print(type(10.0 // 3.0))   # <class 'float'>

# С комплексными числами — НЕ поддерживается
print((10+2j) // 3)        # TypeError

Практические примеры

# 1. Определить количество полных дней
hours = 50
days = hours // 24
remaining_hours = hours % 24
print(f"{hours} часов = {days} дней и {remaining_hours} часов")
# 50 часов = 2 дней и 2 часов

# 2. Разделить список на группы
items = [1, 2, 3, 4, 5, 6, 7, 8, 9]
group_size = 3
num_groups = len(items) // group_size
print(f"Всего {num_groups} полных групп по {group_size}")
# Всего 3 полных групп по 3

# 3. Определить чётность
num = 42
if num % 2 == 0:
    print("Чётное")
else:
    print("Нечётное")

# 4. Индекс в массиве 2D
position = 15
rows = 5
cols = 4
row = position // cols  # 3
col = position % cols   # 3
print(f"Позиция {position} = строка {row}, столбец {col}")

# 5. Пакетная обработка
total_items = 1000
batch_size = 100
num_batches = total_items // batch_size
print(f"Нужно {num_batches} пакетов по {batch_size} элементов")
# Нужно 10 пакетов

Оператор // vs int() vs math.trunc()

# Различные способы получить целое число
value = -3.7

print(-7 // 2)              # -4 (floor division)
print(int(-7 / 2))         # -3 (int отбрасывает дробь)
print(int(-3.7))           # -3 (int отбрасывает дробь)

import math
print(math.floor(-3.7))    # -4 (floor)
print(math.trunc(-3.7))    # -3 (trunc)

# ВАЖНО!
# // это FLOOR (округление вниз) — -4
# int() это TRUNCATE (отбрасывание) — -3
# Они разные для отрицательных чисел!

Таблица сравнения операций деления

На собеседовании

Ожидаемый ответ должен включать:

1. // это целочисленное деление

print(7 // 2)  # 3

1. Результат типа int (или float если операнд float)

print(type(7 // 2))     # int
print(type(7.0 // 2))   # float

1. Округляет ВНИЗ (floor), не к нулю

print(-7 // 2)  # -4, не -3

1. Отличие от int() для отрицательных чисел

print(-7 // 2)     # -4 (floor)
print(int(-7 / 2)) # -3 (truncate)

1. Использование в реальном коде
   • Подсчёт полных групп/порций
   • Преобразование единиц
   • Индексирование в 2D массивах

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