Основы Python: старт и работа в Visual Studio Code

Установка Python и настройка VS Code для разработки

Что вы получите после этой статьи

К концу статьи у вас будет готовая среда разработки:

установленный Python

установленный Visual Studio Code

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

запуск и отладка Python-кода прямо из VS Code

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

!Шаги подготовки среды: от установки Python до запуска проекта в VS Code

Термины, которые нужно понимать

Python — язык программирования и набор инструментов, которые запускают ваш код.

Интерпретатор Python — программа, которая выполняет файлы .py.

VS Code — редактор кода, который становится удобной IDE с расширениями.

Расширение VS Code — “плагин”, добавляющий поддержку языка, подсказки, запуск и отладку.

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

Установка Python

Официальный дистрибутив Python берём только с сайта Python.

Python Downloads

Windows

Откройте страницу загрузки Python и скачайте установщик для Windows.

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

Важный шаг: поставьте галочку Add python.exe to PATH.

Нажмите Install Now.

Если вы пропустили добавление в PATH, Python может не запускаться из терминала командой python. Это лечится переустановкой или ручной настройкой, но проще включить опцию сразу.

macOS

Откройте страницу загрузки Python.

Скачайте установщик для macOS (обычно .pkg) и установите.

После установки откройте Terminal и проверьте версию (раздел ниже).

На macOS может быть предустановлен системный Python (иногда Python 2 или “особый” Python). Для разработки используйте установленный вами Python 3.

Linux

На Linux Python часто уже установлен, но версия может отличаться. В большинстве дистрибутивов Python 3 ставится через менеджер пакетов.

Откройте терминал.

Проверьте, есть ли Python 3: python3 --version.

Если команды нет, установите пакет python3 через менеджер пакетов вашего дистрибутива.

Дальнейшие примеры для Linux чаще используют команду python3 вместо python.

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

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

Windows (часто работает один из вариантов):

- python --version - py --version

macOS:

- python3 --version

Linux:

- python3 --version

Ожидаемый результат: вы видите версию вида Python 3.x.y.

Также полезно проверить, откуда запускается Python:

Windows:

- where python

macOS и Linux:

- which python3

Установка Visual Studio Code

Скачайте и установите VS Code с официального сайта:

Visual Studio Code

После установки запустите VS Code.

Установка расширений Python в VS Code

Минимальный набор — расширение Python от Microsoft. Обычно VS Code предложит поставить дополнительные компоненты (например, Pylance) автоматически.

Откройте в VS Code вкладку расширений: Extensions.

Найдите Python.

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

Официальная страница расширения:

Python extension for Visual Studio Code

Создание проекта и открытие папки в VS Code

Работать лучше не с отдельным файлом, а с папкой проекта.

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

Откройте её в VS Code:

- меню File → Open Folder...

Дальше все команды выполняйте в терминале VS Code.

Создание виртуального окружения

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

Создание .venv

В терминале VS Code выполните команду (подберите вариант под вашу систему):

Windows (часто работает так): python -m venv .venv

Windows (часто рекомендуется так): py -m venv .venv

macOS: python3 -m venv .venv

Linux: python3 -m venv .venv

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

После создания окружение нужно активировать, чтобы команды python и pip ссылались на .venv.

| Система | Команда активации | | --- | --- | | Windows (PowerShell) | .\.venv\Scripts\Activate.ps1 | | Windows (cmd) | .\.venv\Scripts\activate.bat | | macOS / Linux (bash/zsh) | source .venv/bin/activate |

Признак успеха: в начале строки терминала появляется пометка вроде (.venv).

Если PowerShell запрещает запуск скриптов, временно (для текущего окна) можно разрешить выполнение скриптов командой Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process и повторить активацию.

Выбор интерпретатора в VS Code

VS Code должен “понимать”, что вашему проекту нужно использовать Python из .venv.

Откройте палитру команд:

- Windows/Linux: Ctrl+Shift+P - macOS: Cmd+Shift+P

Введите команду Python: Select Interpreter.

Выберите интерпретатор, путь которого содержит .venv.

Если вы всё сделали правильно, VS Code будет устанавливать пакеты в окружение проекта и запускать код тем Python, который вы выбрали.

Первый запуск: файл hello.py

Создайте файл hello.py в папке проекта.

Вставьте код:

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

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

Также можно запустить через интерфейс VS Code:

откройте hello.py

используйте команду Run Python File (обычно появляется кнопка запуска в правом верхнем углу редактора)

