Lecture 08: Organizing Your Code Better - Modules and Introduction to Classes

School CS120
, ,
1

Lecture 08: Organizing Your Code Better - Modules and Introduction to Classes

Welcome to Lecture 08! In our journey so far, we’ve built several applications, including the persistent To-Do List (Lecture 6) and the more complex Contact Book (Lecture 7). As your programs become larger, with more functions and more features, you’ll find that keeping all your code in a single Python file can become quite challenging. It gets harder to find specific pieces of code, harder to manage, and harder to collaborate on if you were working in a team.

Today’s Goals:
In this lecture, we’ll explore two powerful Python features that are essential for organizing our code more effectively as our projects grow, and for structuring our data in a more intuitive and real-world analogous way:

  1. Modules: We’ll learn how to split our code into multiple, logical Python files. These files are called modules. This will dramatically improve organization, make parts of our code reusable in other projects, and help avoid naming conflicts.
  2. Introduction to Classes (Object-Oriented Programming Basics): We’ll take our very first steps into a hugely important programming paradigm called Object-Oriented Programming (OOP). We’ll learn what classes and objects are, and how they allow us to create “blueprints” for representing more complex data and the behaviors associated with that data, making our code more intuitive and powerful.

These concepts are fundamental to writing larger, more maintainable, and more professional Python applications. Let’s begin by looking at modules.

Part 1: Creating and Using Your Own Modules

The Problem: Why Single, Long Scripts Become Hard to Manage

Think back to your Contact Book application from Lecture 7. That single .py file probably contained several functions: display_menu, add_contact, view_contacts, search_contact, delete_contact, load_contacts_from_file, save_contacts_to_file, and the main run_contact_book_app function. For a project of that size, it was perhaps still manageable.

But imagine if that Contact Book application were to grow much larger. What if we wanted to add features for:

  • Different groups of contacts (family, friends, work).
  • Storing birthdays and sending reminders.
  • Handling multiple phone numbers or email addresses per contact.
  • A more sophisticated search.
  • Perhaps even a graphical user interface (GUI) later on!

If we tried to put all the code for these features into that single file, it would quickly become hundreds, maybe thousands, of lines long! This leads to several problems:

  • Hard to Read and Navigate: Finding a specific function or piece of logic would involve a lot of scrolling and searching. It’s like trying to find one specific recipe in a cookbook that has no chapters or index.
  • Difficult to Maintain and Debug: When code is tightly packed, making a change in one part might accidentally break something in another, seemingly unrelated, part. Debugging becomes a headache because it’s hard to isolate where the problem might be.
  • Challenging for Collaboration: If you were working on this large project with other people, everyone would be trying to edit the same giant file. This can lead to “merge conflicts” (where different people change the same lines in different ways) and makes teamwork difficult.
  • Less Reusable: What if the file input/output functions you wrote for the Contact Book (load_contacts_from_file, save_contacts_to_file) were so well-written that you realized you could use them in a completely different project (maybe a new “Personal Diary” app or a “Recipe Book” app)? Copying and pasting code between projects is generally a bad idea because if you find a bug or want to improve that code later, you have to remember to change it in every place you copied it. This violates the DRY principle – Don’t Repeat Yourself.

Modules in Python provide an elegant solution to these problems.

What is a Module?

You’ve actually been using modules since our early lectures! Remember these lines?

  • import json (to work with JSON data for saving/loading)
  • from pathlib import Path (to handle file paths in a modern way)
  • import random (to generate random numbers for the Guess the Number game)

json, pathlib, and random are all examples of Python’s built-in modules. These modules are essentially Python files (.py files) that contain a collection of useful functions, classes (which we’ll learn about soon), and variables, all written by the Python developers to provide common functionalities so you don’t have to write them from scratch.

The fantastic news is that any Python file you create (with a .py extension) can also act as a module!

So, a module is simply a file containing Python definitions (like your functions and, later, class definitions) and statements. The file’s name (without the .py extension) becomes the module’s name when you want to use its contents in another Python script.

Purpose and Benefits of Using Your Own Modules:

  1. Organization: This is a primary benefit. Modules allow you to break down a large program into smaller, more manageable, and logically grouped files. For example, in a complex application:
    • All functions related to the user interface (like displaying menus, getting user input) could go in one module (e.g., ui_manager.py).
    • All functions related to data processing and core logic could go in another (e.g., data_processor.py).
    • All functions for handling file saving and loading could go into a third (e.g., file_operations.py).
      This makes your overall project structure much cleaner and easier to understand.
  2. Reusability: This is where modules truly shine and help you follow the DRY principle. You can define a useful function or a set of related functions in a module once. Then, you can import and use these functions in many different parts of your current application, or even in completely different Python projects you work on in the future. If you write a great function to, say, validate email addresses, you can put it in a module and reuse it everywhere you need email validation.
  3. Maintainability: When your code is organized into logical modules, it’s often easier to maintain and debug. If there’s a bug related to how data is saved, you’d know to look in your file_operations.py module first. Changes within one module are also less likely to accidentally break unrelated parts of your application, as long as the module’s interface (how its functions are called and what they return) remains consistent.
  4. Collaboration: If you’re working on a project with a team, modules allow different people to work on different parts of the application simultaneously and independently. One person could be working on the ui_manager.py module while another works on data_processor.py.
  5. Namespace Management (Avoiding Name Clashes): When you import a module using the standard import module_name syntax, the functions, variables, and classes from that module are accessed using the module’s name as a prefix (e.g., json.dump(), my_custom_module.my_great_function()). This creates a separate “namespace” for the imported module. This is very helpful because it prevents accidental naming conflicts. For example, you might have a function called calculate() in your main script, and you might import a module that also has a function called calculate(). Because of namespaces, my_module.calculate() would be different from your script’s calculate(), avoiding confusion.

How to Create Your Own Module

Creating your own module in Python is as simple as creating a new Python file and saving it with a .py extension.

