Guided: Object-oriented Programming in Python

Welcome to the Guided: Object-oriented Programming in Python Lab

In this hands-on lab, you'll build a Python application using an object-oriented programming (OOP) approach. You'll learn how to structure your code using classes, attributes, and methods, and apply core OOP principles such as encapsulation, inheritance, polymorphism, and abstraction.

By the end of this lab, you'll have experience designing and implementing a real-world system using custom classes and objects, and you'll understand how to model reusable and extensible code structures in Python.

You'll progress through a series of steps that gradually build your understanding and skills with object-oriented Python.

Step Overview

Step 2: Define a Base Class

In this step, you'll create a foundational Employee class that holds common data and behavior for all types of employees. You'll define instance attributes, implement a method, and learn how instance methods represent object-specific behavior. This step demonstrates the OOP principle of encapsulation by grouping related data and actions into a single class.

Step 3: Create Subclasses with Inheritance

Here, you'll define specialized subclasses like FullTimeEmployee and Intern that inherit from the base Employee class. You'll add unique attributes and override methods to reflect real-world differences. This step demonstrates the OOP principle of inheritance, where child classes reuse and extend the functionality of a parent class.

Step 4: Demonstrate Polymorphism

In this step, you'll interact with different employee types through a shared interface by calling the same method (get_contact_info) on each object. You'll also see how some behaviors, like checking whether an employee is a high earner, are specific to a subclass. This step showcases polymorphism, where objects of different types can be used interchangeably if they implement the same methods.

Step 5: Design an Abstract Base Class to Define Shared Behavior

You’ll formalize the shared structure across employee types by creating an abstract base class using Python’s abc module. This ensures all subclasses follow a common contract. You'll define an abstract method that each subclass must implement. This step demonstrates abstraction, which hides implementation details while exposing a clear, consistent interface across related classes.

What You'll Learn

• How to define and instantiate custom Python classes
• How to add and access instance and class attributes
• How to implement class methods and override behavior in subclasses
• How to use inheritance and polymorphism to build reusable, flexible code
• How to create abstract base classes that enforce shared structure

You're ready to get started building a robust, object-oriented application in Python!

Prerequisites

You should have a basic understanding of Python, including how to write functions, instantiate variables, and understand the premise of classes. Familiarity with core object-oriented programming principles like encapsulation, abstraction, inheritance, and polymorphism is not required.

Throughout the lab, you'll have the option to run the Python code provided in the Terminal tab to verify your task implementations for yourself. All commands should be executed from the workspace directory.

Tip: If you need assistance at any point, you can refer to the solution directory. It contains subdirectories for each of the steps with example implementations.

Define a Base Class

In this step, you'll define the foundation of your employee management system using object-oriented programming. You’ll start by creating a base class named Employee that includes attributes and behaviors shared across all employee types.

Every class in Python should include an initializer method called __init__, which is automatically called when a new object is created. This method sets up the object’s initial state. Over the next few tasks, you'll add structure to the Employee class by implementing its initializer, defining instance attributes, and creating a method that returns employee-specific information.

Methods on a class define the behavior of an object—what it can do or how it responds to specific operations. In Python, instance methods are defined inside a class and always take self as their first parameter. The self keyword refers to the specific object that is calling the method, allowing you to access and manipulate that object’s attributes.

For example, when you define a method like get_contact_info, you use self.name and self.email to get the values that belong to that particular employee instance.

def get_contact_info(self):
    return f"{self.name} can be reached at {self.email}"

emp = Employee("Jalen Carter", 1001, "[email protected]")
print(emp.name)                       # Accessing an instance attribute
print(emp.get_contact_info()) # Calling an instance method

Employee.company_name = "Pluralsight"
print(Employee.company_name)

class Employee:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def get_contact_info(self):
        return f"{self.name} can be reached at {self.email}"

class Employee:
    def __init__(self, name):
        self.__name = name  # private attribute

    def get_name(self):
        return self.__name

You can optionally validate your Employee class implementation is working correctly by running python3 employee_script.py in the Terminal. This script will prompt you to create an employee with input from the command line and will error if the employee could not be created. The script will tell you if the employee was created successfully and what the result of employee.get_contact_info() is.

Create Subclasses with Inheritance

In this step, you'll extend your employee management system by creating specialized types of employees that inherit from the base Employee class.

This introduces the object-oriented programming principle of inheritance. Inheritance allows you to define a general class with shared behavior, and then create more specific subclasses that reuse and extend that behavior. This helps reduce code duplication, organize logic more cleanly, and support future changes with minimal effort.

You’ll create subclasses for different types of employees—like full-time workers and interns—and add attributes that are unique to those roles. Along the way, you'll see how Python’s super() function lets you call the parent class’s constructor, allowing each subclass to inherit and extend base functionality.

