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

Установка Python и настройка окружения

В этой статье вы установите Python, настроите рабочее окружение и подготовите Visual Studio Code (VS Code) так, чтобы можно было уверенно запускать Python-проекты.

Что нужно в итоге

К концу статьи у вас должно быть:

Установлен Python 3

Рабочая команда python (или python3) в терминале

Рабочая команда pip для установки библиотек

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

Настроен VS Code с расширением Python и выбранным интерпретатором

!Схема показывает общий порядок действий от установки до первого запуска в VS Code

Важные понятия простыми словами

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

Терминал — окно, где вы вводите команды вроде python --version.

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

pip — менеджер пакетов Python, устанавливает библиотеки.

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

Установка Python

Рекомендуемая версия: последняя стабильная Python 3.

Официальный источник:

Python Downloads

Windows

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

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

Обязательно отметьте галочку Add python.exe to PATH.

Нажмите Install.

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

macOS

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

Установите Python.

Откройте Terminal и проверьте, какая команда работает: python3 обычно доступнее, чем python.

Linux

На Linux Python часто уже установлен, но версия может отличаться.

Проверьте наличие Python командой python3 --version.

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

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

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

В VS Code:

Откройте меню Terminal

Выберите New Terminal

Проверьте версии:

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

Полезные команды для диагностики:

| Задача | Windows | macOS/Linux | |---|---|---| | Узнать, откуда запускается Python | where python | which python3 | | Запустить Python в интерактивном режиме | python | python3 |

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

Скачайте и установите VS Code:

Visual Studio Code

Установка расширения Python для VS Code

Откройте VS Code.

Перейдите в Extensions.

Найдите расширение Python от Microsoft.

Установите.

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

Python extension for Visual Studio Code

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

Создаём папку проекта

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

В VS Code откройте её через File → Open Folder.

Создаём виртуальное окружение (venv)

В терминале VS Code выполните команду в папке проекта.

Windows:

macOS/Linux:

Папка .venv будет содержать отдельный интерпретатор и библиотеки только для этого проекта.

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

venv — Creation of virtual environments

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

Windows (PowerShell):

Windows (cmd):

macOS/Linux:

После активации в терминале обычно появляется пометка окружения, например (.venv).

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

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

Нажмите Ctrl+Shift+P (или Cmd+Shift+P на macOS).

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

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

Если VS Code предлагает создать окружение автоматически, это нормально: главное, чтобы в итоге был выбран интерпретатор из виртуального окружения проекта.

Первый запуск программы

Создайте файл hello.py.

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

Запустите одним из способов:

Кнопкой Run в редакторе

Через терминал командой python hello.py (или python3 hello.py)

Если всё настроено верно, вы увидите текст Hello, VS Code!.

Установка библиотек через pip (внутри venv)

Важно: сначала активируйте .venv, затем устанавливайте библиотеки.

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

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

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

pip documentation

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

Команда python не находится

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

Python не добавлен в PATH

Терминал был открыт до установки Python

Что делать:

Закройте и заново откройте терминал (или перезапустите VS Code).

На Windows переустановите Python и включите Add python.exe to PATH.

На macOS/Linux используйте python3.

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

Признаки:

Библиотека установилась, но импорт не работает

Решение:

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

Выберите интерпретатор через Python: Select Interpreter и укажите .venv.

Устанавливайте библиотеки командой pip в активированном окружении.

На Windows PowerShell не даёт активировать окружение

Иногда PowerShell блокирует запуск скриптов активации.

Что можно сделать:

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

Либо настроить политику выполнения скриптов в PowerShell (это системная настройка, делайте только если понимаете последствия)

Итог

Теперь у вас есть базовая и правильная инфраструктура для обучения:

Python установлен и проверен

VS Code готов к работе с Python

Проекты запускаются из виртуального окружения .venv

В следующей статье вы сможете сосредоточиться на самом Python-коде, не отвлекаясь на настройку среды.

Visual Studio Code для Python: расширения и запуск кода

