🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.
▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube
▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube
Introduction
Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects, which can contain data in the form of attributes (fields or properties) and code in the form of methods (functions). Python is an object-oriented programming language that allows you to create and manipulate objects. This tutorial covers the main OOP concepts in Python, including classes, objects, inheritance, polymorphism, encapsulation, and abstraction.
Table of Contents
- Classes and Objects
- Inheritance
- Polymorphism
- Encapsulation
- Abstraction
1. Classes and Objects
Class
A class is a blueprint for creating objects. It defines a set of attributes and methods that the created objects will have.
Example
class Car:
def __init__(self, brand, model, year):
self.brand = brand
self.model = model
self.year = year
def display_info(self):
return f"Car: {self.brand} {self.model}, Year: {self.year}"
# Creating objects of the Car class
car1 = Car("Toyota", "Corolla", 2020)
car2 = Car("Honda", "Civic", 2019)
# Using the display_info method
print(car1.display_info()) # Output: Car: Toyota Corolla, Year: 2020
print(car2.display_info()) # Output: Car: Honda Civic, Year: 2019
2. Inheritance
Inheritance is a way to create a new class that is based on an existing class. The new class (child class) inherits attributes and methods from the existing class (parent class).
Example
class Vehicle:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def display_info(self):
return f"Vehicle: {self.brand} {self.model}"
class Car(Vehicle):
def __init__(self, brand, model, year):
super().__init__(brand, model)
self.year = year
def display_info(self):
return f"Car: {self.brand} {self.model}, Year: {self.year}"
# Creating an object of the Car class
car = Car("Tesla", "Model S", 2022)
# Using the display_info method
print(car.display_info()) # Output: Car: Tesla Model S, Year: 2022
3. Polymorphism
Polymorphism allows methods to be used interchangeably between different classes. It allows the same method to be defined in different classes, with each class having its own implementation.
Example
class Bird:
def make_sound(self):
return "Tweet"
class Dog:
def make_sound(self):
return "Bark"
def animal_sound(animal):
print(animal.make_sound())
# Creating objects of Bird and Dog classes
bird = Bird()
dog = Dog()
# Using the animal_sound function
animal_sound(bird) # Output: Tweet
animal_sound(dog) # Output: Bark
4. Encapsulation
Encapsulation is the practice of hiding the internal state and functionality of an object and only exposing a limited interface. This is usually done by making attributes private (prefixing them with an underscore) and providing public methods to access and modify them.
Example
class BankAccount:
def __init__(self, owner, balance):
self.owner = owner
self.__balance = balance # Private attribute
def deposit(self, amount):
if amount > 0:
self.__balance += amount
else:
print("Deposit amount must be positive")
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Insufficient funds")
def get_balance(self):
return self.__balance
# Creating an object of the BankAccount class
account = BankAccount("Ravi", 1000)
# Using public methods to interact with the private attribute
account.deposit(500)
print(account.get_balance()) # Output: 1500
account.withdraw(200)
print(account.get_balance()) # Output: 1300
# Attempting to access the private attribute directly (will raise an AttributeError)
# print(account.__balance) # AttributeError: 'BankAccount' object has no attribute '__balance'
5. Abstraction
Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. This can be achieved using abstract classes and methods.
Example
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
return "Bark"
class Cat(Animal):
def make_sound(self):
return "Meow"
# Creating objects of Dog and Cat classes
dog = Dog()
cat = Cat()
# Using the make_sound method
print(dog.make_sound()) # Output: Bark
print(cat.make_sound()) # Output: Meow
Conclusion
Object-Oriented Programming (OOP) in Python provides a powerful and flexible way to organize and manage code. By understanding and utilizing concepts such as classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you can design and implement more robust and maintainable software. This tutorial covered the main OOP concepts in Python with examples to help you get started with OOP in Python.
My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:
Build REST APIs with Spring Boot 4, Spring Security 7, and JWT
[NEW] Learn Apache Maven with IntelliJ IDEA and Java 25
ChatGPT + Generative AI + Prompt Engineering for Beginners
Spring 7 and Spring Boot 4 for Beginners (Includes 8 Projects)
Available in Udemy for Business
Building Real-Time REST APIs with Spring Boot - Blog App
Available in Udemy for Business
Building Microservices with Spring Boot and Spring Cloud
Available in Udemy for Business
Java Full-Stack Developer Course with Spring Boot and React JS
Available in Udemy for Business
Build 5 Spring Boot Projects with Java: Line-by-Line Coding
Testing Spring Boot Application with JUnit and Mockito
Available in Udemy for Business
Spring Boot Thymeleaf Real-Time Web Application - Blog App
Available in Udemy for Business
Master Spring Data JPA with Hibernate
Available in Udemy for Business
Spring Boot + Apache Kafka Course - The Practical Guide
Available in Udemy for Business
Comments
Post a Comment
Leave Comment