Отладка (debug) в VS Code

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

Поставьте точку останова:

- кликните слева от номера строки (появится красная точка)

Откройте раздел Run and Debug.

Запустите отладку:

- Python File

Во время отладки полезны панели:

Variables — значения переменных

Watch — выражения, за которыми вы хотите следить

Call Stack — стек вызовов (какие функции привели к текущей строке)

Справка по отладке в VS Code:

Debugging in Visual Studio Code

Частые проблемы и быстрые решения

Команда python не найдена

Возможные причины:

Python не установлен

Python установлен, но не добавлен в PATH

вы используете систему, где команда называется python3

Решения:

Проверьте версию командой python --version или python3 --version.

На Windows попробуйте py --version.

Если Python установлен, но не находится, переустановите Python и включите Add python.exe to PATH.

VS Code запускает “не тот” Python

Обычно это происходит, если не выбран интерпретатор из .venv.

Решение:

Выполните Python: Select Interpreter.

Выберите интерпретатор внутри .venv.

Пакеты ставятся не туда

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

Решение:

активируйте .venv в терминале

убедитесь, что VS Code выбрал интерпретатор из .venv

Итог

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

Первый проект: запуск, ввод-вывод и структура файлов

Что вы получите после этой статьи

К концу статьи вы сможете:

создать минимальный проект на Python в папке

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

запускать код из терминала и из VS Code

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

избегать типичных ошибок новичка: “не та папка”, “не тот интерпретатор”, “ввод не работает”

Что должно быть сделано заранее

Эта статья опирается на предыдущую: у вас уже должны быть:

установлен Python

установлен VS Code и расширение Python

создан проект и виртуальное окружение .venv

выбран интерпретатор из .venv в VS Code

Если что-то из этого не готово, вернитесь к статье Установка Python и настройка VS Code для разработки.

Как устроен “первый” проект: минимальная структура

В начале важно не усложнять. Вот практичная структура для учебного проекта:

.venv/ — виртуальное окружение проекта

main.py — входная точка (файл, который запускаем)

README.md — короткое описание проекта и как его запускать

!Минимальная структура папки проекта

Зачем нужен файл main.py

main.py — это обычный файл Python, но в учебных и небольших проектах его часто используют как главную точку запуска. Так проще объяснять “как запустить программу” и где искать стартовый код.

Что такое __pycache__ и почему он появляется

Когда вы запускаете Python-код, интерпретатор может создавать папку __pycache__ с “техническими” файлами для ускорения запуска.

это нормально

вручную создавать её не нужно

удаление обычно безопасно (Python создаст её снова)

Запуск Python-файла из терминала VS Code

Откройте терминал в VS Code:

меню Terminal → New Terminal

Убедитесь, что виртуальное окружение активировано. Признак: в начале строки терминала есть (.venv).

Запуск

Перейдите в папку проекта (если вы уже открыли папку проекта в VS Code, обычно терминал уже в ней), и выполните:

Если у вас Linux/macOS и команда python не работает, используйте:

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

У каждой команды запуска есть текущая рабочая папка (working directory). От неё зависят относительные пути к файлам.

если вы запускаете python main.py, находясь в другой папке, относительные пути могут “сломаться”

поэтому по умолчанию запускайте из корня проекта

Запуск из интерфейса VS Code

Есть два самых частых способа.

Run Python File

Откройте main.py.

Нажмите кнопку запуска (обычно справа сверху) или выберите команду Run Python File.

Обычно этот запуск использует терминал VS Code, поэтому input() работает ожидаемо.

Отладка (Run and Debug)

Откройте вкладку Run and Debug.

Выберите запуск Python-файла.

Поставьте breakpoint (красную точку слева от номера строки), если хотите пройти программу пошагово.

Документация VS Code по запуску и отладке:

Debugging in Visual Studio Code

Ввод и вывод: print() и input()

Вывод на экран: print()

Самый простой вывод:

print() умеет печатать несколько значений через запятую:

Ввод с клавиатуры: input()

input() останавливает программу и ждёт, пока пользователь введёт строку и нажмёт Enter.

Важный момент:

input() всегда возвращает значение типа str (строка), даже если вы ввели число

Официальная документация:

Функция input()

Функция print()

Преобразование типов: из строки в число

Если вы хотите работать с числом, преобразуйте строку:

Если пользователь введёт не число (например, десять), int(...) вызовет ошибку. На старте курса достаточно знать:

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

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

Форматирование вывода через f-строки

Очень удобный стиль вывода — f-строки:

Полный пример main.py для первого проекта

Создайте или замените содержимое main.py:

Зачем нужен блок if __name__ == "__main__"

Этот блок помогает отделить:

“код, который выполняется при запуске файла”

от “кода, который можно импортировать из других файлов”

Практический эффект:

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

при импорте main.py не будет автоматически запускать программу целиком

Рекомендуемые правила именования и размещения файлов

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

имена файлов: маленькие буквы, без пробелов, например main.py, utils.py

не называйте файл как стандартный модуль, например random.py, json.py, string.py (это может мешать импортам)

держите точку входа в одном месте: обычно main.py

Частые проблемы и быстрые решения

VS Code запускает “не тот” Python

Признаки:

пакеты ставятся “не туда”

версия Python не та, что вы ожидаете

Решение:

Откройте палитру команд.

Выберите Python: Select Interpreter.

Укажите интерпретатор из .venv.

input() не ждёт ввод или программа “зависает”

Чаще всего проблема в том, где именно вы запускаете программу.

запускайте через терминал VS Code или через Run Python File

если запускаете в режиме отладки, убедитесь, что ввод идёт в терминал, а не в “Debug Console”

Ошибка “No such file or directory” при работе с файлами

Если вы позже начнёте читать файлы по относительному пути, причина часто одна:

программа запущена из другой рабочей папки

Базовое правило на старте:

запускайте программу из корня проекта

Итог

Теперь у вас есть первый “правильный” учебный проект: папка проекта, виртуальное окружение .venv, файл main.py как точка входа и базовые навыки запуска кода из терминала и VS Code. Вы умеете делать ввод через input(), вывод через print() и понимаете, почему рабочая папка и выбранный интерпретатор важны для стабильной работы проекта.

Переменные и типы данных: числа, строки, списки, словари

Что вы получите после этой статьи

К концу статьи вы сможете:

создавать переменные и понимать, что именно в них хранится

различать основные типы данных Python: числа, строки, списки, словари

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

осознанно делать преобразование типов int(), float(), str()

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

Связь с предыдущими темами курса

В прошлых статьях вы настроили Python и VS Code, создали проект и научились запускать main.py, а также использовать print() и input(). Теперь мы расширим “словарь” данных, с которыми работает программа: научимся хранить значения в переменных и выбирать подходящую структуру данных.

Переменные: как Python хранит данные

Переменная в Python — это имя, которое ссылается на объект.

Имя — то, что вы пишете в коде, например age.

Объект — реальное значение в памяти, например число 25 или строка "Анна".

!Переменная в Python хранит не "значение внутри", а ссылку на объект

Присваивание

Присваивание записывается через =:

Это читается как “имя name указывает на строку "Анна"”.

Проверка типа: type()

Чтобы понять, какой тип у значения, используйте type():

Правила именования переменных

Практичные правила для начала:

используйте snake_case: user_name, total_sum

имена должны быть понятными: age лучше, чем a

нельзя начинать имя с цифры: 1value нельзя, value1 можно

нельзя использовать пробелы: user name нельзя

Список ключевых слов Python (их нельзя использовать как имена) есть в документации: Ключевые слова Python.

Числа: int и float

В базовых задачах чаще всего встречаются два числовых типа:

int — целые числа: -3, 0, 42

float — числа с точкой: 3.14, 0.5

Операции с числами

Преобразование строк в числа

input() возвращает строку, поэтому для математики нужно преобразование:

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

Официальная справка:

Функция int()

Функция float()

Строки: str

Строка — это текст. В Python строки записываются в кавычках:

Частые операции со строками

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

Тип str

Функция len()

Индексация и срезы

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

Важное свойство: строки неизменяемые

Строку нельзя “исправить внутри” по индексу:

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

Списки: list

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

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

Тип list

Индексация и изменение элементов

Список, в отличие от строки, можно менять:

Добавление и удаление

Частая ошибка: копирование списка

Если сделать так:

Это произошло потому, что a и b теперь указывают на один и тот же список.

Если нужна отдельная копия, используйте:

Словари: dict

Словарь хранит пары ключ → значение. Это удобно, когда вы хотите быстро получать данные “по имени”.

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

Тип dict

!Словарь хранит соответствия ключей и значений

Доступ по ключу и изменение