Example: Creating a calculator_operations.py Module
Let’s take the basic arithmetic functions (add, subtract, multiply, divide) from our Simple Calculator project (which we built in Lecture 03) and put them into their own module. This will separate the “calculation logic” from the “user interface” part of the calculator.

  1. Create the file: In your project directory (or a new directory, e.g., examples/modules_example/), create a new Python file. Save it with the name calculator_operations.py.

  2. Add functions to the module: Place the following Python code inside this calculator_operations.py file:

    # examples/modules_example/calculator_operations.py

# Define the core arithmetic functions that our calculator will use.
# These functions are now part of the 'calculator_operations' module.

def add(num1, num2):
    """Returns the sum of num1 and num2."""
    return num1 + num2

def subtract(num1, num2):
    """Returns the difference of num1 and num2."""
    return num1 - num2

def multiply(num1, num2):
    """Returns the product of num1 and num2."""
    return num1 * num2

def divide(num1, num2):
    """
    Returns the division of num1 by num2.
    Handles division by zero by returning an error message string.
    (In more advanced scenarios, raising a specific error like ValueError might be preferred,
     but for now, returning a message is simple for the caller to handle.)
    """
    if num2 == 0:
        return "Error! Cannot divide by zero."
    else:
        return num1 / num2

# The special 'if __name__ == "__main__":' block:
# The code inside this block will only run if this specific file
# (calculator_operations.py) is executed directly by Python
# (e.g., by running 'python calculator_operations.py' in the terminal).
# This code will NOT run if this module is imported by another script.
# This makes it a perfect place for testing the functions within this module.
if __name__ == "__main__":
    print("--- Testing the calculator_operations module directly ---")

    test_val1 = 100
    test_val2 = 20

    print(f"Testing add({test_val1}, {test_val2}): Result = {add(test_val1, test_val2)}")
    print(f"Testing subtract({test_val1}, {test_val2}): Result = {subtract(test_val1, test_val2)}")
    print(f"Testing multiply({test_val1}, {test_val2}): Result = {multiply(test_val1, test_val2)}")
    print(f"Testing divide({test_val1}, {test_val2}): Result = {divide(test_val1, test_val2)}")
    print(f"Testing divide({test_val1}, 0): Result = {divide(test_val1, 0)}") # Test division by zero

    print("--- Module self-test complete ---")

    That’s all there is to it! You’ve now created a Python module named calculator_operations. This module contains four functions that provide basic arithmetic capabilities. It also includes a self-testing block.

How to Use Your Module in Another Python File

Now that we have our calculator_operations.py module, let’s see how we can use its functions in another Python script. Create a new Python file, say main_calculator_app.py, and make sure you save it in the same directory as calculator_operations.py for Python to find it easily.

Python offers several ways to import (bring in) code from one module into another:

1. import module_name
This is the most straightforward way to import an entire module. When you use this, any function, class, or variable you want to use from the imported module must be prefixed with module_name. (dot).

calculator_operations.py (Our module - content shown above)

main_calculator_app.py (The script using the module):

# main_calculator_app.py

# Import the entire 'calculator_operations' module.
# Python looks for a file named calculator_operations.py in the same directory (or other search paths).
import calculator_operations # Notice: no .py extension is used when importing

print("--- Using functions via 'import calculator_operations' ---")

number1 = 200
number2 = 25

# To call the 'add' function from the module, we use: module_name.function_name()
sum_result = calculator_operations.add(number1, number2)
print(f"The sum of {number1} and {number2} is: {sum_result}")

product_result = calculator_operations.multiply(7, 8)
print(f"The product of 7 and 8 is: {product_result}")
  • How it works: The import calculator_operations statement makes all the functions inside calculator_operations.py available to main_calculator_app.py, but they reside within the calculator_operations “namespace.” To call them, you specify calculator_operations.function_name().
  • Pros:
    • Clarity: It’s very clear that add() and multiply() are coming from the calculator_operations module. This is great for code readability and understanding, especially in larger projects with many imports.
    • No Name Clashes: If main_calculator_app.py also happened to define its own function named add(), there would be no conflict, because calculator_operations.add() is distinct from a local add().
  • Cons:
    • Can be slightly more verbose to type calculator_operations. every time, especially if you are using many functions from the module frequently.

2. from module_name import name1, name2, ...
This method allows you to import specific names (functions, variables, or classes) directly from a module into the current script’s main namespace. Once imported this way, you can call them directly by their name without needing the module prefix.

calculator_operations.py (Our module - content as before)

main_calculator_app.py (The script using the module):

# main_calculator_app.py
# (Assuming the previous 'import calculator_operations' example is commented out or in a different file)

# Import only the 'add' and 'subtract' functions directly into this script's namespace.
from calculator_operations import add, subtract

print("\n--- Using 'from calculator_operations import add, subtract' ---")

val1 = 120
val2 = 20

sum_direct_result = add(val1, val2) # We can call add() directly now!
print(f"The sum of {val1} and {val2} (direct import) is: {sum_direct_result}")

difference_direct_result = subtract(val1, val2) # subtract() is also directly available.
print(f"The difference of {val1} and {val2} (direct import) is: {difference_direct_result}")

# If you try to use 'multiply' or 'divide' here without importing them specifically,
# Python will raise a NameError because those names are not defined in this script's direct namespace.
# product_error_example = multiply(5, 5) # This line would cause a NameError
  • How it works: from calculator_operations import add, subtract brings only the add and subtract names into main_calculator_app.py’s own scope.
  • Pros:
    • Less typing is required to call the functions (e.g., add() instead of calculator_operations.add()).
  • Cons:
    • Potential for Name Clashes: If you import a function (say, my_func) from one module, and then you import another function also named my_func from a different module (or if you define your own my_func in the current script), the last one imported or defined will overwrite the previous ones. This can lead to confusion and bugs if not managed carefully. It’s generally less of an issue with unique function names but can happen.
    • Reduced Clarity (sometimes): If you have many from ... import ... statements from various modules, it might sometimes be less immediately obvious where a particular function originated without looking at the import section.

3. from module_name import * (Import Everything Directly - Generally Discouraged)
This syntax imports all public names (names that don’t start with an underscore _) defined in module_name directly into the current script’s main namespace.

# main_calculator_app.py
# (Assuming previous import examples are commented out)

