Python с нуля: основы программирования

Установка Python и первая программа

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

1) Что нужно для старта

Чтобы писать и запускать код на Python, вам понадобятся:

Интерпретатор Python (сама программа, которая выполняет ваш код).

Редактор кода (можно простой, можно среду разработки).

Терминал/командная строка (чтобы проверять установку и запускать файлы).

2) Установка Python

Windows

Скачайте установщик Python с официального сайта (раздел Downloads).

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

Важно: поставьте галочку “Add python.exe to PATH” (или похожую).

Нажмите Install.

Зачем PATH? PATH — это список папок, где система ищет программы. Если Python добавлен в PATH, вы сможете запускать его командой python из любого места в терминале.

macOS

Обычно удобнее установить актуальную версию Python через официальный установщик (pkg) с сайта Python.

Важно: в macOS может быть предустановлен Python 2/системный Python, но для обучения лучше использовать установленный вами Python 3.

Linux

Во многих дистрибутивах Python 3 уже есть. Если нет — установите через менеджер пакетов вашего дистрибутива (например, apt, dnf, pacman).

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

Откройте терминал (Windows: PowerShell/Command Prompt; macOS/Linux: Terminal) и выполните:

или, если на вашей системе Python 3 запускается отдельно:

Вы должны увидеть версию, например Python 3.12.x.

Частые проблемы

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

- Windows: скорее всего не добавили Python в PATH. Переустановите Python и включите галочку “Add to PATH”. - macOS/Linux: попробуйте python3.

Открывается Microsoft Store (Windows)

- Значит, система не видит установленный Python в PATH. Проверьте установку и PATH.

4) Первый запуск Python в интерактивном режиме (REPL)

REPL — это режим, где вы вводите команды и сразу видите результат. Запустите:

Вы увидите приглашение вроде >>>. Попробуйте:

Чтобы выйти:

Windows: Ctrl + Z, затем Enter

macOS/Linux: Ctrl + D

5) Выбор редактора кода

Варианты:

IDLE (часто ставится вместе с Python): просто и достаточно для старта.

VS Code / PyCharm: мощные инструменты, но могут быть “тяжелее” для первого дня.

Любой текстовый редактор: можно, но важно сохранить файл с расширением .py.

Главное на старте — чтобы вы могли создать файл *.py и запустить его.

6) Первая программа в файле

Шаг 1. Создайте папку проекта

Например:

или на macOS/Linux:

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

Содержимое:

print(...) — функция, которая выводит текст в консоль.

Шаг 3. Запуск файла

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

Если требуется:

Вывод:

7) Программа с вводом

Добавим ввод имени:

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

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

введённый текст сохраняется в переменную name.

затем мы склеиваем строки через +.

Пример работы:

8) Важные мелочи, которые экономят время

Не называйте файл python.py (и вообще не используйте имена стандартных модулей: random.py, sys.py). Это может “сломать” импорт в будущем.

Следите за кодировкой: обычно UTF-8 по умолчанию — отлично, кириллица работает.

Запускайте из правильной папки: если терминал “не видит” файл, значит вы не там.

---

Задания для закрепления

Установите Python и проверьте версию командой python --version (или python3 --version). Напишите, что вывел терминал.

Создайте файл hello.py, который выводит две строки:

- Привет! - Я изучаю Python.

Создайте файл greet.py, который спрашивает имя и город, а затем выводит строку: Привет, <имя> из <город>!.

(Небольшой вызов) В REPL посчитайте:

- 10 + 25 - 7 * 8 - 100 / 4

<details> <summary> Ответы </summary>

Пример корректного ответа (у вас версия может отличаться):

hello.py:

greet.py:

Пример:

</details>

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

В первой статье вы уже запускали программы, использовали print(...) и input(...). Теперь разберём, как хранить данные в программе, какие бывают типы данных и как правильно делать ввод-вывод.

1) Переменные: что это и зачем

Переменная — это имя, под которым программа хранит значение.

Здесь:

age и name — переменные (имена)

= — оператор присваивания (положить значение в переменную)

Важно: = в программировании не «равно», а именно «присвоить».

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

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

Регистр важен: name и Name — разные переменные.

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

Примеры:

Хорошо: city, user_name, total_sum

Плохо: a, x1x1x1, sumSumSUM

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

В Python у каждого значения есть тип. Самые базовые:

| Тип | Пример | Что хранит | |---|---|---| | int | 10, -3 | целые числа | | float | 3.14, 2.0 | числа с точкой | | str | "Привет" | текст (строки) | | bool | True, False | логические значения | | NoneType | None | «нет значения» |

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

Динамическая типизация

