What are the 4 pillars of OOP Python?

The 4 pillars of object-oriented programming (OOP) in Python (and

generally in programming) are:

 Encapsulation: Bundling data (attributes) and methods

(functions) that operate on the data into a single unit (class).

 Abstraction: Hiding complex implementation details and

providing a simplified interface.

 Inheritance: Allowing a class to inherit attributes and

methods from another class, promoting code reuse.

 Polymorphism: Using a single interface to represent different

data types or objects.

Python OOPs Concepts

 Object Oriented Programming is a fundamental concept in Python,

empowering developers to build modular, maintainable, and
scalable applications.
 By understanding the core OOP principles like classes, objects,
inheritance, encapsulation, polymorphism, and abstraction
programmers can leverage the full potential of Python’s OOP
capabilities to design elegant and efficient solutions to complex
problems.

What is Object-Oriented Programming in Python?

 In Python object-oriented Programming (OOPs) is a programming

paradigm that uses objects and classes in programming.
 It aims to implement real-world entities like inheritance,
polymorphisms, encapsulation, etc. in the programming.
 The main concept of object-oriented Programming (OOPs) or oops
concepts in Python is to bind the data and the functions that work
together as a single unit so that no other part of the code can
access this data.

OOPs Concepts in Python

 Class in Python

 Objects in Python

 Polymorphism in Python

 Encapsulation in Python

 Inheritance in Python

 Data Abstraction in Python

Python Class

 A class is a collection of objects.

 A class contains the blueprints or the prototype from which the
objects are being created.
 It is a logical entity that contains some attributes and methods.

To understand the need for creating a class let’s consider an example,

let’s say you wanted to track the number of dogs that may have different
attributes like breed, and age. If a list is used, the first element could be
the dog’s breed while the second element could represent its age. Let’s
suppose there are 100 different dogs, then how would you know which
element is supposed to be which? What if you wanted to add other
properties to these dogs? This lacks organization and it’s the exact need
for classes.

Some points on Python class:

 Classes are created by keyword class.

 Attributes are the variables that belong to a class.

 Attributes are always public and can be accessed using the dot (.)
operator. Eg.: Myclass.Myattribute

Class Definition Syntax:

class ClassName:
# Statement-1
.
.
.
# Statement-N

Creating an Empty Class in Python

In the above example, we have created a class named Dog using the class
keyword.

# Python3 program to
# demonstrate defining
# a class

class Dog:
pass

Output
Python Objects

 In object oriented programming Python, The object is an entity that

has a state and behavior associated with it.
 It may be any real-world object like a mouse, keyboard, chair, table,
pen, etc. Integers, strings, floating-point numbers, even arrays, and
dictionaries, are all objects.
 More specifically, any single integer or any single string is an object.
 The number 12 is an object, the string “Hello, world” is an object, a
list is an object that can hold other objects, and so on.
 You’ve been using objects all along and may not even realize it.

An object consists of:

 State: It is represented by the attributes of an object. It also

reflects the properties of an object.

 Behavior: It is represented by the methods of an object. It also

reflects the response of an object to other objects.

 Identity: It gives a unique name to an object and enables one

object to interact with other objects.

To understand the state, behavior, and identity let us take the example of
the class dog (explained above).

 The identity can be considered as the name of the dog.

 State or Attributes can be considered as the breed, age, or color of

the dog.

 The behavior can be considered as to whether the dog is eating or

sleeping.

Creating an Object

This will create an object named obj of the class Dog defined above.
Before diving deep into objects and classes let us understand some basic
keywords that will be used while working with objects and classes.

obj = Dog()

The Python self

1. Class methods must have an extra first parameter in the method

definition. We do not give a value for this parameter when we call
the method, Python provides it

2. If we have a method that takes no arguments, then we still have to

have one argument.

3. This is similar to this pointer in C++ and this reference in Java.

When we call a method of this object as myobject.method(arg1, arg2),
this is automatically converted by Python into MyClass.method(myobject,
arg1, arg2) – this is all the special self is about.

The Python __init__ Method

The __init__ method is similar to constructors in C++ and Java. It is run as

soon as an object of a class is instantiated. The method is useful to do any
initialization you want to do with your object. Now let us define a class and
create some objects using the self and __init__ method.

Creating a class and object with class and instance attributes

class Dog:

# class attribute
attr1 = "mammal"

# Instance attribute
def __init__(self, name):
self.name = name

# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")

