До этого момента программы выполняли код последовательно, строка за строкой, и могли выбирать разные ветки выполнения с помощью условий if / elif / else.

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

Для решения таких задач в Python используются циклы.

Что такое цикл

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

Главная идея цикла состоит в том, что код внутри цикла выполняется не один раз, а повторяется. Каждое повторение выполняется по одному и тому же сценарию, но с разными данными или при разных значениях переменных.

Цикл завершается автоматически, когда заканчиваются данные для перебора (в случае for) или когда условие становится ложным (в случае while). Благодаря этому циклы позволяют писать код короче, понятнее и надёжнее, избегая копирования одних и тех же строк.

Итерация

Итерация — это одно выполнение тела цикла, то есть один шаг цикла.

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

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

Пример:

В этом примере тело цикла выполнится три раза — по одному разу на каждую итерацию.

Тело цикла и отступы

Тело цикла — это блок кода, который повторяется на каждой итерации. Именно в теле цикла описывается, что конкретно нужно сделать при каждом повторении.

В Python тело цикла начинается после двоеточия (:) в строке с for или while и выделяется отступом. Отступы являются частью синтаксиса языка, а не просто оформлением.

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

Пример:

Цикл for: перебор значений по очереди

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

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

Пример:

Цикл for последовательно принимает значения от 1 до 5 и на каждой итерации выводит текущее число.

enumerate: когда нужен номер элемента

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

Для этого используется встроенная функция enumerate, которая позволяет одновременно получать индекс элемента и его значение.

Пример:

Здесь index — номер элемента, а value — сам элемент. enumerate не является отдельным типом цикла и используется только тогда, когда индекс действительно нужен.

range(): источник чисел для for

Функция range() создаёт последовательность чисел, которую удобно перебирать в цикле for.

Вызов range(5) даёт числа 0, 1, 2, 3, 4. Верхняя граница не включается, чтобы было удобно работать с количеством элементов и индексами.

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

В этом случае будут получены числа от 1 до 5.

Цикл while: повторение по условию

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

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

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

Пример корректного цикла:

Управление циклами: break и continue

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

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

Оператор continue завершает исполнение текущей итерации цикла и сразу переходит к следующей итерации. Код, расположенный ниже continue в теле цикла, в этом проходе не выполняется, но сам цикл продолжается.

Пример:

В этом примере значение 2 будет пропущено, но цикл продолжит работу.

else в циклах for и while

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

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

Пример:

В этом примере блок else выполнится, потому что цикл завершился без break.

Практические задания — Этап 3. Циклы

Задания идут в простом формате: сначала задача, затем решение и пояснение в аккордеоне.
Это помогает сначала подумать самостоятельно, а потом сравнить подход.

Задание 1. for + range(): числа от 1 до 5

Выведите числа от 1 до 5 включительно, по одному числу на строку.

for i in range(1, 6):
    print(i)

Задание 2. Перебор строки: вывести символы

Дана строка:

text = "Python"

Выведите каждый символ строки на отдельной строке.

text = "Python"

for char in text:
    print(char)

Задание 3. while: числа от 1 до 5

Выведите числа от 1 до 5 с помощью цикла while.

i = 1

while i <= 5:
    print(i)
    i += 1

Задание 4. break: остановить цикл на определённом числе

Выведите числа от 1 до 10, но остановите цикл, когда число станет равным 6.
(То есть 6 печатать не нужно.)

for i in range(1, 11):
    if i == 6:
        break
    print(i)

Задание 5. continue: пропустить значение

Выведите числа от 1 до 5, но пропустите число 3.

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

Контрольные вопросы — Этап 3

Вопрос 1. Что такое итерация цикла?

Вопрос 2. В чём основное различие между циклами for и while?

Вопрос 3. Почему выражение range(5) не включает число 5?

Вопрос 4. Что делает оператор break в цикле?

Вопрос 5. Что произойдёт, если условие в while никогда не станет ложным?

Мини-шпаргалка по циклам

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

