Основы программирования на Python

Введение в Python и настройка среды разработки

Что такое Python и зачем он нужен

Python — это язык программирования, на котором можно писать программы для самых разных задач:

автоматизация рутинных действий (файлы, таблицы, отчёты)

анализ данных и визуализация

веб-разработка

машинное обучение

написание небольших утилит и учебных проектов

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

Как выполняются программы на Python

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

Файл с программой обычно имеет расширение *.py.

Интерпретатор Python запускается командой в терминале (или через кнопку запуска в редакторе кода).

!Схема показывает путь: файл с кодом → интерпретатор → результат выполнения

Что нужно установить для работы

Минимальный набор:

Python 3 (интерпретатор)

редактор кода (например, Visual Studio Code)

терминал (командная строка) для запуска команд

Дополнительно (по желанию):

IDE (например, PyCharm)

Jupyter Notebook для работы в формате ноутбуков

Установка Python

Важное про версии

В этом курсе используется Python 3.

Python 2 устарел и в современных проектах почти не используется.

Windows

Скачайте установщик с сайта Python Downloads.

Запустите установку.

Обязательно отметьте галочку Add python.exe to PATH (это позволит запускать Python из терминала).

macOS

Самый надёжный вариант — установить актуальный Python с официального сайта:

Python Downloads

Альтернативно часто используют Homebrew, но для первого шага проще официальный установщик.

Linux

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

Проверка установки

Откройте терминал (командную строку) и выполните команды.

Проверяем версию Python

Если команда не сработала, попробуйте:

На Windows также может работать:

Проверяем установщик пакетов pip

pip — это стандартный инструмент для установки сторонних библиотек.

Если нужно явно указать Python 3:

Шпаргалка по командам

| Задача | Windows (часто) | macOS/Linux (часто) | |---|---|---| | Проверить версию Python | py --version или python --version | python3 --version | | Запустить файл | py script.py или python script.py | python3 script.py | | Проверить pip | py -m pip --version | python3 -m pip --version |

Выбор и установка редактора кода

Visual Studio Code (рекомендуемый вариант)

Установите Visual Studio Code.

Откройте VS Code → Extensions (расширения).

Установите расширение Python от Microsoft.

Что это даст:

подсветку синтаксиса

автодополнение

запуск и отладку кода

удобную работу с виртуальными окружениями

Альтернатива: PyCharm

PyCharm — полноценная среда разработки (IDE), где многое настроено “из коробки”. Официальная страница:

PyCharm

Для курса достаточно VS Code, но вы можете выбрать то, что удобнее.

Первый запуск Python

Интерактивный режим (REPL)

Интерактивный режим — это когда вы вводите команды по одной строке, и Python сразу их выполняет. Запускается командой:

или:

Пример:

Выйти обычно можно командой exit().

Запуск программы из файла

Создайте папку проекта, например python-course.

Внутри создайте файл hello.py.

Добавьте код:

Запустите из терминала в папке проекта:

Если у вас на системе требуется python3, используйте:

Виртуальное окружение: зачем оно нужно

Когда вы устанавливаете библиотеки через pip, они попадают в среду Python. Чтобы разные проекты не мешали друг другу (например, одному проекту нужна одна версия библиотеки, а другому — другая), используют виртуальные окружения.

Виртуальное окружение — это отдельная “копия” окружения Python внутри папки проекта.

!Диаграмма показывает, что venv изолирует зависимости разных проектов

Создание и использование виртуального окружения (venv)

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

Создать окружение

В папке проекта выполните:

Если у вас команда Python называется python3:

Здесь:

python -m venv — запуск встроенного модуля venv

.venv — имя папки, где будет храниться окружение (часто так и называют)

Активировать окружение

Windows (PowerShell):

Windows (cmd):

macOS/Linux:

Обычно после активации в начале строки терминала появляется пометка с именем окружения.

Установить пакет в окружение

Пример установки библиотеки:

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

Выйти из окружения