# from calculator_operations import * # Example of 'import star' - use with caution!

# print("\n--- Using 'from calculator_operations import *' ---")
# if this import was active, 'divide' would be available directly:
# quotient_star_result = divide(200, 40)
# print(f"200 / 40 (star import) = {quotient_star_result}")
  • Pros: You can call any public function or use any public variable from the module directly without any prefix.
  • Cons (These are significant and why it’s usually bad practice):
    • Namespace Pollution: This can flood your current script’s namespace with potentially many names from the imported module, some of which you might not even intend to use.
    • Readability Suffers Greatly: It becomes very hard to tell where a specific function or variable came from, especially if you use import * from multiple modules. When debugging, you won’t know which module’s my_function() is actually being called.
    • Massively Increased Risk of Name Clashes: The likelihood of accidentally overwriting an existing function or variable in your script (or one imported from another module) with one from the import * module is very high and can lead to very subtle and hard-to-find bugs.
      General Advice: Avoid using from module_name import *. While it might seem convenient for very small, personal scripts or in the interactive Python shell, it’s a bad habit for any code that needs to be readable, maintainable, or that might grow. The explicitness of the other import methods is much preferred.

4. import module_name as alias (Using an Alias/Shorthand)
If a module has a particularly long name, or if you want to use a more convenient shorthand for it, you can import it and assign it an alias (an alternative, usually shorter, name).

# main_calculator_app.py
# (Assuming previous import examples are commented out)

# Import 'calculator_operations' and give it the alias 'calc_ops'
import calculator_operations as calc_ops

print("\n--- Using 'import calculator_operations as calc_ops' ---")

val_x = 77
val_y = 11

# Now use the alias 'calc_ops' to access the functions
sum_aliased_result = calc_ops.add(val_x, val_y)
print(f"{val_x} + {val_y} (using alias) = {sum_aliased_result}")

quotient_aliased_result = calc_ops.divide(val_x, val_y)
print(f"{val_x} / {val_y} (using alias) = {quotient_aliased_result}")
  • How it works: import calculator_operations as calc_ops makes the calculator_operations module available, but you refer to it using the name calc_ops in your code.
  • Pros:
    • Can make your code shorter and more readable if the original module name is very long (e.g., import some_very_long_module_name as short_name).
    • Still maintains good clarity about where the functions are coming from (e.g., calc_ops.add is still quite clear).
    • It can also be used to avoid naming conflicts if you are importing two different modules that happen to have the same name (though this is rare for well-designed libraries).
  • This aliasing technique is quite common, for example, the popular data analysis library pandas is almost universally imported as import pandas as pd.

Where Does Python Look for Modules?
When you write an import my_module statement, Python doesn’t magically know where my_module.py is located. It searches for the module in a specific sequence of directories:

  1. The Current Directory: Python first looks in the same directory where the script that is currently running is located. This is why main_calculator_app.py can find calculator_operations.py if they are placed in the same folder.
  2. PYTHONPATH Environment Variable: If the module isn’t found in the current directory, Python checks the list of directories specified in your system’s PYTHONPATH environment variable (if it’s set). This is a more advanced way to tell Python where to find your custom modules if they are not in the same directory as your main script.
  3. Standard Library Directories: Finally, Python searches the directories where its standard library modules are installed (this is how it finds json, random, pathlib, etc., without you needing to do anything special).

For our current purposes, keeping your module file (like calculator_operations.py) in the same directory as the script that imports it (like main_calculator_app.py) is the simplest way to ensure Python can find it.

The if __name__ == "__main__": Block in Modules (Revisited for Deeper Understanding)

We’ve used this special if statement, if __name__ == "__main__":, in our main application scripts before. Its role becomes even more critical and clear when you start writing your own modules.

  • What is __name__?
    __name__ (pronounced “dunder name dunder” because of the double underscores on each side) is a special built-in variable that Python automatically creates and assigns a value to for every script it runs. The value of __name__ depends on how the script is being executed:

    • When a Python script is run directly from the command line (e.g., you type python my_script.py in your terminal), Python sets the __name__ variable for that specific script to the special string value "__main__".
    • When a Python script (which we’ll now call a module) is imported into another script using an import statement, Python sets the __name__ variable for that imported module to be the name of the module itself (i.e., its filename without the .py extension). For example, if you have import calculator_operations in main_calculator_app.py, then while calculator_operations.py is being imported and its code is being initially processed, its internal __name__ variable will be "calculator_operations".

  • The if __name__ == "__main__": Check:
    This condition, therefore, if __name__ == "__main__":, will only be True if the script containing this line is the one being run directly by the Python interpreter. It will be False if the script is being imported as a module into another script.

Why is this Indispensable for Modules?

  1. Providing Test Code for Your Module: This is the most common and important use. You can place code inside this block to test the functions or classes defined within your module. This test code will run automatically when you execute the module file directly from the terminal (e.g., python calculator_operations.py). This allows you to quickly verify that your module’s components are working as expected. However, when another script imports your module, this test code will not run, which is exactly what you want – the importing script only wants access to your module’s functions/classes, not to see its test outputs.

  2. Allowing a Module to Be Both a Reusable Library and a Standalone Script: Sometimes, a module might primarily provide functions and classes to be used as a library by other programs. However, you might also want that same file to be executable as a standalone script to perform some specific action related to its functionality (e.g., a utility task, a demonstration, or a more complex self-test). The if __name__ == "__main__": block enables this dual capability.

Let’s look at our calculator_operations.py module again:

# calculator_operations.py
# ... (definitions of add, subtract, multiply, divide functions) ...

if __name__ == "__main__":
    # This code ONLY runs if you execute: python calculator_operations.py
    print("--- Testing the calculator_operations module directly ---")
    test_sum = add(50, 25)
    print(f"Test sum (50+25): {test_sum}")
    # ... more tests for subtract, multiply, divide ...
  • If you open your terminal, navigate to the directory containing calculator_operations.py, and run the command python calculator_operations.py, you will see the “— Testing the calculator_operations module directly —” message and the results of the test calculations printed to your console. This is because, in this scenario, __name__ inside calculator_operations.py is equal to "__main__".
  • However, if you run python main_calculator_app.py (which contains import calculator_operations), the test prints from calculator_operations.py’s if __name__ == "__main__": block will not appear in main_calculator_app.py’s console output. This is because when calculator_operations is being imported, its __name__ variable is set to "calculator_operations", so the condition __name__ == "__main__" is false inside the module.