# Accessing class attributes

print("Rodger is a {}".format(Rodger.__class__.attr1))
print("Tommy is also a {}".format(Tommy.__class__.attr1))

# Accessing instance attributes

print("My name is {}".format(Rodger.name))
print("My name is {}".format(Tommy.name))

Output

Rodger is a mammal
Tommy is also a mammal
My name is Rodger
My name is Tommy

Creating Classes and objects with methods

Here, The Dog class is defined with two attributes:

 attr1 is a class attribute set to the value “mammal“. Class

attributes are shared by all instances of the class.

 __init__ is a special method (constructor) that initializes an instance

of the Dog class. It takes two parameters: self (referring to the
instance being created) and name (representing the name of the
dog). The name parameter is used to assign a name attribute to
each instance of Dog.
 The speak method is defined within the Dog class. This method
prints a string that includes the name of the dog instance.

The driver code starts by creating two instances of the Dog class: Rodger
and Tommy. The __init__ method is called for each instance to initialize
their name attributes with the provided names. The speak method is
called in both instances (Rodger.speak() and Tommy.speak()), causing
each dog to print a statement with its name.

class Dog:

# class attribute
attr1 = "mammal"

# Instance attribute
def __init__(self, name):
self.name = name

def speak(self):
print("My name is {}".format(self.name))

# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")

# Accessing class methods

Rodger.speak()
Tommy.speak()

Output

My name is Rodger
My name is Tommy
Python Inheritance:

In Python object oriented Programming, Inheritance is the capability of

one class to derive or inherit the properties from another class. The class
that derives properties is called the derived class or child class and the
class from which the properties are being derived is called the base class
or parent class. The benefits of inheritance are:

 It represents real-world relationships well.

 It provides the reusability of a code. We don’t have to write the

same code again and again. Also, it allows us to add more features
to a class without modifying it.

 It is transitive in nature, which means that if class B inherits from

another class A, then all the subclasses of B would automatically
inherit from class A.

Types of Inheritance:

 Single Inheritance: Single-level inheritance enables a derived

class to inherit characteristics from a single-parent class.

 Multilevel Inheritance: Multi-level inheritance enables a derived

class to inherit properties from an immediate parent class which in
turn inherits properties from his parent class.

 Hierarchical Inheritance: Hierarchical-level inheritance enables

more than one derived class to inherit properties from a parent
class.

 Multiple Inheritance: Multiple-level inheritance enables one

derived class to inherit properties from more than one base class.

Inheritance in Python

In the above article, we have created two classes i.e. Person (parent class)
and Employee (Child Class). The Employee class inherits from the Person
class. We can use the methods of the person class through the employee
class as seen in the display function in the above code. A child class can
also modify the behavior of the parent class as seen through the details()
method.

# Python code to demonstrate how parent constructors

# are called.

# parent class
class Person(object):

# __init__ is known as the constructor

def __init__(self, name, idnumber):
self.name = name
self.idnumber = idnumber
 def display(self):
print(self.name)
print(self.idnumber)

def details(self):
print("My name is {}".format(self.name))
print("IdNumber: {}".format(self.idnumber))

# child class
class Employee(Person):
def __init__(self, name, idnumber, salary, post):
self.salary = salary
self.post = post

# invoking the __init__ of the parent class

Person.__init__(self, name, idnumber)

def details(self):
print("My name is {}".format(self.name))
print("IdNumber: {}".format(self.idnumber))
print("Post: {}".format(self.post))

# creation of an object variable or an instance

a = Employee('Rahul', 886012, 200000, "Intern")

# calling a function of the class Person using

# its instance
a.display()
a.details()

Output

Rahul
886012
My name is Rahul
IdNumber: 886012
Post: Intern
Python Polymorphism :

In object oriented Programming Python, Polymorphism simply means

having many forms. For example, we need to determine if the given
species of birds fly or not, using polymorphism we can do this using a
single function.

Polymorphism in Python

This code demonstrates the concept of Python oops inheritance and

method overriding in Python classes. It shows how subclasses can
override methods defined in their parent class to provide specific behavior
while still inheriting other methods from the parent class.

class Bird:

def intro(self):
print("There are many types of birds.")

def flight(self):
print("Most of the birds can fly but some cannot.")

class sparrow(Bird):

def flight(self):
print("Sparrows can fly.")

class ostrich(Bird):

def flight(self):
print("Ostriches cannot fly.")