Безопасное чтение: get()

Если ключа может не быть, лучше get():

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

Как выбрать тип данных: короткая шпаргалка

| Задача | Подходящий тип | Пример | | --- | --- | --- | | Хранить одно число | int / float | age = 25 | | Хранить текст | str | name = "Анна" | | Хранить последовательность по порядку | list | scores = [10, 20, 30] | | Хранить данные “по ключам” | dict | user = {"name": "Анна"} |

Мини-проект в main.py: анкета и сохранение данных

Создайте (или обновите) main.py в папке проекта и запустите его из терминала VS Code:

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

age преобразуется в int, иначе вы не сможете делать с ним арифметику

hobbies — список, потому что это набор значений “по порядку”

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

Документация по join():

Метод str.join()

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

Путаница типов при вводе

1. input() всегда возвращает str. 2. Для чисел используйте int() или float().

Индексы начинаются с нуля

1. Первый элемент списка или строки — это индекс 0. 2. Последний элемент можно брать через -1.

Попытка изменить строку “на месте”

1. str неизменяемая. 2. Если нужно получить другой текст, создавайте новую строку.

Неожиданное “общее” изменение списка

1. b = a не копирует список, а даёт вторую ссылку на тот же объект. 2. Для копии используйте a.copy().

Ошибка KeyError при чтении из словаря

1. user["age"] упадёт, если ключа нет. 2. Если ключ может отсутствовать, используйте user.get("age").

Итог

Вы научились создавать переменные и понимать их смысл в Python, разобрали основные типы данных: числа (int, float), строки (str), списки (list) и словари (dict). Теперь у вас есть база, чтобы писать более полезные программы: хранить данные пользователя, собирать списки значений, группировать параметры в словари и уверенно работать с вводом-выводом в VS Code.

Условия и циклы: управление логикой программы

Что вы получите после этой статьи

К концу статьи вы сможете:

управлять поведением программы с помощью if / elif / else

составлять условия на основе сравнений и логических операторов and / or / not

использовать циклы while и for для повторяющихся действий

применять break и continue для управления выполнением циклов

написать небольшую консольную программу с меню и обработкой ввода пользователя

Связь с предыдущими темами курса

В прошлых статьях вы:

настроили Python и VS Code, научились запускать main.py

освоили ввод-вывод (input(), print())

познакомились с переменными и типами данных (int, str, list, dict)

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

!Блок-схема показывает, как условия и цикл образуют меню программы

Базовая логика в Python: bool, сравнения и условия

Тип bool

Условия в Python работают на значениях типа bool:

True — истина

False — ложь

Чаще всего bool получается из операций сравнения.

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

| Оператор | Смысл | Пример | | --- | --- | --- | | == | равно | age == 18 | | != | не равно | name != "" | | < | меньше | x < 10 | | <= | меньше или равно | x <= 10 | | > | больше | x > 10 | | >= | больше или равно | x >= 10 |

Пример:

Важно:

= — присваивание

== — сравнение

Если перепутать, программа не будет работать (в условиях нельзя писать =).

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

Выражения сравнения

Ветвление: if, elif, else

Простейшая форма if

Если условие ложно, блок под if пропускается.

if + else

Несколько вариантов: elif

Как это читается:

проверяем первое условие

если оно ложно, проверяем следующее elif

если ни одно не подошло, выполняется else

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

Инструкция if

Отступы важны

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

внутри if / elif / else код должен быть с отступом (обычно 4 пробела)

Пример ошибки новичка:

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

Составные условия: and, or, not

and

Условие истинно, только если истинны обе части:

or

Условие истинно, если истинна хотя бы одна часть:

not

Инвертирует логическое значение:

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

Логические операции

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

Очень частая практика при работе со списками и строками:

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

Операторы принадлежности

"Истинность" значений: как if работает со строками, списками и числами

В if можно использовать не только True/False, но и любые значения.

Частые правила:

пустая строка "" считается ложью

пустой список [] считается ложью

число 0 считается ложью

непустые строки, непустые списки и ненулевые числа считаются истиной

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

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

Цикл while: повторяем, пока условие истинно

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

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

Важно:

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

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

Инструкция while

Цикл for: перебираем элементы

for удобен, когда нужно пройтись по элементам строки, списка или другого набора данных.

Перебор списка

Перебор строки

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

Инструкция for

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

range(n) даёт последовательность чисел от 0 до n - 1.

Вывод будет:

0

1

