class Robot:
    def __init__(self, name, battery):
        self.name = name
        self.battery = battery
        self.history = []

scout = Robot("Scout", 80)
rover = Robot("Rover", 60)
scout.history.append("started")
print(scout.name, scout.history)
print(rover.name, rover.history)

The initializer creates a new list per instance. The example assumes suitable name and battery arguments; a production boundary would validate them.

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

class ReadingList:
    def __init__(self, name):
        self.name = name
        self.titles = []

maya = ReadingList("Maya")
noor = ReadingList("Noor")
alias = maya
alias.titles.append("Python Adventures")
print(maya.titles)
print(noor.titles)
print(alias is maya, maya is noor)

The two initializers created distinct lists. The alias deliberately refers to Maya’s object, so its mutation is visible through Maya too.

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

class Battery:
    def __init__(self, level=100):
        if type(level) is not int or not 0 <= level <= 100:
            raise ValueError("Use 0 to 100")
        self._level = level

    @property
    def level(self):
        return self._level

    def use_energy(self, amount):
        if type(amount) is not int or not 0 <= amount <= self._level:
            raise ValueError("Invalid consumption")
        self._level -= amount
        return self._level

battery = Battery(80)
print(battery.use_energy(20))
before = battery.level
try:
    battery.use_energy(61)
except ValueError:
    assert battery.level == before
print("After rejection:", battery.level)

The property exposes observation while the method owns valid transitions. The underscore is a design convention, not a security barrier.

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

class ReadingList:
    def __init__(self):
        self._titles = []

    def add(self, title):
        if type(title) is not str or not title.strip():
            raise ValueError("Use non-blank text")
        self._titles.append(title.strip())

    def titles(self):
        return tuple(self._titles)

reading = ReadingList()
reading.add("Python Adventures")
snapshot = reading.titles()
reading.add("Robots in Action")
print("Earlier:", snapshot)
print("Current:", reading.titles())

The supported add method preserves the title rule. Returning the actual internal list would allow unchecked appends. A tuple of mutable records would require further attention to their contents.

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

class Robot:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return f"Robot {self.name}"

class DeliveryRobot(Robot):
    def __init__(self, name, destination):
        super().__init__(name)
        self.destination = destination

    def describe(self):
        return super().describe() + f" delivering to {self.destination}"

robot = DeliveryRobot("Courier", "Library")
print(robot.describe())
print(isinstance(robot, Robot))

The override remains callable in the same way and returns the same kind of result. The base initialisation supplies inherited state.

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

class DeliveryRobot:
    def describe(self):
        return "Delivering a book"

class SurveyRobot:
    def describe(self):
        return "Measuring a room"

def report(objects):
    return [obj.describe() for obj in objects]

print(report([DeliveryRobot(), SurveyRobot()]))

Polymorphism can work without shared implementation inheritance. Compatibility still matters; the function assumes a suitable describe method on each supplied object.

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

class FixedSensor:
    def __init__(self, reading):
        self._reading = reading

    def read(self):
        return self._reading

class Robot:
    def __init__(self, sensor):
        self._sensor = sensor

    def distance(self):
        return self._sensor.read()

print(Robot(FixedSensor(25)).distance())
print(Robot(FixedSensor(40)).distance())

Supplying a collaborator makes the dependency explicit and easy to replace in tests. The robot owns the delegation, not the sensor’s measurement implementation.

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 dataclasses import dataclass, field

@dataclass
class ReadingList:
    name: str
    titles: list[str] = field(default_factory=list)

a = ReadingList("Maya")
b = ReadingList("Maya")
print("Initially:", a == b, a is b)
a.titles.append("Python Adventures")
print(a.titles, b.titles)
print("After change:", a == b)

The generated equality observes field values. Each omitted titles argument receives a fresh list. An explicitly shared caller list could still create aliasing.

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 dataclasses import dataclass, FrozenInstanceError

@dataclass(frozen=True)
class Book:
    copy_id: str
    title: str

    def __post_init__(self):
        if type(self.title) is not str or not self.title.strip():
            raise ValueError("Use a non-blank title")

book = Book("B001", "Python Adventures")
try:
    book.title = "Changed"
except FrozenInstanceError:
    print("Ordinary reassignment blocked")
print(book.title)

Frozen fields protect ordinary record use. This small exercise validates the title only; ID format and collection uniqueness need their own explicit requirements.

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 find_first(values: list[int], target: int) -> int | None:
    """Return the first target index or None; do not mutate values."""
    for index, value in enumerate(values):
        if value == target:
            return index
    return None

values = [8, 5, 8]
position = find_first(values, 8)
if position is not None:
    print("Found at:", position)
print("Absent:", find_first(values, 99))
print("Input:", values)

The union captures the two result possibilities. Documentation adds first-match and non-mutation meaning that types alone do not express.

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
from app import demo_library

library = demo_library()
loan = library.lend("B001", "M001", date(2026, 10, 1))
assert loan.due_on == date(2026, 10, 15)
assert not library.available("B001")
assert library.available("B002")
before = library.active_loans()
try:
    library.lend("B001", "M002", date(2026, 10, 1))
except ValueError:
    assert library.active_loans() == before
else:
    raise AssertionError("Repeated loan was not rejected")
assert library.overdue(date(2026, 10, 15)) == ()
assert len(library.overdue(date(2026, 10, 16))) == 1
library.return_book("B001", date(2026, 10, 16))
assert library.available("B001")
print("Library checks passed")

The check inspects both return values and state transitions. B002 remains independently available despite sharing B001’s title. Session records are not saved across restarts.

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
from app import demo_library

library = demo_library()
day = date(2026, 10, 1)
library.lend("B001", "M001", day)
library.lend("B002", "M001", day)
try:
    library.lend("B003", "M001", day)
except ValueError:
    print("Third active loan rejected")
else:
    raise AssertionError("Limit not enforced")
assert len(library.active_loans()) == 2
library.return_book("B001", day)
library.lend("B003", "M001", day)
assert len(library.active_loans()) == 2
assert demo_library().active_loans() == ()
print("Capacity and independence checks passed")

Fresh per-instance dictionaries prevent one library’s loans leaking into another. The handover tests communication as well as code: users should know which file starts the app and what is retained.

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