Core OOP Principles

Object-Oriented Programming is built on four fundamental principles: Encapsulation, Abstraction, Inheritance, and Polymorphism. This chapter covers these principles as they apply to Python, along with related concepts like composition and advanced features.

Encapsulation

Encapsulation is the bundling of data and methods that operate on that data within a single unit (class). It also involves restricting access to certain components to prevent unauthorized modification.

Private Attributes (Name Mangling)

Python doesn’t have true private attributes, but it uses name mangling to make attributes harder to access from outside the class. Prefix an attribute name with double underscores __:

1
class BankAccount:
2
    def __init__(self, balance):
3
        self.__balance = balance  # Private attribute (name mangling)
4

5
    def deposit(self, amount):
6
        if amount > 0:
7
            self.__balance += amount
8

9
    def withdraw(self, amount):
10
        if 0 < amount <= self.__balance:
11
            self.__balance -= amount
12
            return True
13
        return False
14

15
    def get_balance(self):
16
        return self.__balance
17

18
account = BankAccount(1000)
19
account.deposit(500)
20
print(account.get_balance())  # 1500
21

22
# Direct access attempts
23
# print(account.__balance)  # AttributeError: 'BankAccount' object has no attribute '__balance'
24
# But name mangling makes it accessible as:
25
print(account._BankAccount__balance)  # 1500 (not recommended, but possible)

Protected Attributes

By convention, a single underscore _ prefix indicates a protected attribute (should not be accessed from outside, but Python doesn’t enforce this):

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name        # Public
4
        self._age = age         # Protected (convention)
5
        self.__salary = 0       # Private (name mangling)
6

7
    def get_age(self):
8
        return self._age
9

10
person = Person("Alice", 25)
11
print(person.name)      # Alice (public, accessible)
12
print(person._age)       # 25 (protected, accessible but not recommended)
13
# print(person.__salary) # AttributeError

Getters and Setters

Use properties to create getters and setters for controlled access:

1
class Temperature:
2
    def __init__(self, celsius):
3
        self._celsius = celsius
4

5
    @property
6
    def celsius(self):
7
        return self._celsius
8

9
    @celsius.setter
10
    def celsius(self, value):
11
        if value < -273.15:
12
            raise ValueError("Temperature below absolute zero")
13
        self._celsius = value
14

15
    @property
16
    def fahrenheit(self):
17
        return (self._celsius * 9/5) + 32
18

19
    @fahrenheit.setter
20
    def fahrenheit(self, value):
21
        self.celsius = (value - 32) * 5/9
22

23
temp = Temperature(25)
24
print(temp.celsius)      # 25
25
print(temp.fahrenheit)   # 77.0
26

27
temp.fahrenheit = 100
28
print(temp.celsius)      # 37.777...

Polymorphism

Polymorphism means “many forms” - the ability of different classes to be used through the same interface. Python supports polymorphism through duck typing and method overriding.

Duck Typing

“If it walks like a duck and quacks like a duck, it’s a duck.” Python uses duck typing - if an object has the required methods, it can be used regardless of its type:

1
class Dog:
2
    def speak(self):
3
        return "Woof!"
4

5
class Cat:
6
    def speak(self):
7
        return "Meow!"
8

9
class Robot:
10
    def speak(self):
11
        return "Beep boop!"
12

13
def make_sound(animal):
14
    print(animal.speak())
15

16
dog = Dog()
17
cat = Cat()
18
robot = Robot()
19

20
make_sound(dog)    # Woof!
21
make_sound(cat)    # Meow!
22
make_sound(robot)  # Beep boop!

Polymorphism with Inheritance

1
class Shape:
2
    def area(self):
3
        raise NotImplementedError("Subclass must implement area()")
4

5
class Rectangle(Shape):
6
    def __init__(self, length, width):
7
        self.length = length
8
        self.width = width
9

10
    def area(self):
11
        return self.length * self.width
12

13
class Circle(Shape):
14
    def __init__(self, radius):
15
        self.radius = radius
16

17
    def area(self):
18
        return 3.14159 * self.radius ** 2
19

