MBABA313

Advanced Python Techniques

Object Oriented Programming:

Introduction to Object-Oriented Programming

Object-Oriented Programming (OOP) is a programming paradigm where the main focus is on

objects, rather than just functions or logic.
It models software based on real-world entities, making programs modular, scalable, and
easier to maintain.

Python is a multi-paradigm language (supports procedural, functional, and object-oriented

programming), but OOP becomes essential when programs grow large or when we want
reusable components.

In OOP:

 Objects represent data.

 Classes define the blueprint for creating objects.
 Methods define behavior.
 Attributes store object-related information.

Why OOP? (Importance & Advantages)

OOP helps solve several challenges that arise in large scripts:
✔ Organized Code
Instead of having hundreds of unrelated functions, OOP groups related data and behavior.
✔ Reusability
Once a class is written, it can be used in multiple programs.
✔ Modularity
Different classes handle different responsibilities.
✔ Reduced Complexity
You interact with objects without worrying about how they work internally (abstraction).
✔ Scalability
Large programs like games, automation systems, and web apps rely on classes.
Fundamental Concepts of OOP
Class
A class is a template or blueprint used to create objects.
It defines:
 Attributes (variables)
 Methods (functions)
Syntax:
class ClassName:
# attributes and methods

Example:
class Student:
pass

Nayana M Ass. Prof. Dept. of MBA Page 1

 MBABA313
Advanced Python Techniques

Object
An object is an instance of a class.

Example:

s1 = Student()
Each object has its own data stored in the attributes.

Attributes (Object Variables)

Attributes store information within an object.

There are two types:
✔ Instance Attributes
Unique to each object.
✔ Class Attributes
Shared across all objects (rarely used by beginners).

Example:

class Student:
school_name = "ABC School" # class attribute

def __init__(self, name, age):

[Link] = name # instance attribute
[Link] = age

Methods (Object Functions)

Methods define the actions an object can perform.

Three categories:
 Instance methods
 Class methods
 Static methods

The __init__() Method (Constructor)

The constructor is a special method automatically called when an object is created.
Purpose:
 Initialize object attributes
 Set starting values
 Ensure object is ready to use
 Example:

class Dog:
def __init__(self, name, color):
[Link] = name
[Link] = color

self refers to the current object calling the method.

Nayana M Ass. Prof. Dept. of MBA Page 2

 MBABA313
Advanced Python Techniques

Example: Complete Class with Attributes & Methods

class Dog:
def __init__(self, name, age):
[Link] = name
[Link] = age

def bark(self):
print(f"{[Link]} is barking!")

def birthday(self):
[Link] += 1
print(f"{[Link]} is now {[Link]} years old.")

Using it:

d = Dog("Rocky", 2)
[Link]()
[Link]()
Principles of Object-Oriented Programming (Core Ideas)
OOP is built on four main principles:
[Link]
Encapsulation means bundling data and methods together.
We hide internal details and only expose necessary parts.
Example: Private variables
self.__password
Benefits:
 Security
 Data protection
 Cleaner classes

[Link]
Abstraction hides complex implementation and shows only essential features.
Example:
When you call:
[Link]()
You don’t care about fuel injection, spark plugs, or engine cycles.
You only see the action.

[Link]
Inheritance allows one class to reuse the features of another class.
Parent class → base class
Child class → derived class
Example:
class Animal:
def eat(self):
print("Eating")

class Dog(Animal):
def bark(self):

Nayana M Ass. Prof. Dept. of MBA Page 3

 MBABA313
Advanced Python Techniques

print("Barking")

Dog automatically gets the eat() method.

Benefits:
 Eliminates code repetition
 Promotes reusability
 Simplifies design

[Link]
Polymorphism means “many forms.”
A single method name can behave differently based on the object.

Example:

class Cat:

def sound(self):
print("Meow")

class Dog:
def sound(self):
print("Woof")

Calling:

[Link]()

Will behave differently based on the object type.

Types of Methods
Instance Methods
Most common.
Operate on individual objects.
def show(self):
print([Link])

Class Methods
Work with class variables.
@classmethod
def info(cls):
print("This is a class method")