Полезные советы по организации проекта

Создавайте отдельную папку на каждый учебный проект.

Держите исходники в .py файлах с понятными именами (lesson1.py, strings.py, loops.py).

Если используете venv, обычно папку .venv не добавляют в систему контроля версий (к ней мы вернёмся позже в курсе).

Что делать, если что-то не запускается

Частые ситуации:

Команда python не найдена: Python не установлен или не добавлен в PATH (особенно на Windows).

Установлено несколько версий Python: используйте python3 (macOS/Linux) или py (Windows).

pip устанавливает пакеты “не туда”: используйте python -m pip ..., чтобы привязать pip к конкретному Python.

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

Итоги

Вы узнали:

что такое Python и как выполняется код

как установить Python 3 и проверить установку

что такое pip и зачем он нужен

как выбрать редактор кода (VS Code / PyCharm)

как запускать Python в интерактивном режиме и из файла

зачем нужно виртуальное окружение и как работать с venv

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

Типы данных, переменные и ввод-вывод

Как это связано с предыдущей темой

В прошлой статье вы установили Python, научились запускать код из файла и в интерактивном режиме (REPL), а также узнали про виртуальные окружения. Теперь мы начнём писать первые осмысленные программы: хранить данные в переменных, понимать их типы и общаться с пользователем через ввод и вывод.

!Общая картина: ввод → обработка в переменных → вывод результата

Переменные

Что такое переменная

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

Пример:

Здесь:

name — переменная

= — операция присваивания (мы связываем имя и значение)

"Анна" — строковое значение

25 — целое число

Правила именования

В Python имена переменных:

могут содержать буквы, цифры и символ _

не могут начинаться с цифры

чувствительны к регистру (age и Age — разные переменные)

не должны совпадать с ключевыми словами Python (например, if, for, class)

Рекомендуемый стиль — snake_case:

Присваивание и переопределение

Переменной можно присвоить новое значение:

Важно: Python не “добавляет 20 к 10”, а заменяет значение, на которое ссылается имя x.

Типы данных

Зачем нужны типы

Тип данных определяет:

какие значения может хранить объект

какие операции над ним допустимы

как он будет вести себя в выражениях

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

Проверить тип можно функцией type():

Базовые типы, с которых начинаем

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

| Тип | Как выглядит | Пример | Для чего обычно используют | |---|---|---|---| | int | целые числа | 0, -3, 42 | счётчики, количество, индексы | | float | числа с точкой | 3.14, -0.5 | измерения, средние значения | | str | строки (текст) | "Привет" | имена, сообщения, ввод пользователя | | bool | логические значения | True, False | условия, проверки | | NoneType | “нет значения” | None | отсутствие данных, значение “пока неизвестно” |

Подробный справочник по встроенным типам есть в документации: Стандартные типы данных Python.

Строки str

Строки в Python записываются в кавычках:

Частые операции:

Числа int и float

Примеры операций:

Логический тип bool

bool часто появляется в сравнениях:

Сравнения возвращают True или False, и затем их используют в if (к условиям мы перейдём в следующих темах).

Значение None

None означает “значение отсутствует”. Например, вы можете завести переменную заранее:

Позже программа может вычислить результат и заменить None на реальное значение.

Преобразование типов

Почему это важно

Очень частая ситуация: пользователь вводит данные, а input() возвращает строку. Если вы ожидаете число, строку нужно преобразовать.

Пример ошибки:

Правильно:

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

int("123") → 123

float("3.14") → 3.14

str(10) → "10"

bool(0) → False, bool(1) → True

Важно: не любую строку можно преобразовать в число.

Пример, который вызовет ошибку:

Здесь строка содержит точку, поэтому для такого ввода нужно использовать float().

Ввод данных: input()

Функция input():

показывает приглашение (если вы передали строку)

ждёт ввод пользователя

возвращает введённый текст как str

Пример:

Официальное описание: Функция input.

Вывод данных: print()

