basic_class.py

"""
A class is made up of methods and state. This allows code and data to be
combined as one logical entity. This module defines a basic car class,
creates a car instance and uses it for demonstration purposes.
"""

from inspect import isfunction, ismethod, signature


class Car:
 """Basic definition of a car.

 We begin with a simple mental model of what a car is. That way, we
 can start exploring the core concepts that are associated with a
 class definition.
 """

 def __init__(self, make: str, model: str, year: int, miles: float) -> None:
 """Constructor logic."""
 self.make = make
 self.model = model
 self.year = year
 self.miles = miles

 def __repr__(self) -> str:
 """Formal representation for developers."""
 return f"<Car make={self.make} model={self.model} year={self.year}>"

 def __str__(self) -> str:
 """Informal representation for users."""
 return f"{self.make} {self.model} ({self.year})"

 def drive(self, rate_in_mph: int) -> str:
 """Drive car at a certain rate in MPH."""
 return f"{self} is driving at {rate_in_mph} MPH"


def main() -> None:
 # Create a car with the provided class constructor
 car = Car("Bumble", "Bee", 2000, 200000.0)

 # Formal representation is good for debugging issues
 assert repr(car) == "<Car make=Bumble model=Bee year=2000>"

 # Informal representation is good for user output
 assert str(car) == "Bumble Bee (2000)"

 # Call a method on the class constructor
 assert car.drive(75) == "Bumble Bee (2000) is driving at 75 MPH"

 # As a reminder: everything in Python is an object! And that applies
 # to classes in the most interesting way - because they're not only
 # subclasses of object - they are also instances of object. This
 # means that we can modify the `Car` class at runtime, just like any
 # other piece of data we define in Python
 assert issubclass(Car, object) and isinstance(Car, object)

 # To emphasize the idea that everything is an object, let's look at
 # the `drive` method in more detail
 driving = getattr(car, "drive")

 # The variable method is the same as the instance method
 assert driving == car.drive

 # The variable method is bound to the instance
 assert driving.__self__ == car

 # That is why `driving` is considered a method and not a function
 assert ismethod(driving) and not isfunction(driving)

 # And there is only one parameter for `driving` because `__self__`
 # binding is implicit
 driving_params = signature(driving).parameters
 assert len(driving_params) == 1
 assert "rate_in_mph" in driving_params


if __name__ == "__main__":
 main()