Mastering Python OOP: All in One Example
Tags: tutorial, beginners, python, programming
Published: 2024-03-31 09:11:00

Mastering Python OOP: All in One Example
Unlock the full potential of Python's Object-Oriented Programming (OOP) with a deep dive into key concepts. Explore the power of encapsulation, inheritance, polymorphism, and abstraction through professional examples. Elevate your coding skills and design cleaner, modular, and efficient Python applications.

```
from abc import ABC, abstractmethod

# Abstract class for Employee
class Employee(ABC):
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    @abstractmethod
    def calculate_bonus(self):
        pass

# Concrete class representing a Developer
class Developer(Employee):
    def __init__(self, name, salary, programming_language):
        super().__init__(name, salary)
        self.programming_language = programming_language

    def calculate_bonus(self):
        return self.salary * 0.1

# Concrete class representing a Manager
class Manager(Employee):
    def __init__(self, name, salary, team_size):
        super().__init__(name, salary)
        self.team_size = team_size

    def calculate_bonus(self):
        return self.salary * 0.15 + self.team_size * 1000

# Concrete class representing a Company
class Company:
    def __init__(self, name):
        self.name = name
        self.employees = []

    def hire_employee(self, employee):
        self.employees.append(employee)

    def display_employee_info(self):
        for employee in self.employees:
            print(f"{employee.name} - Salary: ${employee.salary}, Bonus: ${employee.calculate_bonus()}")

# Example Usage
if __name__ == "__main__":
    # Creating instances of employees
    dev1 = Developer("Tahsin Soyak", 80000, "Python")
    manager1 = Manager("Bilge Özcan", 100000, 5)

    # Creating a company
    company = Company("Tech Innovators")

    # Hiring employees
    company.hire_employee(dev1)
    company.hire_employee(manager1)

    # Displaying employee information
    company.display_employee_info()
```

Here’s a breakdown of the context:

**Abstract Class (Employee):**
The _Employee _ class is defined as an abstract class. Abstract classes serve as blueprints for other classes and contain at least one abstract method. In this example, _calculate_bonus()_ is the abstract method. All subclasses must implement this method.
The _Employee_ class includes common attributes and methods for all types of employees.
**Concrete Class (Developer):**
The Developer class is a concrete subclass of _Employee_ .
It includes additional attributes, such as programming_language.
It implements the abstract method _calculate_bonus()_ specific to developers. In this example, the bonus is calculated as 10% of the salary.
**Concrete Class (Manager):**
The Manager class is another concrete subclass of Employee.
It includes additional attributes, such as _team_size_ .
It implements the abstract method _calculate_bonus()_ specific to managers. In this example, the bonus is calculated based on both the salary and the size of the team managed.
**Company Class:**
The Company class represents a company that can hire employees.
It has methods to hire employees and display information about all employees.
**Example Usage:**
Two employees are created: one _Developer_ and one _Manager_ .
A Company instance is created, named _Tech Innovators_ .
Employees are hired by the company.
Information about the employees is displayed, including their name, salary, and calculated bonus.
The example demonstrates the following OOP concepts:

Encapsulation: Attributes are encapsulated within classes.
Inheritance: Subclasses are created from a base class.
Polymorphism: Different classes implement the same method in different ways.
Abstraction: An abstract class is used to define a blueprint, ensuring methods are implemented by subclasses.


If you need further information or have specific questions, feel free to ask! Tahsin Soyak tahsinsoyakk@gmail.com