This conditional block is a fundamental best practice for writing Python modules that are both reusable as libraries and independently testable (or runnable as scripts).

Mini-Project/Activity: Refactoring the Simple Calculator

Now, let’s solidify our understanding of modules by applying these concepts to refactor (which means to restructure existing computer code—changing the factoring—without changing its external behavior) the Simple Calculator we built in Lecture 03.

Goal: To separate the calculator’s core arithmetic logic (the functions that do the math) from its user interface logic (the part that interacts with the user, like printing menus and getting input).

Steps:

  1. Create calculator_logic.py (This will be your module):

    • In your Python project folder, create a new Python file. Name it calculator_logic.py.
    • Open your Simple Calculator script from Lecture 03.
    • Move the Functions: Cut (or copy and delete) the definitions of your four arithmetic functions (add(num1, num2), subtract(num1, num2), multiply(num1, num2), and divide(num1, num2)) from your old calculator script.
    • Paste these four function definitions into your new calculator_logic.py file.
    • Add Test Block: At the very end of calculator_logic.py, add an if __name__ == "__main__": block. Inside this block, write a few print() statements that call each of your four functions with some sample numbers and print the results. This will allow you to test this module independently. For example:
      if __name__ == "__main__":
    print("Testing calculator_logic.py...")
    print(f"5 + 3 = {add(5, 3)}")
    print(f"10 - 2 = {subtract(10, 2)}")
    print(f"4 * 6 = {multiply(4, 6)}")
    print(f"10 / 2 = {divide(10, 2)}")
    print(f"10 / 0 = {divide(10, 0)}") # Test division by zero

  2. Create main_calculator_ui.py (This will be your main application script):

    • In the same directory where you saved calculator_logic.py, create another new Python file. Name this file main_calculator_ui.py.
    • This file will now contain the user interface part of your calculator.
    • Go back to your original Simple Calculator script from Lecture 03. Copy the main calculator() function (or whatever you named the function that contained the while True loop for the menu, the prompts for user input, and the if/elif/else block for choosing operations). Paste this entire function into main_calculator_ui.py.
    • Import your module: At the very top of main_calculator_ui.py, you need to add an import statement to make the functions from calculator_logic.py available. Choose one of the import styles we discussed. For clarity, import calculator_logic is a good start.
      # main_calculator_ui.py
import calculator_logic
# Or, if you prefer:
# from calculator_logic import add, subtract, multiply, divide
    • Modify Function Calls: Now, go into the calculator() function (or your main UI function) within main_calculator_ui.py. Find the lines where the actual arithmetic was performed (e.g., result = num1 + num2). You need to change these lines to call the corresponding functions from your calculator_logic module.
      • If you used import calculator_logic:
        # Example inside the if/elif/else block:
if operation_choice == '+':
    result = calculator_logic.add(num1, num2)
elif operation_choice == '-':
    result = calculator_logic.subtract(num1, num2)
# ... and so on for multiply and divide.
      • If you used from calculator_logic import add, subtract, ...:
        # Example inside the if/elif/else block:
if operation_choice == '+':
    result = add(num1, num2) # Call directly
elif operation_choice == '-':
    result = subtract(num1, num2) # Call directly
# ... and so on.
    • Add Main Execution Block: Ensure main_calculator_ui.py also has an if __name__ == "__main__": block at the very end that calls its main user interface function (e.g., calculator()).
      if __name__ == "__main__":
    calculator() # Or whatever your main UI function is named

  3. Test Your Refactored Calculator:

    • Open your terminal or command prompt.
    • Navigate to the directory where you saved calculator_logic.py and main_calculator_ui.py.
    • Test the module first: Run python calculator_logic.py. You should see the output from its test block (the print statements inside its if __name__ == "__main__": section). This confirms your logic module is working on its own.
    • Test the main application: Run python main_calculator_ui.py. The calculator application should start up and function exactly as it did in Lecture 03. You should be able to perform additions, subtractions, etc. However, this time, main_calculator_ui.py is not doing the math itself; it’s calling the functions from your imported calculator_logic.py module to get the results!

By successfully completing this refactoring, you’ve made your calculator program more organized and modular. The calculator_logic.py module now contains reusable arithmetic functions, and main_calculator_ui.py is cleanly focused on the user interaction aspects. This separation is a key principle in writing larger, more maintainable software.

Part 2: Introduction to Object-Oriented Programming (OOP) - Basic Classes

Now, let’s switch gears from organizing code into separate files (modules) to another, very powerful way of organizing and thinking about our code and the data it manages: Object-Oriented Programming (OOP).

OOP is a fundamental programming paradigm (a way of thinking about and structuring programs) that is used extensively in many modern programming languages, including Python. We’ll only scratch the very surface of OOP today by introducing its most basic building blocks: classes and objects.

Problem Statement: Moving Beyond Simple Data Structures for Complex Entities

In our Contact Book project from Lecture 07, we represented each contact using a Python dictionary:

a_single_contact = {
    "name": "Priya Sharma",
    "phone": "9876543210",
    "email": "priya.sharma@example.com"
}

And our entire contact book was a list of these dictionaries. This worked quite well for that project! Dictionaries are great for storing collections of key-value data for a single item.