2

Если нужен диапазон от a до b - 1, используют range(a, b):

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

Функция range()

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

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

Функция enumerate()

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

break — выйти из цикла

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

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

Инструкции break и continue

Мини-проект: меню задач (список дел) в main.py

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

список list для хранения задач

словарь dict для хранения полей одной задачи

while для бесконечного меню

if / elif / else для обработки команд

Создайте (или замените) main.py:

Как запускать:

из терминала VS Code: python main.py (или python3 main.py на Linux/macOS)

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

.strip() убирает пробелы по краям, чтобы ввод был аккуратнее

.lower() позволяет принимать команды в любом регистре

while True делает меню бесконечным, а break завершает программу

при выборе задачи мы переводим номер пользователя в индекс списка: number - 1

Частые ошибки новичка и быстрые способы избежать их

Бесконечный while

Путаница индексов

Ожидание, что input() вернёт число

Слишком сложные условия без скобок

Практичные решения:

Добавляйте вывод в цикле

Проверяйте границы индекса

Преобразовывайте типы и проверяйте ввод

Разбивайте условия на части и используйте скобки

Итог

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

Функции, области видимости и основы работы с ошибками

Что вы получите после этой статьи

К концу статьи вы сможете:

разбивать программу на функции с понятными входами и выходами

понимать, что такое область видимости и почему переменные внутри функции не “протекают” наружу

аккуратно обрабатывать типичные ошибки ввода через try / except

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

Связь с предыдущими темами курса

Ранее вы уже:

настроили Python и VS Code и научились запускать проекты

освоили ввод-вывод (input(), print())

работали с типами (int, str, list, dict)

писали логику через if и циклы, включая меню задач

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

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

Функция позволяет:

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

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

проще тестировать и отлаживать отдельные куски логики

отделить “ввод-вывод” от “вычислений” и правил

Практический ориентир: если вы видите, что блок кода можно описать короткой фразой (например, “показать список задач” или “прочитать номер задачи”), это хороший кандидат на функцию.

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

Минимальная форма

Здесь:

def объявляет функцию

name это параметр

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

greet("Аня") это вызов функции

Официальная документация:

Определение функций (Python Tutorial)

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

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

Важно:

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

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

Несколько return

Это нормально, если вы делаете “ранний выход” при проверках.

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

Термины часто путают:

параметры указываются в объявлении функции: def add(a, b)

аргументы передаются при вызове: add(2, 3)

Аргументы по умолчанию

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

Плохой пример:

Лучше так:

Области видимости: где “живут” переменные

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

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

Локальная переменная

Глобальная переменная

Переменная, созданная на уровне файла, является глобальной для этого файла.

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

Можно использовать global, но в учебных и небольших программах лучше избегать этого и передавать данные через параметры и return.

Практичное правило

если функция должна “что-то знать”, передайте это параметрами

если функция должна “что-то сообщить”, верните результат через return

Так код становится предсказуемее.

Ошибки и исключения: базовая идея

Когда Python не может продолжать выполнение, он поднимает исключение.

Примеры типичных исключений в учебных задачах:

ValueError когда вы делаете int("abc")

KeyError при доступе к отсутствующему ключу d["missing"]

IndexError при неверном индексе списка

Официальная документация:

Ошибки и исключения (Python Tutorial)

try / except: как перехватывать ошибки

Без обработки ошибок

Если пользователь введёт десять, программа упадёт с ValueError.

С обработкой

Здесь:

блок try это код, который может упасть

except ValueError ловит именно ошибку преобразования

else и finally

else выполняется, если ошибок не было

finally выполняется всегда

!Иллюстрация: порядок выполнения блоков try/except/else/finally

Пример:

Когда стоит обрабатывать ошибку, а когда нет

Хорошее базовое правило:

обрабатывайте ошибки, которые ожидаемы из-за пользовательского ввода

не скрывайте ошибки, которые означают баг в вашей логике

Мини-проект: рефакторинг меню задач с функциями и обработкой ввода

Ниже пример того же todo-меню из прошлой статьи, но:

каждая часть вынесена в отдельную функцию

ввод номера задачи сделан безопасным

main() стал коротким и читаемым

Создайте (или замените) main.py:

Что здесь важно с точки зрения темы статьи:

tasks живёт в main(), а функции получают его как параметр и изменяют список

read_task_number() либо возвращает корректный номер, либо None

обработка ValueError сосредоточена в одном месте

