Python OOP Tutorial 1: Classes and Instances

Python’s class system is presented as a practical way to bundle related data and behavior into reusable blueprints—especially when you need many similar objects with their own unique values. The tutorial’s core message is that classes let developers avoid repetitive, error-prone setup code by defining a single structure (a class) and then creating multiple independent objects (instances) from it.

A simple Employee class is introduced to model real-world entities. The distinction between a class and an instance is made early: the class acts as a blueprint, while each Employee created from it becomes a separate instance with its own identity in memory. Two employees created from the same Employee class are shown as distinct objects, even though they share the same underlying structure.

The tutorial then focuses on instance variables—data unique to each object. It demonstrates the manual approach first: assigning attributes like first name, last name, email, and pay directly to each employee instance. That method works, but it quickly becomes verbose and easy to get wrong (the example shows a mistake where one employee’s email assignment isn’t updated correctly). The takeaway is that manually setting attributes defeats much of the benefit of using classes.

To automate initialization, the tutorial introduces Python’s special __init__ method. This method runs automatically whenever a new instance is created. Inside __init__, the instance is received as the first argument (by convention named self), followed by the values needed to set up the object. The tutorial builds the email from first and last names and assigns pay, first, and last to instance variables like self.first, self.last, self.pay, and self.email. With __init__ in place, creating new employees becomes as simple as passing first name, last name, and pay—Python handles the rest.

Next comes behavior: methods. The tutorial shows how printing an employee’s full name can be done repeatedly with string formatting outside the class, but that repetition is exactly what methods are meant to eliminate. A full_name method is added to the Employee class, returning a combined string using self.first and self.last. Calling employee1.full_name() and employee2.full_name() produces the correct result for each instance.

A common pitfall is highlighted: forgetting the self parameter in a method definition. Without self, calling the method triggers a TypeError because Python still passes the instance automatically, meaning the method signature no longer matches what Python provides. The tutorial also compares calling the method on an instance (employee1.full_name()) versus calling it on the class (Employee.full_name(employee1)), clarifying how self gets supplied behind the scenes.

By the end, the foundational pieces are in place: creating classes, understanding class vs instance, initializing instance variables with __init__, and defining instance methods that operate correctly across all objects created from the same class. The next step previewed is class variables and how they differ from instance variables.