However, as the “things” we want to represent in our programs become more complex, just using basic dictionaries and lists might not always be the most organized, intuitive, or robust way to structure our code. Consider these points:

  • Ensuring Consistent Structure: With dictionaries, there’s no guarantee that every contact dictionary will have exactly the same keys. One might have an “email”, another might not. While we can manage this, a more structured approach might be beneficial if we want to enforce that every “contact” entity must have certain pieces of information (e.g., a name and a phone number).
  • Bundling Data with Related Actions: What if we want to define specific actions or behaviors that are directly associated with a contact? For example:
    • A function to format the contact’s address for printing on an envelope.
    • A function to send an SMS or an email to the contact (if they have a phone/email).
      With dictionaries, these actions would typically be separate functions that take a contact dictionary as an argument (e.g., format_address_for_envelope(contact_dictionary) or send_sms_to_contact(contact_dictionary, message_text)).
  • Creating Many Similar “Things”: Dictionaries are great for a single student record like student = {'name': "Rohan", 'id': "S102", 'grade': 10}. But what if we need to create and manage many students, all of whom should have the same basic structure (name, id, grade, a list of courses)? And what if we want functions that specifically operate on student data (like enroll_in_course or calculate_gpa) to be neatly bundled with that student data, rather than floating around as separate functions?

This is where classes in OOP provide a more powerful and organized solution. They allow us to define a “blueprint” for creating “objects” that combine both data (attributes) and the functions that operate on that data (methods).

Core OOP Concepts (Greatly Simplified for Today)

Let’s introduce the two most fundamental concepts in OOP:

  1. Objects:

    • Think about the real world. It’s filled with “objects” – things you can see, touch, or at least conceptualize as distinct entities: a specific car (your family’s car), a particular person (your friend Rohan), a book on your shelf, your phone.

    • In Object-Oriented Programming, an object is a software representation that bundles together:

      • Attributes (Data/State/Properties): These are the characteristics or specific pieces of information that describe the object or define its current state.
        • For a Student object representing Rohan, attributes could be name = "Rohan Mehta", student_id = "S102", current_grade = 10, courses_enrolled = ["Maths", "Physics"].
        • For your family’s Car object, attributes might be color = "blue", make = "Maruti", model = "Swift", current_speed = 0, fuel_level = "half-full".
        • For your pet dog, say Raja, attributes could be name = "Raja", breed = "Labrador", age = 3.
      • Methods (Behaviors/Actions/Functions): These are the actions that the object can perform, or operations that can be performed on or by the object. Methods often work with or modify the object’s attributes.
        • A Student object might have methods like enroll_in_course(course_name), submit_assignment(assignment_details), or display_academic_record().
        • A Car object might have methods like start_engine(), accelerate(amount), brake(), get_fuel_level().
        • Your pet Dog object, Raja, might have methods like make_sound() (which would be “bark!”), fetch(item), or eat(food).

    • So, an object in OOP is a self-contained unit that groups its data (attributes) and the functions that operate on that data (methods).

  2. Classes:

    • If objects are the specific, individual things (like your friend Rohan, your family’s specific blue Maruti Swift car, your pet dog Raja), then a class is the blueprint, template, recipe, or cookie-cutter that is used to create these objects.

    • A class defines:

      • What common attributes all objects of that particular type will possess (e.g., the Student class would define that every student object will have a name, a student_id, and a list of courses_enrolled).
      • What common methods all objects of that type will be able to perform (e.g., the Student class would define that every student object can enroll_in_course()).

    • The class itself is not an object; it’s the abstract definition or the plan. You use the class as a blueprint to create many individual, concrete objects. Each object created from a class is called an instance of that class.

    • Example:

      • You can define a Student class. This class is the general blueprint for what it means to be a student in your program.
      • From this single Student class (the blueprint), you can then create many individual Student objects (instances), such as student_priya, student_rohan, and student_aarav. Each of these objects will have its own specific values for attributes like name and ID, but they will all share the same structure and the same set of available methods as defined by the Student class.
      • Similarly, a Dog class is the blueprint for all dogs. “Raja” and “Sheru” are specific objects (instances) of the Dog class.

OOP, therefore, helps us model real-world entities (or even abstract concepts) in our code in a more organized and intuitive way by bundling their data (attributes) and their behaviors (methods) together into these things called objects, which are created from blueprints called classes.

Defining a Simple Class in Python (e.g., a Student Class)

Let’s see the actual Python syntax for defining a simple class.

Syntax: class ClassName:
You define a class using the class keyword, followed by the name you want to give your class. By Python convention, class names usually start with a capital letter and use CamelCase (also sometimes called PascalCase), where each word in a multi-word name is capitalized (e.g., Student, ContactBookEntry, MyCoolCar).

class Student:
    # This is the basic structure of a class definition.
    # We will soon add the constructor (__init__) and other methods inside this indented block.
    pass # The 'pass' keyword is a Python placeholder that means "do nothing for now."
         # It's used when Python syntax requires an indented block, but you haven't
         # written the actual code for that block yet (like an empty function or class).

This code creates a very simple, essentially empty, class named Student. It doesn’t have any specific attributes or methods defined yet, but it’s a valid Python class.

The __init__(self, ...) Method (The Constructor – Initializing New Objects)
When we create a new object (an instance) from our class blueprint (e.g., we want to create a new student), we almost always want to give that new object some initial attributes right away. For example, when we create a new Student object, we probably want to immediately set their name and student ID.

The __init__ method is a special method in Python classes whose name starts and ends with double underscores (these are often called “dunder” methods, so __init__ is pronounced “dunder-init,” short for “double-underscore init”).

  • Purpose: The __init__ method acts as the constructor for the class. It is automatically called by Python whenever you create a new instance (object) of that class. Its primary job is to initialize the newly created object, which usually means setting its initial instance attributes.
  • self (The Crucial First Parameter): The very first parameter of the __init__ method (and, in fact, of almost all methods you define inside a class that are meant to operate on an instance of that object) must always be self.
    • self is a special variable that Python automatically passes to the method. It acts as a reference to the specific instance of the object itself that is currently being created or that the method is being called on.
    • Think of self as a temporary placeholder for “the actual object that is being worked on right now.” For example, when you later create an object student_priya = Student("Priya", "S101"), and the __init__ method is called for student_priya, inside that __init__ call, self is the student_priya object. If you then create student_rohan = Student("Rohan", "S102"), when __init__ is called for student_rohan, self is the student_rohan object.
    • You do not explicitly pass a value for self when you create an object or call its methods; Python handles that automatically behind the scenes. But you must include self as the first parameter in the method’s definition line.
  • Other Parameters: After self, you can define any other parameters that your __init__ method needs to receive to set up the object’s initial attributes. For our Student class, these might be parameters to accept the student’s name and ID when a new student object is created.