20
def print_area(shape):
21
    print(f"Area: {shape.area()}")
22

23
rect = Rectangle(5, 3)
24
circle = Circle(4)
25

26
print_area(rect)   # Area: 15
27
print_area(circle) # Area: 50.26544

Operator Overloading (Polymorphism)

Polymorphism also applies to operators through special methods:

1
class Vector:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

6
    def __add__(self, other):
7
        return Vector(self.x + other.x, self.y + other.y)
8

9
    def __mul__(self, scalar):
10
        return Vector(self.x * scalar, self.y * scalar)
11

12
    def __str__(self):
13
        return f"Vector({self.x}, {self.y})"
14

15
v1 = Vector(2, 3)
16
v2 = Vector(1, 4)
17
v3 = v1 + v2
18
v4 = v1 * 3
19

20
print(v3)  # Vector(3, 7)
21
print(v4)  # Vector(6, 9)

Abstraction

Abstraction hides complex implementation details and shows only essential features. In Python, abstraction is achieved through abstract base classes.

Abstract Base Classes (ABC)

Use the abc module to create abstract classes:

1
from abc import ABC, abstractmethod
2

3
class Animal(ABC):
4
    @abstractmethod
5
    def make_sound(self):
6
        pass
7

8
    @abstractmethod
9
    def move(self):
10
        pass
11

12
    def sleep(self):
13
        return "Sleeping..."
14

15
class Dog(Animal):
16
    def make_sound(self):
17
        return "Woof!"
18

19
    def move(self):
20
        return "Running on four legs"
21

22
class Bird(Animal):
23
    def make_sound(self):
24
        return "Chirp!"
25

26
    def move(self):
27
        return "Flying"
28

29
# animal = Animal()  # TypeError: Can't instantiate abstract class
30
dog = Dog()
31
bird = Bird()
32

33
print(dog.make_sound())  # Woof!
34
print(bird.move())       # Flying

Abstract Properties

You can also create abstract properties:

1
from abc import ABC, abstractmethod
2

3
class Shape(ABC):
4
    @property
5
    @abstractmethod
6
    def area(self):
7
        pass
8

9
    @property
10
    @abstractmethod
11
    def perimeter(self):
12
        pass
13

14
class Rectangle(Shape):
15
    def __init__(self, length, width):
16
        self.length = length
17
        self.width = width
18

19
    @property
20
    def area(self):
21
        return self.length * self.width
22

23
    @property
24
    def perimeter(self):
25
        return 2 * (self.length + self.width)
26

27
rect = Rectangle(5, 3)
28
print(rect.area)       # 15
29
print(rect.perimeter)  # 16

Composition vs Inheritance

Composition is a design pattern where a class contains objects of other classes, rather than inheriting from them. “Has-a” relationship vs “Is-a” relationship.

Inheritance (Is-a)

1
class Animal:
2
    def move(self):
3
        return "Moving"
4

5
class Dog(Animal):  # Dog IS-A Animal
6
    def bark(self):
7
        return "Woof!"
8

9
dog = Dog()
10
print(dog.move())  # Moving (inherited)
11
print(dog.bark())  # Woof!

Composition (Has-a)

1
class Engine:
2
    def start(self):
3
        return "Engine started"
4

5
class Wheel:
6
    def rotate(self):
7
        return "Wheel rotating"
8

9
class Car:
10
    def __init__(self):
11
        self.engine = Engine()  # Car HAS-A Engine
12
        self.wheels = [Wheel() for _ in range(4)]  # Car HAS-A Wheels
13

14
    def start(self):
15
        return self.engine.start()
16

17
    def drive(self):
18
        return ", ".join([wheel.rotate() for wheel in self.wheels])
19

20
car = Car()
21
print(car.start())  # Engine started
22
print(car.drive())  # Wheel rotating, Wheel rotating, Wheel rotating, Wheel rotating

When to Use Composition vs Inheritance

Use Inheritance when there’s a clear “is-a” relationship and you want to reuse code
Use Composition when there’s a “has-a” relationship or you want more flexibility

1
# Inheritance example
2
class Employee:
3
    def work(self):
