codeskill

Understanding Object-Oriented Programming in Python

Written by

admin_ppsh

in

Object-Oriented Programming (OOP) is a programming paradigm that uses “objects” to design applications and computer programs. It utilizes several techniques from previously established paradigms, including modularity, polymorphism, and encapsulation. Today, we delve into how Python, a language renowned for its simplicity and readability, adopts this powerful concept, and how it can be used to create clean, efficient, and reusable code.

The Pillars of Object-Oriented Programming

OOP in Python is based on four primary principles:

  1. Encapsulation: This involves bundling the data and methods that work on the data within one unit, such as a class in Python. It hides the internal state of the object from the outside.
  2. Abstraction: This principle hides the complex reality while exposing only the necessary parts. It helps in reducing programming complexity and effort.
  3. Inheritance: This is a way to form new classes using classes that have already been defined. It supports code reusability.
  4. Polymorphism: This allows us to define methods in the child class with the same name as defined in their parent class.

Classes and Objects in Python

The primary components of OOP in Python are classes and objects. A class is a blueprint for creating objects (a particular data structure), providing initial values for state (member variables or attributes), and implementations of behavior (member functions or methods).

Defining a Class in Python

Here’s a simple example of a class in Python:

class Dog:
    # Class Attribute
    species = "Canis familiaris"

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # instance method
    def description(self):
        return f"{self.name} is {self.age} years old"

    # Another instance method
    def speak(self, sound):
        return f"{self.name} says {sound}"

Creating Objects in Python

Once we have a class, we can create objects of that class, which are instances of the class:

# Instantiate the Dog class
mikey = Dog("Mikey", 6)

# Access the instance attributes
print(f"{mikey.name} is {mikey.age} years old")  # Mikey is 6 years old

# Is Mikey a mammal?
if mikey.species == "Canis familiaris":
    print(f"{mikey.name} is a {mikey.species}")  # Mikey is a Canis familiaris

Inheritance in Python

Inheritance allows us to define a class that inherits all the methods and properties from another class.

# Parent class
class Dog:
    # ... (as above)

# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return f"{self.name} runs {speed}"

# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return f"{self.name} runs {speed}"

# Child instances
jim = Bulldog("Jim", 12)
print(jim.description())  # Jim is 12 years old

# Child classes inherit attributes and 
# behaviors from the parent class
print(jim.run("slowly"))  # Jim runs slowly

Encapsulation in Python

Encapsulation in Python is defined by private and public attributes and methods.

class Computer:
    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print(f"Selling Price: {self.__maxprice}")

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()  # Selling Price: 900

# change the price
c.__maxprice = 1000
c.sell()  # Selling Price: 900

# using setter function
c.setMaxPrice(1000)
c.sell()  # Selling Price: 1000

Polymorphism in Python

Polymorphism allows us to define methods in the child class with the same name as defined in their parent class.

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

def get_pet_speak(pet):
    print(pet.speak())

# Driver code
dog = Dog()
get_pet_speak(dog)  # Outputs: Woof!

cat = Cat()
get_pet_speak(cat)  # Outputs: Meow!

Conclusion

Object-Oriented Programming in Python helps in structuring code in a logical and clear manner. It makes the code more modular, reusable, and flexible. By using classes and objects, inheritance, encapsulation, and polymorphism, you can write more efficient and manageable code. OOP is a paradigm that, when understood and used effectively, can make a significant difference in the quality and scalability of your Python projects. As you continue to explore Python, keep these OOP principles in mind, and see how they can transform the way you write your Python code.

More posts