Instance Attributes (Storing Data Unique to Each Object):
Inside the __init__ method (and other instance methods), you create and assign values to an object’s attributes using the self variable, followed by a dot . and the attribute name you want to create: self.attribute_name = value_to_assign.
These are called instance attributes because each instance (each individual object created from the class) will have its own, independent copy of these attributes, holding data specific to that instance.

Let’s define our Student class with an __init__ method:

class Student:
    # The __init__ method is the constructor.
    # It's automatically called when you create a new Student object like: Student("Priya Sharma", "S101")
    def __init__(self, name_param, student_id_param):
        # 'self' here refers to the specific, new Student object that is being created right now.

        # We are creating instance attributes 'name' and 'student_id' for this object.
        # The values for these attributes are taken from the parameters passed to __init__.
        self.name = name_param  # e.g., if name_param is "Priya Sharma", self.name becomes "Priya Sharma"
        self.student_id = student_id_param # e.g., self.student_id becomes "S101"

        # We can also initialize other attributes that might not be directly passed as parameters.
        # For example, every new student starts with an empty list to store their courses.
        self.courses_enrolled = []

        print(f"A new Student object has been created for {self.name} with ID {self.student_id}.")

# Now, let's see how to create objects (instances) of our Student class:

# This line does the following:
# 1. Python sees we want to create an object (an instance) of the 'Student' class.
# 2. A new, essentially blank, Student object is created in the computer's memory.
# 3. The __init__ method of the Student class is called *automatically*.
# 4. This newly created blank object itself is passed as the first argument to __init__ (this becomes 'self').
# 5. "Priya Sharma" is passed as the second argument, which matches 'name_param'.
# 6. "S101" is passed as the third argument, which matches 'student_id_param'.
# 7. Inside the __init__ method for this specific object:
#    - self.name = "Priya Sharma" (The 'name' attribute of this Priya object is set)
#    - self.student_id = "S101"   (The 'student_id' attribute of this Priya object is set)
#    - self.courses_enrolled = [] (This Priya object gets its own empty list for courses)
#    - The print statement inside __init__ executes.
student_priya = Student("Priya Sharma", "S101")

# Creating another Student object - this is a completely separate and independent instance.
student_rohan = Student("Rohan Mehta", "S102")
# When this line runs, student_rohan gets its own 'name' ("Rohan Mehta"),
# its own 'student_id' ("S102"), and its own empty 'courses_enrolled' list.
# The attributes of student_priya are not affected by the creation of student_rohan.

Accessing Attributes of an Object:
Once you have created an object (an instance of a class), you can access its attributes (the data stored within that specific object) using dot notation: object_variable_name.attribute_name.

print(f"\nDetails of the student_priya object:")
print(f"  Name: {student_priya.name}")             # Accesses student_priya's 'name' attribute
print(f"  Student ID: {student_priya.student_id}") # Accesses student_priya's 'student_id'
print(f"  Courses: {student_priya.courses_enrolled}") # Accesses student_priya's 'courses_enrolled' list

print(f"\nDetails of the student_rohan object:")
print(f"  Name: {student_rohan.name}")           # Accesses student_rohan's 'name'

# Instance attributes are mutable (changeable) by default, unless you implement specific controls.
student_priya.student_id = "S101-REVISED-ID" # We can change Priya's ID
print(f"Priya's revised Student ID: {student_priya.student_id}")

Adding Methods (Functions Defined Inside a Class that Perform Actions):
Methods are essentially functions that are defined inside the body of a class. They are designed to perform actions related to the object or to operate on the object’s attributes (its data).

  • Just like the __init__ method, all instance methods (methods that are intended to be called on a specific instance of an object) must have self as their very first parameter. This self parameter is what allows the method to “know” which object it’s working with and to access and manipulate that particular object’s own attributes.

Let’s add some methods to our Student class to make our Student objects more capable and “behavioral”:

class Student:
    def __init__(self, name_from_param, student_id_param):
        self.name = name_from_param
        self.student_id = student_id_param
        self.courses_enrolled = []
        # Let's remove the print from __init__ now, as methods will display info.
        # print(f"Student object created for {self.name} (ID: {self.student_id})!")

    # An instance method to display the student's details
    def display_details(self):
        # When this method is called (e.g., student_priya.display_details()),
        # 'self' inside this method will refer to the student_priya object.
        print(f"\n--- Student Profile ---")
        print(f"  Student Name: {self.name}")    # Accesses the 'name' attribute of this specific instance
        print(f"  Student ID:   {self.student_id}") # Accesses the 'student_id' of this instance
        self.list_courses() # We can call other methods of the same object using 'self'

    # An instance method to enroll the student in a new course
    def enroll_in_course(self, course_name_to_add):
        # 'self' allows us to access this particular student's 'courses_enrolled' list
        if course_name_to_add not in self.courses_enrolled: # Avoid duplicate enrollments
            self.courses_enrolled.append(course_name_to_add)
            print(f"{self.name} has successfully enrolled in the course: '{course_name_to_add}'.")
        else:
            print(f"{self.name} is already enrolled in '{course_name_to_add}'.")

    # An instance method to list all courses the student is currently enrolled in
    def list_courses(self):
        if not self.courses_enrolled: # Check if the student's specific courses list is empty
            print(f"  {self.name} is not currently enrolled in any courses.")
        else:
            # '.join()' is a string method that takes a list of strings and
            # concatenates them into a single string, with the specified separator (", " here).
            enrolled_courses_str = ", ".join(self.courses_enrolled)
            print(f"  Courses Enrolled: {enrolled_courses_str}")

# Let's re-create our student objects now that the class definition is updated with methods
student_priya = Student("Priya Sharma", "S101")
student_rohan = Student("Rohan Mehta", "S102")
student_ananya = Student("Ananya Singh", "S103")

