Основы Python: переменные, циклы и логика

Переменные и типы данных: как Python хранит признаки (Features)

Представьте, что вы готовите данные для модели, которая предсказывает стоимость поездки на такси. У вас есть дистанция (12.5 км), класс комфорта («Эконом») и статус пассажира (VIP). В предыдущем курсе мы называли это признаками (Features). Но как именно компьютер держит эти признаки в своей памяти, чтобы алгоритм мог с ними работать?

Для этого в программировании существуют переменные. Это фундамент, без которого не обходится ни один ML-проект, будь то простая линейная регрессия или сложная нейросеть.

Переменная: ярлык для данных

В классической математике запись $x = 5$ означает утверждение: «икс равен пяти». В программировании знак равенства несет совершенно другой смысл. Это оператор присваивания.

Когда мы пишем код: distance = 12.5

Мы даем команду Python: «Создай в памяти объект со значением 12.5 и повесь на него ярлык с именем distance».

Переменная в Python — это не сама коробка с данными, а именная бирка, привязанная к объекту в памяти компьютера.

Имена переменных должны быть говорящими. Если вы назовете признак x1, через неделю вы забудете, что это означало. Если назовете passenger_age — код будет читаться как текст. В Python принято писать имена переменных строчными буквами, разделяя слова нижним подчеркиванием (стиль snake_case).

Четыре фундаментальных типа данных

Машинное обучение — это математика, и в конечном итоге модели «едят» только числа. Однако сырые датасеты приходят к нам в самом разном виде: тексты жалоб, даты, логические флаги («да/нет»).

Чтобы Python понимал, как обрабатывать ту или иную переменную, у каждого объекта есть тип данных. Рассмотрим четыре базовых типа, с которыми ML-инженер работает каждый день.

Тип в Python	Название	Что хранит	Пример из ML-датасета
int	Целое число (Integer)	Числа без дробной части	rooms = 3 (количество комнат)
float	Вещественное число	Числа с плавающей точкой (дробные)	price = 4.5 (цена в миллионах)
str	Строка (String)	Текст, заключенный в кавычки	city = "Moscow" (город)
bool	Логический тип (Boolean)	Только два значения: True или False	is_vip = True (является ли VIP)

Обратите внимание: значение True пишется с заглавной буквы и без кавычек. Если вы напишете "True" в кавычках, Python воспримет это просто как текст (строку), а не как логический флаг.

Динамическая типизация: гибкость Python

В некоторых языках программирования (например, в C++ или Java) при создании переменной вы обязаны жестко указать ее тип. Если вы сказали, что age — это целое число, вы больше никогда не сможете положить туда текст.

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

Эта гибкость делает Python идеальным языком для Data Science — вы можете быстро экспериментировать с данными, не тратя время на описание каждой переменной. Но здесь же кроется опасность: если вы ожидаете число, а в переменную случайно попала строка, модель машинного обучения выдаст ошибку.

Преобразование типов (Type Casting)

В реальном Feature Engineering данные редко приходят в идеальном виде. Часто вы выгружаете датасет из базы данных или CSV-файла, и все числа в нем записаны как текст.

Например, дистанция поездки может прийти в виде строки: raw_distance = "12.5"

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

• int() — пытается превратить значение в целое число.
• float() — превращает значение в дробное число.
• str() — превращает что угодно в текст.
• bool() — превращает значение в логическое True или False.

Пример подготовки признака:

raw_distance = "12.5"
# Превращаем строку в вещественное число
clean_distance = float(raw_distance)

Если вы попытаетесь сделать int("12.5"), Python выдаст ошибку, так как не знает, что делать с точкой внутри текста. А вот при преобразовании дробного числа в целое (int(12.5)) Python просто отбросит дробную часть, и получится 12.

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

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

Арифметические операции и работа с числами в контексте данных