В Этапе 3 были разобраны два основных вида циклов — for и while, а также связанные с ними понятия итерации, тела цикла и отступов. Отдельное внимание уделено функциям range и enumerate, которые упрощают перебор чисел и элементов последовательностей, а также операторам break и continue, позволяющим управлять ходом выполнения цикла.

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

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

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

Чтобы условия были предсказуемыми, важно понимать три вещи: откуда берутся True/False, как формируются проверки через сравнения, и как if/elif/else принимает решение на основе результата. В этом этапе мы выстроим эти знания в правильной последовательности и закрепим практическими примерами.

True и False: откуда берутся значения истины

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

Когда ты пишешь проверку (например, сравнение чисел или строк), Python не “печатает ответ”, а возвращает значение True или False. Эти значения затем используются в условиях, циклах и любых местах, где нужно выбрать поведение программы.

Важно сразу зафиксировать: True и False — это не “текст”, а значения типа bool. Их можно сохранять в переменные, возвращать из функций и комбинировать логическими операторами, как обычные данные.

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

Логическое выражение — это выражение, результат которого всегда либо True, либо False. Самый частый источник логических выражений — сравнения: “больше”, “меньше”, “равно”, “не равно”.

Когда ты пишешь 5 > 3, Python вычисляет это выражение и возвращает True. Если ты пишешь "qa" == "QA", Python возвращает False, потому что строки отличаются. Это и есть “материал”, из которого строятся условия.

Отдельно полезно понимать, что логическое выражение может быть простым (одно сравнение) или составным (несколько проверок через and/or/not). Но в любом случае оно должно давать результат, по которому можно принять решение.

Пример:

5 > 3 # True
5 == 3 # False
"qa" != "QA" # True

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

Операторы сравнения позволяют сравнивать значения и получать булев результат. По сути это “датчики”, которые отвечают на вопросы “равно ли”, “больше ли”, “меньше ли”, и именно на этих ответах строится логика ветвления.

Важно не путать присваивание и сравнение. Присваивание (=) кладёт значение в переменную, а сравнение (==) проверяет равенство и возвращает True/False. Это одна из самых частых ошибок в начале обучения.

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

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

• == — равно
• != — не равно
• > — больше
• < — меньше
• >= — больше или равно
• <= — меньше или равно

Условная конструкция if / elif / else: как Python выбирает ветку

Названия ключевых слов if, elif и else пришли из английского языка и напрямую отражают их смысл:

• if — если
• elif — иначе если (сокращение от else if)
• else — иначе

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

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

Структурно это выглядит так: после условия ставится двоеточие, а ниже идёт блок кода с отступом. В Python отступы — часть синтаксиса, поэтому “сдвиг вправо” здесь не стиль оформления, а способ показать, к чему относится блок.

Если вариантов больше двух, используется elif (“иначе если”). Python проверяет условия сверху вниз и выполняет первый блок, условие которого оказалось истинным. Если ни одно условие не подошло, срабатывает else.

Пример:

age = 17 if age >= 18:
print("Доступ разрешён")
elif age >= 16:
print("Ограниченный доступ")
else:
print("Доступ запрещён")

Логические операторы and / or / not: как объединять проверки

Когда одного сравнения недостаточно, проверки объединяют логическими операторами. Это нормальная ситуация в реальной разработке и тестировании: например, “пользователь авторизован и роль админ”, “код ответа 200 или 204”, “не истёк токен”.

and, or и not — логические операторы, названия которых напрямую отражают их значение в английском языке:

• and означает «и» — все условия должны быть истинны одновременно.
• or означает «или» — достаточно, чтобы истинным было хотя бы одно условие.
• not означает «не» — он инвертирует условие, превращая истинное в ложное и наоборот.

По смыслу эти операторы работают так же, как логика рассуждений в обычной речи, поэтому условия с and, or и not легко читать и понимать даже в сложных проверках.