Функция print() выводит данные на экран.

Пример:

Можно вывести несколько значений сразу:

По умолчанию print() разделяет аргументы пробелами и завершает строку переводом строки.

Официальное описание: Функция print.

Форматирование строк

Конкатенация

Можно “склеивать” строки оператором +:

Минус: если вы склеиваете строку и число, придётся вручную преобразовывать число в строку.

f-строки

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

Что важно:

перед строкой ставится f

внутри {...} пишется выражение Python (например, имя переменной)

Справка: Форматированные строковые литералы (f-strings).

Управление разделителем и концом строки

Иногда полезно менять поведение print():

Мини-программа: диалог с пользователем

Пример программы, которая просит имя и возраст, а затем выводит сообщение:

Здесь вы использовали сразу несколько ключевых вещей:

переменные для хранения данных

input() для получения строк

int() для преобразования ввода в число

арифметику + 1

print() и f-строку для аккуратного вывода

Частые ошибки и как их понимать

Путают присваивание и сравнение

- = — присваивание - == — сравнение (вернёт True или False)

Забывают, что input() возвращает строку

- если нужно число, делайте int(...) или float(...)

Получают ошибку при преобразовании

- int("abc") вызовет ошибку, потому что строка не похожа на целое число

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

Итоги

Вы узнали:

что такое переменные и как работает присваивание

какие базовые типы данных используются чаще всего (int, float, str, bool, None)

как проверять тип через type()

как вводить данные (input()) и выводить результат (print())

как преобразовывать типы и почему это важно

как форматировать строки, особенно через f-строки

Следующий логичный шаг — научиться управлять выполнением программы: ветвлениями (if) и циклами, чтобы программа могла принимать решения и повторять действия.

Условия, циклы и базовые структуры данных

Как это связано с предыдущими темами

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

Чтобы писать действительно полезные программы, нужно уметь:

принимать решения в зависимости от данных пользователя или результатов вычислений

повторять действия нужное количество раз

хранить наборы данных (например, список покупок или набор оценок), а не только одно значение

Эта статья вводит три ключевых инструмента:

условия if/elif/else

циклы while и for

базовые структуры данных: list, tuple, dict, set

!Общая карта того, как условия, циклы и структуры данных соединяются в программе

Условия

Логические значения и сравнения

Условие в Python должно приводиться к логическому значению True или False.

Чаще всего условие получают с помощью операций сравнения:

| Операция | Смысл | Пример | |---|---|---| | == | равно | age == 18 | | != | не равно | name != "Анна" | | < | меньше | x < 0 | | <= | меньше или равно | score <= 100 | | > | больше | temp > 37.0 | | >= | больше или равно | age >= 18 |

Важно не путать:

= это присваивание

== это сравнение

Конструкция if/elif/else

Базовый вид:

Что здесь происходит:

после if пишется условие, затем двоеточие :

блок кода внутри условия задаётся отступами (обычно 4 пробела)

else срабатывает, если условие ложно

Если вариантов больше двух, используют elif:

Логические операторы and, or, not

Иногда одного сравнения мало.

and означает и (оба условия должны быть истинны)

or означает или (достаточно, чтобы хотя бы одно было истинным)

not означает не (инверсия)

Примеры:

Что считается истинным и ложным

Python умеет трактовать некоторые значения как False без явного сравнения.

Чаще всего ложными считаются:

0, 0.0

пустая строка ""

пустые коллекции [], {}, set()

None

Это позволяет писать понятные проверки:

Подробности: Truth Value Testing

Циклы

Цикл нужен, когда действие надо повторить много раз.

Цикл while

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

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

Что важно помнить:

внутри while должно меняться что-то, влияющее на условие, иначе получится бесконечный цикл

while хорошо подходит для сценариев вида повторять, пока не…

Цикл for

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

Пример: перебор символов строки.

Пример: перебор списка.

range() для повторений

Если нужно повторить действие раз, используют range().

Это выведет числа от 0 до 4.