В прошлой статье вы установили Python, создали виртуальное окружение .venv и научились выбирать интерпретатор. Теперь закрепим настройку именно внутри VS Code и разберём, как удобно запускать и отлаживать Python-код.

Что у вас должно быть готово перед началом

Установлен Python 3

Открыт проект в VS Code (папка проекта через Open Folder)

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

В VS Code установлен интерпретатор из .venv

Если это ещё не сделано, вернитесь к предыдущей статье и выполните шаги по установке и настройке окружения.

Какие расширения нужны для комфортной работы

Python (обязательно)

Главное расширение, которое добавляет поддержку Python в VS Code:

запуск Python-файлов

выбор интерпретатора

отладка

интеграция с тестами

Ссылка:

Python (Microsoft)

Pylance (очень рекомендуется)

Pylance отвечает за умные подсказки и анализ кода:

автодополнение (IntelliSense)

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

быстрые переходы к определениям функций и переменных

Ссылка:

Pylance

Jupyter (по желанию)

Если вы планируете работать с ноутбуками .ipynb:

запуск ячеек кода

визуальный вывод результатов

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

Ссылка:

Jupyter

> На старте курса можно спокойно обходиться без Jupyter и писать обычные .py-файлы.

Как убедиться, что VS Code использует правильный Python

Главная идея: VS Code должен запускать код тем же Python, который находится в .venv.

Проверьте это так:

Откройте палитру команд: Ctrl+Shift+P (Windows/Linux) или Cmd+Shift+P (macOS).

Введите Python: Select Interpreter.

Выберите интерпретатор, путь которого указывает на .venv.

Быстрая практическая проверка через терминал VS Code:

python --version показывает версию Python.

Команда с sys.executable выводит путь к исполняемому файлу Python.

Если путь указывает на папку .venv, значит проект настроен правильно.

Способы запуска Python-кода в VS Code

!Как код проходит путь от файла до результата в терминале

Запуск кнопкой Run

Откройте файл, например main.py.

Нажмите кнопку Run (или Run Python File) в правом верхнем углу редактора.

Плюсы:

быстро, не нужно помнить команды

VS Code сам использует выбранный интерпретатор

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

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

Откройте терминал: Terminal → New Terminal.

Убедитесь, что активировано окружение .venv (часто VS Code делает это автоматически для терминала проекта).

Запустите:

Плюсы:

вы понимаете, что именно запускается

легко добавлять аргументы и команды pip

Запуск выделенного фрагмента (по ситуации)

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

Выделите фрагмент кода.

Откройте палитру команд и найдите команду вида Python: Run Selection/Line in Python Terminal.

Плюсы:

удобно для быстрых экспериментов

Минус:

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

Где смотреть вывод и ошибки

Обычно вывод print(...) и сообщения об ошибках появляются:

во встроенном терминале VS Code

Если программа упала с ошибкой (например, SyntaxError или NameError), читайте сообщение целиком:

тип ошибки

файл и строка

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

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

Отладка: как запускать код по шагам

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

Что такое breakpoint

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

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

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

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

Поставьте breakpoint.

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

Нажмите Start Debugging.

Когда выполнение остановится, вы сможете:

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

выполнять код по шагам

понимать, на каком месте логика пошла не так

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

Отладка Python в VS Code

Полезные сочетания и команды

| Действие | Где найти | Зачем нужно | |---|---|---| | Выбор интерпретатора | Python: Select Interpreter | чтобы VS Code использовал .venv | | Запуск файла | кнопка Run | быстрый запуск без команд | | Новый терминал | Terminal → New Terminal | запуск команд python и pip | | Запуск отладки | Run and Debug | выполнение по шагам и просмотр переменных | | Палитра команд | Ctrl+Shift+P / Cmd+Shift+P | быстрый доступ к функциям VS Code |

Типичные проблемы и быстрые решения

Импорт не работает, хотя библиотеку ставили через pip

Чаще всего причина в том, что:

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

Что проверить:

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

запускаете ли вы pip внутри активированного .venv

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

Что сделать:

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

