Python OOP

I. What is Python OOP?

OOP = Object Oriented Programming.

• Python fully supports OOP with Class and Class Inheritance. A Python class is a blueprint for creating from 1 to many objects. It can have:
• Attributes are attached to it to maintain its state. They may be read-only or writeable.
• Methods to modify its state. Syntax to define a class name "Animal":

class Animal:
    def __init__(self, secret_attribute="Suyt"):
        # __init__: constructor that runs when an object is created.
        # self: refers to the current instance of the class
        self.num_eyes = 2
        self.__secret_attribute = secret_attribute # Private variable

    def breathe(self):
        print("Inhale, exhale.")

    def get_secret_attribute(self):
        return self.__secret_attribute

    def make_sound(self):
        pass  # To be implemented by subclasses

II. What are the core concepts or elements of OOPs?

• Class: a blueprint for creating objects class Animal
• Object: an instance of a class. Instantiation is an action that creates an instance from the class nemo_fish = Fish().

• Encapsulation: restricted direct access to attributes or from the outside self.__secret_attribute

• Inheritance: Allows a child class to use methods and properties from parents' classes.
  

class Fish(Animal):
    """Fish class is an inheritance from Animal"""
    def __init__(self):
        super().__init__() # call Animal init

    def breathe(self):
        super().breathe() #call the Animal breathe function, then modify it.
        print("doing this underwater.")

    def swim(self):
        print("moving in the water")

• Polymorphism: allows different classes to use the same method name but different implementations.

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.make_sound())  # Calls the correct method based on the object type

• Abstraction: hiding implementation details and only exposing essential functionalities. For example: we have many 2 kinds of animals: cats, dogs, and fish. We know they care how they make the sound, only care that they can make a sound.

from abc import ABC, abstractmethod # import abstract base class module

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# Getting error if instantiate an abstract class
# dog = Animal()
# TypeError: Can't instantiate abstract class Animal
# without an implementation for abstract method 'make_sound'

# Dog class inherits from Animal so it has to implement method make_sound
class Dog(Animal):
    def make_sound(self):
        return "Woof! Woof!"

perfect_dog = Dog()
print(perfect_dog.make_sound())
# Woof! Woof!