Популярные варианты:

range(stop) даёт 0, 1, ..., stop - 1

range(start, stop) даёт start, ..., stop - 1

range(start, stop, step) даёт последовательность с шагом step

Пример с шагом:

Документация: range

break и continue

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

break завершает цикл полностью

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

Пример: ищем первое число, которое делится на 7.

Пример: печатаем только нечётные числа.

Базовые структуры данных

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

Список list

list хранит упорядоченную коллекцию элементов. Список можно изменять.

Создание:

Доступ по индексу (нумерация начинается с 0):

Частые операции:

Документация: list

Кортеж tuple

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

Когда это удобно:

координаты, размеры, пары значений

данные, которые не должны меняться

Документация: tuple

Словарь dict

dict хранит пары ключ → значение. Удобен, когда нужно быстро получать значение по ключу.

Пример:

Добавление и изменение:

Перебор словаря:

Полезный момент: если обратиться к несуществующему ключу через user["x"], будет ошибка KeyError. Более безопасный вариант для чтения: user.get("x"), который вернёт None (или значение по умолчанию, если его указать).

Документация: dict

Множество set

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

Проверка принадлежности:

Документация: set

Краткое сравнение структур

| Структура | Порядок | Можно менять | Как обращаться | Типичный случай | |---|---|---|---|---| | list | да | да | по индексу | список задач, набор чисел | | tuple | да | обычно нет | по индексу | координаты, пары значений | | dict | по ключам | да | по ключу | данные пользователя, настройки | | set | нет гарантии | да | проверка наличия | уникальные значения, фильтрация дублей |

Мини-пример: считаем средний балл

Ниже программа, которая:

читает оценки через input()

складывает их в список

считает среднее

Здесь вы используете сразу несколько ключевых идей:

for и range() для повторения ввода

list для хранения набора значений

второй цикл for для подсчёта суммы

len() для количества элементов

Частые ошибки и как их избегать

Путают отступы

- В Python отступы задают структуру блоков if, for, while.

Забывают преобразовывать ввод к числу

- input() возвращает str, поэтому для чисел нужно int(...) или float(...).

Получают бесконечный while

- Убедитесь, что внутри цикла меняется переменная, от которой зависит условие.

Путают индексы

- В списке первый элемент имеет индекс 0.

Итоги

Вы научились:

строить ветвления с if/elif/else

использовать сравнения и логические операторы and, or, not

повторять действия с while и for, применять range()

управлять циклом через break и continue

хранить данные в list, tuple, dict, set и выбирать структуру под задачу

Функции, модули и работа с файлами

Как это связано с предыдущими темами

Ранее вы научились работать с переменными и типами данных, использовать условия и циклы, хранить наборы значений в list/dict/set. Теперь следующий шаг к более “взрослым” программам:

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

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

Файлы дают возможность сохранять результаты работы программы и читать данные не только из input().

!Общая картина: функции внутри модулей и взаимодействие с файлами

Функции

Зачем нужны функции

Функция — это именованный фрагмент кода, который можно вызвать в нужный момент.

Функции полезны, потому что:

уменьшают повторение кода

делают программу понятнее (код читается “по шагам”)

упрощают тестирование и поиск ошибок

Официальная справка: Определение функций в Python

Как объявить и вызвать функцию

Функция объявляется через def.

Правила чтения примера:

def greet(name): создаёт функцию с именем greet

name — параметр (в него попадёт значение при вызове)

тело функции — это строки с отступом

greet("Анна") — вызов функции

return: как функция возвращает результат

Функция может вернуть значение оператором return.

Что важно:

return сразу завершает работу функции

возвращаемое значение можно сохранить в переменную и использовать дальше

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

Параметры и аргументы

Термины:

параметры — переменные в объявлении функции (например, a, b)

аргументы — конкретные значения при вызове (например, 10, 20)

#### Позиционные и именованные аргументы По умолчанию аргументы передаются по позиции:

Можно передавать по имени (это повышает читаемость):

Значения по умолчанию

Можно задать значение параметра “если не передали аргумент”.

Возврат нескольких значений

Функция может вернуть несколько значений через кортеж tuple.

Здесь min(numbers), max(numbers) — это кортеж, который затем “распаковывается” в две переменные.

Область видимости (scope): где живут переменные

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

Переменные, созданные вне функций, часто называют глобальными.

Важно:

читать глобальную переменную внутри функции можно

присваивать в глобальную переменную внутри функции без специальных приёмов не стоит

Справка: Области видимости и пространства имён

Докстринги: как документировать функции

Докстринг — строка в начале функции, которая описывает, что она делает.

Докстринги важны, потому что:

помогают вам самим не забыть назначение функции

позволяют получать подсказки через help()

Частая ошибка: изменяемые значения по умолчанию

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

Плохой вариант:

Правильный вариант:

Модули и импорт

Что такое модуль

Модуль — это обычный файл *.py.

Например, если у вас есть файл utils.py, то это модуль utils, и его можно импортировать.

Справка: Модули в Python

Как работает import

Самые популярные способы импорта:

Рекомендации:

import module удобно, когда вы используете много функций из модуля

from module import name удобно для 1–2 функций, но повышает риск конфликтов имён

as помогает сократить длинные имена или сделать псевдоним

Где Python ищет модули

Python сначала ищет:

модуль в текущей папке проекта

модули стандартной библиотеки

установленные пакеты (через pip в вашем окружении)

!Порядок, в котором Python обычно ищет модуль при import

__name__ == "__main__": как отделить запуск от импорта

Один и тот же файл можно:

запускать как программу

импортировать как модуль

Шаблон:

Смысл:

если файл запустили напрямую, выполняется main()

если файл импортировали, main() не вызовется автоматически

Стандартная библиотека: что полезно знать

В Python много “готового из коробки”. Полезные модули для старта:

math — математические функции

random — случайные числа

datetime — дата и время

pathlib — работа с путями

json — чтение и запись JSON

Справка: Стандартная библиотека Python

Пакеты и pip (связь с виртуальным окружением)

Если стандартной библиотеки мало, вы устанавливаете сторонние пакеты через pip (обычно внутри venv, который вы настроили в первой теме курса).

Справка: pip — менеджер пакетов Python

Работа с файлами

Зачем нужны файлы

Файлы позволяют:

хранить результаты работы программы

читать данные из подготовленных наборов (например, список задач)

обмениваться данными между запусками программы

Пути: относительные и абсолютные

Путь к файлу может быть:

относительным (от текущей папки запуска)

абсолютным (полный путь в системе)

Для учебных проектов обычно удобнее относительные пути и структура папок проекта.

Открытие файла: open()

Базовый инструмент — функция open().

Справка: Функция open

Главное правило: файл нужно закрывать. Надёжнее всего делать это через контекстный менеджер with.

Что здесь происходит:

with open(...) as f открывает файл и гарантирует закрытие

"r" означает режим чтения

encoding="utf-8" помогает корректно работать с русским текстом

Справка: Оператор with

!Почему with гарантирует закрытие файла

Режимы открытия файла

| Режим | Смысл | Если файла нет | Если файл есть | |---|---|---|---| | "r" | чтение текста | ошибка | читаем | | "w" | запись текста | создастся | перезапишется | | "a" | дозапись текста | создастся | допишется в конец | | "x" | создать и писать | создастся | ошибка | | "rb" | чтение байтов | ошибка | читаем | | "wb" | запись байтов | создастся | перезапишется |

Для начала чаще всего достаточно "r", "w", "a".

Чтение из файла

Основные способы:

f.read() читает всё содержимое одной строкой

f.readline() читает одну строку

перебор for line in f читает файл построчно (удобно и экономно)

Пример построчного чтения:

strip() убирает пробелы и символ перевода строки \n по краям.

Запись в файл