ещё раз выберите интерпретатор через Python: Select Interpreter

попробуйте запуск через терминал командой python main.py

Итог

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

ставить ключевые расширения для Python в VS Code

проверять, что выбран интерпретатор из .venv

запускать .py-файлы разными способами

находить вывод и читать ошибки

использовать отладку с breakpoint

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

Синтаксис Python: переменные, типы, ввод и вывод

В предыдущих статьях вы настроили Python, виртуальное окружение .venv и научились запускать код в Visual Studio Code разными способами. Теперь можно перейти к самому Python-коду: разберём базовый синтаксис, переменные, основные типы данных, а также ввод и вывод.

Как читать примеры из статьи в VS Code

Откройте папку проекта в VS Code через Open Folder.

Убедитесь, что выбран интерпретатор из .venv через Python: Select Interpreter.

Создайте файл, например main.py.

Копируйте примеры и запускайте:

1. кнопкой Run 2. или через терминал python main.py

Минимальные правила синтаксиса Python

Отступы имеют значение

Python использует отступы (обычно 4 пробела), чтобы обозначать блоки кода. Позже это понадобится для if, for, while, функций.

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

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

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

Комментарии

Комментарий начинается с #. Python игнорирует текст справа от #.

Переменные

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

Пример:

Здесь:

name и age это имена переменных

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

справа записаны значения

Как называть переменные

Правила (иначе будет ошибка):

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

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

нельзя использовать зарезервированные слова Python (например, class, def, if)

Хороший стиль (чтобы код было легко читать):

используйте понятные слова: total_price, user_age

в Python принято snake_case: слова через подчёркивание

Переменные можно переопределять

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

Типы данных

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

В начале чаще всего используются:

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

float дробные числа: 3.14, -0.5

str строки (текст): "Hello", 'Привет'

bool логические значения: True и False

Как узнать тип

Используйте type():

Строки

Строка это текст в кавычках. Одинарные и двойные кавычки в большинстве случаев равнозначны.

Полезные операции со строками:

склеивание (конкатенация) через +

повторение через *

Числа

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

Обратите внимание: / почти всегда даёт float, даже если делится нацело.

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

bool используется в проверках условий.

Позже вы будете встречать выражения, которые вычисляются в True или False.

Вывод в консоль: print

Функция print() выводит значения в терминал.

Вывод нескольких значений

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

В этом случае print сам добавляет пробелы между частями.

f-строки для удобного форматирования

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

Здесь:

f"..." означает форматируемую строку

{name} и {age} заменяются на значения переменных

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

input() читает строку из терминала.

Ключевой момент: input() всегда возвращает тип str, даже если пользователь ввёл число.

!Схема показывает путь данных: ввод → обработка → вывод

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

Так как input() возвращает строку, для чисел нужно преобразование.

str в int

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

str в float

Любое значение в str

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

Но чаще удобнее использовать f-строки:

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

Путают строки и числа

Так нельзя, потому что x это строка. Правильно:

NameError: имя не определено

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

SyntaxError: синтаксическая ошибка

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

Мини-практика в одном файле

Создайте main.py и соберите вместе ввод, преобразование и вывод:

Итог

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

что такое переменные и как их называть

основные типы: int, float, str, bool

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

как получать ввод через input()

почему после input() часто нужно преобразование типов

Дальше эти основы будут постоянно встречаться в любых программах: от простых скриптов до полноценных проектов в VS Code.

Управляющие конструкции: условия, циклы, ошибки

В прошлых статьях вы настроили Python и Visual Studio Code, научились запускать файлы и освоили переменные, типы, input() и print(). Теперь добавим управление потоком выполнения: научимся принимать решения с помощью условий, повторять действия с помощью циклов и правильно читать и обрабатывать ошибки.

Подготовка проекта в VS Code

Откройте папку проекта через Open Folder.

Убедитесь, что выбран интерпретатор из .venv через Python: Select Interpreter.

Создайте файл main.py.

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

Условия: if, elif, else

Условие позволяет выполнять код только если выражение истинно.