4
        return "Working"
5

6
class Manager(Employee):  # Manager IS-A Employee
7
    def manage(self):
8
        return "Managing"
9

10
# Composition example
11
class Salary:
12
    def __init__(self, amount):
13
        self.amount = amount
14

15
class Employee:
16
    def __init__(self, salary):
17
        self.salary = salary  # Employee HAS-A Salary
18

19
    def get_salary(self):
20
        return self.salary.amount
21

22
salary = Salary(50000)
23
employee = Employee(salary)
24
print(employee.get_salary())  # 50000

Data Classes (Python 3.7+)

Data classes automatically generate special methods like __init__, __repr__, and __eq__ for classes that primarily store data:

1
from dataclasses import dataclass
2

3
@dataclass
4
class Point:
5
    x: float
6
    y: float
7

8
    def distance_from_origin(self):
9
        return (self.x ** 2 + self.y ** 2) ** 0.5
10

11
@dataclass
12
class Person:
13
    name: str
14
    age: int
15
    email: str = ""  # Default value
16

17
p1 = Point(3, 4)
18
p2 = Point(3, 4)
19
p3 = Point(5, 6)
20

21
print(p1)           # Point(x=3, y=4)
22
print(p1 == p2)     # True (automatic __eq__)
23
print(p1 == p3)     # False
24
print(p1.distance_from_origin())  # 5.0
25

26
person = Person("Alice", 25, "alice@example.com")
27
print(person)  # Person(name='Alice', age=25, email='alice@example.com')

Data Class Features

1
from dataclasses import dataclass, field
2

3
@dataclass
4
class Student:
5
    name: str
6
    age: int
7
    grades: list = field(default_factory=list)  # Mutable default
8

9
    def add_grade(self, grade):
10
        self.grades.append(grade)
11

12
    def average_grade(self):
13
        return sum(self.grades) / len(self.grades) if self.grades else 0
14

15
student = Student("Alice", 20)
16
student.add_grade(85)
17
student.add_grade(90)
18
student.add_grade(88)
19

20
print(student)                    # Student(name='Alice', age=20, grades=[85, 90, 88])
21
print(student.average_grade())    # 87.666...

Frozen Data Classes

Make data classes immutable:

1
from dataclasses import dataclass
2

3
@dataclass(frozen=True)
4
class Point:
5
    x: float
6
    y: float
7

8
p = Point(3, 4)
9
# p.x = 5  # FrozenInstanceError: cannot assign to field 'x'

`slots` for Memory Optimization

Using __slots__ restricts the attributes an instance can have, saving memory:

1
class RegularClass:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

6
class SlotsClass:
7
    __slots__ = ['x', 'y']
8

9
    def __init__(self, x, y):
10
        self.x = x
11
        self.y = y
12

13
regular = RegularClass(1, 2)
14
slots_obj = SlotsClass(1, 2)
15

16
# regular.z = 3  # Works (can add new attributes)
17
# slots_obj.z = 3  # AttributeError: 'SlotsClass' object has no attribute 'z'
18

19
import sys
20
print(sys.getsizeof(regular))  # Larger size
21
print(sys.getsizeof(slots_obj))  # Smaller size

Note
__slots__ prevents the creation of __dict__, which saves memory but prevents adding new attributes dynamically.

Descriptors

Descriptors are objects that define how attribute access works. Properties are a type of descriptor:

1
class PositiveNumber:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def __get__(self, obj, objtype=None):
6
        return obj.__dict__.get(self.name, 0)
7

8
    def __set__(self, obj, value):
9
        if value < 0:
10
            raise ValueError("Value must be positive")
11
        obj.__dict__[self.name] = value
12

13
class Rectangle:
14
    width = PositiveNumber('width')
15
    height = PositiveNumber('height')
16

17
    def __init__(self, width, height):
18
        self.width = width
19
        self.height = height
20

21
    def area(self):
22
        return self.width * self.height
23

24
rect = Rectangle(5, 3)
25
print(rect.area())  # 15
26

27
# rect.width = -5  # ValueError: Value must be positive

