Classes and Objects

Object-Oriented Programming (OOP) is a programming paradigm that organizes code into objects, which are instances of classes. Python is an object-oriented language that supports classes and objects, allowing you to model real-world entities and their behaviors.

What is a Class?

A class is a blueprint or template for creating objects. It defines the attributes (data) and methods (functions) that the objects created from it will have.

What is an Object?

An object is an instance of a class. It’s a concrete realization of the class blueprint, with its own set of attribute values.

Think of a class as a cookie cutter and objects as the cookies made from it. The cookie cutter (class) defines the shape, while each cookie (object) can have different decorations (attribute values).

Defining a Class

To define a class in Python, use the class keyword followed by the class name:

1
class Person:
2
    pass  # Empty class

Note
By convention, class names in Python use PascalCase (each word starts with a capital letter), e.g., Person, BankAccount, StudentRecord.

Creating Objects

To create an object (instance) from a class, call the class name like a function:

1
class Person:
2
    pass
3

4
# Create objects (instances)
5
person1 = Person()
6
person2 = Person()
7

8
print(type(person1))  # <class '__main__.Person'>
9
print(person1)        # <__main__.Person object at 0x...>

Instance Variables

Instance variables are attributes that belong to a specific instance (object). Each object has its own copy of instance variables.

You can add instance variables to an object by simply assigning values to them:

1
class Person:
2
    pass
3

4
person1 = Person()
5
person1.name = "Alice"
6
person1.age = 25
7
person1.phone_number = "1234567890"
8

9
person2 = Person()
10
person2.name = "Bob"
11
person2.age = 30
12

13
print(person1.name, person1.age, person1.phone_number)  # Alice 25
14
print(person2.name, person2.age)  # Bob 30
15
# If we try to print person2.phone_number, it will raise an AttributeError

The `init` Method (Constructor)

The __init__ method is a special method called a constructor. It’s automatically called when an object is created. Use it to initialize instance variables.

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
person1 = Person("Alice", 25)
7
person2 = Person("Bob", 30)
8

9
print(person1.name, person1.age)  # Alice 25
10
print(person2.name, person2.age)  # Bob 30

Understanding `self`

The self parameter refers to the instance of the class. It’s automatically passed when you call a method on an object. You must include self as the first parameter of instance methods.

1
class Person:
2
    def __init__(self, name):
3
        self.name = name  # self refers to the current instance
4

5
    def introduce(self):
6
        print(f"My name is {self.name}")
7

8
person = Person("Alice")
9
person.introduce()  # My name is Alice
10
# When calling person.introduce(), Python automatically passes person as self

Instance Methods

Instance methods are functions defined inside a class that operate on instance variables. They must have self as their first parameter.

1
class Rectangle:
2
    def __init__(self, length, width):
3
        self.length = length
4
        self.width = width
5

6
    def area(self):
7
        return self.length * self.width
8

9
    def perimeter(self):
10
        return 2 * (self.length + self.width)
11

12
    def display(self):
13
        print(f"Rectangle: {self.length}x{self.width}")
14
        print(f"Area: {self.area()}")
15
        print(f"Perimeter: {self.perimeter()}")
16

17
rect = Rectangle(5, 3)
18
rect.display()
19
# Rectangle: 5x3
20
# Area: 15
21
# Perimeter: 16

Public, Protected, and Private Attributes

Python uses naming conventions to indicate the intended visibility of attributes and methods. Unlike some languages, Python doesn’t enforce strict access control, but these conventions help communicate intent.

Public Attributes

Public attributes are accessible from anywhere. By default, all attributes in Python are public (no special prefix):

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name      # Public attribute
4
        self.age = age        # Public attribute
5

6
    def display(self):        # Public method
7
        print(f"{self.name} is {self.age} years old")
8

9
person = Person("Alice", 25)
10
print(person.name)        # Alice (accessible)
11
print(person.age)         # 25 (accessible)
12
person.display()          # Alice is 25 years old (accessible)

Protected Attributes

Protected attributes are indicated by a single underscore prefix _. This is a convention that signals “this is for internal use” but Python doesn’t prevent access:

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

5
    def get_balance(self):
6
        return self._balance
7

8
    def _validate_amount(self, amount):  # Protected method
9
        return amount > 0
10

11
account = BankAccount(1000)
12
print(account.get_balance())     # 1000 (using public method)
13
print(account._balance)          # 1000 (accessible but not recommended)
14
print(account._validate_amount(50))  # True (accessible but not recommended)

Note
Protected attributes can still be accessed from outside the class, but the underscore prefix signals to other developers that these are intended for internal use and shouldn’t be accessed directly.

Private Attributes

Private attributes use a double underscore prefix __. Python performs name mangling on these attributes, making them harder (but not impossible) to access from outside the class:

1
class BankAccount:
2
    def __init__(self, balance, account_number):
3
        self.balance = balance           # Public
4
        self._account_number = account_number  # Protected
5
        self.__pin = "1234"              # Private (name mangling)
6

7
    def get_pin(self):
8
        return self.__pin
9

10
    def __validate_pin(self, pin):       # Private method
11
        return self.__pin == pin
12

13
account = BankAccount(1000, "ACC001")
14
print(account.balance)              # 1000 (public - accessible)
15
print(account._account_number)     # ACC001 (protected - accessible but not recommended)
16
print(account.get_pin())            # 1234 (using public method)
17
# print(account.__pin)              # AttributeError: 'BankAccount' object has no attribute '__pin'
18
# print(account.__validate_pin("1234"))  # AttributeError
19

20
# Name mangling: Python changes __pin to _BankAccount__pin
21
print(account._BankAccount__pin)   # 1234 (not recommended, but possible)

How Name Mangling Works

When you use __attribute_name, Python automatically renames it to _ClassName__attribute_name:

1
class MyClass:
2
    def __init__(self):
3
        self.public = "public"
4
        self._protected = "protected"
5
        self.__private = "private"
6

7
obj = MyClass()
8
print(obj.public)              # public
9
print(obj._protected)         # protected
10
# print(obj.__private)        # AttributeError
11

12
# Name mangling in action
13
print(obj._MyClass__private)  # private (mangled name)

When to Use Each

Public (no prefix): Use for attributes and methods that are part of the class’s public API
Protected (_single_underscore): Use for internal attributes/methods that subclasses might need
Private (__double_underscore): Use for attributes/methods that should not be accessed from outside, even by subclasses

1
class Employee:
2
    def __init__(self, name, salary):
3
        self.name = name                    # Public - part of API
4
        self._department = "Engineering"    # Protected - internal use
5
        self.__salary = salary              # Private - sensitive data
6

7
    def get_salary(self):                   # Public method to access private data
8
        return self.__salary
9

10
    def _calculate_bonus(self):             # Protected - internal calculation
11
        return self.__salary * 0.1
12

13
    def get_total_compensation(self):       # Public method
14
        return self.__salary + self._calculate_bonus()
15

16
emp = Employee("Alice", 50000)
17
print(emp.name)                             # Alice (public)
18
print(emp._department)                      # Engineering (protected - accessible)
19
print(emp.get_salary())                     # 50000 (using public method)
20
print(emp.get_total_compensation())         # 55000.0
21
# print(emp.__salary)                       # AttributeError

Class Variables

Class variables are shared by all instances of a class. They are defined at the class level, outside of any method.

1
class Dog:
2
    species = "Canis familiaris"  # Class variable (shared by all instances)
3

4
    def __init__(self, name, breed):
5
        self.name = name          # Instance variable
6
        self.breed = breed        # Instance variable
7

8
dog1 = Dog("Buddy", "Golden Retriever")
9
dog2 = Dog("Max", "German Shepherd")
10

11
print(dog1.species)  # Canis familiaris
12
print(dog2.species)  # Canis familiaris
13
print(Dog.species)   # Canis familiaris (can access via class name)
14

15
# Modifying class variable affects all instances
16
Dog.species = "Canis lupus"
17
print(dog1.species)  # Canis lupus
18
print(dog2.species)  # Canis lupus

Class Methods

Class methods are methods that are bound to the class rather than an instance. They can access and modify class variables. Use the @classmethod decorator and cls as the first parameter.

1
class Student:
2
    total_students = 0  # Class variable
3

4
    def __init__(self, name):
5
        self.name = name
6
        Student.total_students += 1
7

8
    @classmethod
9
    def get_total_students(cls):
10
        return cls.total_students
11

12
    @classmethod
13
    def reset_count(cls):
14
        cls.total_students = 0
15

16
student1 = Student("Alice")
17
student2 = Student("Bob")
18
student3 = Student("Charlie")
19

20
print(Student.get_total_students())  # 3
21
Student.reset_count()
22
print(Student.get_total_students())  # 0

Static Methods

Static methods are methods that don’t access instance or class data. They are utility functions related to the class but don’t need access to instance or class variables. Use the @staticmethod decorator.

1
class MathUtils:
2
    @staticmethod
3
    def add(a, b):
4
        return a + b
5

6
    @staticmethod
7
    def multiply(a, b):
8
        return a * b
9

10
# Can be called on the class or instance
11
result1 = MathUtils.add(5, 3)  # 8
12
result2 = MathUtils.multiply(4, 7)  # 28
13

14
obj = MathUtils()
15
result3 = obj.add(10, 20)  # 30 (also works on instance)

The `del` Method (Destructor)

The __del__ method is called when an object is about to be destroyed. It’s rarely used in Python due to automatic garbage collection.