Запись делается методом write().

Если вы используете "w", файл будет перезаписан. Чтобы дописывать в конец, используйте "a".

Работа с путями через pathlib

pathlib помогает собирать пути без ручной “склейки” строк.

Справка: pathlib — объектные пути

Пример:

Мини-проект: читаем числа из файла и считаем статистику

Пусть в файле numbers.txt лежат числа, по одному в строке:

10

20

5

Сделаем программу, которая:

читает числа

складывает их в список

считает сумму и среднее

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

read_ints() отделяет чтение файла от остальной логики

calc_stats() считает статистику и возвращает два значения

avg может быть None, если список пуст

Path("numbers.txt") задаёт путь в текущей папке проекта

Ошибки при работе с файлами и как их обрабатывать

Самые частые ситуации:

файл не найден (FileNotFoundError)

неверная кодировка (UnicodeDecodeError)

строка не преобразуется в число (ValueError)

Базовый шаблон try/except:

Справка: Встроенные исключения Python

JSON: удобный формат для сохранения списков и словарей

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

Справка: Модуль json

Запись словаря в JSON:

Чтение:

Итоги

Вы узнали:

как создавать функции, передавать параметры и возвращать значения через return

что такое область видимости и почему локальные переменные “не выходят наружу”

как документировать функции через докстринги

что такое модуль, как работает import, и зачем нужен __name__ == "__main__"

как читать и записывать файлы через open() и безопасный шаблон with

как работать с путями через pathlib

как сохранять структуры данных в JSON через модуль json

Обработка ошибок и мини-проекты для закрепления

Как это связано с предыдущими темами

Ранее вы научились:

писать программы с переменными, условиями и циклами

хранить данные в list/dict/set

разбивать логику на функции и подключать модули

читать и записывать файлы, в том числе JSON

Но в реальной жизни программы сталкиваются с ситуациями, которые ломают “идеальный сценарий”:

пользователь вводит не число, а текст

файла нет или он в другой кодировке

в JSON попал испорченный текст

деление на ноль

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

!Схема показывает, как работает try/except/else/finally

Что такое исключения и зачем они нужны

Исключение (exception) — это сигнал о том, что во время выполнения произошла ошибка, и обычный поток выполнения прерывается.

Примеры типичных исключений:

ValueError — значение неправильного формата (например, int("abc"))

ZeroDivisionError — деление на ноль

FileNotFoundError — файл не найден

KeyError — нет ключа в словаре при обращении d["key"]

TypeError — операция применена к неподходящим типам

Если исключение не обработать, Python остановит программу и покажет traceback.

Как читать traceback

Traceback (стек вызовов) — это текст, который помогает найти место ошибки.

Обычно в нём важно:

тип исключения (например, ValueError)

сообщение (например, invalid literal for int())

строка и файл, где произошло исключение

цепочка вызовов функций, если ошибка случилась “глубоко внутри”

Чем лучше вы читаете traceback, тем быстрее находите и исправляете ошибки.

Справка: Ошибки и исключения в Python

Базовая конструкция try/except

Чтобы программа не падала, потенциально опасный код помещают в блок try, а обработку ошибок — в except.

Что происходит:

если всё прошло успешно, except не выполняются

если возник ValueError, управление перейдёт в except ValueError

если возник ZeroDivisionError, управление перейдёт в except ZeroDivisionError

Почему лучше ловить конкретные исключения

Иногда пишут так:

Это допустимо в редких случаях (например, чтобы показать “что-то пошло не так” на верхнем уровне программы), но чаще вредно:

можно случайно скрыть реальную ошибку в логике

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

Практическое правило: начинайте с конкретных исключений.

try/except/else/finally

У try есть дополнительные части.

else: код, который выполняется только если ошибок не было

else удобно использовать, чтобы отделить “успешный путь” от обработки ошибок.

finally: код, который выполняется всегда

finally выполняется:

и при успешном выполнении

и при исключении

даже если вы вышли через return внутри try