Calling Methods on Objects:
You call a method on a specific object using dot notation, similar to how you access attributes: object_variable_name.method_name(any_other_arguments_the_method_expects). Remember, Python automatically and implicitly passes the object itself (student_priya or student_rohan in our examples) as the first self argument to the method.

# Calling methods on the student_priya object:
student_priya.enroll_in_course("Python Programming Fundamentals")
student_priya.enroll_in_course("Data Structures with Python")

# Let's try enrolling Priya in Python Programming again to see the check in action:
student_priya.enroll_in_course("Python Programming Fundamentals")

# Now display Priya's details, which will also list her courses
student_priya.display_details()
# Expected Output:
# Priya Sharma has successfully enrolled in 'Python Programming Fundamentals'.
# Priya Sharma has successfully enrolled in 'Data Structures with Python'.
# Priya Sharma is already enrolled in 'Python Programming Fundamentals'.

# --- Student Profile ---
#   Student Name: Priya Sharma
#   Student ID:   S101
#   Courses Enrolled: Python Programming Fundamentals, Data Structures with Python


# Calling methods on the student_rohan object:
student_rohan.enroll_in_course("Calculus I")
student_rohan.enroll_in_course("Linear Algebra for Beginners")
student_rohan.display_details()
# Expected Output:
# Rohan Mehta has successfully enrolled in 'Calculus I'.
# Rohan Mehta has successfully enrolled in 'Linear Algebra for Beginners'.

# --- Student Profile ---
#   Student Name: Rohan Mehta
#   Student ID:   S102
#   Courses Enrolled: Calculus I, Linear Algebra for Beginners

# Display Ananya's details (she has no courses yet)
student_ananya.display_details()
# Expected Output:
# --- Student Profile ---
#   Student Name: Ananya Singh
#   Student ID:   S103
#   Ananya Singh is not currently enrolled in any courses.

This Student class now serves as a complete blueprint. Each Student object we create (student_priya, student_rohan, student_ananya) is an independent, self-contained instance. Each has its own set of attributes (holding its own name, ID, and its own list of courses), but they all share the same defined behaviors (the methods like display_details, enroll_in_course, list_courses) because they were created from the same Student class blueprint. This is the essence of how classes and objects help in structuring and organizing programs in an object-oriented way.

Mini-Project/Activity: Creating and Using Student Objects

Now it’s your turn to get hands-on!

  1. Define the Student Class:

    • Open your Python editor (like VS Code, PyCharm, or an online Python interpreter like Replit).
    • Carefully type (or copy and paste) the complete Student class definition we just developed (the one that includes __init__, display_details, enroll_in_course, and list_courses methods).

  2. Create Some Student Objects:

    • In the same Python file, below your class definition (not indented under the class), write some code to create at least two or three different Student objects.
    • Assign each object to a variable with a unique name (e.g., stud1, stud2, or more descriptive names like vikram_student, meera_student).
    • When you create each student, provide different names and student IDs as arguments to the Student() constructor.
      # Example:
vikram_student = Student("Vikram Aditya", "S104")
meera_student = Student("Meera Krishnan", "S105")
aarav_student = Student("Aarav Patil", "S106")

  3. Interact with Your Student Objects:

    • For each student object you created, call its enroll_in_course() method a couple of times to enroll them in some courses. You can make up course names like “Introduction to History,” “Algebra Basics,” “Creative Writing,” etc.
    • Try enrolling one student in the same course more than once to see how your enroll_in_course method handles this (it should print that they are already enrolled).
      # Example:
vikram_student.enroll_in_course("Introduction to Physics")
vikram_student.enroll_in_course("Organic Chemistry")

meera_student.enroll_in_course("World History")
meera_student.enroll_in_course("Introduction to Physics") # Meera also takes Physics!

aarav_student.enroll_in_course("Python Programming")
aarav_student.enroll_in_course("Python Programming") # Trying to enroll Aarav twice
    • Call the display_details() method for each of your student objects to see their complete profile, including their name, ID, and their unique list of enrolled courses.
    • If you created a student object and didn’t enroll them in any courses, call list_courses() specifically on that student object to see the “not currently enrolled in any courses” message for them.

This hands-on activity is very important. It will help solidify your understanding of how a class acts as a blueprint and how each object (instance) created from that class maintains its own distinct data while sharing the common behaviors (methods) defined by the class.

Briefly: Modules and Classes Together

As your Python projects grow larger and more organized, it’s very common and highly recommended practice to define your classes within their own modules (separate .py files). This further enhances organization, reusability, and maintainability.

  • For example, you could save the Student class definition (everything from class Student: down to its last method) in a separate Python file named, for instance, student_module.py or perhaps school_models.py if you plan to have more classes related to a school system.

  • Then, in your main application script (e.g., a script named school_administration_system.py that manages student enrollments), you would import the Student class from your module:

    # school_administration_system.py (This is your main program file)

# Assuming student_module.py is in the same directory or in a place Python can find it
from student_module import Student

# Alternatively, if you used 'import student_module', you would then write:
# priya_object = student_module.Student("Priya S.", "S106")

# Now you can create Student objects using the imported Student class
priya_object = Student("Priya S.", "S106")

priya_object.enroll_in_course("Advanced Python Programming")
priya_object.enroll_in_course("Introduction to Machine Learning")

priya_object.display_details()

This approach keeps your project structure very clean and logical:

  • student_module.py: This file defines the “blueprint” – what a Student is (its attributes) and what it can do (its methods). It’s like a library of your custom data types.
  • school_administration_system.py: This file (or other files) can then use that blueprint by importing the Student class to create and manage actual Student objects to run the application.

We’ll be using this pattern of defining classes in modules more and more as we build more complex applications.

Recap of Concepts Learned