Базовый пример:

Здесь важно:

if проверяет условие.

после условия стоит двоеточие :.

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

else выполняется, если условие в if ложно.

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

elif означает иначе если.

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

!Блок-схема показывает, как Python выбирает ветку if/elif/else

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

Условия чаще всего строятся на сравнении значений.

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

| Оператор | Значение | Пример | |---|---|---| | == | равно | x == 10 | | != | не равно | x != 10 | | < | меньше | x < 10 | | <= | меньше или равно | x <= 10 | | > | больше | x > 10 | | >= | больше или равно | x >= 10 |

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

and требует, чтобы оба условия были истинны.

or требует, чтобы хотя бы одно условие было истинно.

not переворачивает результат.

Что считается истинным: истинность значений

Иногда в if используют не сравнение, а само значение.

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

пустые значения обычно считаются ложными: пустая строка "", число 0

непустые значения обычно считаются истинными: строка "hello", число 5

Пример:

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

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

Здесь:

count меняется на каждом шаге

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

break и continue

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

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

Цикл for: перебираем последовательности

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

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

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

Если нужно начать не с нуля:

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

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

IndentationError: неправильные отступы

Python требует единых отступов для блоков.

Неправильно:

Правильно:

== и =

= присваивает значение

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

Неправильно:

Правильно:

ValueError при преобразовании int()

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

Если ввести abc, будет ошибка. Ниже разберём, как это обработать.

Ошибки и исключения: как читать и как обрабатывать

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

Что смотреть в первую очередь:

тип ошибки, например NameError, TypeError, ValueError

файл и номер строки

текст ошибки, который обычно прямо говорит, что не так

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

Built-in Exceptions

Обработка ошибок через try и except

Если вы ожидаете, что пользователь может ввести неверные данные, используйте try/except.

Здесь:

код внутри try выполняется как обычно

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

else и finally в обработке ошибок

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

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

Когда не стоит ловить все ошибки подряд

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

Так можно скрыть реальную причину проблемы и усложнить отладку. На старте лучше:

ловить конкретные ошибки (например, ValueError)

читать трассировку в терминале VS Code

ставить breakpoint и смотреть значения переменных во время выполнения (это вы уже делали в статье про отладку)

Документация по конструкции try:

Errors and Exceptions

!Схема показывает, в каком порядке выполняются try/except/else/finally

Мини-практика: меню в цикле с проверкой ввода

Пример объединяет while, if/elif/else, преобразование типов и обработку ошибок.

Итог

Теперь вы умеете управлять выполнением программы:

использовать if/elif/else для ветвления логики

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

повторять действия через while и for, применять break и continue

читать сообщения об ошибках и понимать, где и почему программа падает

обрабатывать ожидаемые ошибки ввода через try/except, при необходимости используя else и finally

С этими инструментами вы уже можете писать небольшие интерактивные программы в VS Code и уверенно двигаться дальше к функциям и структурам данных.

Функции и модули: структура программы

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

функции — помогают выделять повторяющиеся или логически цельные действия

модули — помогают раскладывать программу по файлам и переиспользовать код

В результате ваши программы станут:

короче и понятнее

удобнее для отладки

проще для расширения (добавлять новые возможности)

!Схема показывает, как код делится на файлы и подключается через import

Функции

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

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

Функции используют, чтобы:

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

дать блоку кода понятное имя

разделить программу на небольшие части

Объявление и вызов функции

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

Важно:

после имени функции идут скобки ()

после строки с def ...: начинается блок с отступом

чтобы выполнить функцию, её нужно вызвать по имени

Параметры (входные данные)

Параметры позволяют передавать в функцию значения.

Здесь name — параметр, а значения "Аня", "Игорь" — аргументы.

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

print() показывает текст в терминале, но не возвращает результат.

Если функция должна вернуть значение, используется return.

Правило:

return завершает работу функции и отдаёт значение наружу

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

Ранний выход из функции

return можно использовать для досрочного завершения.