Любая модель машинного обучения «видит» мир исключительно через числа. Текст, изображения, поведение пользователей — всё это на этапе подготовки данных превращается в массивы int и float. Но сырые данные редко бывают готовы к использованию сразу. Чтобы помочь алгоритму найти закономерности, ML-инженер должен уметь комбинировать, масштабировать и преобразовывать эти числа.

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

Базовая арифметика и особенность деления

Сложение (+), вычитание (-) и умножение (*) в Python работают интуитивно понятно. Если вы складываете два целых числа (int), результат будет целым. Если хотя бы одно из чисел дробное (float), результат автоматически станет дробным.

А вот операция деления (/) ведет себя иначе.

Операция	Синтаксис	Пример в коде	Результат	Тип результата
Сложение	+	15 + 5	20	int
Вычитание	-	15.5 - 5	10.5	float
Умножение	*	10 * 2	20	int
Деление	/	10 / 2	5.0	float

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

Продвинутые операторы: разделение и группировка

При подготовке признаков (Feature Engineering) часто возникает задача разбить одно число на компоненты или сгруппировать данные. Для этого в Python есть два связанных оператора: целочисленное деление (//) и взятие остатка (%).

• Целочисленное деление (//) отбрасывает дробную часть и показывает, сколько раз делитель целиком помещается в числе.
• Остаток от деления (%) показывает, что осталось после того, как мы забрали все целые части.

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

duration_minutes = 135

# Сколько полных часов?
hours = duration_minutes // 60
# Результат: 2

# Сколько минут осталось?
minutes = duration_minutes % 60
# Результат: 15

Оператор % — один из самых недооцененных инструментов новичка. С его помощью можно легко проверять числа на четность (если x % 2 == 0, число четное), извлекать последнюю цифру числа или зацикливать значения.

Возведение в степень и корни

Для возведения числа в степень используется двойная звездочка (**).

area = 5 ** 2  # 5 в квадрате = 25
volume = 2 ** 3  # 2 в кубе = 8

Математическое свойство степеней позволяет использовать этот же оператор для извлечения корней. Квадратный корень — это возведение в степень $\frac{1}{2}$ (или $0.5$).

# Извлечение квадратного корня
root = 81 ** 0.5
# Результат: 9.0

Практика: вычисление расстояния между объектами

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

Алгоритмам часто нужно понимать, насколько два объекта «похожи» друг на друга. Например, в рекомендательных системах похожесть пользователей можно оценить геометрически — вычислив расстояние между ними на графике признаков. Самый популярный метод — евклидово расстояние.

Формула евклидова расстояния опирается на теорему Пифагора:

$$d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$

Где:

• $x$ и $y$ — это значения признаков (например, возраст и количество покупок).
• Индексы $1$ и $2$ обозначают первого и второго пользователя.
• Разность координат возводится в квадрат, результаты складываются, и из суммы извлекается квадратный корень.

Напишем код для вычисления этого расстояния, используя базовые переменные и арифметику Python:

# Признаки первого пользователя
user1_age = 25
user1_purchases = 10

# Признаки второго пользователя
user2_age = 30
user2_purchases = 22

# Вычисляем разницу по каждому признаку
diff_age = user2_age - user1_age
diff_purchases = user2_purchases - user1_purchases

# Применяем формулу: возводим в квадрат, складываем и извлекаем корень
distance = (diff_age ** 2 + diff_purchases ** 2) ** 0.5

print(distance) # Результат: 13.0

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

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

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

counter = 0
counter += 1  # Эквивалентно: counter = counter + 1

metric = 100.0
metric /= 2   # Эквивалентно: metric = metric / 2

Такие операторы (+=, -=, *=, /=) не просто экономят место. Они делают код более читаемым, четко показывая намерение: «изменить текущее значение переменной на заданную величину». Этот механизм станет нашим главным инструментом, когда мы перейдем к автоматизации обработки данных через циклы. Но перед тем как зациклить вычисления, нам нужно научить программу принимать решения на основе этих чисел.

Логические выражения и операторы сравнения для фильтрации данных

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

В прошлой главе мы научились вычислять новые значения с помощью математики. Но как объяснить компьютеру, какие именно данные нас интересуют? Для этого в программировании используются логические выражения — инструкции, которые задают вопрос данным и всегда получают однозначный ответ: «Да» (True) или «Нет» (False).

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

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

Результатом любого сравнения всегда является значение типа bool (логический тип), принимающее только два значения: True или False.

Оператор	Значение	Математический аналог	Пример в коде	Результат
==	Равно	$a = b$	5 == 5	True
!=	Не равно	$a \neq b$	10 != 5	True
>	Больше	$a > b$	7 > 10	False
<	Меньше	$a < b$	7 < 10	True
>=	Больше или равно	$a \geq b$	10 >= 10	True
<=	Меньше или равно	$a \leq b$	5 <= 10	True

Главная ловушка для начинающих: путаница между = и ==. Одинарный знак = — это присваивание (положить значение в переменную). Двойной == — это сравнение (проверить, равны ли значения).

Посмотрим, как это работает на примере признаков (фичей) клиента:

user_age = 25
required_age = 18

# Проверяем, достиг ли пользователь нужного возраста
is_adult = user_age >= required_age
print(is_adult)  # Выведет: True

# Проверяем статус
status = "premium"
is_basic = status == "basic"
print(is_basic)  # Выведет: False

Логические операторы: комбинируем условия

В реальных ML-задачах редко бывает достаточно одного условия. Например, чтобы предложить клиенту кредит, он должен быть совершеннолетним И иметь стабильный доход. Или же он может быть VIP-клиентом, ИЛИ иметь поручителя.

Для связывания простых сравнений в сложные фильтры Python использует три логических слова: and, or и not.

1. Строгое условие: and (И)

Оператор and требует, чтобы все условия были истинными. Если хотя бы одно условие ложно (False), всё выражение становится ложным.

income = 50000
credit_score = 750

# Кредит одобрят только если доход от 40000 И рейтинг от 700
is_approved = (income >= 40000) and (credit_score >= 700)
print(is_approved) # True, так как обе части True

2. Мягкое условие: or (ИЛИ)

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

is_student = True
is_pensioner = False

# Скидка дается либо студентам, либо пенсионерам
gets_discount = is_student or is_pensioner
print(gets_discount) # True, так как первое условие True

3. Отрицание: not (НЕ)

Оператор not просто переворачивает логическое значение: True превращается в False, а False — в True. Это полезно, когда нам нужно исключить какую-то категорию.

is_banned = False

# Пользователь может войти, если он НЕ заблокирован
can_login = not is_banned
print(can_login) # True

Чтобы лучше прочувствовать, как изменение параметров влияет на итоговый результат сложного логического выражения, поэкспериментируйте с интерактивным фильтром:

Порядок вычисления (приоритет операций)

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

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

1. Математические вычисления (+, -, *, / и т.д.)
2. Сравнения (>, <, ==, != и т.д.)
3. not
4. and
5. or

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

amount = 500
is_verified = True
is_cancelled = False

# Как это прочитает Python?
valid_transaction = amount > 1000 or is_verified and not is_cancelled

Шаги вычисления под капотом:

1. Сравнение: amount > 1000 превращается в False.
2. not: not is_cancelled превращается в True.
3. Теперь выражение выглядит так: False or True and True.
4. and: True and True дает True.
5. Выражение сокращается до: False or True.
6. or: Итог — True.

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

valid_transaction = (amount > 1000) or (is_verified and (not is_cancelled))

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

Мы научились формулировать сложные условия и получать ответ True или False. Но пока наша программа просто констатирует факт. В следующей главе мы сделаем так, чтобы в зависимости от этого ответа код принимал решения и выполнял разные действия — мы познакомимся с условными конструкциями (If-Else).

Условные конструкции: реализация жестких правил (If-Else)

Мы уже умеем вычислять истинность выражений, получая True или False. Но само по себе знание, что температура сервера превысила норму ($T > 80$), бесполезно, если программа просто перейдет к следующей строке кода. Нам нужно, чтобы код реагировал на данные: отправлял алерт при перегреве и молчал при нормальной работе.

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

Базовое ветвление: if и else

Самая простая форма принятия решений — это оператор if (если). Он проверяет логическое условие. Если условие истинно (True), выполняется определенный блок кода. Если ложно (False) — этот блок игнорируется.

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

sensor_temp = 85.5
threshold = 80.0

if sensor_temp > threshold:
    print("Внимание: перегрев!")
    status = "critical"
else:
    print("Температура в норме.")
    status = "ok"

print("Проверка завершена.")

Обратите внимание на две критические особенности синтаксиса Python:

1. Двоеточие (:) в конце строк с if и else. Оно сигнализирует интерпретатору: «дальше начнется блок кода, который относится к этому условию».
2. Отступы (Indentation). В Python блоки кода выделяются не скобками, а пробелами в начале строки (обычно 4 пробела). Все строки с одинаковым отступом под условием считаются единым блоком. Как только отступ возвращается на прежний уровень (как в строке print("Проверка завершена.")), Python понимает, что условная конструкция закончилась.

Множественный выбор: elif

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

Для цепочки взаимоисключающих проверок используется оператор elif (сокращение от else if).

user_logins = 15

if user_logins >= 20:
    category = "High Activity"
elif user_logins >= 10:
    category = "Medium Activity"
elif user_logins > 0:
    category = "Low Activity"
else:
    category = "Inactive"

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

В примере выше при user_logins = 15 первое условие ($15 \geq 20$) дает False. Второе условие ($15 \geq 10$) дает True. Переменная category получает значение "Medium Activity", и программа сразу выходит из всей конструкции, игнорируя проверку $15 > 0$, хотя математически она тоже верна.

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

Правила могут зависеть друг от друга. Внутри любого блока if, elif или else можно написать новую условную конструкцию. Это называется вложенностью. С каждым уровнем вложенности отступ увеличивается еще на 4 пробела.

Рассмотрим простейшую эвристическую модель оценки недвижимости. Сначала мы разделяем объекты на жилые и коммерческие, а затем применяем к ним разные правила оценки.

property_type = "residential"
area_sqm = 45
distance_to_subway_km = 0.5

if property_type == "commercial":
    if area_sqm > 100:
        price_tier = "Premium Commercial"
    else:
        price_tier = "Standard Commercial"
else:
    # Если не коммерческая, считаем жилой
    if distance_to_subway_km <= 1.0:
        price_tier = "High Demand Residential"
    else:
        price_tier = "Standard Residential"

Вложенные условия — это фундамент алгоритма «Дерево решений» (Decision Tree). Разница лишь в том, что сейчас мы придумываем пороги (100 квадратных метров, 1.0 км) из головы, а модель машинного обучения найдет оптимальные пороги сама, проанализировав тысячи проданных квартир.

Жесткие правила отлично работают для единичных объектов. Но в реальности ML-инженер работает с датасетами, содержащими миллионы строк. Писать отдельный if для каждой строки невозможно. Нам нужен механизм, который заставит код с условными конструкциями пробежаться по всему набору данных автоматически.

Циклы For и While: автоматизация обработки датасетов

В прошлой главе мы написали логику, которая оценивает один объект: например, проверяет, превышает ли температура сервера критическую отметку. Но в машинном обучении мы никогда не работаем с одним объектом. Датасеты состоят из тысяч, а иногда и миллионов строк. Если у нас есть 10 000 записей, мы не можем скопировать блок if-else 10 000 раз.

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

В Python есть два основных типа циклов, которые решают разные задачи: while и for.

Цикл while: повторение до достижения цели

Цикл while (пока) работает как зацикленный оператор if. Он проверяет логическое условие: если оно истинно (True), выполняется блок кода внутри цикла. Затем Python возвращается в начало и снова проверяет условие. Это продолжается до тех пор, пока условие не станет ложным (False).

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

Классический пример из машинного обучения — процесс тренировки модели. Мы хотим, чтобы алгоритм обучался, пока его ошибка (error) не станет меньше определенного порога (например, $error \leq 0.2$).

error = 1.0

while error > 0.2:
    # Имитация процесса обучения
    error = error - 0.3

print("Обучение завершено. Итоговая ошибка:", error)

У цикла while есть одна критическая особенность — риск бесконечного цикла. Если условие никогда не станет False (например, если бы мы забыли написать строку error = error - 0.3), программа будет работать вечно, пока не зависнет или не исчерпает память. Поэтому внутри блока while всегда должно происходить что-то, что приближает условие к завершению.

Цикл for и функция range: работа с известным объемом

Если while ждет выполнения условия, то цикл for (для) создан для перебора готовых последовательностей. Мы используем его, когда точно знаем, сколько раз нужно выполнить код, или когда у нас есть набор данных, по которому нужно пройти от начала до конца.

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

Синтаксис выглядит так:

for i in range(5):
    # Этот код выполнится 5 раз

Функция range() может принимать разные аргументы, задавая старт, финиш и шаг:

• range(5) — сгенерирует числа от 0 до 4. Важно: программисты считают с нуля, поэтому финишное число (5) не включается в результат.
• range(1, 4) — сгенерирует числа 1, 2, 3.
• range(0, 10, 2) — сгенерирует числа с шагом 2: 0, 2, 4, 6, 8.

Переменная i (сокращение от index или integer) на каждом шаге цикла автоматически принимает следующее значение из сгенерированной последовательности.

В контексте ML цикл for с range() часто используется для задания количества эпох — полных проходов алгоритма по обучающим данным:

epochs = 3

for epoch in range(1, epochs + 1):
    # Здесь модель обновляет свои веса
    print("Завершена эпоха номер", epoch)

Обратите внимание: мы написали epochs + 1, чтобы число 3 включилось в последовательность.

Сравнение подходов: когда что использовать

Выбор между while и for зависит от архитектуры вашей задачи.

Характеристика	Цикл while	Цикл for
Главный принцип	Работает, пока условие True	Перебирает элементы последовательности
Количество шагов	Заранее неизвестно	Известно до начала цикла
Риск бесконечности	Высокий (если забыть обновить переменную)	Отсутствует (последовательность конечна)
Пример в ML	Обучать, пока точность не достигнет 95%	Обучать ровно 100 эпох

Практика: объединяем переменные, логику и циклы

Давайте посмотрим, как все изученные нами инструменты работают вместе. Цикл for умеет перебирать не только числа из range(), но и символы в строке (str).

Представим, что мы получили сырые данные о поле клиентов в виде одной сплошной строки: "MFFMFMM", где M — Male (мужчина), а F — Female (женщина). Наша задача — автоматизировать подсчет количества женщин в этом мини-датасете.

raw_data = "MFFMFMM"
female_count = 0  # Переменная-счетчик

for person in raw_data:
    if person == "F":
        female_count += 1  # Увеличиваем счетчик на 1

print("Количество женщин в датасете:", female_count)

Как это работает:

1. Мы создали переменную female_count и присвоили ей стартовое значение 0.
2. Цикл for берет строку "MFFMFMM" и отщепляет от нее по одному символу. На первом шаге переменная person равна "M", на втором — "F" и так далее. Это называется итерацией.
3. Внутри цикла работает жесткое правило if: мы сравниваем текущий символ со строкой "F".
4. Если условие истинно, срабатывает оператор присваивания с вычислением (+=), и счетчик увеличивается.

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

Управление итерациями: операторы break и continue в потоках данных

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

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

Оператор continue: фильтрация шума

Представьте, что вы анализируете текстовый лог активности пользователей. Каждая буква в строке — статус транзакции: S (Success), P (Pending) и E (Error). Ваша задача — подсчитать только успешные и ожидающие транзакции, игнорируя ошибки.

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

Посмотрим на это в коде:

log_data = "SPEES"
processed_count = 0

for status in log_data:
    if status == "E":
        continue  # Пропускаем ошибки, идем к следующей букве

    # Этот код выполнится только для "S" и "P"
    processed_count += 1
    print("Обработан статус:", status)

print("Всего обработано:", processed_count)

Как алгоритм видит этот процесс:

1. Берет S. Условие status == "E" ложно. Увеличивает счетчик.
2. Берет P. Условие ложно. Увеличивает счетчик.
3. Берет E. Условие истинно. Срабатывает continue. Цикл бросает текущий шаг и мгновенно возвращается наверх. Счетчик не увеличивается.
4. Снова берет E. Снова continue.
5. Берет S. Условие ложно. Увеличивает счетчик.

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

Оператор break: экстренное торможение

Если continue говорит «пропусти этот шаг», то оператор break говорит «останови весь цикл навсегда». Как только срабатывает break, Python выходит из цикла, даже если в последовательности еще остались элементы или условие while все еще истинно.

В машинном обучении break — основа техники, которая называется Early Stopping (ранняя остановка).

Обучение модели (например, нейросети) происходит в цикле. Алгоритм раз за разом просматривает данные, и с каждой итерацией (эпохой) его ошибка снижается. Но если ошибка упала до приемлемого минимума, скажем, $E < 0.01$, нет смысла тратить вычислительные мощности серверов и продолжать цикл.

epoch = 1
error = 0.90

while epoch <= 100:
    # Имитация обучения: ошибка падает на каждой эпохе
    error -= 0.15

    if error < 0.10:
        print("Достигнута нужная точность на эпохе", epoch)
        break  # Полностью уничтожаем цикл

    epoch += 1

print("Обучение завершено. Финальная ошибка:", error)

В этом примере мы заложили 100 эпох (epoch <= 100). Но благодаря break, цикл остановится уже на 6-й эпохе.

Архитектура конвейера: if, continue и break вместе

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

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

• for / while — обеспечивают движение потока данных.
• if — проверяет конкретный элемент на соответствие правилам.
• continue и break — управляют самим потоком, опираясь на решения if.

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

Рассмотрим комплексный пример. Мы получаем поток данных с датчиков температуры. Нормальная температура — около 20 градусов. Значение 0 означает, что датчик не передал данные (пропуск связи). Значение больше 100 градусов означает пожар — нужно немедленно остановить сбор данных и поднять тревогу.

Реализуем эту логику:

sensor_data = "22,0,21,105,22,20"
# Поскольку мы еще не изучали списки, сымитируем поток
# через строковые переменные и заранее извлеченные значения.
# Допустим, мы читаем данные в цикле while

current_index = 1
while current_index <= 5:
    # Имитация получения данных с датчика
    if current_index == 1: temp = 22
    elif current_index == 2: temp = 0
    elif current_index == 3: temp = 21
    elif current_index == 4: temp = 105
    elif current_index == 5: temp = 22

    current_index += 1

    if temp == 0:
        print("Нет данных, ждем следующие...")
        continue  # Пропускаем запись в базу

    if temp > 100:
        print("КРИТИЧЕСКАЯ ТЕМПЕРАТУРА! ОСТАНОВКА СИСТЕМЫ!")
        break  # Останавливаем весь процесс сбора

    print("Записано в базу:", temp)

В этом сценарии температура 22 запишется в базу. Значение 0 вызовет continue — цикл пропустит запись и пойдет за следующей порцией. Температура 21 запишется. А вот 105 спровоцирует break — цикл умрет, и последняя температура 22 даже не будет прочитана.

Фундамент заложен

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

Вы понимаете, как данные хранятся (int, float, str, bool), как они преобразуются (арифметика), как алгоритм принимает решения (if-else) и как он автоматизирует рутину (for, while, break, continue).

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