Важно знать ещё одно поведение Python: and и or возвращают один из операндов, а не обязательно True/False. Это полезно для значений “по умолчанию”, но иногда удивляет новичков, поэтому лучше увидеть это на примерах.

Пример 1. and — оба условия должны быть истинны

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

Пример 2. or — достаточно одного истинного условия

В этом примере проверка пройдёт, если код ответа равен 200 или 204. Остальные значения приведут к тому, что if не выполнится.

Пример 3. not — отрицание условия

Оператор not инвертирует значение условия. Если пользователь не заблокирован (False), условие становится истинным, и код выполняется.

Короткое замыкание: почему некоторые части условия не выполняются

Python применяет короткое замыкание (short-circuit) при вычислении and и or. Это означает, что иногда вторая часть выражения не вычисляется, потому что результат уже понятен по первой части.

Для A and B правило такое: если A уже “ложное”, то всё выражение ложное, и B вычислять не нужно. Для A or B наоборот: если A уже “истинное”, то всё выражение истинное, и B можно не вычислять.

Практическая польза огромная: это позволяет писать безопасные проверки, которые не падают на None, и экономить вычисления. В автотестах это часто спасает от ошибок вида “у None нет атрибута”.

Пример:

Что здесь важно

Оператор and проверяет условия слева направо.

1. Сначала проверяется:

   user is not None


   Так как user = None, это условие ложное.

2. Для and действует правило:

   если первая часть ложная, всё выражение уже ложное

3. Поэтому Python не проверяет вторую часть:

   user.name == "Viktor"


   и просто пропускает её.

Практические задания — Этап 2. Условия и логика

Сначала попробуйте решить сами. Затем откройте решение и пояснение.

Задание 1. Простое сравнение

Даны переменные:

a = 10
b = 7

Выведите результат проверок:

• a > b
• a == b
• a != b

a = 10
b = 7

print(a > b)   # True
print(a == b)  # False
print(a != b)  # True

Задание 2. if / else: проверка возраста

Дана переменная:

age = 17

Если возраст меньше 18 — вывести "Доступ запрещён",
иначе вывести "Доступ разрешён".

age = 17

if age < 18:
    print("Доступ запрещён")
else:
    print("Доступ разрешён")

Задание 3. elif: оценка по баллам

Дано число баллов:

score = 72

Сделайте вывод:

• если баллы меньше 50 → "Не сдано"
• если баллы от 50 до 79 включительно → "Сдано"
• если баллы 80 и выше → "Отлично"

score = 72

if score < 50:
    print("Не сдано")
elif score <= 79:
    print("Сдано")
else:
    print("Отлично")

Задание 4. and/or: сложное условие

Даны:

is_logged_in = True
is_admin = False

Нужно вывести "Доступ к настройкам", если пользователь либо администратор,
либо просто вошёл в систему. Иначе вывести "Нет доступа".

is_logged_in = True
is_admin = False

if is_admin or is_logged_in:
    print("Доступ к настройкам")
else:
    print("Нет доступа")

Задание 5. not: инверсия условия

Дана переменная:

is_blocked = False

Если пользователь НЕ заблокирован — вывести "Можно продолжать",
иначе — "Пользователь заблокирован".

is_blocked = False

if not is_blocked:
    print("Можно продолжать")
else:
    print("Пользователь заблокирован")

Контрольные вопросы — Этап 2

Ответьте самостоятельно, затем откройте ответ и пояснение.

Вопрос 1. Чем отличается = от ==?

Вопрос 2. Что возвращает оператор сравнения, например 5 > 3?

Вопрос 3. Когда срабатывает блок else?

Вопрос 4. В чём разница между and и or?

Вопрос 5. Что делает not?

Мини-шпаргалка по Этапу 2

if condition:
    ...
elif other_condition:
    ...
else:
    ...

Итог Этапа 2

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

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

• что такое логическое выражение и почему его результатом являются значения True или False;
• как работают операторы сравнения (==, !=, >, <, >=, <=);
• чем отличается присваивание значения (=) от проверки равенства (==);
• как использовать конструкции if, elif и else для ветвления логики;
• как объединять и инвертировать условия с помощью операторов and, or и not.

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

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

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

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