Static Methods
Independent utility functions inside a class.
@staticmethod
def greet():
print("Hello!")

Nayana M Ass. Prof. Dept. of MBA Page 4

 MBABA313
Advanced Python Techniques

What Is Inheritance?
Inheritance means creating a new class (child class) from an existing class (parent class).
The child class automatically inherits:
 Attributes
 Methods
 Behaviors

Why Use Inheritance?

✔ Avoid duplicating code
✔ Reuse existing functionality
✔ Build more specialized classes
✔ Organize code into a hierarchy
✔ Make automation programs cleaner

Example from real world:

 Parent class → Animal

 Child classes → Dog, Cat, Cow

All animals eat and breathe, so instead of repeating this, they inherit it.

Basic Syntax of Inheritance

class ParentClass:
# parent attributes and methods

class ChildClass(ParentClass):
# child-specific attributes/methods
Simple Example
Parent class
class Animal:
def eat(self):
print("The animal is eating.")

Child class
class Dog(Animal):
def bark(self):
print("The dog is barking.")

Using inheritance
d = Dog()
[Link]() # inherited from Animal
[Link]() # own method
Output:
The animal is eating.
The dog is barking.

Nayana M Ass. Prof. Dept. of MBA Page 5

 MBABA313
Advanced Python Techniques

The super() Function

super() is used to call the parent class’s constructor or methods.
Useful when the child class has its own __init__() method.

Example:
class Animal:
def __init__(self, name):
[Link] = name

class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # call parent constructor
[Link] = breed

Usage:

d = Dog("Rocky", "Labrador")
print([Link])
print([Link])
Overriding Methods
A child class can replace a parent method by creating a method with the same name.

class Animal:
def sound(self):
print("Animals make sound")

class Dog(Animal):
def sound(self):
print("Dog barks")

Usage:

d = Dog()
[Link]()

Multi-Level Inheritance

Parent → Child → Grandchild

class A:
pass

class B(A):
pass

class C(B):
pass

Nayana M Ass. Prof. Dept. of MBA Page 6

 MBABA313
Advanced Python Techniques

Multiple Inheritance (Python-Specific Feature)

A class can inherit from multiple parents.

class A:
pass

class B:
pass

class C(A, B):

pass

POLYMORPHISM:

Polymorphism means "many forms". It refers to the ability of an entity (like a function or
object) to perform different actions based on the context.
Why do we need Polymorphism?
 Ensures consistent interfaces across different classes.
 Allows objects to respond differently to the same method call.
 Promotes loose coupling by relying on shared behavior, not specific types.
 Enables writing flexible, reusable code that works across types.
 Simplifies testing and future extension of code.
Example of Polymorphism
A remote control can operate multiple devices like a TV, AC or music system. You press
the power button and each device responds differently TV turns on, AC starts cooling,
music system plays music.
Polymorphism here means same interface (power button), but different behavior based on
device (object).
Types of Polymorphism
Polymorphism in Python refers to ability of the same method or operation to behave
differently based on object or context. It mainly includes compile-time and runtime
polymorphism.

1. Compile-time Polymorphism
Compile-time polymorphism means deciding which method or operation to run during
compilation, usually through method or operator overloading.

Nayana M Ass. Prof. Dept. of MBA Page 7

 MBABA313
Advanced Python Techniques

Python doesn’t because it’s dynamically typed it resolves method calls at runtime, not
during compilation.
Example:
This code demonstrates method overloading in Python using default and variable-length
arguments. The multiply() method works with different numbers of inputs, mimicking
compile-time polymorphism.

class Calculator:
def multiply(self, a=1, b=1, *args):
result = a * b
for num in args:
result *= num
return result

# Create object
calc = Calculator()

# Using default arguments

print([Link]())
print([Link](4))

# Using multiple arguments

print([Link](2, 3))
print([Link](2, 3, 4))

Output
1
4
6
24

2. Runtime Polymorphism (Overriding)

