Class Methods, Static Methods and Properties

class Pizza:
    def __init__(self, toppings):
        self.toppings = toppings

    def describe(self):                     # instance method — needs a specific pizza
        return f"Pizza with {', '.join(self.toppings)}"

    @classmethod
    def margherita(cls):                    # class method — receives the CLASS, not an instance
        return cls(["tomato", "mozzarella", "basil"])

    @staticmethod
    def is_valid_topping(topping):          # static method — receives NEITHER
        return topping.lower() not in {"pineapple"}

p = Pizza.margherita()          # an alternate way to construct a Pizza, no instance needed yet
print(p.describe())             # "Pizza with tomato, mozzarella, basil"
print(Pizza.is_valid_topping("pineapple"))   # False

class User:
    def __init__(self, username, email, is_admin=False):
        self.username = username
        self.email = email
        self.is_admin = is_admin

    @classmethod
    def from_api_response(cls, data):
        return cls(
            username=data["user_name"],
            email=data["contact_email"],
            is_admin=data.get("role") == "admin",
        )

    @classmethod
    def guest(cls):
        return cls(username="guest", email="")

api_data = {"user_name": "asha", "contact_email": "asha@example.com", "role": "admin"}
u1 = User.from_api_response(api_data)
u2 = User.guest()

class Pizza:
    @staticmethod
    def is_valid_topping(topping):
        banned = {"pineapple", "anchovy"}
        return topping.lower() not in banned

# Callable from the class, without needing to build a Pizza first:
print(Pizza.is_valid_topping("mushroom"))   # True

# Also callable from an instance — works, but doesn't use the instance at all
p = Pizza()
print(p.is_valid_topping("pineapple"))      # False

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        return self.width * self.height

r = Rectangle(4, 5)
print(r.get_area())     # 20 — has to be called as a method

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width * self.height

r = Rectangle(4, 5)
print(r.area)            # 20 — no parentheses! Reads exactly like a data attribute
r.area = 30               # AttributeError — this property has no setter yet (see below)

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self.height = height

    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, value):
        if value <= 0:
            raise ValueError("width must be positive")
        self._width = value

r = Rectangle(4, 5)
r.width = 10        # runs the setter — validated
r.width = -3        # ValueError: width must be positive

A Subscription class originally stores monthly_price as a plain public attribute, used directly across dozens of call sites throughout the codebase. A new business rule arrives: the price must never be set below the plan's configured minimum, and every assignment needs to log a price-change event for billing audit purposes.

class Subscription:
    def __init__(self, plan_minimum, monthly_price):
        self.plan_minimum = plan_minimum
        self.monthly_price = monthly_price

class Subscription:
    def __init__(self, plan_minimum, monthly_price):
        self.plan_minimum = plan_minimum
        self._monthly_price = monthly_price

    @property
    def monthly_price(self):
        return self._monthly_price

    @monthly_price.setter
    def monthly_price(self, value):
        if value < self.plan_minimum:
            raise ValueError(f"Price cannot go below the plan minimum of ${self.plan_minimum}")
        log_price_change(self._monthly_price, value)
        self._monthly_price = value

Why this mattered

Every one of the dozens of existing call sites reading or writing sub.monthly_price = ... continued working with zero changes — the property is indistinguishable from a plain attribute to calling code. Had the class instead switched to get_monthly_price()/set_monthly_price() methods (the pattern from languages without properties), every single call site across the codebase would have needed updating in the same PR — a far larger, riskier change for what is fundamentally an internal implementation detail.