Object-Oriented Programming (OOP) is a programming paradigm that uses objects and classes to design and develop applications. It enables developers to model real-world entities, making code more modular, reusable, and easier to maintain. Python, being an object-oriented language, provides robust support for OOP concepts.
Basic Concepts of OOP
Classes and Objects
A class is a blueprint for creating objects. An object is an instance of a class.
class Dog:
# Class attribute
species = "Canis familiaris"
# Initializer / Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Create an instance of the Dog class
my_dog = Dog("Buddy", 3)
print(my_dog.name) # Output: Buddy
print(my_dog.age) # Output: 3
Attributes and Methods
Attributes are variables that belong to a class, and methods are functions that belong to a class.
class Dog:
# Initializer / Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Method to get dog's description
def description(self):
return f"{self.name} is {self.age} years old."
# Method to simulate a bark
def bark(self, sound):
return f"{self.name} says {sound}"
# Create a new Dog object
my_dog = Dog("Buddy", 3)
print(my_dog.description()) # Output: Buddy is 3 years old.
print(my_dog.bark("Woof")) # Output: Buddy says WoofEncapsulation
Encapsulation is the bundling of data with the methods that operate on that data.
class Car:
def __init__(self, model, year):
self._model = model # Protected attribute
self.__year = year # Private attribute
def get_year(self):
return self.__year
# Create a Car object
my_car = Car("Toyota", 2020)
print(my_car._model) # Output: Toyota
print(my_car.get_year()) # Output: 2020Inheritance
Inheritance allows a class to inherit attributes and methods from another class.
class Animal:
def __init__(self, name):
self.name = name
def make_sound(self):
raise NotImplementedError("Subclasses must implement this method")
class Dog(Animal):
def make_sound(self):
return "Woof"
class Cat(Animal):
def make_sound(self):
return "Meow"
# Create instances of Dog and Cat
dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.make_sound()) # Output: Woof
print(cat.make_sound()) # Output: Meow
Polymorphism
Polymorphism allows methods to be used interchangeably across different class instances.
class Animal:
def __init__(self, name):
self.name = name
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
return "Woof"
class Cat(Animal):
def make_sound(self):
return "Meow"
def animal_sound(animal):
print(animal.make_sound())
# Create instances
dog = Dog("Buddy")
cat = Cat("Whiskers")
# Demonstrate polymorphism
animal_sound(dog) # Output: Woof
animal_sound(cat) # Output: MeowAbstraction
Abstraction hides the complex implementation details and shows only the necessary features of an object.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * (self.radius ** 2)
# Create instances
rect = Rectangle(10, 5)
circle = Circle(7)
print(rect.area()) # Output: 50
print(circle.area()) # Output: 153.86Creating Classes and Objects in Python
Classes are created using the class keyword, and objects are instantiated by calling the class.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# Creating an object of the Person class
person1 = Person("Alice", 30)
print(person1.name) # Output: Alice
print(person1.age) # Output: 30Attributes and Methods in Python
Attributes are defined within the __init__ method and methods are defined as regular functions within the class.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
return f"Hello, my name is {self.name}."
# Creating an object of the Person class
person1 = Person("Alice", 30)
print(person1.greet()) # Output: Hello, my name is Alice.Encapsulation in Python
Encapsulation can be achieved using private and protected attributes.
class BankAccount:
def __init__(self, account_number, balance):
self.__account_number = account_number # Private attribute
self.__balance = balance # Private attribute
def deposit(self, amount):
self.__balance += amount
def get_balance(self):
return self.__balance
# Creating an object of the BankAccount class
account = BankAccount("123456789", 1000)
account.deposit(500)
print(account.get_balance()) # Output: 1500Inheritance in Python
Inheritance is implemented by defining a new class that inherits from an existing class.
class Vehicle:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def start(self):
return "Vehicle started"
class Car(Vehicle):
def __init__(self, brand, model, year):
super().__init__(brand, model)
self.year = year
def start(self):
return f"{self.brand} {self.model} ({self.year}) started"
# Creating an object of the Car class
my_car = Car("Toyota", "Camry", 2020)
print(my_car.start()) # Output: Toyota Camry (2020) startedPolymorphism in Python
Polymorphism is implemented by having different classes with the same method names.
class Bird:
def fly(self):
return "Bird can fly"
class Airplane:
def fly(self):
return "Airplane can fly"
def flying_ability(entity):
print(entity.fly())
# Create instances
bird = Bird()
airplane = Airplane()
# Demonstrate polymorphism
flying_ability(bird) # Output: Bird can fly
flying_ability(airplane) # Output: Airplane can flyAbstraction in Python
Abstraction is implemented using abstract base classes and methods.
from abc import ABC, abstractmethod
class Employee(ABC):
@abstractmethod
def calculate_salary(self):
pass
class FullTimeEmployee(Employee):
def __init__(self, name, salary):
self.name = name
self.salary = salary
def calculate_salary(self):
return self.salary
class PartTimeEmployee(Employee):
def __init__(self, name, hourly_rate, hours_worked):
self.name = name
self.hourly_rate = hourly_rate
self.hours_worked = hours_worked
def calculate_salary(self):
return self.hourly_rate * self.hours_worked
# Create instances
full_time = FullTimeEmployee("John", 5000)
part_time = PartTimeEmployee("Jane", 20, 100)
print(full_time.calculate_salary()) # Output: 5000
print(part_time.calculate_salary()) # Output: 2000Conclusion
Object-Oriented Programming in Python offers a powerful way to organize and manage complex code. By understanding and implementing OOP concepts such as classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you can create scalable and maintainable applications.
Leave a Reply