Частые ошибки новичка в функциях и исключениях

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

Делать много логики в main() вместо выноса в функции

Ловить все ошибки через except Exception, скрывая настоящие баги

Использовать изменяемые значения по умолчанию (например, items=[])

Итог

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

Модули, пакеты и виртуальные окружения (pip, venv)

Что вы получите после этой статьи

К концу статьи вы сможете:

понимать разницу между модулем и пакетом в Python

импортировать свой код из других файлов и собирать небольшие проекты из нескольких модулей

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

использовать виртуальные окружения venv, чтобы зависимости проекта не конфликтовали

фиксировать зависимости в requirements.txt и разворачивать проект на другой машине

Связь с предыдущими темами курса

Ранее вы настроили Python и VS Code, создали проект с .venv, запускали main.py, работали с типами, условиями, циклами, функциями и базовой обработкой ошибок.

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

!Как связаны файлы проекта, импорты и зависимости внутри виртуального окружения

Термины, которые нужно понимать

Модуль — один файл .py, который можно импортировать.

Пакет — папка с Python-кодом, которую тоже можно импортировать (обычно содержит файл __init__.py).

Библиотека (пакет PyPI) — сторонний пакет, который устанавливают через pip.

PyPI — официальный каталог Python-пакетов.

pip — инструмент для установки пакетов.

venv — инструмент для создания виртуальных окружений.

Полезные источники:

Документация Python: модули

Документация Python: пакеты

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

PyPI (каталог пакетов)

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

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

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

Если весь код хранить в main.py, то со временем:

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

сложно переиспользовать части логики

неудобно тестировать и отлаживать

Гораздо лучше: выделять отдельные части в отдельные модули.

Пример: модуль utils.py

Создайте структуру в проекте:

main.py

utils.py

utils.py:

main.py:

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

import utils подключает файл utils.py как модуль

доступ к функциям модуля идёт через точку: utils.read_int(...)

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

Зачем нужен пакет

Пакет — это способ собрать несколько модулей в одну логическую часть проекта, например:

app — код приложения

app.services — бизнес-логика

app.storage — работа с данными

Минимальная структура пакета

Создайте структуру:

main.py

app/

app/__init__.py

app/utils.py

app/utils.py:

main.py:

Важно:

файл app/__init__.py может быть пустым, но он явно обозначает папку как пакет

импорт из пакета выглядит так: from app.utils import normalize_command

Частая ошибка: запуск из неправильной папки

Импорты зависят от того, откуда вы запускаете Python.

Практическое правило для учебного проекта:

открывайте в VS Code корень проекта (папку)

запускайте python main.py из терминала, который открыт в корне проекта

pip: установка сторонних библиотек

Что такое сторонние пакеты

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

HTTP-запросы

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

чтение разных форматов данных

Такие библиотеки обычно ставят из PyPI через pip.

Как проверить, что вы ставите пакеты в .venv

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

Проверьте:

Почему часто рекомендуют python -m pip, а не просто pip:

так вы гарантируете, что pip относится к этому Python (и к этому .venv)

Установка пакета

Пример: установим пакет requests.

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

Или посмотреть список пакетов:

Мини-пример использования установленной библиотеки

main.py:

Если это не запускается, проверьте:

выбран ли интерпретатор .venv в VS Code

активировано ли окружение в терминале

venv: зачем нужно виртуальное окружение и как оно помогает

Проблема без venv

Если ставить пакеты глобально, быстро появляется конфликт:

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

другой проект требует другую

Виртуальное окружение решает это:

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

у каждого проекта свой набор пакетов

Напоминание: создание и активация .venv

Создание:

Windows: py -m venv .venv

macOS/Linux: python3 -m venv .venv

Активация:

Windows (PowerShell): \.\.venv\Scripts\Activate.ps1

macOS/Linux: source .venv/bin/activate

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

venv — создание виртуальных окружений

Фиксация зависимостей: requirements.txt

Зачем фиксировать зависимости

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

Как создать requirements.txt

Обычно делают так:

Файл requirements.txt попадёт в проект, и его можно хранить в репозитории.

Как установить зависимости из requirements.txt

На чистой машине или после создания новой .venv:

Как это связано с VS Code

VS Code должен использовать интерпретатор из .venv, иначе:

пакеты будут ставиться не туда

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

Проверьте интерпретатор:

команда Python: Select Interpreter

выберите путь, содержащий .venv

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