Такой стиль особенно полезен вместе с обработкой ошибок, которую вы проходили в теме try/except.

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

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

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

храните данные внутри функции и возвращайте результат через return

избегайте изменения глобальных переменных без необходимости

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

Определение функций в Python

Докстроки: краткое описание функции

Докстрока — это строка в начале функции, которая объясняет, что она делает.

Докстроки полезны, потому что:

их видно в подсказках VS Code

они помогают другим (и вам в будущем) понимать код

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

Строки документации (docstrings)

Модули

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

Модуль — это обычный файл .py, который можно подключить в другой файл с помощью import.

Например, вы создаёте файл utils.py, а затем используете его функции в main.py.

Пример: выносим функции в отдельный файл

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

Файл utils.py:

Файл main.py:

Обратите внимание:

import utils подключает модуль целиком

функции вызываются с префиксом utils.

Варианты импорта

| Вариант | Пример | Когда удобно | |---|---|---| | Импорт модуля | import utils | когда в модуле много функций и важно видеть, откуда они пришли | | Импорт конкретного имени | from utils import is_even | когда нужно 1–2 функции и хочется короче запись | | Псевдоним | import utils as u | когда имя длинное или конфликтует |

Пример from ... import ...:

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

Когда вы пишете import utils, Python ищет utils.py:

в текущей папке проекта (там, где запускаете программу)

в стандартной библиотеке Python

в установленных пакетах текущего окружения .venv

Это ещё одна причина, почему важно:

открывать в VS Code именно папку проекта через Open Folder

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

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

Модули в Python

Стандартная библиотека: модули, которые уже есть

Python поставляется со множеством готовых модулей.

Примеры:

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

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

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

Иногда один и тот же файл хочется:

импортировать (использовать его функции)

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

Для этого используют проверку if __name__ == "__main__":.

Файл utils.py:

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

когда файл запускают напрямую, __name__ равен строке "__main__"

когда файл импортируют, __name__ равен имени модуля (например, "utils"), и тестовый код не выполняется

Это защищает вас от ситуации, когда при импорте неожиданно запускаются print() или ввод через input().

Запуск модулей в VS Code

Самое простое:

запускать main.py кнопкой Run или командой python main.py

Иногда полезно запускать модуль как модуль:

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

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

Командная строка Python: опция -m

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

Для небольших учебных программ удобен такой подход:

main.py — точка входа, где происходит ввод, выбор сценария, вызов функций

utils.py, strings.py, calc.py — модули с логикой и функциями

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

Главная идея:

в main.py минимум логики, максимум вызовов функций

в модулях максимум логики, минимум ввода/вывода

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

ModuleNotFoundError

Обычно означает одно из двух:

файл модуля лежит не рядом с main.py (или вы запускаете программу не из папки проекта)

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

Что проверить:

вы открыли папку проекта через Open Folder

выбран интерпретатор из .venv через Python: Select Interpreter

Импорт вроде работает, но выполняется лишний код

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

Решение:

перенесите тестовый запуск под if __name__ == "__main__":

Итог

Теперь вы умеете структурировать программы:

выделять повторяющийся код в функции

передавать данные через параметры и получать результат через return

понимать разницу между локальными и глобальными переменными

раскладывать код по файлам с помощью модулей и import

использовать if __name__ == "__main__":, чтобы модуль было удобно и импортировать, и запускать

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

Работа с пакетами: pip и виртуальные окружения

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

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

научились запускать код в Visual Studio Code и выбирать интерпретатор

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

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

Что такое пакет, библиотека и зависимость

Чтобы не путаться в терминах:

Пакет (package) — набор кода, который можно установить в окружение Python. Чаще всего это то, что вы ставите командой pip install ....

Библиотека — разговорное слово: обычно имеется в виду пакет, который решает какую-то задачу (например, работа с HTTP).

Зависимости (dependencies) — пакеты, которые нужны вашему проекту, чтобы он работал.

Важно отличать от того, что вы уже проходили:

Модуль — это файл .py (например, utils.py) в вашем проекте.