1
class Person:
2
    def __init__(self, name):
3
        self.name = name
4
        print(f"{self.name} created")
5

6
    def __del__(self):
7
        print(f"{self.name} destroyed")
8

9
person1 = Person("Alice")
10
del person1  # Alice destroyed

Note
The __del__ method is not guaranteed to be called immediately when del is used, as Python uses garbage collection. It’s called when the object is actually destroyed by the garbage collector.

Special Methods (Magic Methods / Dunder Methods)

Python provides special methods (also called magic methods or dunder methods) that allow you to define how objects behave with built-in operations. They are surrounded by double underscores.

`str` and `repr`

__str__: Returns a human-readable string representation (for end users)
__repr__: Returns an unambiguous string representation (for developers)

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
    def __str__(self):
7
        return f"{self.name}, {self.age} years old"
8

9
    def __repr__(self):
10
        return f"Person('{self.name}', {self.age})"
11

12
person = Person("Alice", 25)
13
print(str(person))    # Alice, 25 years old
14
print(repr(person))   # Person('Alice', 25)
15
print(person)         # Alice, 25 years old (calls __str__)

`len`

Defines the behavior of len() function:

1
class ShoppingCart:
2
    def __init__(self):
3
        self.items = []
4

5
    def add_item(self, item):
6
        self.items.append(item)
7

8
    def __len__(self):
9
        return len(self.items)
10

11
cart = ShoppingCart()
12
cart.add_item("Apple")
13
cart.add_item("Banana")
14
print(len(cart))  # 2

`eq` and `ne`

Define equality and inequality comparison:

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

6
    def __eq__(self, other):
7
        if isinstance(other, Point):
8
            return self.x == other.x and self.y == other.y
9
        return False
10

11
    def __ne__(self, other):
12
        return not self.__eq__(other)
13

14
p1 = Point(1, 2)
15
p2 = Point(1, 2)
16
p3 = Point(3, 4)
17

18
print(p1 == p2)  # True
19
print(p1 == p3)  # False
20
print(p1 != p3)  # True

`lt`, `le`, `gt`, `ge`

Define comparison operators (<, <=, >, >=):

1
class Student:
2
    def __init__(self, name, grade):
3
        self.name = name
4
        self.grade = grade
5

6
    def __lt__(self, other):
7
        return self.grade < other.grade
8

9
    def __le__(self, other):
10
        return self.grade <= other.grade
11

12
    def __gt__(self, other):
13
        return self.grade > other.grade
14

15
    def __ge__(self, other):
16
        return self.grade >= other.grade
17

18
student1 = Student("Alice", 85)
19
student2 = Student("Bob", 90)
20
student3 = Student("Charlie", 85)
21

22
print(student1 < student2)   # True
23
print(student1 > student2)  # False
24
print(student1 <= student3) # True

`add`, `sub`, `mul`, etc.

Define arithmetic operations:

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 __sub__(self, other):
10
        return Vector(self.x - other.x, self.y - other.y)
11

12
    def __mul__(self, scalar):
13
        return Vector(self.x * scalar, self.y * scalar)
14

15
    def __str__(self):
16
        return f"Vector({self.x}, {self.y})"
17

18
v1 = Vector(2, 3)
19
v2 = Vector(1, 4)
20
v3 = v1 + v2
21
v4 = v1 * 3
22

23
print(v3)  # Vector(3, 7)
24
print(v4)  # Vector(6, 9)

`getitem` and `setitem`

Enable indexing and slicing:

1
class MyList:
2
    def __init__(self, items):
3
        self.items = list(items)
4

5
    def __getitem__(self, index):
6
        return self.items[index]
7

8
    def __setitem__(self, index, value):
9
        self.items[index] = value
10

11
    def __len__(self):
12
        return len(self.items)
13

14
my_list = MyList([1, 2, 3, 4, 5])
15
print(my_list[0])      # 1
16
print(my_list[1:4])    # [2, 3, 4]
17
my_list[2] = 10
18
print(my_list[2])      # 10

Properties

Properties allow you to define methods that can be accessed like attributes, providing a way to add getters, setters, and deleters.

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 cannot be 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...

Complete Example

Here’s a complete example combining multiple concepts:

1
class BankAccount:
2
    # Class variable
3
    account_count = 0
4

5
    def __init__(self, owner, initial_balance=0):
6
        self.owner = owner
7
        self._balance = initial_balance  # Private by convention
8
        BankAccount.account_count += 1
9
        self.account_number = BankAccount.account_count
10

11
    def deposit(self, amount):
12
        if amount > 0:
13
            self._balance += amount
14
            return True
15
        return False
16

17
    def withdraw(self, amount):
18
        if 0 < amount <= self._balance:
19
            self._balance -= amount