Complete Example: Library System

Here’s a comprehensive example combining multiple OOP principles:

1
from abc import ABC, abstractmethod
2
from dataclasses import dataclass
3
from typing import List
4

5
# Abstraction
6
class Item(ABC):
7
    def __init__(self, title, author):
8
        self.title = title
9
        self.author = author
10
        self._is_checked_out = False
11

12
    @abstractmethod
13
    def get_info(self):
14
        pass
15

16
    def check_out(self):
17
        if not self._is_checked_out:
18
            self._is_checked_out = True
19
            return True
20
        return False
21

22
    def return_item(self):
23
        if self._is_checked_out:
24
            self._is_checked_out = False
25
            return True
26
        return False
27

28
# Inheritance and Polymorphism
29
class Book(Item):
30
    def __init__(self, title, author, isbn):
31
        super().__init__(title, author)
32
        self.isbn = isbn
33

34
    def get_info(self):
35
        status = "Checked out" if self._is_checked_out else "Available"
36
        return f"Book: {self.title} by {self.author} (ISBN: {self.isbn}) - {status}"
37

38
class Magazine(Item):
39
    def __init__(self, title, author, issue_number):
40
        super().__init__(title, author)
41
        self.issue_number = issue_number
42

43
    def get_info(self):
44
        status = "Checked out" if self._is_checked_out else "Available"
45
        return f"Magazine: {self.title} by {self.author} (Issue: {self.issue_number}) - {status}"
46

47
# Composition
48
@dataclass
49
class Address:
50
    street: str
51
    city: str
52
    zip_code: str
53

54
    def __str__(self):
55
        return f"{self.street}, {self.city} {self.zip_code}"
56

57
class Member:
58
    def __init__(self, name, member_id, address):
59
        self.name = name
60
        self.member_id = member_id
61
        self.address = address  # Composition: Member HAS-A Address
62
        self.checked_out_items = []  # Composition: Member HAS-A list of Items
63

64
    def check_out_item(self, item):
65
        if item.check_out():
66
            self.checked_out_items.append(item)
67
            return True
68
        return False
69

70
    def return_item(self, item):
71
        if item in self.checked_out_items:
72
            item.return_item()
73
            self.checked_out_items.remove(item)
74
            return True
75
        return False
76

77
# Polymorphism in action
78
def display_item_info(item):
79
    print(item.get_info())
80

81
# Usage
82
book1 = Book("Python Basics", "John Doe", "123-456")
83
magazine1 = Magazine("Tech Weekly", "Jane Smith", 42)
84

85
address = Address("123 Main St", "Springfield", "12345")
86
member = Member("Alice", "M001", address)
87

88
member.check_out_item(book1)
89
member.check_out_item(magazine1)
90

91
# Polymorphism: same function works with different types
92
display_item_info(book1)      # Book: Python Basics by John Doe (ISBN: 123-456) - Checked out
93
display_item_info(magazine1)  # Magazine: Tech Weekly by Jane Smith (Issue: 42) - Checked out
94

95
print(f"Member: {member.name}, Address: {member.address}")
96
# Member: Alice, Address: 123 Main St, Springfield 12345

Exercises

Exercise 1: Encapsulation with Properties

Create a class BankAccount with a private _balance attribute. Use properties to get and set the balance, ensuring it cannot be set to a negative value. Read initial balance, then a new balance, and display both.

Answer:

1
class BankAccount:
2
    def __init__(self, balance):
3
        self._balance = balance
4

5
    @property
6
    def balance(self):
7
        return self._balance
8

9
    @balance.setter
10
    def balance(self, value):
11
        if value >= 0:
12
            self._balance = value
13

14
initial = float(input())
15
new_balance = float(input())
16

17
account = BankAccount(initial)
18
print(f"Initial balance: {account.balance}")
19
account.balance = new_balance
20
print(f"New balance: {account.balance}")

Exercise 2: Polymorphism with Duck Typing

Create three classes Dog, Cat, and Bird, each with a speak() method. Create a function make_animal_speak() that takes any object with a speak() method and calls it. Test with all three classes.

Answer:

1
class Dog:
2
    def speak(self):
3
        return "Woof!"
4

5
class Cat:
6
    def speak(self):
7
        return "Meow!"
8

9
class Bird:
10
    def speak(self):
11
        return "Chirp!"
12

13
def make_animal_speak(animal):
14
    return animal.speak()
15

16
dog = Dog()
17
cat = Cat()
18
bird = Bird()
19

20
print(make_animal_speak(dog))
21
print(make_animal_speak(cat))
22
print(make_animal_speak(bird))

Exercise 3: Abstract Base Class

Create an abstract base class Shape with abstract methods area() and perimeter(). Create concrete classes Rectangle and Circle that implement these methods. Read values and display areas and perimeters.

Answer:

1
from abc import ABC, abstractmethod
2
import math
3

4
class Shape(ABC):
5
    @abstractmethod
6
    def area(self):
7
        pass
8

9
    @abstractmethod
10
    def perimeter(self):
11
        pass
12

13
class Rectangle(Shape):
14
    def __init__(self, length, width):
15
        self.length = length
16
        self.width = width
17

18
    def area(self):
19
        return self.length * self.width
20

21
    def perimeter(self):
22
        return 2 * (self.length + self.width)
23

24
class Circle(Shape):
25
    def __init__(self, radius):
26
        self.radius = radius
27

28
    def area(self):
29
        return math.pi * self.radius ** 2
30

31
    def perimeter(self):
32
        return 2 * math.pi * self.radius
33

34
length = float(input())
35
width = float(input())
36
radius = float(input())
37

38
rect = Rectangle(length, width)
39
circle = Circle(radius)
40

41
print(f"Rectangle - Area: {rect.area()}, Perimeter: {rect.perimeter()}")
42
print(f"Circle - Area: {circle.area():.2f}, Perimeter: {circle.perimeter():.2f}")

Exercise 4: Composition

Create a Engine class with a start() method and a Car class that has an Engine (composition). Create a Car and start its engine.

Answer:

1
class Engine:
2
    def start(self):
3
        return "Engine started"
4

5
class Car:
6
    def __init__(self):
7
        self.engine = Engine()  # Composition: Car HAS-A Engine
8

9
    def start_car(self):
10
        return self.engine.start()
11

12
    def drive(self):
13
        return "Car is ready to drive!"
14

15
car = Car()
16
print(car.start_car())
17
print(car.drive())

Exercise 5: Data Class

Create a data class Student with fields name, age, and grade. Create two Student objects with the same values and one with different values. Test equality comparison.

Answer:

1
from dataclasses import dataclass
2

3
@dataclass
4
class Student:
5
    name: str
6
    age: int
7
    grade: int
8

9
name1 = input()
10
age1 = int(input())
11
grade1 = int(input())
12
name2 = input()
13
age2 = int(input())
14
grade2 = int(input())
15

16
student1 = Student(name1, age1, grade1)
17
student2 = Student(name1, age1, grade1)  # Same values
18
student3 = Student(name2, age2, grade2)   # Different values
19

20
print(student1 == student2)  # True
21
print(student1 == student3)  # False

Core OOP Principles

Table of Contents

Table of Contents

Course Progress

Core OOP Principles

Encapsulation

Private Attributes (Name Mangling)

Protected Attributes

Getters and Setters

Polymorphism

Duck Typing

Polymorphism with Inheritance

Operator Overloading (Polymorphism)

Abstraction

Abstract Base Classes (ABC)

Abstract Properties

Composition vs Inheritance

Inheritance (Is-a)

Composition (Has-a)

When to Use Composition vs Inheritance

Data Classes (Python 3.7+)

Data Class Features

Frozen Data Classes

`slots` for Memory Optimization

Descriptors

Complete Example: Library System

Exercises

Exercise 1: Encapsulation with Properties

Encapsulation with Properties

Exercise 2: Polymorphism with Duck Typing

Polymorphism with Duck Typing

Exercise 3: Abstract Base Class

Abstract Base Class

Exercise 4: Composition

Composition

Exercise 5: Data Class

Data Class

Course Progress