Scribd
Upload
167 views8 pages

Oops in Python

This document discusses the principles of object-oriented programming (OOP) in Python, including classes, objects, polymorphism, encapsulation, and inheritance. It provides code examples to illustrate class definitions, object creation, methods, class methods, static methods, and encapsulation. The key principles of OOP allow programs to be designed using objects and classes that bind data to related functions.

Uploaded by

Dharshini 195
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
167 views8 pages

Oops in Python

This document discusses the principles of object-oriented programming (OOP) in Python, including classes, objects, polymorphism, encapsulation, and inheritance. It provides code examples to illustrate class definitions, object creation, methods, class methods, static methods, and encapsulation. The key principles of OOP allow programs to be designed using objects and classes that bind data to related functions.

Uploaded by

Dharshini 195
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 8

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.

You might also like