This lecture introduced two major topics that are pivotal for writing better-organized, more scalable, and more professional Python code:

  1. Modules:

    • We learned that any Python file (ending with .py) can serve as a module.
    • We understood how to create our own modules by simply putting related functions (and, as we’ll see more of, classes) into a separate file. This helps in organizing code based on functionality.
    • We practiced various ways of importing code from our modules into other scripts:
      • import module_name (which requires you to use module_name.function_name() to access its contents).
      • from module_name import specific_function_or_class (which allows direct access to specific_function_or_class() without the module prefix).
      • import module_name as alias (which provides a shorthand, like alias.function_name(), for using the module’s contents).
      • (And we noted to use from module_name import * with significant caution due to potential namespace pollution).
    • We reinforced the critical role and behavior of the if __name__ == "__main__": block within modules. This block allows a module to contain test code or script-like functionality that only runs when the module file is executed directly, and not when it’s imported by another script.
    • We applied these concepts by refactoring our Simple Calculator from a previous lecture into a calculator_logic.py module (for the math functions) and a main_calculator_ui.py script (for the user interaction).

  2. Introduction to Object-Oriented Programming (OOP) with Classes:

    • Objects: We conceptualized objects as software representations of real-world or abstract entities. Objects are characterized by their attributes (the data or state that describes them) and their methods (the behaviors or actions they can perform, often operating on their own attributes).
    • Classes: We understood classes as blueprints or templates that are used to create these objects. A class defines the common structure (the set of attributes an object will have) and common behaviors (the methods an object can perform) for all objects of that specific type.
    • class Keyword: We learned the syntax class ClassName: to begin a class definition in Python.
    • The __init__(self, ...) Method (Constructor): We explored this special method, which is automatically called by Python whenever a new object (an instance) of the class is created. Its primary role is to initialize the instance attributes of the new object, setting up its initial state.
    • self Keyword: We learned that self is a crucial first parameter in instance methods (including __init__). It acts as a reference to the specific object instance itself that the method is being called on, allowing the method to access and modify that instance’s attributes and call its other methods.
    • Instance Attributes: These are variables that belong to a specific instance of a class (an object). They are defined using the self.attribute_name = value syntax, typically within the __init__ method, and they store the data that is unique to each object.
    • Instance Methods: These are functions defined inside a class that are designed to operate on the attributes of an instance of that class. They always take self as their first parameter.
    • Creating Objects (Instantiation): We learned that the process of creating an object from a class (e.g., my_student_object = Student("Aarav Kumar", "S107")) is called instantiation. This action automatically invokes the class’s __init__ method to set up the new object.
    • We practiced these fundamental OOP basics by defining a Student class with attributes and methods, and then creating and interacting with several Student objects.

These concepts – modules for organizing code at the file level, and classes/objects for structuring data and behavior at a more granular, entity-focused level – are absolutely foundational to modern software development in Python and many other programming languages. Mastering them will significantly enhance your ability to design, build, and maintain more complex and sophisticated applications.

Homework Challenges

Now it’s time to put your new knowledge of modules and basic classes into practice! These challenges will help you solidify your understanding.

  1. Module Refactor for the Persistent To-Do List:

    • Task: Take your persistent To-Do List application from Lecture 06 (the one that uses JSON and pathlib, for example, todo_list_app_persistent.py).
    • Steps:
      1. Create a new Python module file. A good name might be todo_file_manager.py.
      2. Move the file operations functions – specifically load_tasks_from_file(filepath) and save_tasks_to_file(tasks_list, filepath) – from your main To-Do list script into this new todo_file_manager.py module.
      3. In your main To-Do list script (e.g., todo_list_app_persistent.py), you will now need to import these two functions from your todo_file_manager module (e.g., from todo_file_manager import load_tasks_from_file, save_tasks_to_file).
      4. Ensure that your main To-Do List application still works correctly – it should load tasks at the start and save them after changes, but now it will be using the imported file management functions.
      5. Don’t forget to add an if __name__ == "__main__": block to your new todo_file_manager.py module. Inside this block, write some simple test code to verify its functions. For example, you could create a dummy list of tasks, save it using your save_tasks_to_file function (to a temporary test filename), then immediately load it back using your load_tasks_from_file function, and print the loaded tasks to confirm that the save and load operations are working correctly within the module itself.

  2. Class Design 1: Rectangle

    • Task: Define a Python class named Rectangle to represent a rectangle.
    • Details:
      • The __init__ method should accept two arguments (besides self): length and width. These should be stored as instance attributes (e.g., self.length and self.width).
      • Implement a method called calculate_area(self) that calculates and returns the area of the rectangle (reminder: area = length × width).
      • Implement a method called calculate_perimeter(self) that calculates and returns the perimeter of the rectangle (reminder: perimeter = 2 × (length + width)).
      • Implement a method called display_dimensions(self) that prints the length and width of the rectangle in a user-friendly format (e.g., “Rectangle: Length = [value of length], Width = [value of width]”).
    • Testing (in the if __name__ == "__main__": block of your script where you define the Rectangle class):
      • Create at least two different Rectangle objects with different length and width values (e.g., rect1 = Rectangle(10, 5) and rect2 = Rectangle(7, 3)).
      • For each Rectangle object you create:
        • Call its display_dimensions() method.
        • Call its calculate_area() method, store the returned result in a variable, and then print the area (e.g., “The area is: [calculated area]”).
        • Call its calculate_perimeter() method, store the result, and print the perimeter.

  3. Class Design 2: Book

    • Task: Define a Python class named Book to represent information about a book.
    • Details:
      • The __init__ method should accept three arguments (besides self): title (a string), author (a string), and num_pages (an integer). Store these as instance attributes.
      • Implement a method get_summary(self) that prints a string summarizing the book’s details, for example: “Title: ‘The Adventures of Python Programming’, Author: Anita Coder, Pages: 350”.
      • (Optional Advanced Challenge) Implement a method is_long_read(self) that returns True if self.num_pages is greater than 500, and False otherwise.
    • Testing (in the if __name__ == "__main__": block):
      • Create a few different Book objects with various titles, authors, and page counts.
      • Call the get_summary() method on each of your book objects.
      • If you implemented the is_long_read() method, call it for each book and print a message like “‘[Book Title]’ is a long read.” or “‘[Book Title]’ is not a very long read.” based on what the method returns.

These exercises will give you valuable hands-on experience with the fundamental concepts of creating and using your own modules for better code structure, and defining and using classes to model objects with their own data and behaviors. These are essential skills for writing well-organized, readable, and scalable Python programs. Have fun experimenting!