Python позволяет одной и той же переменной в разное время хранить разные типы:

Это удобно, но требует внимательности: вы сами следите, что лежит в переменной.

3) Строки (str) и кавычки

Строку можно записывать в одинарных или двойных кавычках:

Если внутри строки нужна кавычка того же типа — используйте другой тип или экранирование \:

4) Ввод: input() всегда возвращает строку

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

Если вы ждёте число, нужно преобразование.

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

int("12") → 12

float("3.14") → 3.14

str(10) → "10"

Пример: попросим возраст и прибавим 1.

Если ввести не число (например, abc), будет ошибка ValueError.

5) Вывод: print() и полезные настройки

print() может выводить несколько значений за раз:

По умолчанию между аргументами ставится пробел. Это можно изменить параметром sep:

И можно управлять окончанием строки параметром end (по умолчанию \n — перенос строки):

6) Склейка строк и форматирование

Склейка через +

Но важно: строки и числа так складывать нельзя.

Исправления:

f-строки (самый удобный способ)

В фигурных скобках {...} можно писать переменные и даже выражения:

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

Комментарий:

year преобразуем через int(...), иначе вычитание не сработает.

age — результат вычисления, сохраняем в переменную, чтобы не повторять формулу.

---

Задания для закрепления

1) Создайте переменные a = 7 и b = 3. Выведите:

их сумму

их произведение

2) Пользователь вводит длину и ширину прямоугольника (как числа с точкой). Выведите периметр.

3) Пользователь вводит своё имя и любимое число (целое). Выведите фразу в формате f-строки: Имя: <имя>, любимое число: <число>.

4) Что выведет этот код? (ответ текстом)

<details> <summary> Ответы </summary>

1)

2) Периметр: . Здесь:

длина и ширина — введённые числа

+ складывает их

умножение на 2 даёт сумму всех сторон

3)

4) input() возвращает строку. Поэтому x + "5" — это склейка строк. Например, если ввести 12, будет выведено:

</details>

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

Программа становится «умной», когда умеет:

Принимать решения (выполнять разные ветки кода).

Повторять действия (делать одно и то же много раз).

В Python за это отвечают условия (if) и циклы (for, while).

1) Условия: if / elif / else

Базовая форма:

Главное правило: код внутри ветки должен быть с отступом (обычно 4 пробела).

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

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

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

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

== равно

!= не равно

<, <=, >, >=

Логические операторы:

and — оба условия истинны

or — хотя бы одно истинно

not — отрицание

Пример с несколькими условиями:

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

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

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

3) Вложенные условия и «ранний выход»

Иногда условие внутри условия читается тяжело:

Часто проще объединить логикой:

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

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

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

break и continue

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

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

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

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

range() — генератор чисел

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

Полезные формы:

Пример: сумма чисел от 1 до 100:

6) else у циклов (редко, но полезно)

У циклов бывает else: он выполняется только если цикл завершился без break.

Здесь else сработает, потому что break не был выполнен.

7) Типичные ошибки новичков

1) Неправильные отступы

2) Путают границы range: range(5) не включает 5.

3) Бесконечный while: забыли изменить переменную, влияющую на условие.

---

Задания для закрепления

1) Пользователь вводит целое число. Выведите:

"Положительное", если число > 0

"Отрицательное", если число < 0

"Ноль", если число равно 0

2) Пользователь вводит пароль. Если пароль равен строке "python", вывести "Доступ", иначе "Ошибка".

3) Дано число n (ввод). Выведите сумму чисел от 1 до n включительно с помощью for.

4) Выведите все числа от 10 до 1 (включительно) с шагом -1.

5) Пользователь вводит числа по одному. Как только введёт 0 — остановиться и вывести, сколько чисел было введено до нуля.

6) Дан список:

Найдите первое чётное число и выведите его. Если чётных нет — выведите "нет".

<details> <summary> Ответы </summary>

1)

2)

3)

4)

5)

6)

</details>

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

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

1) Список (list): упорядоченная коллекция

Список хранит элементы в определённом порядке и позволяет изменять содержимое.

Индексы и срезы

Индексация начинается с 0.

Отрицательные индексы — с конца.

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

> remove(value) выдаст ошибку, если значения нет. Если не уверены — проверяйте через in.

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

Важный момент: изменяемость (mutability)

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

Если нужна независимая копия списка (поверхностная):

2) Кортеж (tuple): как список, но неизменяемый

Кортеж похож на список, но его нельзя менять (удобно для «фиксированных» наборов).

Часто кортежи используют для распаковки:

3) Словарь (dict): ключ → значение

Словарь хранит пары: ключ и соответствующее значение.

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

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

