Creating and Using Python Classes

45 minutes
  • 3 Learning Objectives

About this Hands-on Lab

As we work on more and more complex problems, we need to start creating custom types to have manageable models for the data we’re working with. Python is an object-oriented programming language, and creating classes is something we will do frequently to solve problems using Python. In this hands-on lab, we’ll define a custom class with some functionality and attributes that will allow us to model an `Employee` in our code. The `` script includes code that will utilize this class and provide us with some feedback to know if we’ve created a class that meets our requirements.

To feel comfortable completing this lab, you’ll want to know how to create and use Python classes (watch the “Creating and Using Python Classes” video from the Certified Associate in Python Programming Certification course).

Learning Objectives

Successfully complete this lab by achieving the following learning objectives:

Create the `employee` Module with an Empty `Employee` Class

Before we write any code, let’s see what we need to do to get the file to execute to the next step by looking at the error:

$ python3.7
Traceback (most recent call last):
  File "", line 1, in <module>
    from employee import Employee
ModuleNotFoundError: No module named 'employee'

This error shows us the first thing we need to do is create the module and the Employee class within it. The error doesn’t tell us anything else, though, so we’ll take the smallest step possible to move to the next step. Let’s create an empty class now:


class Employee:

Running again, we’ll see a new error:

$ python3.7
Traceback (most recent call last):
  File "", line 7, in <module>
TypeError: Employee() takes no arguments
Implement the `Employee.__init__` Method

Our next error is related to not having an __init__ method that takes arguments. To know what we need to implement, let’s look at how the Employee instances are being created in


from employee import Employee

employee_1 = Employee(
    name="Kevin Bacon",
    title="Executive Producer",
employee_2 = Employee("Bruce Wayne", "", "CEO")

# Rest of code omitted

We can see here the positional order for our arguments is given from the employee_2 line, and the name of the attributes are provided by the keyword argument usage when employee_1 is instantiated. The phone_number attribute is optional since it isn’t used to create employee_2. Let’s take this knowledge and implement the __init__ method now:


class Employee:
    def __init__(self, name, email_address, title, phone_number=None): = name
        self.email_address = email_address
        self.title = title
        self.phone_number = phone_number

Now we shouldn’t have any issues creating our instances in

$ python3.7
Traceback (most recent call last):
  File "", line 12, in <module>
AttributeError: 'Employee' object has no attribute 'email_signature'
Implement the `Employee.email_signature` Method

The last few expressions in the file demonstrate how the email_signature method should work. The two main things to note are:

  • By default, the phone_number attribute is not included in the string that is returned; but if include_phone is true, then it is added to the end of the second line.
  • If there is no phone_number, then the phone number portion will not be printed, even if include_phone is true.

Let’s implement this method now:


class Employee:
    def __init__(self, name, email_address, title, phone_number=None): = name
        self.email_address = email_address
        self.title = title
        self.phone_number = phone_number

    def email_signature(self, include_phone=False):
        signature = f"{} - {self.title}n{self.email_address}"
        if include_phone and self.phone_number:
            signature += f" ({self.phone_number})"
        return signature

By checking if include_phone and self.phone_number are both true, we’re able to determine if we should add the phone number to the signature. Let’s run one more time to ensure everything works. We should see no output if we’ve implemented the method correctly.


Additional Resources

We're in the process of building a larger system that can work with internal employee information. To begin, we want to create a simple version of the Employee class that can hold on to an employee's name, title, email address, and phone number. Specifically, we want the class to have these attributes:

  • name: String, required
  • title: String, required
  • email_address: String, required
  • phone_number: String, optional

For the time being, we would like to have an instance of Employee generate an email signature that the employee could use.

  • email_signature: Returns multi-line string with email signature. If this method receives include_phone with a true value, then it should include the employee's phone number; otherwise, it should be left off.

Another engineer on the team wrote a script that demonstrates how the class could be used, and it will provide us with a means to check our implementation. We will run as we're creating the Employee class in the module.

Logging In

Using the Terminal To Complete the Lab

There are a couple of ways to get in and work with the code. One is to use the credentials provided in the lab, log in with SSH, and use a text editor in the terminal, such as Vim.

Note: When copying and pasting code into Vim from the lab guide, first enter :set paste (and then i to enter insert mode) to avoid adding unnecessary spaces and hashes. To save and quit the file, press Escape followed by :wq. To exit the file without saving, press Escape followed by :q!.

Using VS Code To Complete the Lab

You can also access the lab using VS Code in the browser. If you'd like to go this route, then follow the steps below:

  1. Navigate to the public IP address of the workstation server (provided in your lab credentials) on port 8080, using http (e.g., http://PUBLIC_IP:8080).
  2. If you receive a notification indicating the connection is not secure, click Advanced. Then, proceed to the server.
  3. Use the password provided in your lab credentials.

What are Hands-on Labs

Hands-on Labs are real environments created by industry experts to help you learn. These environments help you gain knowledge and experience, practice without compromising your system, test without risk, destroy without fear, and let you learn from your mistakes. Hands-on Labs: practice your skills before delivering in the real world.

Sign In
Welcome Back!

Psst…this one if you’ve been moved to ACG!

Get Started
Who’s going to be learning?