Пакет — то, что ставится через pip и попадает в окружение (обычно в папку site-packages).

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

Виртуальное окружение (обычно .venv) — это отдельная папка с:

своим интерпретатором Python

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

Это нужно, чтобы:

разные проекты не ломали друг друга (одному проекту нужна версия пакета 1.0, другому 2.0)

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

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

!Сравнение системной установки пакетов и изолированных окружений проекта

Главное правило: pip должен работать внутри .venv

Вы устанавливаете пакеты туда, откуда запускается ваш код.

Поэтому порядок обычно такой:

Открыть папку проекта в VS Code через Open Folder

Активировать .venv в терминале (или убедиться, что VS Code активировал сам)

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

Запустить код

Как проверить, что вы в нужном окружении

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

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

pip: установка пакетов

pip — это инструмент, который устанавливает пакеты из репозитория PyPI и встраивает их в текущее окружение Python.

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

pip documentation

Installing packages

Рекомендуемый способ запуска pip

Самый надёжный способ — запускать pip через ваш Python:

Почему так лучше:

вы точно используете pip, привязанный к текущему python

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

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

Пример:

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

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

Обновление пакета

Удаление пакета

Виртуальные окружения: создание и активация

Вы уже создавали .venv в начале курса, но здесь соберём команды в одном месте.

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

venv — Creation of virtual environments

Создание .venv

Windows:

macOS/Linux:

Активация .venv

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

После активации в терминале обычно появляется префикс вроде (.venv).

Деактивация

В любом терминале:

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

Когда вы ставите пакеты, важно уметь:

записать, какие пакеты нужны проекту

восстановить их на другом компьютере

Для учебных и небольших проектов чаще всего используют файл requirements.txt.

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

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

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

pip freeze выводит список пакетов с версиями

> сохраняет вывод в файл

Пример строк в requirements.txt:

Здесь == означает строго эта версия. Это помогает воспроизводимости: у вас и у другого человека будут одинаковые версии.

Как установить зависимости из файла

На чистом окружении (например, после создания новой .venv):

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

Храните в репозитории:

ваш код

requirements.txt

И не храните:

папку .venv

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

VS Code важно настроить так, чтобы:

был выбран интерпретатор именно из .venv

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

Если интерпретатор выбран неверно, часто возникают симптомы:

вы установили пакет, но import не работает

автодополнение и подсказки в VS Code не видят библиотеку

Что проверить:

Команда Python: Select Interpreter и выбор Python из .venv

В терминале python -c "import sys; print(sys.executable)" и путь на .venv

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

ModuleNotFoundError после установки

Обычно причина одна: пакет поставили не в то окружение.

Что сделать:

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

Устанавливайте пакеты так: python -m pip install ...

Перезапустите терминал VS Code (иногда он остаётся в старом состоянии)

Установилось, но подсветка ошибок в редакторе осталась

Иногда анализатор кода (Pylance) обновляется не сразу.

Что сделать:

убедитесь, что интерпретатор выбран правильно

попробуйте перезагрузить окно VS Code: Developer: Reload Window

На Windows PowerShell не даёт активировать .venv

Если PowerShell блокирует активацию скриптов:

используйте cmd для активации

либо настройте политику выполнения скриптов (это системная настройка, делайте только если понимаете последствия)

Итог

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

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

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

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

сохранять зависимости в requirements.txt и разворачивать окружение командой pip install -r requirements.txt

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

Отладка и мини-проект в VSC

В прошлых статьях вы настроили Python и .venv, научились запускать код в Visual Studio Code, разобрали синтаксис, условия и циклы, функции и модули, а также установку пакетов через pip. В этой статье вы соберёте всё вместе: освоите практическую отладку в VS Code и сделаете мини-проект, где отладка действительно пригодится.

Что вы получите в итоге

Понимание, как читать traceback и быстро находить причину ошибки.

Навык отладки с breakpoint в VS Code: шаги, переменные, Call Stack.

Мини-проект Проверка сайта: ввод URL → запрос → понятный вывод результата.

