Data Abstraction Exercise Solutions | KalviGavani

(a) 30 (b) (10, 20) (c) 1020 (d) Error

Data abstraction is the principle of hiding the implementation details of data and exposing only the essential operations. Users interact with data through a well-defined interface without knowing how it is stored or processed internally.

Real-life example — ATM machine:

• You insert a card, enter a PIN, and select an amount. The ATM dispenses cash.
• You do not know (or need to know) how the ATM connects to the bank's servers, verifies your account, or updates the balance.
• The ATM's buttons and screen are the interface; the banking network is the hidden implementation.

Programming example:

# User knows only make_pair(), first(), second()
def make_pair(x, y):
    return (x, y)    # Could change to [x, y] or {"a":x, "b":y}

def first(p):
    return p[0]

def second(p):
    return p[1]

p = make_pair(10, 20)
print(first(p))   # 10
print(second(p))  # 20

Constructors create an instance of an ADT. Selectors retrieve individual components from that instance.

# Student ADT
# Constructor: creates a student record
def make_student(name, roll_no, marks):
    return (name, roll_no, marks)

# Selectors: retrieve components
def get_name(student):
    return student[0]

def get_roll_no(student):
    return student[1]

def get_marks(student):
    return student[2]

# Usage
s = make_student("Kavi", 101, 95)
print(get_name(s))      # Kavi
print(get_roll_no(s))   # 101
print(get_marks(s))     # 95

The user creates a student with make_student() and accesses data through selectors. The internal tuple representation is hidden.

An Abstract Data Type (ADT) is a mathematical model for a data type defined by its behaviour — the operations that can be performed on it — without specifying how those operations are implemented or how data is stored internally.

Example — Stack ADT:

• Operations (interface): push(item), pop(), peek(), is_empty(), size()
• Behaviour: Last-In, First-Out (LIFO)
• Implementation (hidden): Could use a list, linked list, or array — the user does not know or care.

# Stack ADT implementation using a list (hidden from user)
class Stack:
    def __init__(self):
        self.__items = []    # Private attribute (encapsulation)

    def push(self, item):      # Interface method
        self.__items.append(item)

    def pop(self):              # Interface method
        if not self.is_empty():
            return self.__items.pop()
        return None

    def peek(self):             # Interface method
        if not self.is_empty():
            return self.__items[-1]
        return None

    def is_empty(self):         # Interface method
        return len(self.__items) == 0

    def size(self):             # Interface method
        return len(self.__items)

# User interacts only through the interface
s = Stack()
s.push(10)
s.push(20)
s.push(30)
print(s.pop())     # 30
print(s.peek())    # 20
print(s.size())    # 2

Python supports encapsulation through classes, private attributes, and public methods.

• Private attributes use __ prefix (name mangling makes direct access difficult).
• Public methods provide controlled access to private data.
• @property decorator allows getter/setter-style access.

class BankAccount:
    def __init__(self, owner, balance):
        self.__owner = owner       # Private attribute
        self.__balance = balance   # Private attribute

    # Getter methods (interface)
    def get_owner(self):
        return self.__owner

    def get_balance(self):
        return self.__balance

    # Controlled modification
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"Deposited {amount}. Balance: {self.__balance}"
        return "Invalid amount"

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return f"Withdrew {amount}. Balance: {self.__balance}"
        return "Insufficient balance or invalid amount"

# Usage — only interface methods are accessible
acc = BankAccount("Kavi", 1000)
print(acc.get_balance())   # 1000
print(acc.deposit(500))    # Deposited 500. Balance: 1500
print(acc.withdraw(200))   # Withdrew 200. Balance: 1300
# acc.__balance = 0  ← Does NOT modify the actual attribute (name mangled)

1. Simplifies complexity: Users interact with a simple interface without understanding internal details. 2. Easier maintenance: Implementation can change without affecting code that uses the interface. 3. Reduces errors: Internal data is protected from accidental modification. 4. Improves modularity: Each module exposes only what others need. 5. Enhances security: Sensitive data is hidden behind access-controlled methods. 6. Promotes reusability: Well-defined ADTs can be reused across programs.

