1/15/25, 10:57 AM OOP in Python.
ipynb - Colab
keyboard_arrow_down Debre Berhan University
College of Computing
Department of Software Engineering
Principle of Programming
SEng 2021
01/15/2025
keyboard_arrow_down OOP
add Code add Text
keyboard_arrow_down Contents
Programming paradigms
Classes
Object
Four pillars of OOP
keyboard_arrow_down Learning Outcomes
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 1/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
Describe and implement object-oriented programming concepts such as classes, objects and
inheritance using python.
Demonstrate and apply the concepts and principles of Python programming language to real
world problems to develop a computer-based solution.
keyboard_arrow_down Introduction
Programming Paradigms
Programming paradigms is the way/style of writing a program
It is not refering to the specifice proramming language
Popular paradigms
Imparative
Procedural
Functional
Declarative
Object oriented
Imparative: step by step commanding a computer to do a specific task
Procedural: make code in a subroutines/procedures to improve modularity
Functional: Assing in avairable, pass as argument, returned from other function
Declarative: Hide the complexity and bringing programming language to human languge and
thinking.
OOP: Real wold entities coded as an object.
keyboard_arrow_down Imparative
numbers = [1,2,3,4,5,6,7,8,9,10]
sum = 0
for number in numbers:
if number == 8:
continue
else:
sum += number
print("Sum of the first ten integers except 8 =",sum)
Sum of the first ten integers except 8 = 47
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 2/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
keyboard_arrow_down Procedural
numbers = [1,2,3,4,5,6,7,8,9,10]
def add():
sum = 0
for number in numbers:
if number == 8:
continue
else:
sum += number
return sum
print("Sum of the first ten integers except 8 =",add())
Sum of the first ten integers except 8 = 47
keyboard_arrow_down Functional
numbers = [1,2,3,4,5,6,7,8,9,10]
def add():
sum = 0
for number in numbers:
if number == 8:
continue
else:
sum += number
return sum
print("Sum of the first ten integers except 8 =",add())
Sum of the first ten integers except 8 = 47
keyboard_arrow_down Declarative
Examples
filter()
map()
reduce()
sum()
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 3/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def add():
# Filter out the number 8
filtered_numbers = filter(lambda x: x != 8, numbers)
# Sum the filtered numbers
total_sum = sum(filtered_numbers)
return total_sum
print("Sum of the first ten integers except 8 =", add())
Sum of the first ten integers except 8 = 47
keyboard_arrow_down OOP
-- class
-- variables
-- method
-- object
-- properties
-- best practices
keyboard_arrow_down Benfites of OOP
Reusability of code.
Easier debugging and maintenance.
Improved modularity and scalability.
keyboard_arrow_down Class
It is a bluprint of an real-world object/entity
It is like a form/template for real-world object
It used to bundle propeties and methods
It is user defined data type
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 4/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
Syntax
class <name>:
properties
method/s
class is a keyword to start class
class name by convension it is a singular noun and if it is more than a word better to follow
pascal style
After a name colon(:) is followed
Then inside properites and methods could be defined when necessary and if not it can be
defined without them like below
Dot(.) is an operator used to access class members
class Student:
...
class Studen:
pass
print(Student)
<class '__main__.Student'>
print(type(Student))
<class 'type'>
x = 90
print(type(x))
<class 'int'>
Class with instance attributes
keyboard_arrow_down _init_() method
It is magic method used to set attributes of a class
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 5/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
It helps to pass data when an object is inistantiating
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
student1 = Student("John", 20) # object instansation
print("Name:",student1.name, ",Age:",student1.age)
student2 = Student("Abel", 22) # object instansation
print("Name:",student2.name, ",Age:",student1.age)
Name: John ,Age: 20
Name: Abel ,Age: 20
Class can be defined like this also, but it is not good practice
class Student:
first_name = None
last_name = None
student1 = Student()
student1.first_name = "John"
student1.last_name = "Doe"
print(student1.first_name, student1.last_name)
print("-"*50)
student2 = Student()
student2.first_name = "Abel"
student2.last_name = "Samuael"
print(student2.first_name, student2.last_name)
John Doe
--------------------------------------------------
Abel Samuael
keyboard_arrow_down Variables
Instance attribute/variable
Class attribute/variable
keyboard_arrow_down Instance variables
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 6/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
They are specific for an instance of a class
Example
name
age
keyboard_arrow_down Class Variable
They could be refered by a class directly
Example
first_name
last_name
keyboard_arrow_down Methods
They are functions in a class
They could be:
instance method
decorator
class method
magic/danda method
keyboard_arrow_down Instance method
These are the most common methods in a class, which operate on instance-level data.
They take self as the first parameter to access instance attributes and other instance
methods. However, the word self can be any name of the first parameter
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 7/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
def print_info(self):
print("Name:",self.name, ",Age:",self.age)
student1 = Student("John", 20) # object instansation
student1.print_info()
student2 = Student("Abel", 22) # object instansation
student2.print_info()
Name: John ,Age: 20
Name: Abel ,Age: 22
keyboard_arrow_down Decorator
A decorator in Python is a design pattern used to modify or enhance the behavior of a
function, method, or class without permanently changing its structure.
Decorators are applied using the @decorator_name syntax.
keyboard_arrow_down Class method
These methods operate on the class itself rather than an instance.
They take cls as the first parameter to access class attributes or modify the class state.
Defined using the @classmethod decorator.
class Student:
name = None
age = None
@classmethod
def print_info(cls):
print("Name:",cls.name, ",Age:",cls.age)
Student.name = "John"
Student.age = 20
Student.print_info()
Name: John ,Age: 20
keyboard_arrow_down Magic/dunda methods
Special methods in Python that start and end with double underscores (__).
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 8/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
They provide built-in behavior for custom objects, such as operator overloading and object
initialization.
examples _init_, _str_, _gt_
_str_()
It use to print string of an object
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Name:{self.name}, Age:{self.age}"
student1 = Student("John", 20) # object instansation
print(student1)
student2 = Student("Abel", 22) # object instansation
print("Name:",student2.name, ",Age:",student1.age)
Name:John, Age:20
Name: Abel ,Age: 20
_eq_()
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Name:{self.name}, Age:{self.age}"
def __eq__(self, other):
return self.age == other.age
student1 = Student("John", 20) # object instansation
print(student1)
student2 = Student("Abel", 22) # object instansation
print(student1.name, "is equal with", student2.name, ":", student1 == student2)
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 9/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
Name:John, Age:20
John is equal with Abel : False
_gt_()
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Name:{self.name}, Age:{self.age}"
def __gt__(self, other):
return self.age > other.age
student1 = Student("John", 20) # object instansation
print(student1)
student2 = Student("Abel", 22) # object instansation
print(student1.name, "is elder than", student2.name, ":", student1 > student2)
Name:John, Age:20
John is elder than Abel : False
keyboard_arrow_down Object
An instance of a class
Exmple
student1
keyboard_arrow_down Properties(getter and setter)
To make attributes private use _(underscor) or __(double underscore) as a convension
However, it does not prevent the propery from modified by a user
@property decorator is used for a getter
@<name>.setter for a setter
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 10/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
student1 = Student("John", 20) # object instansation
student1.name = "Abel"
print(student1.name)
Abel
keyboard_arrow_down Four pillars of OOP
1. Inheritance
It is a code reuse mechanism
There is a super/base/parent class which has some code defined and drived/sub/child class
that reused the code already defined in super/base/parent class
Syntax
class Base:
...
class Derived(Base):
...
class User:
def __init__(self, name, age):
self.name = name
self.age = age
class Student(User):
def __init__(self, name, age, student_id):
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 11/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
super().__init__(name, age)
self.student_id = student_id
def __str__(self):
return f"Name:{self.name}, Age:{self.age}, Student ID:{self.student_id}"
student1 = Student("John", 20, 12345)
print(student1)
Name:John, Age:20, Student ID:12345
class User:
def __init__(self, name, age):
if not name:
raise ValueError("Missing name")
if not age:
raise ValueError("Missing age")
self.name = name
self.age = age
class Student(User):
def __init__(self, name, age, student_id):
super().__init__(name, age)
self.student_id = student_id
def __str__(self):
return f"Name:{self.name}, Age:{self.age}, Student ID:{self.student_id}"
name = input("Enter your name: ")
age = input("Enter your age: ")
student_id = input("Enter your student ID: ")
student1 = Student(name, age, student_id)
print(student1)
Enter your name: sdvsd
Enter your age: dvsd
Enter your student ID: dvsd
Name:sdvsd, Age:dvsd, Student ID:dvsd
keyboard_arrow_down Multiple inheritance
Not recommended
Syntax
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 12/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
class Base1:
...
class Base2:
...
class Derived(Base1, Base2):
...
2. Abstraction
It is the process of hiding implementation details and showing only essential features to the
user.
It is achieved in Python using abstract base classes (ABC) and the @abstractmethod
decorator.
from abc import ABC, abstractmethod
class Animal(ABC): # Abstract base class
@abstractmethod
def sound(self):
pass
class Dog(Animal): # Concrete class
def sound(self):
return "Bark"
class Cat(Animal): # Concrete class
def sound(self):
return "Meow"
# Usage
animals = [Dog(), Cat()]
for animal in animals:
print(animal.sound())
Bark
Meow
3. Encapsulation
It is the bundling of data and methods into a single unit (class) and restricting direct access to
some components using access modifiers (_ for protected and __ for private).
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 13/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
class BankAccount:
def __init__(self, balance):
self.__balance = balance # Private attribute
def deposit(self, amount):
if amount > 0:
self.__balance += amount
def get_balance(self):
return self.__balance
# Usage
account = BankAccount(100)
account.deposit(50)
print(account.get_balance()) # 150
#print(account.__balance) # AttributeError: 'BankAccount' object has no attribute '__balanc
150
4. Polymorphism
It means "many forms."
It allows objects of different classes to be treated as objects of a common superclass. This is
achieved through method overriding and duck typing.
class Shape:
def area(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius * self.radius
# Usage
shapes = [Rectangle(3, 4), Circle(5)]
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 14/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
for shape in shapes:
print(shape.area())
12
78.5
keyboard_arrow_down Best practices
Single responsibility principle
Open closed principle
Liskov substitution principle
Interface segregation principle
Dependency inversion principle
SOLID
keyboard_arrow_down Summary
Programming Paradigms: The document introduces different programming paradigms
including imperative, procedural, functional, declarative, and object-oriented.
It provides examples of imperative, procedural, functional and declarative paradigms.
Classes: A class is a blueprint for creating objects. It is a user-defined data type that bundles
properties and methods. The syntax for defining a class is class :. A class can be defined with
or without properties and methods.
The init() method helps to pass data when an object is instantiated.
Classes can have instance attributes, which are specific to an instance of a class.
Classes can also have class attributes, which can be referred to directly by the class.
Methods: These are functions within a class.
Instance methods operate on instance-level data and take self as the first parameter.
Class methods operate on the class itself and take cls as the first parameter. They are
defined using the @classmethod decorator.
Magic/dunder methods are special methods that start and end with double underscores
and provide built-in behavior for custom objects, such as init, str, eq, and gt.
Objects: An object is an instance of a class.
Properties: These are used to make attributes private using underscores (_ or __). The
@property decorator is used for a getter, and @<name>.setter is used for a setter.
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 15/16
1/15/25, 10:57 AM OOP in Python.ipynb - Colab
Four Pillars of OOP:
Inheritance: A mechanism for code reuse, where a derived/sub/child class inherits from
a super/base/parent class. The syntax is class Derived(Base):. The super() function can
be used to call methods from the parent class. Multiple inheritance is possible but not
recommended.
Abstraction: The process of hiding implementation details and showing only essential
features. This is achieved using abstract base classes (ABC) and the @abstractmethod
decorator.
Encapsulation: The bundling of data and methods into a single unit (class), restricting
direct access to some components using access modifiers (_ for protected and __ for
private).
Polymorphism: Allows objects of different classes to be treated as objects of a common
superclass through method overriding and duck typing.
Best Practices: The document mentions SOLID principles, including the single responsibility
principle, open-closed principle, Liskov substitution principle, interface segregation principle,
and dependency inversion principle
https://colab.research.google.com/drive/1jNuAXUpZJRMNkSzYdUueSZyMnpcteh2T#scrollTo=A-_H6w3SdLFu&printMode=true 16/16