Готовая структура проекта из нескольких файлов, которую удобно расширять.

!Как отладка связывает сообщение об ошибке с конкретной строкой кода и состоянием переменных

Отладка в VS Code: базовый рабочий процесс

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

Практичный порядок действий:

Воспроизведите проблему (ошибка или неправильное поведение).

Прочитайте сообщение в терминале.

Найдите файл и строку, где всё сломалось.

Поставьте breakpoint перед проблемным местом.

Запустите Debug и проверьте значения переменных.

Исправьте код и повторите запуск.

Как читать traceback (трассировку ошибок)

Когда программа падает, Python печатает traceback в терминал VS Code.

Что в нём самое важное:

Тип ошибки, например ValueError, NameError, TypeError.

Файл и номер строки, где ошибка произошла.

Последняя строка traceback обычно содержит самую конкретную причину.

Пример (укороченный):

Как это читать:

Ошибка произошла в main.py на строке 12.

Проблемная операция: int(text).

Причина: строку 'abc' нельзя превратить в целое число.

Справка от Python:

Errors and Exceptions

Breakpoint и запуск Debug

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

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

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

Подходы (любой удобен):

Вкладка Run and Debug → Start Debugging.

Команда из палитры Python: Debug Python File.

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

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

Отладка по шагам: что нажимать и зачем

Во время остановки на breakpoint вы обычно используете:

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

Step Over: выполнить текущую строку и перейти на следующую (не заходя внутрь функций).

Step Into: зайти внутрь функции и смотреть, что происходит там.

Step Out: выйти из текущей функции обратно к месту вызова.

Полезные панели:

Variables: текущие значения переменных.

Watch: свои выражения для наблюдения (например, url, response.status_code).

Call Stack: цепочка вызовов, как вы пришли в текущую строку.

Как использовать Call Stack по делу

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

Конфигурация запуска: аргументы и рабочая папка

Иногда программе нужны аргументы командной строки (например, режим работы), или важно, из какой папки идёт запуск.

Для этого используют файл .vscode/launch.json. VS Code может создать его сам.

Пример конфигурации, которая передаёт аргумент --timeout:

Важно:

Это не обязательно для старта.

Но это удобно, когда вы хотите запускать проект одинаково каждый раз.

Мини-проект: Проверка сайта (HTTP Check)

Вы сделаете консольную программу, которая:

принимает URL от пользователя

делает HTTP-запрос

выводит понятный результат

не падает от типичных ошибок (неверный адрес, нет интернета)

Что понадобится

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

Пакет requests.

Установка (внутри .venv):

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

Requests: HTTP for Humans

Структура проекта

Сделайте в папке проекта файлы:

main.py

http_client.py

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

Реализация

Файл http_client.py

Этот модуль отвечает только за запросы и обработку сетевых ошибок.

Файл main.py

Этот файл отвечает за ввод и вывод, а также вызывает функцию из модуля.

Как отлаживать этот мини-проект в VS Code

Сценарий для отладки

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

Идеи для теста:

Введите пустую строку.

Введите example.com без https://.

Введите заведомо неверный адрес https://no-such-domain-12345.example.

Где ставить breakpoint

Удобные точки:

В main.py на строке result = check_url(...).

В http_client.py на строке response = requests.get(...).

В http_client.py на строке status = response.status_code.

Что смотреть:

Значение url.

Что лежит в result перед выводом.

Какая ветка except сработала.

Что в response.status_code, если запрос успешен.

Типовая ситуация: “всё работает, но вывод странный”

Если вывод не соответствует ожиданиям:

Поставьте breakpoint перед print(...).

Откройте Variables.

Проверьте, что именно вернула функция check_url.

Если нужно, зайдите внутрь check_url через Step Into.

Как сохранить зависимости мини-проекта

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

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

Итог

Теперь вы умеете отлаживать Python-проекты в VS Code на практике:

читать traceback и быстро находить источник ошибки

останавливать выполнение на breakpoint и проверять переменные

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

понимать роль Call Stack

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

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