20
            return True
21
        return False
22

23
    @property
24
    def balance(self):
25
        return self._balance
26

27
    @classmethod
28
    def get_account_count(cls):
29
        return cls.account_count
30

31
    @staticmethod
32
    def validate_amount(amount):
33
        return isinstance(amount, (int, float)) and amount > 0
34

35
    def __str__(self):
36
        return f"Account {self.account_number}: {self.owner}, Balance: ${self._balance:.2f}"
37

38
    def __repr__(self):
39
        return f"BankAccount('{self.owner}', {self._balance})"
40

41
account1 = BankAccount("Alice", 1000)
42
account2 = BankAccount("Bob", 500)
43

44
print(account1)  # Account 1: Alice, Balance: $1000.00
45
account1.deposit(200)
46
account1.withdraw(150)
47
print(account1.balance)  # 1050.0
48
print(BankAccount.get_account_count())  # 2

Exercises

Exercise 1: Basic Class and Object

Create a class called Car with instance variables brand and model. Create an object and set these values, then print them.

Answer:

1
class Car:
2
    def __init__(self, brand, model):
3
        self.brand = brand
4
        self.model = model
5

6
brand = input()
7
model = input()
8
car = Car(brand, model)
9
print(f"Brand: {car.brand}, Model: {car.model}")

Exercise 2: Instance Methods

Create a class called Circle with a constructor that takes radius. Add methods area() and circumference() that return the area and circumference of the circle. Read the radius from input and display both values.

Answer:

1
import math
2

3
class Circle:
4
    def __init__(self, radius):
5
        self.radius = radius
6

7
    def area(self):
8
        return math.pi * self.radius ** 2
9

10
    def circumference(self):
11
        return 2 * math.pi * self.radius
12

13
radius = float(input())
14
circle = Circle(radius)
15
print(f"Area: {circle.area():.2f}")
16
print(f"Circumference: {circle.circumference():.2f}")

Exercise 3: Class Variables and Methods

Create a class called Book with a class variable total_books = 0. Increment this counter in the constructor. Add a class method get_total() that returns the total number of books created. Create 3 books and print the total.

Answer:

1
class Book:
2
    total_books = 0
3

4
    def __init__(self, title):
5
        self.title = title
6
        Book.total_books += 1
7

8
    @classmethod
9
    def get_total(cls):
10
        return cls.total_books
11

12
book1 = Book("Python Basics")
13
book2 = Book("Advanced Python")
14
book3 = Book("Python Mastery")
15

16
print(f"Total books: {Book.get_total()}")

Exercise 4: Special Methods

Create a class called Fraction with numerator and denominator. Implement __str__ to display as “numerator/denominator” and __eq__ to compare two fractions. Read two fractions and check if they are equal.

Answer:

1
class Fraction:
2
    def __init__(self, numerator, denominator):
3
        self.numerator = numerator
4
        self.denominator = denominator
5

6
    def __str__(self):
7
        return f"{self.numerator}/{self.denominator}"
8

9
    def __eq__(self, other):
10
        if isinstance(other, Fraction):
11
            return (self.numerator * other.denominator ==
12
                    self.denominator * other.numerator)
13
        return False
14

15
num1 = int(input())
16
den1 = int(input())
17
num2 = int(input())
18
den2 = int(input())
19

20
f1 = Fraction(num1, den1)
21
f2 = Fraction(num2, den2)
22

23
print(f1)
24
print(f2)
25
if f1 == f2:
26
    print("Fractions are equal")
27
else:
28
    print("Fractions are not equal")

Exercise 5: Properties

Create a class called Rectangle with private _width and _height. Use properties to get and set these values, ensuring they are always positive. Read width and height, create a rectangle, then read new values and update them.

Answer:

1
class Rectangle:
2
    def __init__(self, width, height):
3
        self._width = width
4
        self._height = height
5

6
    @property
7
    def width(self):
8
        return self._width
9

10
    @width.setter
11
    def width(self, value):
12
        if value > 0:
13
            self._width = value
14

15
    @property
16
    def height(self):
17
        return self._height
18

19
    @height.setter
20
    def height(self, value):
21
        if value > 0:
22
            self._height = value
23

24
w1 = float(input())
25
h1 = float(input())
26
w2 = float(input())
27
h2 = float(input())
28

29
rect = Rectangle(w1, h1)
30
print(f"Width: {rect.width}, Height: {rect.height}")
31

32
rect.width = w2
33
rect.height = h2
34
print(f"Width: {rect.width}, Height: {rect.height}")

Table of Contents

Table of Contents

Course Progress

Exercise 1: Basic Class and Object

Exercise 2: Instance Methods

Exercise 3: Class Variables and Methods

Exercise 4: Special Methods

Exercise 5: Properties

Course Progress