Python Object Oriented Programming

...

Magic methods in Python are the special methods that start and end with the double underscores. They are also called dunder methods. Magic methods are not meant to be invoked directly by you, but the invocation happens internally from the class on a certain action.

The unified modeling language (UML) is a general-purpose modeling language that is intended to provide a standard way to visualize the design of a system.(It's worth mentioning that when using Pycharm, the IDE generates a UML diagram automatically!)
Although, in software engineering, most practitioners do not use UML, but instead produce informal hand drawn diagrams; these diagrams, however, often include elements from UML. 

#class introduction
class Car:

    # The __init__ method is used to initialize the attributes of the class.
    def __init__(self, make, model, year, color):
        self.make = make
        self.model = model
        self.year = year
        self.color = color

    # This method is used to print a message indicating that the car is driving.
    def drive(self):
        print("This " + self.model + " is driving")

    # This method is used to print a message indicating that the car is stopped.
    def stop(self):
        print("This " + self.model + " is stopped")

    # This method is used to print the attributes of the Car object in a formatted string.
    def __str__(self):
        return f"\nmake: {self.make}\nmodel: {self.model}\nyear: {self.year}\ncolor: {self.color}"

    # This method is used to compare if two Car objects are equal by checking their attributes.
    def __eq__(self, other):
        if isinstance(other, Car):
            return (self.make == other.make) and (self.model == other.model) and (self.year == other.year) and (self.color == other.color)
        else:
            return False

Copy

The code defines a Car class that represents a car and has four attributes: make, model, year, and color.

The __init__ method is used to initialize these attributes, and the class has three methods: drive(), stop(), and __str__().

The drive() method prints a message indicating that the car is driving, and the stop() method prints a message indicating that the car is stopped.

The __str__() method returns a formatted string that displays the attributes of the car object.

The __eq__() method is used to compare if two Car objects are equal by checking their attributes. It returns True if all the attributes of two Car objects are equal and False otherwise.

car_1 = Car("Chevy","Corvette",2021,"blue")
car_2 = Car("Ford","Mustang",2022,"red")
print(car_2)
car_2.drive()
print(car_2 == car_1)
Copy

#inheritance
class Car:

    # The __init__ method is used to initialize the attributes of the class.
    def __init__(self, make, model, year, color):
        self.make = make
        self.model = model
        self.year = year
        self.color = color

    # This method is used to print a message indicating that the car is driving.
    def drive(self):
        print("This " + self.model + " is driving")

    # This method is used to print a message indicating that the car is stopped.
    def stop(self):
        print("This " + self.model + " is stopped")

    # This method is used to print the attributes of the Car object in a formatted string.
    def __str__(self):
        return f"\nmake: {self.make}\nmodel: {self.model}\nyear: {self.year}\ncolor: {self.color}"

class PlaceHolder(Car):
    pass

class Truck(Car):

	def __init__(self,make,model,year,color,weight):
	    #super().__init__(self,make,model,year,color)
	    Car.__init__(self,make,model,year,color)
	    self.weight = weight

truck_1 = Truck("Tesla","Cyber truck",2024,"silver",5000)

print(truck_1)
Copy

The code defines a Car class that represents a car and has four attributes: make, model, year, and color. The class has three methods: drive(), stop(), and __str__().

The drive() method prints a message indicating that the car is driving, and the stop() method prints a message indicating that the car is stopped. The __str__() method returns a formatted string that displays the attributes of the car object.

There are two additional classes defined: PlaceHolder and Truck. The PlaceHolder class inherits from the Car class but does not define any additional attributes or methods.

The Truck class also inherits from the Car class and adds a new attribute called weight in the __init__ method. The Truck class initializes the make, model, year, and color attributes of the Car class by calling the __init__() method of the Car class using either super().__init__(self, make, model, year, color) or Car.__init__(self, make, model, year, color).

The Truck class instance truck_1 is created using the Truck class constructor, which takes in make, model, year, color, and weight attributes.

Finally, the print() function is used to print the truck_1 object, which calls the __str__() method of the Car class to display the attributes of the object.

from abc import ABC, abstractmethod

class Car(ABC):
    # define an abstract method that must be implemented by any concrete subclass
    @abstractmethod
    def start_engine(self):
        pass
    
    # define an initializer that sets the make and model of the car
    def __init__(self, make, model):
        self.make = make
        self.model = model

class SportsCar(Car):
    # provide a concrete implementation for the start_engine() method
    def start_engine(self):
        return "The {0} {1} engine is starting...".format(self.make, self.model)

class SedanCar(Car):
    # provide a different concrete implementation for the start_engine() method
    def start_engine(self):
        return "The {0} {1} engine is starting...".format(self.make, self.model)

# create a list of cars, including one sports car and one sedan car
cars = [SportsCar("Ferrari", "F430"), SedanCar("Toyota", "Camry")]

# call the start_engine() method for each car, which executes the appropriate implementation based on the type of car

Copy

The code defines an abstract base class Car that is inherited by two concrete subclasses: SportsCar and SedanCar. The Car class has one abstract method, start_engine(), which must be implemented by any concrete subclass that inherits from it.

The SportsCar and SedanCar classes both inherit from the Car class and provide a concrete implementation for the start_engine() method. The implementation uses string formatting to return a message indicating that the engine is starting for the given make and model of the car.

A list called cars is created that includes one instance of SportsCar and one instance of SedanCar. Finally, a loop iterates over the list of cars and calls the start_engine() method for each car, which executes the appropriate implementation based on the type of car.

This code demonstrates the concept of polymorphism, where objects of different types can be treated as if they are the same type, as long as they implement the same methods or have the same attributes. In this case, both SportsCar and SedanCar are treated as Car objects, so they can be added to the same list and looped over in the same way.

The Car class is an example of encapsulation in Python. It demonstrates how to use private instance variables and getter methods to restrict direct access to class attributes.

class Car:
    def __init__(self, make, model, year):
        # Initialize private instance variables
        self.__make = make
        self.__model = model
        self.__year = year
        self.__speed = 0

    def get_make(self):
        # Getter method for private variable __make
        return self.__make

    def get_model(self):
        # Getter method for private variable __model
        return self.__model

    def get_year(self):
        # Getter method for private variable __year
        return self.__year

    def get_speed(self):
        # Getter method for private variable __speed
        return self.__speed

    def accelerate(self):
        # Increase the speed of the car by 10 km/h
        self.__speed += 10

    def brake(self):
        # Decrease the speed of the car by 10 km/h
        self.__speed -= 10
Copy

In this example, the __make, __model, __year, and __speed instance variables are marked as private by prefixing them with two underscores. Private variables can only be accessed within the class definition. To access these private variables, getter methods are defined that return the values of the private variables. This ensures that external code cannot directly modify the state of the object.

A Car object is created with the make "Honda", model "Accord", and year 2021. The car is accelerated twice and then braked once. The make, model, year, and speed of the car are printed using the getter methods.

# Create a Car object with make "Honda", model "Accord", and year 2021
car = Car("Honda", "Accord", 2021)

# Accelerate the car twice and then brake once
car.accelerate()
car.accelerate()
car.brake()

# Print the make, model, year, and speed of the car using the getter methods
print("Make:", car.get_make())
print("Model:", car.get_model())
print("Year:", car.get_year())
print("Speed:", car.get_speed(), "km/h")
Copy

In Python, protected variables are denoted with a single underscore prefix (e.g., _make). This indicates that the variable should not be accessed from outside the class, but can be accessed from within the class hierarchy.

In the following example, we define a Car class with two protected instance variables: _make and _model. The _start_engine method is also protected, which means it can only be accessed from within the class hierarchy.

Then, we define a SportCar subclass that inherits from Car. The race method of SportCar calls the _start_engine method from the parent Car class and prints a message indicating that the car is racing.

class Car:
    def __init__(self, make, model):
        self._make = make  # protected variable
        self._model = model  # protected variable

    def _start_engine(self):
        print(f"The {self._make} {self._model} engine is starting...")

class SportCar(Car):
    def race(self):
        self._start_engine()
        print("I'm racing now!")
Copy

We can create a SportCar object with make "Ferrari" and model "F430" and call the race method:

sport_car = SportCar("Ferrari", "F430")
sport_car.race()
Copy

Note that the protected variables _make and _model can be accessed from within the class hierarchy (i.e., from the Car and SportCar classes), but not from outside the class hierarchy. For example, the following line would raise an AttributeError:

print(sport_car._make)
Copy