Чаще всего finally нужен для освобождения ресурсов. В современном Python для файлов обычно используют with, но finally всё равно полезен.

Поднимать исключения самостоятельно: raise

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

Пример: функция принимает возраст.

Здесь важно:

raise ValueError("...") создаёт исключение вручную

as e позволяет получить текст сообщения

Справка: Оператор raise

Валидация пользовательского ввода: устойчивые циклы

Одна из самых частых задач новичка — сделать ввод “неубиваемым”: пока пользователь не введёт корректно, программа просит повторить.

Шаблон: ввод целого числа

Почему это хороший подход:

функция переиспользуется

логика ввода отделена от логики программы

исключение не “роняет” программу

Подход EAFP: сначала пробуем, потом обрабатываем

В Python часто используют стиль EAFP — Easier to Ask Forgiveness than Permission.

Смысл:

вместо множества проверок “а можно ли?”

вы пробуете сделать действие

и ловите исключение, если нельзя

Пример с чтением ключа словаря.

Вариант с безопасным чтением:

Вариант EAFP (уместен, если отсутствие ключа — редкий случай и это ошибка данных):

Важно: выбирайте стиль по ситуации. Если отсутствие данных — нормальная ветка, часто удобнее get().

Работа с файлами и ошибки ввода-вывода

При работе с файлами часто встречаются:

FileNotFoundError — файла нет

PermissionError — нет прав

UnicodeDecodeError — ошибка декодирования текста

Пример устойчивого чтения:

JSON и ошибки формата

Когда вы читаете JSON, возможна ситуация: файл существует, но внутри невалидный JSON. Тогда возникает json.JSONDecodeError.

Справка: Модуль json

Мини-проекты для закрепления

Дальше — несколько небольших проектов, которые объединяют всё, что вы изучили: функции, циклы, структуры данных, файлы и обработку ошибок.

!Иллюстрация показывает, как разнести код по файлам и слоям

Мини-проект: консольный калькулятор с защитой от ошибок

Цель: сделать калькулятор, который не падает при неверном вводе.

Возможности:

операции +, -, *, /

повтор работы, пока пользователь не введёт команду выхода

обработка: неверное число, неверная операция, деление на ноль

Пример реализации:

Что здесь закрепляется:

устойчивый ввод через цикл и try/except

разделение на функции

собственное исключение через raise для деления на ноль (можно и без raise, но так видно общий подход)

Мини-проект: анализатор чисел из файла (устойчивое чтение)

Цель: прочитать файл, в котором числа по строкам, и посчитать сумму и среднее, игнорируя “плохие” строки.

Полезный сценарий: данные “грязные”, но программу нельзя ронять из-за одной ошибки.

Что здесь закрепляется:

работа с файлами через with

частичная обработка ошибок: файл — критично, строка — не критично

использование enumerate(..., start=1) для информативных сообщений

Мини-проект: список задач (todo) с сохранением в JSON

Цель: хранить задачи между запусками.

Данные удобно хранить в JSON как список словарей:

[{"title": "Купить хлеб", "done": false}, ...]

Пример программы (упрощённый, но рабочий):

Что здесь закрепляется:

чтение и запись JSON

обработка FileNotFoundError и json.JSONDecodeError

защита от неверного номера (ValueError, IndexError)

структура данных “список словарей”

Типичные ошибки при обработке исключений

Слишком широкий except Exception без необходимости

Пустой except без действий

Скрытие ошибок вместо исправления

Смешивание логики программы и логики ввода-вывода

Хорошая практика: выносить ввод, валидацию и чтение файлов в функции, а основную логику держать отдельно.

Итоги

Теперь вы умеете:

понимать исключения и читать traceback

использовать try/except, а также else и finally

поднимать исключения через raise для проверки корректности данных

строить устойчивый ввод и обработку ошибок при работе с файлами и JSON

собирать небольшие консольные проекты, которые не ломаются от реальных ошибок ввода