Инструменты прошлого урока - виртуальные окружения и pip - в этот раз не понадобятся, у проекта нет ни одной внешней библиотеки. Зато понадобятся почти все навыки курса: списки и словари, функции, циклы, условия, работа с файлами и json. Урок двадцать четвёртый - итоговый, и его смысл не в новой теории, а в сборке: из отдельных кирпичей складывается настоящий проект, который запускается, работает и переживает перезапуск. Менеджер задач для консоли выбран не случайно. Список дел люди ведут и на бумаге, и в голове, а вот программа, которая хранит этот список сама, - уже настоящая разработка. К концу урока получится приложение, которым можно пользоваться каждый день: записать дела, отметить сделанное, убрать лишнее и не бояться закрыть терминал.
Задача проекта и план сборки менеджера задач
Любой проект начинается не с кода, а с формулировки. Пока список требований живёт в голове, он неизбежно расползается; стоит выписать его на бумагу - и работа превращается в чек-лист. У менеджера задач пять требований, и звучат они как записка из быта, а не как техническое задание: добавить задачу, показать весь список с номерами и статусами, отметить выполненную, удалить лишнюю, сохранить всё между запусками. Формулировка - уже половина решения, потому что каждая часть списка намекает на отдельный кусок кода.
Почему именно консольное приложение, а не сайт или окно с кнопками? Консоль не тянет за собой лишних зависимостей и не заставляет разбираться с интерфейсом раньше времени. Всё внимание уходит туда, где живёт суть программирования, - на структуру и операции над ней. Для итогового проекта курса это честная расстановка приоритетов: сначала научиться держать сведения в правильной форме, а наводить красоту всегда успеется.
План сборки состоит из четырёх этапов. На первом задачи живут в обычном списке Python, прямо в памяти. На втором появляются четыре функции - по одной на каждую операцию. На третьем список переезжает в файл tasks.json, и проект обретает память, не зависящую от открытого терминала. На четвёртом всё накрывается меню на цикле while, и разрозненные части становятся программой. Порядок здесь принципиален: сначала данные, потом операции, потом внешний мир, потом интерфейс. Каждый этап заканчивается запуском в терминале, и код не растёт быстрее, чем понимание. Приём мелких шагов - возможно, самая полезная привычка из этого урока, она работает и в маленьких скриптах, и в больших сервисах.
Список словарей как хранилище задач
Самая частая ошибка новичка в подобных задачах - завести два параллельных списка: один с текстами, второй со статусами. Проживёт такая конструкция ровно до первого удаления. Индексы разъезжаются, и программа с уверенным видом показывает не то, что есть на самом деле. Правильное хранилище держит задачу целиком в одном месте, и для этого идеально подходит словарь внутри списка:
tasks = [
{"text": "Купить хлеб", "done": False},
{"text": "Дописать отчёт", "done": True},
]
Каждый словарь - одна задача. Ключ text отвечает за описание, ключ done за статус: False значит "ещё в работе", True значит "готово". Почему статус именно логического типа, а не строка "сделано"? Строку легко написать с опечаткой, и сравнение молча перестанет работать, а у bool всего два честных значения, обмануть которые заметно труднее. Пара ключей text и done - это контракт проекта: любая функция, получившая задачу, знает, что внутри лежат описание и флаг, и не гадает при каждом обращении.
У контракта есть и приятное свойство - расширяемость. Когда дойдёт до идей развития, в словарь спокойно добавятся новые ключи вроде приоритета или даты, а старый код продолжит работать, потому что text и done никуда не денутся. Список словарей удобен ещё и тем, что задачи остаются в порядке добавления, а доступ к любой идёт по индексу. Здесь же всплывает вечная арифметика Python: человек нумерует с единицы, язык считает с нуля, значит номер задачи на экране всегда на один больше её индекса в списке.
Функции для добавления просмотра отметки и удаления задач
Четыре операции - четыре функции. Дробить код на функции стоит не ради красоты, а ради спокойствия: каждая маленькая функция проверяется отдельно, и ошибка не размазывается по всей программе. Все они принимают список tasks и меняют его на месте, поэтому возвращать ничего не нужно.
Начать логично с добавления:
def add_task(tasks, text):
task = {"text": text, "done": False}
tasks.append(task)
print("Задача добавлена.")
Новая задача всегда получает done со значением False, и это логично: только что записанное дело ещё не сделано. Дальше просмотр списка:
def show_tasks(tasks):
if not tasks:
print("Список пока пуст.")
return
for number, task in enumerate(tasks, start=1):
status = "выполнена" if task["done"] else "в работе"
print(f"{number}. [{status}] {task['text']}")
Здесь два приёма, которые стоит забрать в копилку. Функция enumerate с параметром start=1 сразу выдаёт номера с единицы, как в блокноте, и ручные счётчики не нужны вовсе. А проверка if not tasks отлавливает пустой список до цикла: без неё пользователь увидит лишь мигающий курсор и решит, что программа зависла. Отметка выполнения и удаление устроены похожим образом:
def complete_task(tasks, number):
index = number - 1
if 0 <= index < len(tasks):
tasks[index]["done"] = True
print("Задача отмечена как выполненная.")
else:
print("Нет задачи с таким номером.")
def delete_task(tasks, number):
index = number - 1
if 0 <= index < len(tasks):
removed = tasks.pop(index)
print("Удалено:", removed["text"])
else:
print("Нет задачи с таким номером.")
Проверка диапазона здесь не перестраховка, а необходимость: пользователь обязательно введёт номер семь, когда задач пять, или вообще напишет слово вместо числа. Метод pop удаляет элемент и заодно возвращает его, поэтому программа успевает вежливо сообщить, что именно пропало из списка. Один нюанс ради честности: печать внутри функций - упрощение, на которое учебный проект имеет право. В больших программах вычисление и вывод разделяют, но на этом этапе мешать их безопаснее для головы.
Сохранение задач в файл tasks.json
У текущей версии есть изъян: после закрытия терминала список живёт ровно ноль секунд. Переменные существуют в оперативной памяти, а память очищается при выходе. Лекарство знакомо по восемнадцатому уроку, где встречались файлы и формат json, - теперь его пора применить в настоящем проекте. Формат json прекрасно ложится на структуру из списка словарей: список превращается в массив, словари - в объекты, True и False - в true и false. Изобретать ничего не требуется, стандартный модуль json делает всё сам:
import json
import os
FILE_NAME = "tasks.json"
def load_tasks():
if os.path.exists(FILE_NAME):
with open(FILE_NAME, "r", encoding="utf-8") as f:
return json.load(f)
return []
def save_tasks(tasks):
with open(FILE_NAME, "w", encoding="utf-8") as f:
json.dump(tasks, f, ensure_ascii=False, indent=2)
Три детали, на которых чаще всего спотыкаются. Аргумент ensure_ascii=False оставляет кириллицу в файле в человеческом виде, иначе русский текст превратится в последовательности вроде \u041a, и читать файл глазами станет мучением. Параметр indent=2 добавляет отступы: на работу программы он не влияет, зато при отладке файл открывается, и внутри виден ровно тот список, который ожидается. Проверка os.path.exists отвечает за самый первый запуск: файла ещё нет, и попытка читать его без проверки обернулась бы исключением, поэтому молча возвращается пустой список.
Хранить задачи в текстовом файле с запятыми тоже можно было бы, но тогда каждую строку пришлось бы разбирать вручную и отдельно договариваться, как отличать выполненное от невыполненного. Json избавляет от этой работы: структура списка словарей записывается и читается в два вызова, а ошибка формата честно сообщается при загрузке. Писать файл логично после каждого изменения, а не только при выходе: запасная страховка стоит копейки, зато внезапно закрытый терминал больше ничего не портит - на диске уже лежит актуальная версия списка.
Меню на цикле while и выборе пункта
Остался интерфейс. Консольное меню строится на связке while True и input: цикл крутится бесконечно, показывает пункты, читает выбор и выполняет нужную ветку через if и elif, а выход делается через break:
def main():
tasks = load_tasks()
print("Менеджер задач запущен.")
while True:
print()
print("1 - показать задачи")
print("2 - добавить задачу")
print("3 - отметить выполненной")
print("4 - удалить задачу")
print("5 - выйти")
choice = input("Выберите пункт: ").strip()
if choice == "1":
show_tasks(tasks)
elif choice == "2":
text = input("Текст задачи: ").strip()
if text:
add_task(tasks, text)
else:
print("Пустую задачу добавить нельзя.")
elif choice == "3":
complete_task(tasks, ask_number())
elif choice == "4":
delete_task(tasks, ask_number())
elif choice == "5":
save_tasks(tasks)
print("Список сохранён. До встречи!")
break
else:
print("Такого пункта нет, введите число от 1 до 5.")
Метод strip() убирает случайные пробелы вокруг ввода: без него вариант " 2 " не совпал бы со строкой "2", и человек попал бы в ветку ошибки, хотя вроде нажал нужную цифру. Сравнение идёт со строкой, а не с числом, потому что input всегда возвращает строку; превращение в int происходит уже внутри ask_number - маленького помощника, который не выпустит пользователя, пока тот не введёт число:
def ask_number():
while True:
raw = input("Номер задачи: ").strip()
if raw.isdigit():
return int(raw)
print("Нужно число, попробуйте ещё раз.")
Ветвь else здесь работает страховкой на любой неожиданный ввод, а заодно гарантирует, что меню снова появится на экране и подскажет допустимые значения. Важная деталь: при выборе пункта 5 программа вызывает save_tasks перед выходом. Формально это дублирование, ведь сохранение уже происходит после каждого изменения, но явная запись при выходе стоит одной строки и лишний раз напоминает, кто в проекте отвечает за порядок на диске.
Полный код итогового проекта одним блоком
Теперь всё складывается в один файл. В финальной версии есть два отличия от учебных фрагментов: вызов save_tasks перенесён прямо в add_task, complete_task и delete_task, чтобы список сохранялся после каждого изменения, а блок if __name__ == "__main__" запускает main только тогда, когда файл исполняют напрямую, а не импортируют. Код готов к копированию целиком:
import json
import os
FILE_NAME = "tasks.json"
def load_tasks():
if os.path.exists(FILE_NAME):
with open(FILE_NAME, "r", encoding="utf-8") as f:
return json.load(f)
return []
def save_tasks(tasks):
with open(FILE_NAME, "w", encoding="utf-8") as f:
json.dump(tasks, f, ensure_ascii=False, indent=2)
def add_task(tasks, text):
tasks.append({"text": text, "done": False})
save_tasks(tasks)
print("Задача добавлена.")
def show_tasks(tasks):
if not tasks:
print("Список пока пуст.")
return
for number, task in enumerate(tasks, start=1):
status = "выполнена" if task["done"] else "в работе"
print(f"{number}. [{status}] {task['text']}")
def complete_task(tasks, number):
index = number - 1
if 0 <= index < len(tasks):
tasks[index]["done"] = True
save_tasks(tasks)
print("Задача отмечена как выполненная.")
else:
print("Нет задачи с таким номером.")
def delete_task(tasks, number):
index = number - 1
if 0 <= index < len(tasks):
removed = tasks.pop(index)
save_tasks(tasks)
print("Удалено:", removed["text"])
else:
print("Нет задачи с таким номером.")
def ask_number():
while True:
raw = input("Номер задачи: ").strip()
if raw.isdigit():
return int(raw)
print("Нужно число, попробуйте ещё раз.")
def main():
tasks = load_tasks()
print("Менеджер задач запущен.")
while True:
print()
print("1 - показать задачи")
print("2 - добавить задачу")
print("3 - отметить выполненной")
print("4 - удалить задачу")
print("5 - выйти")
choice = input("Выберите пункт: ").strip()
if choice == "1":
show_tasks(tasks)
elif choice == "2":
text = input("Текст задачи: ").strip()
if text:
add_task(tasks, text)
else:
print("Пустую задачу добавить нельзя.")
elif choice == "3":
complete_task(tasks, ask_number())
elif choice == "4":
delete_task(tasks, ask_number())
elif choice == "5":
save_tasks(tasks)
print("Список сохранён. До встречи!")
break
else:
print("Такого пункта нет, введите число от 1 до 5.")
if __name__ == "__main__":
main()
Проверять проект лучше по сценарию, а не глазами: запустить файл, добавить две задачи, показать список, отметить первую выполненной, удалить вторую, выйти через пункт 5. Потом запустить снова и убедиться, что список на месте, а у первой задачи статус "выполнена". Последний шаг - открыть tasks.json в блокноте и посмотреть на структуру глазами: момент, когда становится видно, как программа раскладывает сведения по полкам, запоминается надолго. Код стоит не копировать, а набрать руками: пальцы запоминают структуру лучше, чем глаза, и каждая опечатка становится маленьким уроком чтения сообщений об ошибках.
Идеи расширения проекта после сдачи работы
Готовое приложение - не финиш, а фундамент, и дорабатывать его можно бесконечно. Структура словарей специально оставляет место для новых ключей, поэтому каждое из направлений ниже ложится на проект без переделки основы. Вот варианты на вырост:
- добавить каждой задаче ключ priority с числом важности и выводить сначала самые срочные дела;
- прикрутить дедлайны через модуль datetime, сохраняя дату в отдельном ключе и помечая просроченные задачи при показе;
- научить программу искать по подстроке, чтобы вместо всего списка печатать только совпадения;
- ввести категории или теги, отделяющие работу от дома и учёбы;
- собрать статистику, считая выполненные задачи за день или за неделю;
- разрешить редактировать текст существующей задачи по её номеру.
Каждый пункт - это маленький проект с той же схемой, что и весь сегодняшний урок: изменить структуру словаря, подправить функции, проверить запуск. Если в ход пойдут сторонние библиотеки, например tabulate для аккуратных таблиц в консоли, пригодится виртуальное окружение из прошлого урока - зависимости сохраняются в requirements.txt, и проект остаётся переносимым на другой компьютер. А следующий, последний урок курса как раз о том, куда двигаться дальше: веб-разработка, автоматизация рутины, работа с таблицами - у каждого пути теперь есть общая база под ногами.
Ещё в начале курса список казался просто набором квадратных скобок, а теперь это хранилище для настоящей программы, которая живёт на диске и переживает перезапуск. Итоговый проект собран, проверен и работает. Самый подходящий момент открыть терминал, запустить менеджер задач и записать в него первое дело - придумать, что писать дальше.