Если ключа нет, user["x"] даст ошибку. Часто удобнее:

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

Удаление

> Ключами в словаре обычно делают строки или числа. Главное требование: ключ должен быть неизменяемым (например, список ключом быть не может).

4) Множество (set): уникальные элементы без порядка

set хранит только уникальные значения и хорошо подходит для проверки «уже встречалось ли».

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

5) Как выбрать структуру

list — важен порядок, нужны дубликаты, часто добавляете/удаляете.

tuple — набор фиксирован, менять не нужно.

dict — нужно быстро находить значение по ключу (например, «имя → телефон»).

set — важна уникальность и быстрый поиск «есть ли элемент».

---

Задания для закрепления

1) Дан список nums = [3, 1, 3, 5, 1]. Создайте множество уникальных значений и выведите его.

2) Пользователь вводит 3 слова. Сохраните их в список и выведите второе слово.

3) Дан словарь:

Добавьте ключ "in_stock" со значением True

Увеличьте price на 30

Выведите все пары ключ-значение через items()

4) Есть список имён: names = ["Аня", "Борис", "Аня", "Дима", "Борис"]. Посчитайте, сколько раз встречается каждое имя, и сохраните результат в словарь вида {"Аня": 2, ...}.

5) (Небольшой вызов) Дан список чисел. Создайте новый список из квадратов только чётных чисел.

<details> <summary> Ответы </summary>

1)

2)

3)

4)

5)

</details>

Функции и основы модульности кода

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

один и тот же код начинает повторяться;

код трудно читать и тестировать, потому что всё «свалено» в одном месте.

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

1) Функция: что это

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

Простейший пример:

Важно:

def создаёт функцию.

Код внутри функции имеет отступ.

Функция не выполняется, пока вы её не вызвали: greet().

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

Функции могут принимать данные через параметры:

Термины:

параметр — переменная в определении (name);

аргумент — конкретное значение при вызове ("Аня").

Несколько параметров

3) return: как функция отдаёт результат

print() показывает текст на экране, но не возвращает результат для дальнейших вычислений.

Для результата используется return:

Правила return:

после return функция завершается сразу;

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

4) Функция как «мини-программа»: разделяйте ответственность

Хорошая привычка: одна функция — одна понятная задача.

Плохо (смешали ввод, вычисления и вывод):

Лучше разделить:

Циклы и условия вы уже знаете (см. прошлую статью про управление логикой) — здесь важно, что они «живут» внутри функций так же, как и в обычном коде.

5) Значения по умолчанию и именованные аргументы

Параметр по умолчанию

Именованные аргументы (keyword arguments)

Можно явно указать, какой параметр вы передаёте:

Это повышает читаемость, особенно когда параметров много.

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

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

Если снаружи есть переменная с тем же именем — это другое значение:

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

Докстрока — строка в начале функции в тройных кавычках. Её удобно читать в подсказках редактора.

8) Модульность: разделяем проект на файлы

В Python каждый файл .py — модуль.

Пример структуры:

utils.py:

main.py:

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

проще ориентироваться: «утилиты» отдельно, «логика запуска» отдельно;

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

меньше риска повторять один и тот же код (DRY — Don’t Repeat Yourself).

9) Блок запуска: if __name__ == "__main__"

Иногда модуль содержит и функции, и небольшой «запускной» код для проверки.

Смысл:

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

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

---

Задания для закрепления

1) Напишите функцию multiply(a, b), которая возвращает произведение.

2) Напишите функцию safe_int(text), которая пытается превратить строку в число:

если получается, возвращает int;

если нет, возвращает None.

Подсказка: используйте try/except.

3) Напишите функцию count_words(s), которая возвращает количество слов в строке. Считайте, что слова разделены пробелами.

4) Разбейте код на модули:

создайте файл math_utils.py с функцией is_even(n);

в main.py импортируйте is_even и выведите "чётное" или "нечётное" для введённого числа.

<details> <summary> Ответы </summary>

1)

2)

3)

4) math_utils.py:

main.py:

</details>

Работа с файлами и обработка ошибок

Файлы позволяют программе сохранять данные между запусками: результаты, заметки, настройки. А обработка ошибок помогает делать программы устойчивыми: не падать из‑за «неправильного ввода» или отсутствующего файла.

1) Пути к файлам: где Python ищет файл

Если вы пишете просто имя файла ("data.txt"), Python ищет его в текущей рабочей папке (той, из которой вы запускаете программу).

Чтобы избежать путаницы:

Храните файлы рядом с вашим main.py (особенно на старте).

Явно печатайте, где вы находитесь:

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

Работа с файлом начинается с open(path, mode, encoding=...).

Частые режимы:

"r" — чтение (если файла нет, будет ошибка)

"w" — запись (создаст файл или перезапишет существующий)

"a" — дозапись в конец (создаст файл, если его нет)

Для текстовых файлов почти всегда указывайте кодировку:

Но вручную закрывать файл легко забыть — лучше использовать with.

3) Контекстный менеджер with: файл закроется сам

Плюс with: даже если внутри произойдёт ошибка, файл корректно закроется.

4) Чтение файла: read, readline, readlines, перебор строк

Прочитать весь файл целиком

Удобно для небольших файлов.

Читать построчно (экономно по памяти)

Часто строка заканчивается символом перевода строки \n, поэтому print(line) может давать «пустые строки». Обычно делают так:

5) Запись в файл: write и writelines

Перезаписать файл

Важно: write() не добавляет перенос строки сам — \n нужно писать явно.

Дописать в конец

6) Обработка ошибок: try/except

Ошибки бывают «ожидаемые»:

файла нет (FileNotFoundError)

нет прав на запись (PermissionError)

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

Чтобы программа не завершалась аварийно, используйте try/except:

Несколько except

> Подробный ввод‑вывод и преобразования типов были в статье про переменные и input() — здесь важно, что ошибки конвертации удобно ловить через ValueError.

else и finally

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

finally выполняется всегда (например, чтобы вывести «завершение»)

7) Практический мини-пример: «лог» действий

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

---

Задания для закрепления

1) Создайте файл hello_file.txt и запишите в него две строки: Привет и Это файл.

2) Прочитайте hello_file.txt и выведите его содержимое на экран.

3) Пользователь вводит 3 строки. Запишите их в файл lines.txt, по одной строке на строку.

4) Прочитайте lines.txt построчно и выведите строки без лишних пустых строк.

5) Напишите код, который пытается прочитать файл missing.txt. Если файла нет — вывести "Файл missing.txt не найден" (без падения программы).

6) Пользователь вводит число. Выведите 100 / n. Обработайте две ошибки: неверный ввод и деление на ноль.

<details> <summary> Ответы </summary>

1)

2)

3)

4)

5)

6)

</details>

Итоговый мини-проект: программа на Python

Мини-проект — это способ собрать вместе то, что вы уже умеете: переменные, условия, циклы, структуры данных, функции, модули, файлы и обработку ошибок. Сделаем небольшую, но «настоящую» консольную программу: список дел (ToDo) с сохранением в файл.

1) Что должна уметь программа

Функциональность (минимум):

Показать список дел.

Добавить дело.

Отметить дело выполненным.

Удалить дело.

Сохранять дела в файл и загружать при старте.

Команды будем вводить текстом (например: add, list, done, delete, exit).

2) Формат хранения данных (простой текст)

Чтобы не усложнять, сохраним каждое дело отдельной строкой в файле tasks.txt.

Формат строки:

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

done — 0 (не выполнено) или 1 (выполнено)

text — описание

Разделитель — символ |.

Пример файла:

В программе будем хранить задачи как список словарей:

3) План: разложим на функции

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

load_tasks(path) — прочитать файл и вернуть список задач

save_tasks(path, tasks) — записать список задач в файл

print_tasks(tasks) — аккуратно вывести

add_task(tasks, text) — добавить

mark_done(tasks, task_id) — отметить выполненной

delete_task(tasks, task_id) — удалить

Технику with open(...) и обработку ошибок try/except смотрите в статье «Работа с файлами и обработка ошибок»; ниже — готовое применение.

4) Реализация (вариант в одном файле)

Создайте main.py рядом с tasks.txt (или программа сама создаст файл при сохранении).

5) Проверка: пример сессии

6) Как улучшить проект (без переписывания всего)

Добавить команду stats (сколько всего / сколько сделано).

Разрешить add Купить хлеб в одну строку (разбор команды).

Вынести функции чтения/записи в отдельный модуль storage.py, а интерфейс оставить в main.py (см. статью про модульность).

---

Задания для закрепления

1) Добавьте команду stats, которая выводит:

всего задач

выполнено

осталось

2) Сделайте команду undone, которая снимает отметку выполненности по id.

3) Сделайте команду search: пользователь вводит слово, программа выводит только те задачи, где слово встречается в тексте (без учёта регистра).

4) (Небольшой вызов) Сделайте автосохранение: после add/done/delete/undone файл сохраняется автоматически.

<details> <summary> Ответы </summary>

1) stats

В main():

2) undone

В main() добавьте ветку по аналогии с done.

3) search

4) Автосохранение: после изменения списка вызывайте save_tasks.

Например, после добавления:

То же самое после done/delete/undone.

</details>