Python Modules, Classes and Objects Explained with Examples

• Modules organize and expose reusable names.
• Classes define structure and behavior; objects carry actual state.
• Dot notation connects them: module.Class(), object.attribute and object.method().

Python Module, Class and Object Hierarchy

MODULE / PACKAGE
  ├── classes
  ├── functions
  └── variables
        │
        └── ClassName(arguments)  →  OBJECT IN MEMORY

Examples:
datetime module → datetime class → timestamp object
pathlib module  → Path class     → OUTPUT_FOLDER object
pandas package  → DataFrame class→ event_data object

Module vs Class vs Object in Python

Module: a reusable code namespace

A module is normally a .py file containing Python code. A package is a directory-based module structure. Modules can expose functions, variables, classes and submodules. Standard-library examples include datetime, pathlib and sys; third-party packages include pandas, pyodbc and openpyxl.

Class: the blueprint

A class describes which data an object may hold and which operations it can perform. Attributes represent state; methods implement behavior. Think of a recipe that can produce many dishes, or a blueprint that can produce many houses.

class ReportJob:
    def __init__(self, name, output_folder):
        self.name = name                 # instance attribute
        self.output_folder = output_folder

    def full_path(self):                 # instance method
        return self.output_folder / self.name

Object: a specific instance

An object is a concrete instance with actual values. Creating it is called instantiation. Two objects from the same class share the defined behavior but can contain different data.

job_a = ReportJob("SQF-02.xlsx", Path(r"D:\SQF_Reports"))
job_b = ReportJob("Daily.xlsx", Path(r"D:\Daily_Reports"))

How Python Modules, Classes and Objects Work Together

1. Write or import a module. Python locates the file/package and creates a module namespace.
2. Define or obtain a class. The class statement executes during import, or the class is imported directly.
3. Create an object. Calling a class normally invokes object construction and initialization.
4. Use the object. Read its attributes and call its methods with dot notation.

# 1. Import a class from a module
from pathlib import Path

# 2. Path is the class blueprint
# 3. Calling it creates an object
output_folder = Path(r"D:\SQF_Reports")

# 4. Use attributes and methods
print(output_folder.name)
output_folder.mkdir(parents=True, exist_ok=True)

4. Detailed Example: datetime

The standard-library datetime module contains a class also named datetime. This identical naming is why imports can initially look confusing.

import datetime
now_a = datetime.datetime.now()

from datetime import datetime
now_b = datetime.now()

print(now_b.year)                    # attribute
print(now_b.strftime("%Y-%m-%d"))   # instance method
print(now_b.isoformat())             # instance method

datetime.now() is a class method that returns a new datetime object. That object contains real values—year, month, day, hour, minute and second—and provides formatting and transformation methods. datetime(2026, 7, 26, 9, 35, 42) creates another object explicitly.

5. Detailed Example: pathlib.Path

pathlib is the module; Path is a class; OUTPUT_FOLDER is an object representing one specific filesystem path. The slash operator works because the class implements operator overloading.

from pathlib import Path

OUTPUT_FOLDER = Path(r"D:\SQF_Reports")
report_file = OUTPUT_FOLDER / "SQF-02.xlsx"

OUTPUT_FOLDER.mkdir(parents=True, exist_ok=True)
print(OUTPUT_FOLDER.exists())
print(OUTPUT_FOLDER.name)
print(report_file.parent)
print(report_file.resolve())

The expression OUTPUT_FOLDER / "SQF-02.xlsx" calls special path behavior such as __truediv__; it does not perform arithmetic division. The result is another Path object.

6. Detailed Example: pandas.DataFrame

pandas is imported using the conventional alias pd. DataFrame is the class used for tabular data. Functions such as pd.read_sql_query() construct and return DataFrame objects.

import pandas as pd

event_data = pd.read_sql_query(query, connection)

print(event_data.shape)      # attribute-like tuple: rows, columns
print(event_data.columns)    # column labels
print(event_data.dtypes)     # data types
print(event_data.empty)      # boolean property

clean_data = event_data.copy()
clean_data = clean_data.fillna("")
clean_data.to_excel("SQF-02.xlsx", index=False)

event_data and clean_data are different DataFrame objects. They inherit DataFrame methods such as copy(), fillna(), astype() and to_excel(), while their rows, columns and values form the object state.

7. Complete Import and Usage Flow

from datetime import datetime
from pathlib import Path
import sys
import pandas as pd
import pyodbc
from openpyxl.styles import Font, Alignment, PatternFill

OUTPUT_FOLDER = Path(r"D:\SQF_Reports")
OUTPUT_FOLDER.mkdir(parents=True, exist_ok=True)
timestamp = datetime.now()

connection = pyodbc.connect(connection_string, timeout=15)
event_data = pd.read_sql_query(query, connection)

header_font = Font(bold=True)
alignment = Alignment(horizontal="center", vertical="center")
header_fill = PatternFill(fill_type="solid", fgColor="F4B183")

if event_data.empty:
    connection.close()
    sys.exit("No data found")

The flow combines several creation patterns. Path(...), Font(...) and Alignment(...) instantiate classes directly. datetime.now(), pyodbc.connect() and pd.read_sql_query() are callable APIs that return objects. In every case, the assigned variable becomes a reference to the returned object.

8. Quick Reference Table

9. Where Modules, Classes and Objects Live in Memory

from datetime import datetime
from pathlib import Path

timestamp = datetime.now()
OUTPUT_FOLDER = Path(r"D:\SQF_Reports")

print(type(timestamp))       # <class 'datetime.datetime'>
print(type(OUTPUT_FOLDER))   # platform-specific Path subclass
print(timestamp.__class__)
print(id(timestamp))         # identity for this process run

10. Key Terminology

11. Summary Comparison

import pathlib
print(type(pathlib))
print(pathlib.Path)
print(type(pathlib.Path))

from pathlib import Path
a = Path("reports")
b = Path("archive")
print(type(a), a.name)
print(type(b), b.name)
print(a is b)

from datetime import datetime
stamp = datetime.now()
print(stamp.year)
print(stamp.strftime("%Y-%m-%d %H:%M:%S"))
print(callable(stamp.strftime))

import pandas as pd
data = pd.DataFrame({"Tag": ["Level", "Pressure"], "Value": [72.5, 4.8]})
print(type(data))
print(data.shape)
print(data.to_string(index=False))