Runtime polymorphism means that the behavior of a method is decided while program is
running, based on the object calling it.
In Python, this happens through Method Overriding a child class provides its own version
of a method already defined in the parent class. Since Python is dynamic, it supports this,
allowing same method call to behave differently for different object types.
Example:
This code shows runtime polymorphism using method overriding. The sound() method is
defined in base class Animal and overridden in Dog and Cat. At runtime, correct method is
called based on object's class.

class Animal:
def sound(self):
return "Some generic sound"

class Dog(Animal):

Nayana M Ass. Prof. Dept. of MBA Page 8

 MBABA313
Advanced Python Techniques

def sound(self):
return "Bark"

class Cat(Animal):
def sound(self):
return "Meow"

# Polymorphic behavior
animals = [Dog(), Cat(), Animal()]
for animal in animals:
print([Link]())
Output
Bark
Meow
Some generic sound
Polymorphism in Built-in Functions
Python’s built-in functions like len() and max() are polymorphic they work with different
data types and return results based on type of object passed. This showcases it's dynamic
nature, where same function name adapts its behavior depending on input.
Example:
This code demonstrates polymorphism in Python’s built-in functions handling strings, lists,
numbers and characters differently while using same function name.

print(len("Hello")) # String length

print(len([1, 2, 3])) # List length

print(max(1, 3, 2)) # Maximum of integers

print(max("a", "z", "m")) # Maximum in strings
Output
5
3
3
z
Polymorphism in Operators
In Python, same operator (+) can perform different tasks depending on operand types. This
is known as operator overloading. This flexibility is a key aspect of polymorphism in
Python.
Example:
This code shows operator polymorphism as + operator behaves differently based on data
types adding integers, concatenating strings and merging lists all using same operator.

print(5 + 10) # Integer addition

print("Hello " + "World!") # String concatenation
print([1, 2] + [3, 4]) # List concatenation
Output
15
Hello World!
[1, 2, 3, 4]

Nayana M Ass. Prof. Dept. of MBA Page 9

 MBABA313
Advanced Python Techniques

Python Exception Handling

Python Exception Handling allows a program to gracefully handle unexpected events (like
invalid input or missing files) without crashing. Instead of terminating abruptly, Python lets
you detect the problem, respond to it, and continue execution when possible.

Handling Simple Exception

n = 10
try:
res = n / 0
except ZeroDivisionError:
print("Can't be divided by zero!")
Output
Can't be divided by zero!
Explanation: Dividing a number by 0 raises a ZeroDivisionError. The try block contains
code that may fail and except block catches the error, printing a safe message instead of
stopping the program.

Difference Between Errors and Exceptions

Errors and exceptions are both issues in a program, but they differ in severity and handling.
Let's see how:
 Error: Serious problems in the program logic that cannot be handled. Examples include
syntax errors or memory errors.
 Exception: Less severe problems that occur at runtime and can be managed using
exception handling (e.g., invalid input, missing files).
Example: This example shows the difference between a syntax error and a runtime
exception.

Nayana M Ass. Prof. Dept. of MBA Page 10

 MBABA313
Advanced Python Techniques

# Syntax Error (Error)