VS Code: Python environments

Частые проблемы и быстрые решения

ModuleNotFoundError: No module named ...

Причины:

пакет не установлен в текущем окружении

VS Code использует не тот интерпретатор

вы запускаете скрипт не из корня проекта, и Python не видит ваш пакет

Решения:

выполните python -m pip list и убедитесь, что пакет есть

выберите интерпретатор .venv в VS Code

запускайте python main.py из корня проекта

pip ставит пакеты глобально, а не в .venv

Чаще всего:

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

используется другой pip

Надёжный способ:

используйте python -m pip install ... в терминале, где активировано .venv

Ошибка импорта из-за имени файла

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

Примеры плохих имён файлов:

json.py

random.py

requests.py

Правило:

не называйте свои файлы так же, как популярные пакеты и модули

Итог

Модуль — это файл .py, пакет — это папка с Python-кодом (обычно с __init__.py). С помощью импортов вы собираете программу из частей, а с помощью pip устанавливаете сторонние библиотеки из PyPI. Виртуальное окружение venv изолирует зависимости проекта и защищает от конфликтов версий. Если вы добавите requirements.txt, проект можно будет быстро развернуть на любой машине — особенно удобно при работе в VS Code.

Отладка и полезные расширения VS Code для Python

Что вы получите после этой статьи

К концу статьи вы сможете:

запускать Python-код в режиме отладки в VS Code

понимать ключевые инструменты отладки: breakpoint, пошаговое выполнение, просмотр переменных, Watch, Call Stack

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

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

собрать минимальный набор расширений VS Code для комфортной разработки на Python

Что должно быть сделано заранее

Эта статья опирается на предыдущие темы курса. У вас уже должны быть:

установлен Python

установлен VS Code и расширение Python

создан проект с виртуальным окружением .venv

выбран интерпретатор из .venv в VS Code

Если вы сомневаетесь, вернитесь к статье Установка Python и настройка VS Code для разработки.

Зачем нужна отладка, если есть print()

print() помогает быстро посмотреть значения, но у него есть минусы:

нужно вручную вставлять и удалять вывод

сложно понять, кто и когда изменил переменную

неудобно разбирать ветвления и циклы

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

Термины, которые понадобятся:

Breakpoint — точка останова, место, где выполнение программы приостанавливается

Step Over — выполнить текущую строку и перейти к следующей, не заходя внутрь вызываемой функции

Step Into — зайти внутрь функции, которая вызывается на текущей строке

Step Out — выйти из текущей функции к месту, откуда она была вызвана

Call Stack — список активных вызовов функций, который показывает путь выполнения к текущей строке

Watch — список выражений, значения которых вы хотите видеть во время отладки

Официальная справка:

Отладка в Visual Studio Code

Отладка Python в Visual Studio Code

!Показано, где в VS Code находятся основные панели отладки

Базовый сценарий отладки в VS Code

Создаём breakpoint

Откройте файл main.py.

Кликните слева от номера строки.

Появится красная точка — breakpoint.

Запускаем отладку

Самый простой способ для одного файла:

откройте вкладку Run and Debug

выберите запуск Python File

Альтернатива через палитру команд:

Python: Debug Python File

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

Смотрим значения переменных

Обычно используются три панели:

Variables — текущие переменные (локальные и глобальные) и их значения

Watch — выражения, которые вы добавили вручную, например tasks, len(tasks), user.get("age")

Call Stack — цепочка вызовов функций

Практический совет:

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

Пошаговое выполнение: как читать код “вживую”

В режиме отладки сверху появляется панель управления.

Continue продолжает выполнение до следующего breakpoint

Step Over помогает пройти строка за строкой, не углубляясь в функции

Step Into удобно, когда вы хотите понять, что делает конкретная функция

Step Out помогает быстро вернуться на уровень выше, если вы “зашли слишком глубоко”

Когда использовать:

используйте Step Over, если вы доверяете функции и хотите быстрее пройти код

используйте Step Into, если функция ваша и вы хотите проверить логику внутри

Debug Console и Terminal: где вводить input()

В Python-скриптах новичков часто встречается input(). Важно понимать разницу:

Terminal — полноценный терминал, в котором корректно работает ввод

Debug Console — консоль отладчика, она удобна для выражений и логов, но input() там часто ведёт себя иначе

Практическое правило:

для программ с input() запускайте отладку так, чтобы ввод шёл через Terminal