obj_bird = Bird()
obj_spr = sparrow()
obj_ost = ostrich()

obj_bird.intro()
obj_bird.flight()

obj_spr.intro()
obj_spr.flight()

obj_ost.intro()
obj_ost.flight()

Output :

There are many types of birds.

Most of the birds can fly but some cannot.
There are many types of birds.
Sparrows can fly.
There are many types of birds.
Ostriches cannot fly.
Python Encapsulation :

 In Python object oriented programming, Encapsulation is one of the

fundamental concepts in object-oriented programming (OOP).
 It describes the idea of wrapping data and the methods that work on
data within one unit.
 This puts restrictions on accessing variables and methods directly
and can prevent the accidental modification of data.
 To prevent accidental change, an object’s variable can only be
changed by an object’s method.
 Those types of variables are known as private variables.

A class is an example of encapsulation as it encapsulates all the data that

is member functions, variables, etc.

Encapsulation in Python

In the above example, we have created the c variable as the private

attribute. We cannot even access this attribute directly and can’t even
change its value.

# Python program to
# demonstrate private members
# "__" double underscore represents private attribute.
# Private attributes start with "__".

# Creating a Base class

class Base:
def __init__(self):
self.a = "GeeksforGeeks"
self.__c = "GeeksforGeeks"

# Creating a derived class

class Derived(Base):
def __init__(self):

# Calling constructor of
# Base class
Base.__init__(self)
print("Calling private member of base class: ")
print(self.__c)

# Driver code
obj1 = Base()
print(obj1.a)

# Uncommenting print(obj1.c) will

# raise an AttributeError

# Uncommenting obj2 = Derived() will

# also raise an AtrributeError as
# private member of base class
# is called inside derived class

Output

GeeksforGeeks

Data Abstraction

 It hides unnecessary code details from the user.

 Also, when we do not want to give out sensitive parts of our code
implementation and this is where data abstraction came.
 Data Abstraction in Python can be achieved by creating abstract
classes.

class Rectangle:
def __init__(self, length, width):
self.__length = length # Private attribute
self.__width = width # Private attribute

def area(self):
return self.__length * self.__width

def perimeter(self):
return 2 * (self.__length + self.__width)

rect = Rectangle(5, 3)
print(f"Area: {rect.area()}") # Output: Area: 15
print(f"Perimeter: {rect.perimeter()}") # Output: Perimeter: 16

# print(rect.__length) # This will raise an AttributeError as length and

width are private attributes

Output

Area: 15
Perimeter: 16
Difference between abstract class and interface in Python?

Abstract Class Interface

An abstract features developer’s class
All methods of an interface are
1. can consist of abstract as well as
abstract
concrete methods

It is used when all the feature need to

It is used when there are some
2. be implemented differently for
common feature shared by all objects
different objects

Its developer responsibility to create a

Any 3rd person will responsible for
3. child class for the features of an
creating a child class
abstract class

4. It is comparatively fast It is comparatively slow

Python has a built-in module that you can use to make random numbers.

The random module has a set of methods:

Method Description

seed() Initialize the random number generator

getstate() Returns the current internal state of the random number generator

setstate() Restores the internal state of the random number generator

getrandbits() Returns a number representing the random bits

randrange() Returns a random number between the given range

randint() Returns a random number between the given range

choice() Returns a random element from the given sequence

choices() Returns a list with a random selection from the given sequence

shuffle() Takes a sequence and returns the sequence in a random order

sample() Returns a given sample of a sequence

random() Returns a random float number between 0 and 1

uniform() Returns a random float number between two given parameters

Returns a random float number between two given parameters, you can also set a
triangular()
mode parameter to specify the midpoint between the two other parameters

Returns a random float number between 0 and 1 based on the Beta distribution
betavariate()
(used in statistics)

Returns a random float number based on the Exponential distribution (used in

expovariate()
statistics)

Returns a random float number based on the Gamma distribution (used in

gammavariate()
statistics)

Returns a random float number based on the Gaussian distribution (used in

gauss()
probability theories)

lognormvariate() Returns a random float number based on a log-normal distribution (used in

 probability theories)

Returns a random float number based on the normal distribution (used in

normalvariate()
probability theories)

Returns a random float number based on the von Mises distribution (used in
vonmisesvariate()
directional statistics)

Returns a random float number based on the Pareto distribution (used in

paretovariate()
probability theories)

Returns a random float number based on the Weibull distribution (used in

weibullvariate()
statistics)