Python Instance Methods

Five runnable programs that move from a basic form to a reusable boundary. Keep external effects separate, validate data at the edge, and make every successful or rejected result visible to the caller.

This focused Python OOP example demonstrates one concrete rule. Run it first, then change an input or value and compare the new result with the contract.

Python

class Book:
    def __init__(self, title: str) -> None:
        self.title = title

print(Book("Python").title)

Python

Try next: use a boundary value or an invalid value where the example owns validation, then keep the outcome explicit for its caller.

This focused Python OOP example demonstrates one concrete rule. Run it first, then change an input or value and compare the new result with the contract.

Python

class Counter:
    def __init__(self) -> None:
        self.value = 0
    def increment(self) -> None:
        self.value += 1

c = Counter(); c.increment(); print(c.value)

1

Try next: use a boundary value or an invalid value where the example owns validation, then keep the outcome explicit for its caller.

This focused Python OOP example demonstrates one concrete rule. Run it first, then change an input or value and compare the new result with the contract.

Python

from dataclasses import dataclass

@dataclass(frozen=True)
class Money:
    cents: int

print(Money(499))

Money(cents=499)

Try next: use a boundary value or an invalid value where the example owns validation, then keep the outcome explicit for its caller.

This focused Python OOP example demonstrates one concrete rule. Run it first, then change an input or value and compare the new result with the contract.

Python

class Formatter:
    def format(self, value: str) -> str: return value.upper()
class Report:
    def __init__(self, formatter: Formatter) -> None: self._formatter = formatter
    def render(self, title: str) -> str: return self._formatter.format(title)

print(Report(Formatter()).render("weekly"))

WEEKLY

Try next: use a boundary value or an invalid value where the example owns validation, then keep the outcome explicit for its caller.

This focused Python OOP example demonstrates one concrete rule. Run it first, then change an input or value and compare the new result with the contract.

Python

class Inventory:
    def __init__(self, available: int) -> None: self._available = available
    def reserve(self, amount: int) -> None:
        if amount <= 0 or amount > self._available: raise ValueError("invalid reservation")
        self._available -= amount

i=Inventory(3); i.reserve(2); print("reserved")

reserved

Try next: use a boundary value or an invalid value where the example owns validation, then keep the outcome explicit for its caller.

Start by naming the value the next line depends on. This keeps the lesson input explicit before we apply a transformation or call an external boundary. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

lesson = "Python OOP Instance Methods"
print(lesson.upper())

PYTHON OOP INSTANCE METHODS

Try next: Replace the sample value with one from your own notes, predict the result, and then run it.

A small guard makes the allowed and rejected path visible. We want a caller to receive an intentional result instead of discovering an unexplained failure later. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

def accepted(value: str) -> bool:
    return bool(value.strip())

print(accepted("Python OOP Instance Methods"))

True

Try next: Try an empty value as well as the normal value and describe why the two outcomes differ.

This step returns a value instead of mixing the rule with display or storage work. That separation gives us a small unit we can run, test, and reuse. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

def double(value: int) -> int:
    return value * 2

print(double(6))

12

Try next: Call the same rule twice with different inputs and confirm that each result depends only on its input.

Use a named branch where the business rule changes. A future reader should be able to point at the condition and state the result for both sides. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

score = 7
result = "ready" if score >= 5 else "review"
print(result)

ready

Try next: Change the boundary value by one and explain exactly which branch becomes active.

Collections become safer when we can see which value is read, which value is derived, and whether the original collection remains owned by the caller. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

lessons = ["Python OOP Instance Methods", "boundary"]
print(" | ".join(lessons))

Python OOP Instance Methods | boundary

Try next: Add one more item and predict the derived result before executing the code.

A named outcome is easier to test than an implied side effect. We can now distinguish a successful path from a rejected path without guessing from console noise. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

outcome = {"status": "ready", "lesson": "Python OOP Instance Methods"}
print(outcome["status"])

ready

Try next: Rename the outcome in your own words while preserving the same success and failure rule.

Work through one value at a time. The point is not to memorize syntax; it is to see how the accumulator or output changes after each repeatable step. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

total = 0
for value in [1, 2, 3]:
    total += value

print(total)

6

Try next: Use a shorter collection first, then add one value and trace the extra iteration aloud.

The core rule prepares a value, while the outer line decides how to show it. That keeps the result usable by a UI, test, API, or command-line caller. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

def display(value: str) -> str:
    return f"Lesson: {value}"

print(display("Python OOP Instance Methods"))

Lesson: Python OOP Instance Methods

Try next: Change only the display text and verify that the underlying rule and result stay unchanged.

A useful example includes the nearest boundary, not only the happy path. We are making the behavior inspectable before a real caller relies on it. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

def quantity(value: int) -> int:
    if value < 1:
        raise ValueError("quantity must be positive")
    return value

print(quantity(1))

1

Try next: Try the lowest supported value and then one value just outside the accepted range.

A compact assertion turns the lesson into a repeatable promise. It helps us catch a changed rule before a larger program hides the source of the mistake. We are applying that habit while revisiting Python OOP: Instance Methods.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Python

result = "Python OOP Instance Methods".upper()
assert result == "PYTHON OOP INSTANCE METHODS"
print("contract holds")

contract holds

Try next: Deliberately change the expected value once, observe the failed check, and then restore the correct contract.

Python Instance Methods is useful only when its contract stays visible. Before adding another layer, state the input, the normal output, the boundary value, the failure behavior, and the owner of every mutable resource. This makes a small example transferable to a service, command-line program, job worker, or test.

Trace each example in order: identify the supplied value, follow the branch or call boundary, and predict the output before executing it. Then change one input. If you cannot explain the new result, replace hidden state or a compact shortcut with an explicit named rule.

• Test one normal input and write the exact expected result.
• Test the nearest boundary or empty value and name the intended outcome.
• Reject invalid input deliberately; do not allow a silent fallback to look like success.
• Keep printing, storage, credentials, and network work outside the reusable core rule.
• Explain why this feature makes the next reader's job safer, not only shorter.

Professional Python is not about using the most compact feature. It is about preserving a clear data flow, a small responsibility, and an observable failure path while the program grows.

• Copying an advanced feature without identifying the responsibility it owns.
• Hiding mutation, external work, or error handling behind a short expression.
• Treating a printed line as a complete contract instead of returning or exposing a testable result.
• Adding private data to an example output or exception message.