This step demonstrates the object-oriented programming principle of inheritance. Inheritance allows you to define a general class with shared attributes and methods, then create specialized subclasses that reuse and extend that functionality. By building subclasses like FullTimeEmployee and Intern, you avoid repeating code and create a clear structure where common logic is defined once in the base Employee class and reused by its children. This promotes clean, maintainable, and scalable code. ## Validation Script

You can optionally validate your FullTimeEmployee and Intern class implementations by running the following scripts in the Terminal:

• python3 specific_type_of_employee_script.py
  This script allows you to create an employee of a specific type (e.g., Employee, FullTimeEmployee, or Intern) using command line input. It will display an error if the employee could not be created and will confirm successful creation if it works. The script also prints the result of calling get_contact_info() and the type of employee that was created. This is especially helpful for verifying that get_contact_info() is overridden correctly in the Intern class, and that object-specific attributes are displayed based on the employee type.

• python3 full_time_employee_script.py
  This script specifically validates your FullTimeEmployee implementation. It prompts you to enter the required details to create a FullTimeEmployee object. After creation, it prints contact info, salary, and whether the employee is considered a high earner. This allows you to confirm that the is_high_earner() method works as expected: employees earning less than 100k are not high earners, while those earning 100k or more are.

These scripts are a great way to manually confirm that your classes are working before moving on.

Demonstrate Polymorphism

In this step, you'll explore the object-oriented programming principle of polymorphism. Polymorphism allows different object types to respond to the same method call in ways specific to their class. This enables you to write flexible code that works across many different types of objects, as long as they implement a common interface or method.

In Python, polymorphism is often seen when a method like get_contact_info() is defined in a base class, but overridden in subclasses like Intern. You can then loop through a list of mixed employee types and call get_contact_info() without needing to check which subclass each object belongs to—each one responds in its own way.

In the tasks that follow, you'll:

• Create a list containing objects of multiple employee types.
• Call a shared method (get_contact_info) across all of them and observe different outputs.
• Call a method that only exists on one subclass (is_high_earner) to demonstrate that certain behaviors are specific to object type.

These tasks reinforce how polymorphism supports clean, extensible design by allowing objects to share method names while implementing their own behavior.

You can optionally validate your implementation of the tasks above by running employee.py as a script. To do this, run the following command in the Terminal:

python3 employee.py

The output should include the contact information for the three employee objects you created, followed by their high earner status—if applicable. Only employees with a salary attribute (like FullTimeEmployee) should show a high earner result. Others will display a message indicating that they don’t have a salary attribute.

This is a useful way to verify both polymorphic behavior and object-specific logic in your code.

Design an Abstract Base Class to Define Shared Behavior

In this step, you'll apply the object-oriented programming principle of abstraction by creating an abstract base class to represent the shared structure and behavior of all employee types.

Abstraction allows you to define a common interface for a group of related classes, while hiding or deferring the specific implementation details to those subclasses. It helps enforce consistency and keeps your codebase clean and extensible.

Python provides support for abstraction through the abc module, which lets you define abstract base classes. These classes can include abstract methods—methods that must be implemented by any subclass. You can think of them as "promises" that any class inheriting from the base must fulfill.

In this step, you'll:

• Create a new abstract base class called AbstractEmployee.
• Move shared attributes and methods into this class.
• Add an abstract method that all subclasses must implement.
• Update Employee, FullTimeEmployee, and Intern to inherit from AbstractEmployee instead of directly from object.

After creating the AbstractEmployee base class, your other classes (Employee, FullTimeEmployee, Intern) must inherit from it. This ensures that all subclasses implement the required abstract methods and follow a common structure.

This approach improves long-term maintainability, enforces a clear contract across related classes, and supports future extensions of your system.

To test your implementation of the abstract class and the required get_role_description() method, run the following script in the Terminal:

python3 abstract_employee_script.py

This script allows you to create any number of employees of different types using command-line input. After you've finished creating employees, it will print each one's type, contact information, and role description.

Use this to confirm that:

• All employee types are created successfully
• get_contact_info() and get_role_description() work for each type as you expect
• Inheritance and abstraction are functioning correctly across your class hierarchy

Conclusion

Congratulations on completing the lab!

You've now built a Python application using object-oriented programming principles from the ground up. Along the way, you:

• Defined custom classes and created reusable object structures
• Used instance and class attributes to manage data
• Leveraged inheritance to avoid duplication and extend functionality
• Applied polymorphism to interact with different objects through a common interface
• Implemented abstraction using Python’s abc module to enforce consistent structure across related classes

Together, these techniques form the foundation of professional, maintainable, and scalable Python code.

You now have the tools to model real-world systems using object-oriented design—a critical skill in software development, whether you're building a single module or an entire application architecture.

Ready to take it further? Try extending this lab with additional subclasses, custom methods, or even integrating with external data sources to simulate a more complete system. Happy coding!