Если вы используете launch.json, ниже в статье будет настройка "console": "integratedTerminal".

Полезные виды breakpoints

Условный breakpoint

Иногда не хочется останавливаться на каждой итерации цикла. Можно остановиться только при выполнении условия.

Как поставить:

нажмите правой кнопкой по breakpoint

выберите Edit Breakpoint…

задайте условие, например i == 10 или len(tasks) > 5

Это особенно полезно в for и while.

Logpoint

Logpoint выводит сообщение, но не останавливает программу.

Зачем это нужно:

вы получаете “умный лог”, не меняя код

после отладки logpoint легко удалить

Как поставить:

правый клик по полю слева от номера строки

Add Logpoint…

Остановка на исключениях

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

В VS Code это настраивается в Run and Debug:

включите остановку на исключениях (Exception Breakpoints)

Смысл:

вы увидите, на какой строке возникла ошибка

сможете посмотреть переменные, которые к ней привели

launch.json: управляемый запуск проекта

Когда проект растёт, полезно явно описать, как именно его запускать.

Как создать launch.json

Откройте Run and Debug.

Нажмите create a launch.json file.

Выберите Python.

VS Code создаст папку .vscode/ и файл launch.json.

Пример конфигурации для main.py

Что означают ключевые поля:

program — какой файл запускать

console — куда направить ввод-вывод; integratedTerminal обычно лучший вариант для input()

cwd — рабочая папка; помогает относительным путям к файлам

args — аргументы командной строки (попадут в sys.argv)

env — переменные окружения для запуска

justMyCode — если true, отладчик меньше “проваливается” во внутренности библиотек

Официальная справка:

Документация по отладке Python в VS Code

Полезные расширения VS Code для Python

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

Обязательный минимум

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

- Python (Microsoft)

Pylance — быстрые подсказки, автодополнение, базовая проверка типов и навигация по коду

- Pylance

Что вы почувствуете сразу:

меньше ошибок из-за опечаток

удобнее переходить к определению функции

понятнее, что именно вы импортируете

Форматирование кода: чтобы стиль был ровным

Форматтер — инструмент, который автоматически приводит код к единому стилю.

Рекомендуемый вариант:

Black Formatter

- Black Formatter

Полезная настройка: форматирование при сохранении.

В Settings можно включить Format On Save, либо прописать в settings.json:

Смысл:

вы меньше спорите с собой о стиле

код легче читать

проще заметить реальные ошибки логики среди ровно оформленного текста

Линтер: чтобы находить проблемы раньше запуска

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

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

Ruff

- Ruff

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

импортировали модуль, но не используете

создали переменную, но забыли применить

написали условие, которое всегда истинно или всегда ложно

Jupyter: если вы хотите ноутбуки внутри VS Code

Если вы планируете изучать Python через эксперименты и заметки, установите:

Jupyter

- Jupyter

Улучшение читаемости ошибок

Error Lens — показывает ошибки и предупреждения прямо в строке кода

- Error Lens

Git в повседневной работе

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

GitLens — расширенные подсказки по Git, история строк, авторство

- GitLens

Практический мини-сценарий: отладка меню задач

Возьмите версию todo-программы из прошлой статьи про функции и ошибки и поставьте breakpoint:

на строку, где вы меняете статус задачи на выполненную: tasks[number - 1]["done"] = True

Что проверить в отладке:

чему равен number

чему равен len(tasks)

что содержит tasks[number - 1]

как меняется tasks после выполнения строки

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

Частые проблемы и быстрые решения

Breakpoint “серый” и не срабатывает

Обычно причины такие:

вы запускаете не отладку, а обычный запуск

VS Code использует не тот интерпретатор Python

Решения:

запускайте через Run and Debug

проверьте Python: Select Interpreter и выберите .venv

ModuleNotFoundError, хотя пакет установлен

Чаще всего VS Code смотрит не в то окружение.

Решения:

убедитесь, что активировано .venv

проверьте Python: Select Interpreter

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

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

Установка пакетов (pip)

Итог

Вы научились запускать Python в режиме отладки в VS Code, ставить breakpoint, выполнять код пошагово, смотреть переменные, стек вызовов и значения из Watch. Вы разобрались, почему для программ с input() важен запуск в Terminal, и научились настраивать запуск через launch.json. Также вы собрали набор расширений, которые делают разработку на Python в VS Code заметно удобнее: подсказки, форматирование, линтинг и улучшение отображения ошибок.