Python To-Do List Project Syllabus

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.

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.

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.

When viewing tasks, how would you visually distinguish completed from incomplete tasks in a console app?

Check each task's `done` boolean and render a marker, e.g. `"[x]"` if `task["done"]` is True else `"[ ]"`, prefixed before the title.

What should the View Tasks feature do when the task list is empty, and why is this an important edge case?

It should print a friendly message such as "No tasks found" instead of nothing. Handling the empty case prevents confusing blank output and is a common edge case testers check.

For "Mark Task as Complete," how do you convert a user-entered 1-based task number into the correct list index, and what bounds check is needed?

Subtract 1: `index = number - 1`. Validate that `0 <= index < len(tasks)` before accessing, to avoid an IndexError or modifying the wrong/nonexistent task.

Write the core line that marks the task at position `index` as complete in a list of task dictionaries.

`tasks[index]["done"] = True`. This sets the `done` key of the selected task dictionary to True.

What Python exception is raised when you access a list position that doesn't exist, and how do you guard against it in the complete/delete features?

`IndexError`. Guard against it by validating the index range (`0 <= index < len(tasks)`) before access, or by wrapping access in a `try/except IndexError` block.

For the "Delete Task" feature, contrast `del tasks[index]`, `tasks.pop(index)`, and `tasks.remove(value)`.

`del tasks[index]` removes by position and returns nothing. `tasks.pop(index)` removes by position and returns the removed item. `tasks.remove(value)` removes the first element equal to `value` (by value, not index).

Why can deleting tasks while iterating forward over the same list with `for` cause skipped items, and what is a safe alternative?

Removing an element shifts later elements left, so the loop's advancing index skips the item that moved into the freed slot. Safe alternatives: iterate over a copy, build a new filtered list with a comprehension, or iterate in reverse.

How would you delete all completed tasks at once using a list comprehension?

Rebuild the list keeping only incomplete tasks: `tasks = [t for t in tasks if not t["done"]]`. This creates a new list excluding every task whose `done` value is True.

What is the difference between unit testing and integration testing in the context of the to-do app?

Unit testing verifies a single function in isolation (e.g., `add_task` adds one item). Integration testing verifies that multiple components work together correctly (e.g., add then view then delete behave consistently end-to-end).

Name the two most common Python testing frameworks/modules and one distinguishing feature of each.

`unittest` (built into the standard library, class-based with `assertEqual` etc.) and `pytest` (third-party, uses plain `assert` statements and concise fixtures). pytest requires installation; unittest does not.

In Python's `unittest`, what base class do test cases inherit from and what naming prefix must test methods use?

Test cases inherit from `unittest.TestCase`, and each test method name must start with the prefix `test` (e.g., `def test_add_task(self):`) so the runner discovers it.

Describe the Arrange-Act-Assert (AAA) pattern for structuring a single test case.

Arrange: set up inputs and state (e.g., create an empty task list). Act: invoke the function under test (e.g., call `add_task`). Assert: verify the outcome (e.g., check the list length and contents are correct).

Write a one-line assertion (pytest style) verifying that after adding a task, the list length is 1.

`assert len(tasks) == 1`. After calling `add_task`, this confirms exactly one task was appended to the previously empty list.

What command runs all tests with pytest, and what command runs unittest test discovery from the command line?

pytest: simply run `pytest` (it auto-discovers `test_*.py`). unittest: run `python -m unittest` or `python -m unittest discover`.

In test output, what is the difference between a test "failure" and a test "error"?

A failure means an assertion was checked but the actual result did not match the expected value. An error means the test raised an unexpected exception before/instead of reaching the assertion (a problem in the code or the test setup).

What is code coverage, and roughly what does it measure?

Code coverage is the percentage of source code lines (or branches) executed while the test suite runs. It is measured with tools like `coverage.py` and indicates how much of the code is exercised by tests—though high coverage does not guarantee correctness.

Define a "bug" and distinguish a syntax error from a logic error in Python.

A bug is any defect causing incorrect behavior. A syntax error violates Python's grammar so the code won't even run/parse. A logic error runs without crashing but produces the wrong result because the algorithm or condition is incorrect.

What is a traceback in Python and how does it help during the Fix Bugs stage?

A traceback is the error report Python prints when an unhandled exception occurs, listing the call stack from the entry point down to the line that raised the error. It pinpoints the file, line number, and exception type to locate the bug.

Name two debugging techniques: the simplest print-based one and the standard-library interactive debugger.

Print debugging: inserting `print()` statements to inspect variable values at runtime. Interactive debugging: using `pdb` (e.g., `import pdb; pdb.set_trace()` or `breakpoint()`) to step through code, inspect state, and set breakpoints.

What is a regression, and how do automated tests help prevent regressions when fixing bugs?

A regression is when a previously working feature breaks due to a new change. Re-running the automated test suite after each fix catches regressions immediately, because broken behavior surfaces as a newly failing test.

What does it mean to "package" a Python application, and which two files commonly configure modern packaging?

Packaging means bundling code, metadata, and dependencies into a distributable, installable format. Modern configuration uses `pyproject.toml` (and historically `setup.py`/`setup.cfg`) to declare the project name, version, dependencies, and entry points.

What are the two standard Python distribution formats produced for PyPI, and which is the preferred binary format?

An sdist (source distribution, a `.tar.gz`) and a wheel (`.whl`). The wheel is the preferred built/binary format because it installs faster without a build step.

What is semantic versioning (SemVer), and what do the three numbers in $MAJOR.MINOR.PATCH$ signify?

SemVer is a versioning convention $MAJOR.MINOR.PATCH$: increment MAJOR for incompatible (breaking) API changes, MINOR for new backward-compatible features, and PATCH for backward-compatible bug fixes.

Contrast packaging a console-distributable wheel (via pip) with bundling a standalone executable using a tool like PyInstaller.

A wheel requires the end user to have Python and pip installed, then `pip install` the package. PyInstaller bundles the interpreter and dependencies into a single self-contained executable that runs on machines without Python installed.

What is PyPI, and what command-line tool is conventionally used to upload a built distribution to it?

PyPI is the Python Package Index, the public repository for Python packages. `twine` is the standard tool used to securely upload built sdists and wheels, e.g. `twine upload dist/*`.

List three common channels for distributing a finished to-do app to users.

Publishing to PyPI for `pip install`; sharing the source repository (e.g., GitHub) with install instructions; and distributing a standalone executable/installer built with a tool like PyInstaller. (Containerizing with Docker is another option.)

Name three effective methods for collecting user feedback after release, and explain why feedback drives the Implement Improvements stage.

Methods: a GitHub issue tracker, surveys/feedback forms, and in-app analytics or direct user interviews. Feedback identifies real bugs, pain points, and desired features, so improvements are prioritized by actual user needs rather than guesswork—closing the iterative development loop.