with open("practice_log.txt", "w", encoding="utf-8") as file:
    file.write("First idea\n")
with open("practice_log.txt", "a", encoding="utf-8") as file:
    file.write("Second idea\n")
with open("practice_log.txt", "r", encoding="utf-8") as file:
    restored = file.read()
print(repr(restored))
assert restored == "First idea\nSecond idea\n"

The final read supplies persistence evidence. Appending alone would accumulate another second line on each run; this script deliberately resets its known fixture first.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

with open("practice_log.txt", "w", encoding="utf-8") as file:
    file.write("Run one\n")
with open("practice_log.txt", "a", encoding="utf-8") as file:
    file.write("Run two\n")
with open("practice_log.txt", encoding="utf-8") as file:
    print(file.read(), end="")

The change preserves earlier content while adding a new line. A context manager closes the file but does not protect content from a deliberately truncating mode.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

import csv

record = {"name": "Maya", "amount": "2.50", "note": 'Lunch, "small" drink'}
with open("practice.csv", "w", encoding="utf-8", newline="") as file:
    writer = csv.DictWriter(file, fieldnames=["name", "amount", "note"])
    writer.writeheader()
    writer.writerow(record)
with open("practice.csv", encoding="utf-8", newline="") as file:
    restored = next(csv.DictReader(file))
assert restored == record
print(restored["note"])
print(type(restored["amount"]).__name__)

The CSV module follows delimiter and quote rules. An ordinary reader preserves field text but does not independently validate a currency amount.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

import json

def decode_players(text):
    data = json.loads(text)
    if type(data) is not list:
        raise ValueError("Use a list of records")
    for row in data:
        if type(row) is not dict or set(row) != {"name", "score"}:
            raise ValueError("Use name and score fields")
        if type(row["name"]) is not str or not row["name"].strip():
            raise ValueError("Use a non-blank name")
        if type(row["score"]) is not int or not 0 <= row["score"] <= 10:
            raise ValueError("Use an integer score from 0 to 10")
    return data

print(decode_players('[{"name":"Maya","score":8}]'))

Every stage has a purpose: parsing syntax, checking collection shape and validating record values. An empty list is permitted under this contract.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def parse_quantity(text):
    quantity = int(text)
    if not 0 <= quantity <= 20:
        raise ValueError("Use quantity 0 to 20")
    return quantity

for text in ["bad", "21", "0", "20"]:
    try:
        quantity = parse_quantity(text)
    except ValueError:
        print("Rejected:", text)
    else:
        print("Accepted:", quantity)

The caller catches the expected ValueError and controls feedback. Conversion and range remain distinct even though the demonstration gives both rejection routes a short message.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def parse_score(text):
    score = int(text)
    if not 0 <= score <= 10:
        raise ValueError("Use 0 to 10")
    return score

scores = [8]
for text in ["11", "0"]:
    before = scores.copy()
    try:
        candidate = parse_score(text)
    except ValueError:
        assert scores == before
        print("Rejected without changing scores")
    else:
        scores.append(candidate)
print(scores)

The parser returns only an acceptable value. The rejected candidate never reaches the mutation. A copy of this flat integer list is sufficient to compare its before and after values.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

from pathlib import Path

folder = Path("practice_data")
folder.mkdir(parents=True, exist_ok=True)
path = folder / "notes.txt"
path.write_text("café\n", encoding="utf-8")
print(path.name, path.stem, path.suffix)
print(path.read_text(encoding="utf-8"), end="")
print("Proposed export:", path.with_suffix(".csv").name)
print("Text still exists:", path.is_file())

Joining and suffix changes build Path objects. mkdir and write_text perform filesystem operations. Relative practice_data is based on the current working directory.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

from datetime import date
import re

def parse_day(text):
    if not re.fullmatch(r"[0-9]{4}-[0-9]{2}-[0-9]{2}", text):
        raise ValueError("Use YYYY-MM-DD")
    return date.fromisoformat(text)

start = parse_day("2026-12-31")
end = parse_day("2027-01-01")
print("Elapsed days:", (end - start).days)
print("Leap date:", parse_day("2024-02-29"))

Calendar objects handle different month lengths and year boundaries. The parser’s exact-format requirement is stricter than all forms the standard ISO parser supports.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

import unittest

def parse_count(text):
    value = int(text)
    if not 0 <= value <= 10:
        raise ValueError("Use 0 to 10")
    return value

class CountTests(unittest.TestCase):
    def test_accepted(self):
        for value in [0, 1, 9, 10]:
            with self.subTest(value=value):
                self.assertEqual(parse_count(str(value)), value)

    def test_rejected(self):
        for text in ["-1", "11", "ten", ""]:
            with self.subTest(text=text):
                with self.assertRaises(ValueError):
                    parse_count(text)

if __name__ == "__main__":
    unittest.main()

Tests distinguish the endpoints rather than mirroring an incorrect condition. subTest labels failures for a particular input. A passing suite covers these stated cases, not every possible application requirement.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

from pathlib import Path
from tempfile import TemporaryDirectory
import json
import unittest

class JsonTests(unittest.TestCase):
    def setUp(self):
        self.temporary = TemporaryDirectory()
        self.addCleanup(self.temporary.cleanup)
        self.path = Path(self.temporary.name) / "practice.json"

    def round_trip(self, expected):
        with self.path.open("w", encoding="utf-8") as file:
            json.dump(expected, file, ensure_ascii=False)
        with self.path.open(encoding="utf-8") as file:
            actual = json.load(file)
        self.assertEqual(actual, expected)

    def test_unicode_record(self):
        self.round_trip([{"note": "café", "amount_cents": 250}])

    def test_empty(self):
        self.round_trip([])

if __name__ == "__main__":
    unittest.main()

Each test gets fresh resources and reads from disk. The round-trip helper is not discovered as a test because its name does not start test_.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

from pathlib import Path
from tempfile import TemporaryDirectory
from model import build_expense, total_cents, money
from storage import save_expenses, load_expenses

rows = [build_expense("2026-10-01", "food", "0.10", "A"),
        build_expense("2026-10-02", "travel", "0.20", "B")]
with TemporaryDirectory() as folder:
    path = Path(folder) / "expenses.json"
    save_expenses(path, rows)
    restored = load_expenses(path)
    assert restored == rows
    assert total_cents(restored) == 30
    print("Reloaded total:", money(total_cents(restored)))

The check tests connected validation, storage and calculation. The manual quit-and-reopen workflow also verifies the application entry point and actual chosen save location.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

import unittest

def category_totals(expenses):
    totals = {}
    for row in expenses:
        category = row["category"]
        totals[category] = totals.get(category, 0) + row["amount_cents"]
    return totals

class CategoryTests(unittest.TestCase):
    def test_empty(self):
        self.assertEqual(category_totals([]), {})

    def test_groups_without_mutation(self):
        rows = [{"category": "food", "amount_cents": 10},
                {"category": "food", "amount_cents": 20},
                {"category": "travel", "amount_cents": 50}]
        before = [row.copy() for row in rows]
        self.assertEqual(category_totals(rows), {"food": 30, "travel": 50})
        self.assertEqual(rows, before)

if __name__ == "__main__":
    unittest.main()

The helper creates a new output dictionary and leaves the supplied records untouched. The test uses a deliberately small calculation fixture; full expense schema validation belongs to the model boundary.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.