Что такое переменные в Python

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

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

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

Что такое данные и типы данных

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

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

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

Что такое объект и функция type()

Объект — это конкретное значение, размещённое в памяти среды выполнения Python. К объектам относятся, например, число 5, строка "5" или логическое значение True.

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

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

Основные типы данных

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

int — целые числа

Тип int (integer) используется для представления целых чисел без дробной части. К таким значениям относятся, например, 0, 5 и -12. Тип int применяется при подсчётах, работе с количествами, индексами и счётчиками.

Важно учитывать, что число 5 и строка "5" — это разные значения с разным поведением.

float — числа с плавающей точкой

Тип float используется для чисел с дробной частью, таких как 3.14, 10.0 или -0.5. Он применяется в задачах, связанных с измерениями, процентами и средними значениями.

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

str — строки (текст)

Тип str (string) предназначен для хранения текстовых данных. К строкам относятся, например, "hello", "123" и "QA tester".

Даже если строка визуально похожа на число, для Python она остаётся текстом и не участвует в числовых вычислениях.

bool — логический тип

Тип bool (Boolean) может принимать только два значения: True и False. Эти значения происходят из математической логики, где любое утверждение является либо истинным, либо ложным.

Например, выражение «5 больше 3» имеет значение True, а выражение «2 больше 10» — значение False. Python использует тип bool для хранения результатов проверок, логических условий и состояний.

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

None — отсутствие значения

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

None применяется в ситуациях, когда значение ещё не задано, функция ничего не вернула или отсутствие данных является осознанным решением.

Приведение типов: зачем и почему

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

Функция int() используется для преобразования в целое число. При этом дробная часть отбрасывается, а не округляется.

Функция float() преобразует значение в число с плавающей точкой.

Функция str() преобразует значение в строку.

Функция bool() показывает, считается ли значение логически истинным или ложным.

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

Арифметические операции в Python

Python поддерживает стандартные арифметические операции:

• сложение (+);
• вычитание (-);
• умножение (*);
• деление (/);
• целочисленное деление (//);
• возведение в степень (**);
• взятие остатка от деления (%).

Арифметические операции применяются к числовым типам данных (int, float).

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

Практические задания — Этап 1. Типы данных в Python

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

Задание 1. Определение типов данных

Определите типы следующих значений:

• 42
• "42"
• 42.0
• True

print(type(42))     # int
print(type("42"))   # str
print(type(42.0))   # float
print(type(True))   # bool

Задание 2. Число или строка?

Дан код:

a = "10"
b = 5
result = a + b
print(result)

Объясните, почему код не работает, и исправьте его.

a = "10"
b = 5
result = int(a) + b
print(result)  # 15

Задание 3. Приведение типов

Дано значение:

x = 7.8

Преобразуйте его в целое число и объясните полученный результат.

x = 7.8
y = int(x)
print(y)  # 7

Задание 4. Истина или ложь

Определите, какой результат вернёт функция bool() для значений:

• 0
• "0"
• ""
• None

print(bool(0))      # False
print(bool("0"))    # True
print(bool(""))     # False
print(bool(None))   # False

Контрольные вопросы

Ответьте на вопросы самостоятельно, затем откройте блок с ответом и пояснением.

Типы данных в Python

Вопрос 1. Почему значение "5" не является числом?

Вопрос 2. Чем отличаются int и float?

Вопрос 3. Почему int(3.9) возвращает 3, а не 4?

Вопрос 4. Почему bool(0) — это False, а bool("0") — True?

Вопрос 5. Что означает значение None и почему оно не равно False?

Мини-шпаргалка

type(value)   # проверка типа
int(x)        # преобразование в целое
float(x)      # преобразование в дробное
str(x)        # преобразование в строку
bool(x)       # преобразование в логическое значение

Итог Этапа 1

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

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

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