print("Hello world" # Missing closing parenthesis

# ZeroDivisionError (Exception)
n = 10
res = n / 0

Explanation: A syntax error stops the code from running at all, while an exception like
ZeroDivisionError occurs during execution and can be caught with exception handling.

Syntax and Usage

Python provides four main keywords for handling exceptions: try, except, else and finally
each plays a unique role.
try:
# Code
except SomeException:
# Code
else:
# Code
finally:
# Code
 try: Runs the risky code that might cause an error.
 except: Catches and handles the error if one occurs.
 else: Executes only if no exception occurs in try.
 finally: Runs regardless of what happens useful for cleanup tasks like closing files.

Custom Exceptions in Python

In Python, exceptions occur during the execution of a program that disrupts the normal
flow of the program’s instructions. When an error occurs, Python raises an exception,
which can be caught and handled using try and except blocks.
Here’s a simple example of handling a built-in exception:
try:
result = 10 / 0
except ZeroDivisionError:
print("You cannot divide by zero!")

In this example, ZeroDivisionError is a built-in exception that gets raised when you attempt
to divide by zero.

Why Define Custom Exceptions?

Custom exceptions are useful in the following scenarios:
1. Clarity: They provide clear, specific error messages that are relevant to your
application.
2. Granularity: They allow for more fine-grained error handling, making it easier to
pinpoint and address specific issues.
3. Reusability: They can be reused across different parts of your application or even in
different projects.
Defining a Custom Exception
To define a custom exception in Python, you need to create a new class that inherits from
the built-in Exception class or one of its subclasses.
Nayana M Ass. Prof. Dept. of MBA Page 11
 MBABA313
Advanced Python Techniques

class MyCustomError(Exception):
"""Exception raised for custom error scenarios.

Attributes:
message -- explanation of the error
"""

def __init__(self, message):

[Link] = message
super().__init__([Link])
In this example, MyCustomError is a custom exception class that inherits from Exception.
It has an __init__ method that takes a message parameter and passes it to the base class
constructor.
Defining a Custom Exception
To define a custom exception we create a new class that inherits from the built-in
'Exception' class and override its methods to customize its behavior for specificity.

class MyCustomError(Exception):
"""Exception raised for custom error in the application."""

def __init__(self, message, error_code):

super().__init__(message)
self.error_code = error_code

def __str__(self):
return f"{[Link]} (Error Code: {self.error_code})"

Raising a Custom Exception

To raise a custom exception, use the raise keyword followed by an instance of your custom
exception.
def divide(a, b):
if b == 0:
raise MyCustomError("Division by zero is not allowed", 400)
return a / b

Here the divide method raises the 'MyCustomError' when an attempt to divide by zero is
made.
Handling Custom Exceptions
Custom exceptions can be handled similar to built-in exceptions using a `try...except`
block.
try:
result = divide(10, 0)
except MyCustomError as e:
print(f"Caught an error: {e}")

Here divide function raises `MyCustomError` and it is caught and handled by the `except`
block.
Python Modules
A Module in python is a file containing definitions and statements. A module can define
functions, classes and variables. Modules help organize code into separate files so that
Nayana M Ass. Prof. Dept. of MBA Page 12
 MBABA313
Advanced Python Techniques

programs become easier to maintain and reuse. Instead of writing everything in one place,
related functionality can be grouped into its own module and imported whenever needed.

Create a Python Module

To create a Python module, write the desired code and save that in a file with .py extension.
Let's understand it better with an example:
Example: Let's create a [Link] in which we define two functions, one add and another
subtract.

# [Link]
def add(x, y):
return (x+y)

def subtract(x, y):

return (x-y)

Import module
Modules can be used in another Python file using the import statement. When Python sees
an import, it loads the module if it exists in the interpreter’s search path.
Syntax:
import module
Example: Now, we are importing the calc that we created earlier to perform add operation.
import calc
print([Link](10, 2))
Output
12

Types of Import Statements

1. Import From Module: This allows importing specific functions, classes, or variables
rather than the whole module.
from math import sqrt, factorial
print(sqrt(16))
print(factorial(6))
Output
4.0
720
Import All Names: * imports everything from a module into the current namespace.
from math import *
print(sqrt(16))
print(factorial(6))
Output
4.0
720

Nayana M Ass. Prof. Dept. of MBA Page 13

 MBABA313
Advanced Python Techniques

Types of Modules in Python

Python provides several kinds of modules. Each type plays a different role in application
development.

1. Built-in Modules: These come bundled with Python and require no installation - e.g.,
math, random, os.
import random
print([Link](1, 5))
Output
4
Explanation: [Link]() returns a random number within the given range.

2. User-Defined Modules: These are modules you create yourself, such as [Link].
import calc
print([Link](20, 5))
Output
15
Explanation: The module is created manually and then imported into another script.

3. External (Third-Party) Modules: These modules are installed using pip - e.g., NumPy,
Pandas, Requests.
import requests
r = [Link]("[Link]
print(r.status_code)
Output
200

[Link] Modules: A package is a directory containing multiple modules, usually with

an __init__.py file.
Example Directory
mypkg/
__init__.py
[Link]
[Link]

Using a module from a package

from mypkg import utils
print(utils.some_func())

calls a function named some_func(), the output will be whatever that function returns.
If [Link] contains something like:
def some_func():
return "Hello"
Output
Hello

Nayana M Ass. Prof. Dept. of MBA Page 14

 MBABA313
Advanced Python Techniques

What is a Python Module?

A module can be imported by multiple programs for their application, hence a single code
can be used by multiple programs to get done with their functionalities faster and reliably.
Install a Python Module with pip
Below are some of the steps by which we can follow to install a Python module with pip in
Windows:
Step 1: Open the Command Prompt
Open the command prompt (Windows) or terminal (Mac or Linux) on your computer.
Step 2: Installing Python Modules with Pip
Use the following command to install a module via pip, which is the package installer for
Python:
pip install <module name>
Replace <module name> with the name of the module you want to install. For example, to
install the popular numpy module, you would use:
pip install numpy
Step 3: Verifying Module Installation
You can now use the module in your Python code by importing it at the beginning of your
script. For example, if you installed the numpy module, you would add the following line at
the top of your script:
import numpy

Python Packages
Python packages are a way to organize and structure code by grouping related modules into
directories.
 A package is essentially a folder that contains an __init__.py file and one or more
Python files (modules).
 Allows modules to be easily shared and distributed across different applications.
Key Components of a Python Package
 Module: A single Python file containing reusable code (e.g., [Link]).
 Package: A directory containing modules and a special __init__.py file.
 Sub-Packages: Packages nested within other packages for deeper organization.

Nayana M Ass. Prof. Dept. of MBA Page 15

 MBABA313
Advanced Python Techniques

How to create and access packages in python

1. Create a Directory: Make a directory for your package. This will serve as the root
folder.
2. Add Modules: Add Python files (modules) to the directory, each representing specific
functionality.
3. Include __init__.py: Add an __init__.py file (can be empty) to the directory to mark it
as a package.
4. Add Sub packages (Optional): Create subdirectories with their own __init__.py files
for sub packages.
5. Import Modules: Use dot notation to import, e.g., from mypackage.module1 import
greet.
Example:
# Initialize the main package
from .calculate import calculate
from .basic import add, subtract
from .advanced import multiply, divide

math_operations/[Link]:
This calculate file is a simple placeholder that prints "Performing calculation...", serving as
a basic demonstration or utility within the package.

def calculate():
print("Performing calculation...")
# Export functions from the basic sub-package
from .add import add
from .sub import subtract

math_operations/basic/[Link]:
def add(a, b):
return a + b

math_operations/basic/[Link]:
def subtract(a, b):
return a – b

Example:
Now, let's take an example of importing the module into a code and using the function:
from math_operations import calculate, add, subtract

Nayana M Ass. Prof. Dept. of MBA Page 16

 MBABA313
Advanced Python Techniques

# Using the placeholder calculate function

calculate()

# Perform basic operations

print("Addition:", add(5, 3))
print("Subtraction:", subtract(10, 4))

Output:
6
8

Introduction to jupyter notebooks:

Jupyter Notebook is an open-source web application that allows you to create and share
documents that contain live code, equations, visualizations and narrative text. Jupyter
supports for over 40 different programming languages and Python is one of them.
1. Install Jupyter Notebook with Anaconda
Install Python and Jupyter using Anaconda Distribution, which includes Python, Jupyter
Notebook and other commonly used packages for scientific computing and data science.
2. Install Jupyter Notebook using PIP
Install Jupyter using PIP package manager used to install and manage software
packages/libraries written in Python.
Setup
Command to Launch Jupyter Notebook
jupyter notebook
This will start up Jupyter and your default browser should start (or open a new tab) to
following URL: [Link]

Nayana M Ass. Prof. Dept. of MBA Page 17

 MBABA313
Advanced Python Techniques

When notebook opens in your browser, you will see Notebook Dashboard, which will show
a list of notebooks, files and subdirectories in the directory where notebook server was
started. Often this will be your home directory:

Creating a Jupyter Notebook

Now on dashboard, you can see a new button at top right corner. Click it to open a drop-
down list and then if you'll click on Python3, it will open a new notebook.

Nayana M Ass. Prof. Dept. of MBA Page 18

 MBABA313
Advanced Python Techniques

Renaming Jupyter Notebooks

We can notice that at the top of the page is the word Untitled. This is the title for the page
and the name of your Notebook. We can change the name by simply clicking on it.

Run and Debug Jupyter Notebook Code Cell

Let’s try adding the following code to that cell:
Running a cell means that we want to execute the cell’s contents. To execute a cell, you can
just select the cell and click Run button that is in the row of buttons along the top. It’s
towards the middle.

Jupyter Notebook Menu Items

Jupyter Notebook contains a list of menus which can be used to perform various functions.
1. File: allows you to perform actions like creating and opening notebooks, saving your
work, exporting notebooks in different formats, managing checkpoints and closing
notebooks.
2. Edit: provides various editing options for the cells within your notebook. You can cut,
copy, paste, delete, merge, split and manipulate cells using these edit functions.
3. View: provides options to control the appearance and layout of your notebook interface,
allowing you to customize its display to your preferences and needs.
4. Insert: contains options for adding new cells and other elements to your notebook,
allowing you to insert code, text or various types of content into your document.

Nayana M Ass. Prof. Dept. of MBA Page 19

 MBABA313
Advanced Python Techniques

5. Cell: provides options for manipulating individual cells within your notebook. You can
use it to run, delete and modify cells, as well as change their cell type (e.g., code or
markdown). This menu is essential for cell-level operations in your notebook.
6. Kernel: allows you to interrupt or restart the computation process, reconnect to a kernel
and change the kernel (i.e., programming language and environment) for your
notebook. It’s crucial for managing execution state of a Jupyter Notebook.
7. Widgets: used for working with interactive widgets, which are graphical elements that
enhance interactivity and user experience of your notebook. You can use this menu to
create, display and interact with widgets like buttons, sliders, text boxes and more.
8. Help: offers documentation and resources to assist users in understanding and using
Jupyter Notebook effectively.
Jupyter Notebook is an open-source web application that allows the creation and sharing of
documents containing live code, equations, visualizations, and narrative text. It is widely used
in data science, machine learning, and scientific computing for its interactive and iterative
nature.
Writing Code in Jupyter Notebook:
 Launch Jupyter Notebook:
Open your terminal or command prompt and type jupyter notebook. This will open a new tab
in your web browser displaying the Jupyter dashboard.
 Create a New Notebook:
From the dashboard, navigate to the desired directory and click on "New" in the top right
corner, then select a kernel (e.g., Python 3) to create a new notebook.
 Code Cells:
Notebooks consist of cells. By default, new cells are "code" cells. You can type your Python
code directly into these cells.

print("Hello, Jupyter!")
x = 10
y = 20
result = x + y
print(result)

x = 10
y = 20
result = x + y
print(result)
 Markdown Cells: You can change the cell type to "Markdown" to add explanatory text,
headings, lists, and other formatted content using Markdown syntax. This allows you to
document your code and analysis within the same document.

# Introduction to Jupyter
This notebook demonstrates basic Python code execution.
Running Code in Jupyter Notebook:
 Select a Cell:
Click on the code cell you want to execute.
 Run the Cell:
 Click the "Run" button (a right-pointing triangle) in the toolbar.

Nayana M Ass. Prof. Dept. of MBA Page 20

 MBABA313
Advanced Python Techniques

 Press Shift + Enter to run the current cell and move to the next cell (or create a new one if it's
the last cell).
 Press Ctrl + Enter (or Cmd + Enter on macOS) to run the current cell and keep the focus on
it.
 Press Alt + Enter to run the current cell and insert a new cell below it, keeping the focus on
the newly inserted cell.
 Output:
The output of the executed code will appear directly below the code cell. This includes
printed statements, variable values, plots, and any error messages.
 Kernel:
The kernel is the computational engine that executes the code. You can restart the kernel
(e.g., if code gets stuck or you want to clear variables) or interrupt its execution from the
"Kernel" menu in the toolbar.

Nayana M Ass. Prof. Dept. of MBA Page 21