Data abstraction separates the what (interface) from the how (implementation) of a data type. The user interacts only through constructors and selectors; the internal storage is hidden.

Example — A Point ADT:

Version 1 — Using a tuple internally:

# Constructor
def make_point(x, y):
    return (x, y)    # Internal: tuple

# Selectors
def x_coord(point):
    return point[0]

def y_coord(point):
    return point[1]

# Other operations
def distance_from_origin(point):
    return (x_coord(point)**2 + y_coord(point)**2) ** 0.5

Version 2 — Using a dictionary internally (implementation changed):

# Constructor
def make_point(x, y):
    return {"x": x, "y": y}    # Internal: dictionary

# Selectors
def x_coord(point):
    return point["x"]

def y_coord(point):
    return point["y"]

# distance_from_origin stays the same — uses only selectors
def distance_from_origin(point):
    return (x_coord(point)**2 + y_coord(point)**2) ** 0.5

User code (works identically in both versions):

p = make_point(3, 4)
print(x_coord(p))             # 3
print(y_coord(p))             # 4
print(distance_from_origin(p))  # 5.0

Notice that the user code does not change even though the internal representation changed from a tuple to a dictionary. This is the power of data abstraction.

Encapsulation in Python is achieved by bundling data and methods in a class and controlling access through private attributes and public methods.

Approach 1 — Using getter and setter methods:

class Student:
    def __init__(self, name, marks):
        self.__name = name      # Private attribute
        self.__marks = marks    # Private attribute

    # Getters
    def get_name(self):
        return self.__name

    def get_marks(self):
        return self.__marks

    # Setters (with validation)
    def set_name(self, name):
        if len(name) > 0:
            self.__name = name
        else:
            print("Name cannot be empty")

    def set_marks(self, marks):
        if 0 <= marks <= 100:
            self.__marks = marks
        else:
            print("Marks must be between 0 and 100")

s = Student("Kavi", 85)
print(s.get_name())    # Kavi
s.set_marks(95)        # Valid
s.set_marks(150)        # Marks must be between 0 and 100

Approach 2 — Using @property decorator:

class Student:
    def __init__(self, name, marks):
        self.__name = name
        self.marks = marks   # Uses the setter via property

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        if len(name) > 0:
            self.__name = name
        else:
            raise ValueError("Name cannot be empty")

    @property
    def marks(self):
        return self.__marks

    @marks.setter
    def marks(self, marks):
        if 0 <= marks <= 100:
            self.__marks = marks
        else:
            raise ValueError("Marks must be between 0 and 100")

s = Student("Bala", 78)
print(s.name)     # Bala  (calls the @property getter)
s.name = "Arun"   # (calls the @name.setter)
print(s.marks)    # 78
# s.marks = 150   # Raises ValueError

Advantages of encapsulation:

• Data is protected from accidental modification.
• Validation logic is centralised in setters.
• Internal representation can change without affecting the user.
• Access control enforces the principle of least privilege.

How they complement each other:

Abstraction and encapsulation work together. Abstraction defines what operations are available; encapsulation ensures those operations are the only way to interact with data.

class Temperature:
    """Abstraction: user sees only Celsius access.
       Encapsulation: internal storage is in Kelvin (hidden)."""
    def __init__(self, celsius):
        self.__kelvin = celsius + 273.15   # Private: stored in Kelvin

    # Abstraction: interface in Celsius (user-friendly)
    @property
    def celsius(self):
        return self.__kelvin - 273.15

    @celsius.setter
    def celsius(self, value):
        if value >= -273.15:
            self.__kelvin = value + 273.15
        else:
            raise ValueError("Below absolute zero!")

    @property
    def fahrenheit(self):
        return self.celsius * 9/5 + 32

