Hello Python enthusiasts, welcome back to Programming In Python! Here in this article, I will try to briefly explain and cover the Python OOP concepts
Python OOP Concepts
Object-oriented programming (OOP) is a programming paradigm that emphasizes the use of classes and objects to structure code and solve complex problems. Python is an object-oriented programming language that supports many OOP concepts, including:
1. Classes and Objects
2. Encapsulation
3. Abstraction
4. Inheritance
5. Polymorphism
6. Access Modifiers
7. Abstract Classes
8. Interfaces
In this article, we will discuss each of these concepts in more detail.
Classes and Objects
Classes are user-defined blueprints that define the attributes and methods of objects. Objects are instances of classes that can be created and manipulated in code.
Here is an example of a class in Python that defines a simple Person object:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def say_hello(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
person = Person("Alice", 30)
person.say_hello()
In this example, we define a `Person` class with an `_init_` method that initializes the `name` and `age` attributes of the object. We also define a `say_hello` method that prints a greeting using the object’s `name` and `age` attributes. We then create a `Person` object called `person` with the name “Alice” and age 30, and we call the `say_hello` method on the object.
Ad:
Learn Python Programming Masterclass – Enroll Now.
Udemy
Encapsulation
Encapsulation is the concept of wrapping data and methods together in a class so that they are not accessible from outside the class. Encapsulation allows us to hide the implementation details of a class and only expose the necessary functionality.
In Python, we can use naming conventions to indicate the intended access level of a class or method. For example, we can prefix a variable or method name with an underscore to indicate that it should be treated as private.
Here is an example of a class in Python that uses encapsulation:
class BankAccount:
def __init__(self, account_number, balance):
self._account_number = account_number
self._balance = balance
def deposit(self, amount):
self._balance += amount
def withdraw(self, amount):
if amount > self._balance:
raise ValueError("Insufficient balance")
self._balance -= amount
def get_balance(self):
return self._balance
In this example, we define a `BankAccount` class with two private attributes `_account_number` and `_balance`, and three methods `deposit`, `withdraw`, and `get_balance`. The methods are used to manipulate the object’s balance attribute, but the attributes themselves are private and cannot be accessed directly from outside the class.
Abstraction
Abstraction is the concept of focusing on the essential features of an object and ignoring the details that are not relevant to its behavior. Abstraction allows us to create more generic and reusable classes and methods.
In Python, we can use abstract classes and interfaces to implement abstraction.
Inheritance
Inheritance is the concept of creating a new class that is a modified version of an existing class. The new class, called the subclass, inherits the attributes and methods of the existing class, called the superclass, and can also define its own attributes and methods.
In Python, we can define a subclass by inheriting from a superclass using the syntax `class Subclass(Superclass):`.
Here is an example of a subclass in Python that inherits attributes and methods from a superclass:
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow."
dog = Dog("Fido")
cat = Cat("Whiskers")
print(dog.name + ": " + dog.speak())
print(cat.name + ": " + cat.speak())
In this example, we define an abstract `Animal` class with an `_init_` method that initializes the `name` attribute, and an abstract `speak` method that raises a `NotImplementedError` exception. We then define two subclasses `Dog` and `Cat` that inherit from `Animal` and implement their own `speak` methods. Finally, we create two objects, one of each subclass, and call their `speak` methods.
Polymorphism
Polymorphism is the concept of using the same method or function to handle different types of objects. Polymorphism allows us to write more generic and reusable code.
In Python, we can achieve polymorphism through inheritance and duck typing. Duck typing is a programming concept that allows us to determine the type of an object based on its behavior rather than its class.
Here is an example of polymorphism in Python using inheritance:
class Shape:
def area(self):
raise NotImplementedError("Subclass must implement abstract method")
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 * self.radius
shapes = [Rectangle(5, 10), Circle(7)]
for shape in shapes:
print("Area:", shape.area())
In this example, we define an abstract `Shape` class with an abstract `area` method, and two subclasses `Rectangle` and `Circle` that inherit from `Shape` and implement their own `area` methods. We then create a list of `Shape` objects, which includes one `Rectangle` and one `Circle`, and call their `area` methods in a loop.
Ad:
Learn Python Programming Masterclass – Enroll Now.
Udemy
Access Modifiers
Access modifiers are used to control the visibility and accessibility of attributes and methods in a class. In Python, we can use naming conventions to indicate the intended access level of a class or method. We can prefix a variable or method name with a single underscore `_` to indicate that it should be treated as protected, and with two underscores `__` to indicate that it should be treated as private.
Here is an example of access modifiers in Python:
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self._odometer = 0
self.__engine_size = "2.0L"
def drive(self, miles):
self._odometer += miles
def get_odometer(self):
return self._odometer
def get_engine_size(self):
return self.__engine_size
car = Car("Toyota", "Camry", 2022)
car.drive(1000)
print("Odometer:", car.get_odometer())
print("Engine Size:", car.get_engine_size())
In this example, we define a `Car` class with four public attributes `make`, `model`, `year`, and `_odometer`, and one private attribute `__engine_size`. We also define three methods `drive`, `get_odometer`, and `get_engine_size`, where `drive` and `get_odometer` are public methods, and `get_engine_size` is a private method.
Conclusion
Object-oriented programming is a powerful paradigm that allows us to write more organized, reusable, and maintainable code. Python provides all the necessary features and tools to support OOP, including classes, objects, inheritance, polymorphism, and access modifiers.
In this article, we have covered the basics of OOP in Python, including classes and objects, inheritance and polymorphism, and access modifiers. We have also provided examples of each concept to help you understand how they work in practice.
We hope that this article has helped you to understand the basics of OOP in Python and inspired you to explore this paradigm further. With more practice and experience, you will be able to design and implement more complex and sophisticated systems using OOP principles.