Python To-Do List Project Syllabus

To-Do List Project syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for To-Do List Project in Python, not a summary of it.

1. 1

   Set Up Environment

   2 topics

   • Install Python
   • Set Up Virtual Environment
2. 2

   Plan the Application

   2 topics

   • Define Features
     • Add Task
     • View Tasks
     • Mark Task as Complete
     • Delete Task
   • Design Data Structure
     • Choose Data Storage Method
     • Define Task Attributes
3. 3

   Set Up Project Structure

   2 topics

   • Create Main Application File
   • Create Modules for Different Features
4. 4

   Implement Features

   4 topics

   • Add Task Feature
     • Create Function to Add Task
     • Update Data Storage
   • View Tasks Feature
     • Create Function to List Tasks
     • Format Task Display
   • Mark Task as Complete Feature
     • Create Function to Update Task Status
     • Update Data Storage
   • Delete Task Feature
     • Create Function to Delete Task
     • Update Data Storage
5. 5

   Test the Application

   3 topics

   • Write Test Cases
   • Run Tests
   • Fix Bugs
6. 6

   Deploy the Application

   2 topics

   • Package the Application
   • Distribute to Users
7. 7

   Maintain the Application

   2 topics

   • Collect User Feedback
   • Implement Improvements

To-Do List Project flashcards for Python

23 of 50 cards from the To-Do List Project deck — real questions with worked answers.

1. What is the recommended source for downloading the official Python interpreter, and how do you verify a successful installation from the command line?

   Download from python.org (the official CPython distribution). Verify by running $python --version$ (or $python3 --version$), which prints the installed version string, e.g. Python 3.12.x.

2. On Windows, why is the "Add Python to PATH" checkbox important during installation?

   It adds the Python executable directory to the system PATH environment variable so you can invoke `python` and `pip` from any terminal directory without specifying the full install path.

3. What command verifies that pip (Python's package installer) is available, and what does pip stand for?

   Run `pip --version` (or `python -m pip --version`). pip stands for "Pip Installs Packages," the standard package-management tool for Python.

4. What is a Python virtual environment and what problem does it solve?

   A virtual environment is an isolated directory containing its own Python interpreter and installed packages. It solves dependency conflicts by keeping each project's packages separate from the global installation and other projects.

5. Which standard-library module creates virtual environments, and what is the full command to create one named `venv`?

   The `venv` module. Command: `python -m venv venv` (the second `venv` is the target folder name).

6. How do you activate a virtual environment on macOS/Linux versus Windows?

   macOS/Linux: `source venv/bin/activate`. Windows (cmd/PowerShell): `venv\Scripts\activate`. Once active, the shell prompt is typically prefixed with the environment name.

7. What command deactivates an active virtual environment, regardless of operating system?

   Simply run `deactivate`. This restores the shell to use the global/system Python interpreter.

8. How do you record and later reproduce a project's exact dependencies using pip?

   Record with `pip freeze > requirements.txt` to capture installed packages and pinned versions; reproduce with `pip install -r requirements.txt` in a fresh environment.

9. In the requirements-gathering (Define Features) stage of a to-do app, what is the minimal set of core CRUD-style features a student should list?

   Add a task (Create), View tasks (Read), Mark a task complete (Update), and Delete a task (Delete). These map to the four CRUD operations: Create, Read, Update, Delete.

10. What is the difference between a functional requirement and a non-functional requirement when defining features?

    A functional requirement describes WHAT the system must do (e.g., "add a task"). A non-functional requirement describes HOW it performs or a quality constraint (e.g., persistence, speed, usability, reliability).

11. When designing the data structure for a single to-do task, what fields are commonly stored?

    Typically: a unique id, a title/description (string), a completed/done status (boolean), and optionally a creation timestamp, due date, and priority.

12. Why is a Python dictionary a natural choice for representing one task, and a list a natural choice for the whole to-do collection?

    A dictionary maps named keys (e.g., 'title', 'done') to values, modeling a record with labeled fields. A list maintains an ordered, indexable, mutable sequence of those task dictionaries, allowing iteration and indexed access.

13. Compare a Python list and a tuple for storing tasks: which is appropriate for a mutable to-do list and why?

    A list is appropriate because it is mutable—tasks can be added, removed, or modified in place. A tuple is immutable, so it cannot grow or change after creation, making it unsuitable for a dynamic task collection.

14. What is the Big-O time complexity of appending a task to the end of a Python list versus deleting a task by index?

    Appending to the end is amortized $O(1)$. Deleting an element by index (or value) is $O(n)$ because subsequent elements must be shifted to fill the gap.

15. Why might a dictionary keyed by task id give faster lookups than a list when retrieving a specific task?

    Dictionary key lookup is average-case $O(1)$ (hash-based), whereas searching a list for a task by id requires a linear scan that is $O(n)$.

16. What is the conventional name for the entry-point file of a Python application, and what idiom guards its startup code?

    The entry-point file is conventionally `main.py`. Startup code is guarded by `if __name__ == "__main__":` so it runs only when the file is executed directly, not when imported as a module.

17. Explain what the variable `__name__` evaluates to when a file is run directly versus imported.

    When a file is run directly, `__name__` equals the string `"__main__"`. When the file is imported as a module, `__name__` equals the module's name (the filename without the .py extension).

18. What is a Python module and how does it differ from a package?

    A module is a single `.py` file containing reusable code (functions, classes, variables). A package is a directory of modules, traditionally containing an `__init__.py` file, that groups related modules under one namespace.

19. When splitting a to-do app into modules for different features, what is a clean separation of concerns you might use?

    Separate by responsibility: e.g., a `storage` module for load/save persistence, a `tasks` module for add/view/complete/delete logic, and `main.py` for the user interface and program flow that imports the others.

20. What two import syntaxes let `main.py` use a function `add_task` defined in a module `tasks.py`?

    Either `import tasks` then call `tasks.add_task(...)`, or `from tasks import add_task` then call `add_task(...)` directly.

21. Write a minimal Python function signature for an "add task" feature that appends a new uncompleted task to a list.

    `def add_task(tasks, title):` whose body does `tasks.append({"title": title, "done": False})`. It mutates the passed-in `tasks` list, adding a dictionary with the title and a default `done` value of False.

22. Why does appending a dictionary inside a function modify the caller's list without a return statement?

    Lists are passed by object reference; the function receives a reference to the same list object. `append` mutates that shared object in place, so the change is visible to the caller without returning anything.

23. For the "View Tasks" feature, how can you display tasks with a 1-based number while iterating a 0-based list?

    Use `enumerate(tasks, start=1)`, e.g. `for i, task in enumerate(tasks, start=1): print(i, task["title"])`. The `start=1` argument makes the counter begin at 1 for user-friendly numbering.

See more To-Do List Project flashcards →

Planning To-Do List Project for Python

To-Do List Project (Python) FAQ