# User interacts only in Celsius or Fahrenheit
t = Temperature(25)
print(t.celsius)      # 25.0
print(t.fahrenheit)    # 77.0
t.celsius = 100
print(t.celsius)      # 100.0
# t.__kelvin           # AttributeError (encapsulated)

• Abstraction: The user sees Celsius and Fahrenheit (the interface) — they do not need to know data is stored in Kelvin.
• Encapsulation: __kelvin is private; the user cannot modify it directly, ensuring the invariant (Kelvin >= 0) is maintained.

Version 1 — Internal representation: tuple

# Constructor
def make_student(name, roll_no, marks):
    return (name, roll_no, marks)

# Selectors
def get_name(student):
    return student[0]

def get_roll_no(student):
    return student[1]

def get_marks(student):
    return student[2]

# Operations (use only selectors, never direct indexing)
def get_grade(student):
    marks = get_marks(student)
    if marks >= 90: return "A"
    elif marks >= 80: return "B"
    elif marks >= 70: return "C"
    elif marks >= 60: return "D"
    else: return "F"

def display_student(student):
    print(f"Name: {get_name(student)}")
    print(f"Roll No: {get_roll_no(student)}")
    print(f"Marks: {get_marks(student)}")
    print(f"Grade: {get_grade(student)}")

Version 2 — Internal representation: dictionary (implementation changed)

# Constructor (different internal structure)
def make_student(name, roll_no, marks):
    return {"name": name, "roll": roll_no, "marks": marks}

# Selectors (updated for dictionary)
def get_name(student):
    return student["name"]

def get_roll_no(student):
    return student["roll"]

def get_marks(student):
    return student["marks"]

# get_grade and display_student remain EXACTLY THE SAME
# They use selectors, not direct indexing
def get_grade(student):
    marks = get_marks(student)
    if marks >= 90: return "A"
    elif marks >= 80: return "B"
    elif marks >= 70: return "C"
    elif marks >= 60: return "D"
    else: return "F"

def display_student(student):
    print(f"Name: {get_name(student)}")
    print(f"Roll No: {get_roll_no(student)}")
    print(f"Marks: {get_marks(student)}")
    print(f"Grade: {get_grade(student)}")

User code (unchanged in both versions):

s = make_student("Kavi", 101, 92)
display_student(s)
# Name: Kavi
# Roll No: 101
# Marks: 92
# Grade: A

This demonstrates that changing the internal representation (tuple to dictionary) does not affect any code that uses the ADT through its interface (constructors and selectors).

An Abstract Data Type (ADT) is a data type defined by its behaviour — the set of operations available — rather than by its internal implementation. Different implementations can be used as long as they provide the same interface.

Stack ADT — Last In, First Out (LIFO)

class Stack:
    def __init__(self):
        self.__items = []

    def push(self, item):
        self.__items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.__items.pop()
        return None

    def peek(self):
        if not self.is_empty():
            return self.__items[-1]
        return None

    def is_empty(self):
        return len(self.__items) == 0

    def size(self):
        return len(self.__items)

s = Stack()
s.push(10)
s.push(20)
s.push(30)
print(s.pop())    # 30
print(s.peek())   # 20
print(s.size())   # 2

Queue ADT — First In, First Out (FIFO)

class Queue:
    def __init__(self):
        self.__items = []

    def enqueue(self, item):
        self.__items.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.__items.pop(0)
        return None

    def front(self):
        if not self.is_empty():
            return self.__items[0]
        return None

    def is_empty(self):
        return len(self.__items) == 0

    def size(self):
        return len(self.__items)

q = Queue()
q.enqueue("A")
q.enqueue("B")
q.enqueue("C")
print(q.dequeue())   # A
print(q.front())     # B
print(q.size())      # 2

Key ADT characteristics:

• Operations are defined by behaviour, not implementation.
• The user does not know or care if the stack/queue uses a list, linked list, or array internally.
• Implementation can be swapped without affecting user code.