Oops in Python

OOPS IN PYTHON:
Object-Oriented Programming (OOP in Python) allows us to design

programs using objects and classes. This principle binds data and
the related functions. C++, C#, Python, and Java are some of the
OOP languages. In this article, we are going to look at
the Principles of OOP with code examples.
Principles of OOP
 Class
 Objects
 Polymorphism
 Encapsulation
 Inheritance
 Data Abstraction
Class
In Python, a class is a blueprint for creating objects. A class defines
the attributes and methods of its objects. A class defines what an
object of that class will look like and how it will behave.
What is an Object ?
An object is an instance of a class. It represents a specific item that is
created based on the class definition. An object has its own unique
identity, state, and behavior.
We are using class keyword for creating a class
class Person:
# Other lines
Constructor and self
__init__is a special method. It is also known as the constructor of

the class, which is automatically called when an object of the class is
created. It is used to initialize the object’s attributes and necessary
setups.
The__init__ method usually takes at least one parameter, which

is self. It refers to the instance of the object being created.
class Person:
def __init__(self, name, age):
""" Initializing attributes """
self.name = name
self.age = age
Creating Object
For creating objects, we need to call the constructor, which

is __init__ method.
By callingClassName() as a method, which isPerson in this case. So by

doing this, we are calling __init__ method of the Person class.
Creating two unique objects
person1 = Person("John", 25)
person2 = Person("Alice", 30)
Methods
Methods are functions that are defined inside a class and are called
on objects of that class.
They have access to the object’s attributes and can modify them.
The first parameter of a method is typically namedself. To call a

method, you use dot notation, specifying the object followed by the
method name.
class Person:
def __init__(self, name, age):
""" Initializing attributes """
self.name = name
self.age = age
def get_info():
"""Method"""
print("Name:", name, " Age:", age)
Creating a unique object

person1 = Person("John", 25)
Calling a method with a notation

person1.get_info()
Class Methods
Class methods are defined using the@classmethod decorator and are

bound to the class rather than the instance of the class.
They have access to class-level variables and perform actions related
to classes rather than individual objects. (To define a class-level
variable, you need to place it directly below the class declaration.)
The first parameter of a class method is typically named,cls which

refers to the class itself.
To call a class method in Python, you use the class name followed by
the method name in dot notation.
You can found more information about decorators in this

article.
class Circle:
class-level variables
pi = 3.14
def __init__(self, radius):

self.radius = radius
def calculate_area(self):
return Circle.pi * self.radius * self.radius
@classmethod
def change_pi(cls, new_pi):
cls.pi = new_pi
# Creating Circle objects

circle1 = Circle(5)
circle2 = Circle(10)
Calling an instance method

area1 = circle1.calculate_area()
print (area 1) # Output: 78.5
Calling a class method

Circle.change_pi(3.14159)
area2 = circle2.calculate_area()
print(area2) # Output: 314.159
Static Methods
Static methods are defined using the@staticmethod decorator and are
not bound to the class but rather to the instance of the class.
They don’t have access to the object’s attributes or class-level

variables, as they are independent of the class state.
Static methods are typically used for utility functions or operations

that don’t depend on the class or instance context.
They are similar to regular functions. But they are placed inside a
class for organizational purposes.
You can found more information about decorators in this

article.
class MathUtils:
@staticmethod
def square(x):
return x * x
@staticmethod
def cube(x):
return x * x * x
Calling static methods directly

result1 = MathUtils.square(5)
print(result1) # Output: 25
result2 = MathUtils.cube(3)
print(result2) # Output: 27
Static methods can be accessed directly from the class itself by using
dot notation.
Polymorphism
Polymorphism allows objects of different types to be treated as
objects of a common superclass. Subclasses have access to all
methods and attributes.
class Person:
def __init__(self, name):
self.name = name
def get_details(self):
return f"Name: {self.name}"
class Employer(Person):
def __init__(self, name, company):
super().__init__(name)
self.company = company
def get_details(self):
return Name: {self.name}, Company: {self.company}"
Creating objects of different classes

person = Person("John")
employer = employer ("Alice, "XYZ Corp")
Calling the function with different objects

person.get_details() Output: Name: John
employer.get_details() # Output: Name: Alice, Company: XYZ Corp
In this example, sublcassPerson is the superclass

of Employer sublcass. Employer class have an access to attributes
of Person class and its methods.
Also, as you see, theget_details() method is overridden, which

means it is redefined in the subclass.
Encapsulation
Encapsulation helps protect the data from unauthorized access and
ensures proper maintenance.
Some common access modifiers used in Python:
 Public: Public members (attributes and methods) are

accessible from anywhere, both inside and outside the
class.
 Private: Private members are denoted by using double

underscores (__) as a prefix before the attribute or method
name. They can only be accessed within the class itself, not
from outside the class.
 Protected: Protected members are denoted by using a

single underscore (_) as a prefix before the attribute or
method name. They can be accessed within the class and its
subclasses (derived classes), but not from outside the class
hierarchy.
Normal private and protected members are accessible from outside

the class. But we expect that users do not interfere with these
members.
class BankAccount:
def __init__(self, account_number, balance):
self.account_number = account_number
self.__balance = balance # Private attribute
def get_balance(self):
return self.__balance
def deposit(self, amount):

self.__balance += amount
def withdraw(self, amount):

if self.__balance >= amount:
self.__balance -= amount
else:
print("Insufficient balance.")
# Creating a BankAccount object

account = BankAccount("123456789", 1000)
Accessing attributes and calling methods

print(account.get_balance()) # Output: 1000
account.deposit(500)
print(account.get_balance()) # Output: 1500
account.withdraw(2000) Output: Insufficient balance
Conclusion
Finally, Object-Oriented Programming (OOP) is a strong paradigm
that enables developers to create and arrange code in a more
ordered and modular fashion. Python, as an object-oriented
language, offers extensive support for OOP principles.

Oops in Python

Uploaded by

Oops in Python

Uploaded by

OOPS IN PYTHON:

Object-Oriented Programming (OOP in Python) allows us to design

We are using class keyword for creating a class

Constructor and self

initis a special method. It is also known as the constructor of

Theinit method usually takes at least one parameter, which

For creating objects, we need to call the constructor, which

By callingClassName() as a method, which isPerson in this case. So by

The first parameter of a method is typically namedself. To call a

Creating a unique object

Calling a method with a notation

Class methods are defined using the@classmethod decorator and are

The first parameter of a class method is typically named,cls which

You can found more information about decorators in this

def init(self, radius):

# Creating Circle objects

Calling an instance method

Calling a class method

They don’t have access to the object’s attributes or class-level

Static methods are typically used for utility functions or operations

You can found more information about decorators in this

Calling static methods directly

Creating objects of different classes

Calling the function with different objects

In this example, sublcassPerson is the superclass

Also, as you see, theget_details() method is overridden, which

 Public: Public members (attributes and methods) are

 Private: Private members are denoted by using double

 Protected: Protected members are denoted by using a

Normal private and protected members are accessible from outside

def deposit(self, amount):

def withdraw(self, amount):

# Creating a BankAccount object

Accessing attributes and calling methods

You might also like