No history yet

Object Oriented Fundamentals

From Scripts to Blueprints

You've already worked with variables, lists, and loops to write scripts that perform tasks. This is a great start, but as programs grow, managing all that loose data can get messy. Imagine tracking user information using separate lists for names, emails, and ages. It works, but it's clumsy. A single change could require updating multiple lists, and it's easy for them to get out of sync.

Object-Oriented Programming (OOP) offers a better way. Instead of managing separate pieces of data, we can bundle related data and the functions that operate on that data into a single, neat package called an object. The blueprint for creating these objects is called a class.

Think of a class as a cookie cutter and objects as the cookies. The cutter defines the shape and pattern, but each cookie is a distinct, individual creation.

Let's define a simple blueprint for a user profile. In Python, we use the class keyword.

class UserProfile:
    pass # We'll fill this in shortly

This code doesn't do much yet, but it creates a new type called UserProfile. We can now create individual instances, or objects, from this blueprint.

The Constructor and 'self'

To make our blueprint useful, we need a way to give each object its own unique data when it's created. This is done with a special method called __init__, which acts as the object's constructor. It runs automatically whenever a new object is created.

The first parameter of every method inside a class is always self. It's a reference to the specific instance of the class that the method is being called on. This is how an object keeps track of its own data, distinguishing it from other objects of the same class.

class UserProfile:
    # The constructor method
    def __init__(self, username, email):
        # These are called instance attributes
        self.username = username
        self.email = email
        self.is_active = True # A default value

# Create two different instances (objects)
user1 = UserProfile("alex_c", "alex@example.com")
user2 = UserProfile("maria_g", "maria@example.com")

# Access their unique data
print(user1.username) # Output: alex_c
print(user2.email)    # Output: maria@example.com

In the example above, self.username = username assigns the username value passed into the constructor to an instance attribute also called username. The self prefix ties that piece of data to the specific object being created. That's why user1.username is different from user2.username—they are separate objects with their own copies of the instance attributes.

Notice that instance attributes are defined inside __init__. This ensures every UserProfile object is guaranteed to have a username, email, and is_active status right from the moment it's created. This is far more reliable than using a dictionary, where you might forget a key or misspell it.

Methods and Encapsulation

Now let's add behavior. Functions defined inside a class are called methods. They let us define actions the objects can perform. This practice of bundling data (attributes) with the code that works on that data (methods) is a core OOP principle called encapsulation(). It helps organize your code and protects data from accidental modification.

Let's model a bank account. An account has a balance, but you shouldn't be able to just set the balance to any number. Instead, you should only interact with it through controlled actions like deposit and withdraw.

class BankAccount:
    # Class attribute: shared by all instances
    interest_rate = 0.02

    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    # A method to add money
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"Deposited 💲{amount}. New balance: 💲{self.balance}")
        else:
            print("Deposit amount must be positive.")

    # A method to remove money
    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            print(f"Withdrew 💲{amount}. New balance: 💲{self.balance}")
        else:
            print("Invalid withdrawal amount.")

account1 = BankAccount("John Doe", 1000)
account1.deposit(500)
account1.withdraw(2000) # This will fail safely
account1.withdraw(200)

In this example, the deposit and withdraw methods provide a safe, predictable way to modify the account's balance. You can't accidentally set the balance to a negative number. This is a huge advantage over using a simple variable or a dictionary.

You might have also noticed the interest_rate attribute. This is a class attribute, defined directly inside the class but outside of any method. Unlike instance attributes, class attributes are shared by all objects of the class. If you change BankAccount.interest_rate, that change will be reflected across all BankAccount instances.

By combining data and behavior into classes, you create reusable and organized components. This makes your code easier to understand, maintain, and expand, forming the foundation of professional software development.

Time to check your understanding of these core concepts.

Quiz Questions 1/6

In Object-Oriented Programming, what is the primary role of a class?

Quiz Questions 2/6

Which special method is automatically called when a new object is created from a class in Python, and is used to initialize the object's attributes?

With these fundamentals in place, you are ready to start building more complex and robust applications.