Adv-Python Unit 3: Complete Concept Guide

1. Introduction to Python ModulesCopy Anchor Link

1.1 What is a Module?Copy Anchor Link

A module is a Python file (with .py extension) that contains:

• Functions
• Classes
• Variables
• Executable statements

The file name becomes the module name without the .py extension. For example, calculator.py becomes the module calculator.

Key Insight: A module is not a separate programming language. It is simply a Python file that can be reused by importing it into another Python file.

1.2 Why Use Modules?Copy Anchor Link

1.3 Module, Package, and LibraryCopy Anchor Link

Hierarchy: Library ⊃ Package ⊃ Module

1.4 Python Module WorkflowCopy Anchor Link

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌──────────────┐    ┌─────────────┐
│ 1. Create   │ →  │ 2. Write &  │ →  │ 3. Package  │ →  │ 4. Distribute│ →  │ 5. Import & │
│   Module    │    │    Test     │    │   Module    │    │              │    │    Reuse    │
└─────────────┘    └─────────────┘    └─────────────┘    └──────────────┘    └─────────────┘
       ↑                                                                          │
       └────────────────────── Iterate & Improve ─────────────────────────────────┘

Step 1: Create Module — Write functions, classes, and variables in a .py file.

Step 2: Write & Test — Test with different inputs to verify correctness and reliability.

Step 3: Package Module — Organize into standard directory structure with __init__.py, metadata files.

Step 4: Distribute — Share through PyPI or private repository; version release.

Step 5: Import & Reuse — Import into multiple programs using pip install and import.

Iterate & Improve — Fix bugs, optimize, add features; update, test, repackage, redistribute.

2. Creating and Using ModulesCopy Anchor Link

2.1 Steps to Create a ModuleCopy Anchor Link

1. Create a new Python file with a meaningful name (e.g., mymath.py).
2. Define functions, variables, or classes inside the file.
3. Save the file in the same folder as the program that will use it.
4. Use the import statement in another Python file.
5. Access module members using dot notation: module_name.function_name().

2.2 Example: User-Defined ModuleCopy Anchor Link

File: calculator_tools.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

PI = 3.14159

File: main.py

import calculator_tools

print(calculator_tools.add(10, 5))      # 15
print(calculator_tools.subtract(10, 5)) # 5
print(calculator_tools.PI)              # 3.14159

2.3 Explanation TableCopy Anchor Link

2.4 Best Practices for Creating ModulesCopy Anchor Link

• Keep each module focused on one main purpose.
• Use meaningful function and variable names.
• Avoid writing too much executable code directly at module level.
• Add comments or docstrings to explain important functions.
• Test the module independently before using it in a larger project.

3. Naming and Renaming ModulesCopy Anchor Link

3.1 Module Naming RulesCopy Anchor Link

3.2 Renaming Modules Using AliasesCopy Anchor Link

Python allows an imported module to be given a shorter name using the as keyword. This does not rename the original file; it only creates an alias inside the current program.

import math as m
print(m.sqrt(25))   # 5.0
print(m.pi)         # 3.14159...

import random as rd
number = rd.randint(1, 10)
print(number)

Common Aliases:

• import numpy as np
• import pandas as pd
• import matplotlib.pyplot as plt

Important: Do not create files named math.py, random.py, json.py, or re.py in your project folder. These names can hide the original built-in modules and cause confusing errors.

4. Variables in Modules, Built-in Modules, and dir() FunctionCopy Anchor Link

4.1 Variables in ModulesCopy Anchor Link

A module can store variables just like a normal Python program. These variables can be accessed after importing the module. Module-level variables are useful for:

• Constants
• Configuration values
• Version numbers
• Shared settings

File: college_info.py

college_name = "ABC Institute"
course = "Python Programming"
semester = 5

File: main.py

import college_info

print(college_info.college_name)  # ABC Institute
print(college_info.course)        # Python Programming
print(college_info.semester)      # 5

4.2 Built-in ModulesCopy Anchor Link

Python includes many ready-to-use modules in its standard library.

Examples:

import math
print(math.sqrt(64))  # 8.0

import random
print(random.choice(["red", "blue", "green"]))

from datetime import date
print(date.today())

4.3 The dir() FunctionCopy Anchor Link

The dir() function returns a list of names available inside an object or module. It is useful for exploring what functions, classes, constants, and attributes are provided by a module.

import math
print(dir(math))
print(math.sqrt(16))

5. Importing from ModulesCopy Anchor Link

5.1 Types of Import StatementsCopy Anchor Link

Examples:

# Import full module
import math
print(math.sqrt(81))  # 9.0

# Import specific names
from math import sqrt, pi
print(sqrt(81))  # 9.0
print(pi)        # 3.14159...

# Import with alias
import math as m
print(m.factorial(5))  # 120

5.2 The __name__ VariableCopy Anchor Link

When a Python file is run directly, its special variable __name__ is set to "__main__". When the same file is imported as a module, __name__ becomes the module name. This allows a file to contain test code that runs only when the file is executed directly.

File: greetings.py

def welcome(name):
    return "Welcome, " + name

if __name__ == "__main__":
    print(welcome("Student"))

Why it matters: The __name__ == "__main__" pattern prevents test code from running automatically when a module is imported into another program.

6. JSON in PythonCopy Anchor Link

6.1 What is JSON?Copy Anchor Link

JSON stands for JavaScript Object Notation. It is a lightweight text format used for storing and exchanging structured data. JSON is widely used in:

• Web applications
• APIs
• Configuration files
• Databases
• Data transfer between systems

6.2 JSON Data Types and Python MappingCopy Anchor Link

6.3 The json ModuleCopy Anchor Link

Memory Aid:

• loads/dumps → work with strings (the ‘s’ stands for string)
• load/dump → work with files

6.4 Parsing JSON StringsCopy Anchor Link

import json

student_json = '{"name": "Ravi", "age": 21, "marks": 88}'
student = json.loads(student_json)

print(student["name"])   # Ravi
print(student["marks"])  # 88

6.5 Converting Python to JSONCopy Anchor Link

import json

student = {
    "name": "Ravi",
    "age": 21,
    "marks": 88
}

json_string = json.dumps(student, indent=4)
print(json_string)

6.6 Parsing Nested JSONCopy Anchor Link

import json

data = '''
{
    "student": {
        "name": "Meena",
        "age": 20,
        "subjects": ["Python", "DBMS", "AI"]
    }
}
'''

obj = json.loads(data)
print(obj["student"]["name"])        # Meena
print(obj["student"]["subjects"][0]) # Python

6.7 Reading and Writing JSON FilesCopy Anchor Link

import json

# Writing JSON to file
student = {
    "name": "Meena",
    "semester": 5,
    "skills": ["Python", "SQL"]
}

with open("student.json", "w") as file:
    json.dump(student, file, indent=4)

# Reading JSON from file
with open("student.json", "r") as file:
    data = json.load(file)

print(data["skills"])  # ['Python', 'SQL']

6.8 JSON Errors and SolutionsCopy Anchor Link

Safer way to read optional values:

name = data.get("name", "Unknown")
print(name)

7. Regular Expressions and RegEx FunctionsCopy Anchor Link

7.1 What is a Regular Expression?Copy Anchor Link

A Regular Expression (RegEx) is a pattern used to match text. It is useful for:

• Validating input (emails, phone numbers)
• Extracting values from text
• Searching documents
• Cleaning text
• Replacing unwanted content

7.2 Regular Expression WorkflowCopy Anchor Link

┌───────────┐    ┌───────────┐    ┌──────────────┐    ┌─────────────────┐    ┌──────────────┐
│ 1. Pattern│ →  │ 2. Compile│ →  │ 3. Search/   │ →  │ 4. Process/     │ →  │ 5. Validate/ │
│   Define  │    │  Pattern  │    │    Match     │    │    Extract      │    │    Output    │
└───────────┘    └───────────┘    └──────────────┘    └─────────────────┘    └──────────────┘

Step 1: Pattern — Define the regular expression pattern. Step 2: Compile — Compile the pattern into a regex object. Step 3: Search/Match — Search the target string for matches. Step 4: Process/Extract — Process the matches or extract the needed information. Step 5: Validate/Output — Validate results and output or store them.

7.3 RegEx MetacharactersCopy Anchor Link

7.4 Common Functions in the re ModuleCopy Anchor Link

7.5 RegEx ExamplesCopy Anchor Link

Example 1: Find all numbers

import re
text = "My marks are 85 and my attendance is 92"
numbers = re.findall(r"\d+", text)
print(numbers)  # ['85', '92']

Example 2: Validate email

import re
email = "student@example.com"
pattern = r"^[\w.-]+@[\w.-]+\.\w+$"

if re.fullmatch(pattern, email):
    print("Valid email")
else:
    print("Invalid email")

Example 3: Clean whitespace

import re
sentence = "Python    is   easy"
cleaned = re.sub(r"\s+", " ", sentence)
print(cleaned)  # Python is easy

Raw Strings: RegEx patterns are usually written as raw strings using r"pattern". This avoids confusion with Python escape characters such as \n and \t.

8. Exception HandlingCopy Anchor Link

8.1 What is an Exception?Copy Anchor Link

An exception is an error that occurs while a program is running. Without exception handling, the program stops immediately. With exception handling, the program can:

• Display a meaningful message
• Recover from the error
• Close resources safely

8.2 Basic try-except StructureCopy Anchor Link

try:
    number = int(input("Enter a number: "))
    print(100 / number)
except ValueError:
    print("Please enter only numbers.")
except ZeroDivisionError:
    print("Cannot divide by zero.")

8.3 Common Exceptions in PythonCopy Anchor Link

8.4 Multiple ExceptionsCopy Anchor Link

Multiple except blocks are used when different errors require different responses. Python checks the except blocks from top to bottom and runs the first matching block.

try:
    x = int(input("Enter number: "))
    y = int(input("Enter divisor: "))
    print(x / y)
except ValueError:
    print("Invalid input.")
except ZeroDivisionError:
    print("Cannot divide by zero.")
except Exception as e:
    print("Unexpected error:", e)

8.5 else and finally BlocksCopy Anchor Link

try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("File not found.")
else:
    print("File read successfully.")
finally:
    print("Program finished.")

• else block: Runs only if no exception occurs.
• finally block: Runs whether or not an exception occurs. Commonly used to close files, release resources, or display final messages.

8.6 Raising ExceptionsCopy Anchor Link

def set_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    return age

print(set_age(20))   # 20
# print(set_age(-5)) # Raises ValueError

Best Practice: Avoid using a bare except: block because it catches all errors and can hide programming mistakes. Catch specific exceptions whenever possible.

9. File HandlingCopy Anchor Link

9.1 What is File Handling?Copy Anchor Link

File handling allows a program to store data permanently and read data from external sources. Python can work with text files, CSV files, JSON files, binary files, logs, and many other formats.

9.2 Safe File Handling WorkflowCopy Anchor Link

┌──────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ 1. Open  │ →  │ 2. Read/     │ →  │ 3. Process   │ →  │ 4. Close     │ →  │ 5. Handle    │
│   File   │    │    Write     │    │    Data      │    │   Safely     │    │    Errors    │
└──────────┘    └──────────────┘    └──────────────┘    └──────────────┘    └──────────────┘

Step 1: Open File — Open in appropriate mode (read, write, append). Step 2: Read/Write — Read from or write to the file as required. Step 3: Process Data — Process, validate, or transform data as needed. Step 4: Close Safely — Close the file to release resources and ensure data is saved. Step 5: Handle Errors — Catch and handle exceptions to prevent crashes and ensure reliability.

9.3 File Opening ModesCopy Anchor Link

9.4 Opening and Closing FilesCopy Anchor Link

The open() function is used to open a file. It returns a file object. Files should be closed after use to avoid resource leakage. The recommended method is to use the with statement because it closes the file automatically.

# Using with statement (recommended)
with open("students.txt", "r") as file:
    print(file.read())

# Manual opening and closing
file = open("students.txt", "r")
print(file.read())
file.close()

9.5 Reading FilesCopy Anchor Link

# Read entire file
with open("students.txt", "r") as file:
    print(file.read())

# Read one line
with open("students.txt", "r") as file:
    print(file.readline())

# Read line by line
with open("students.txt", "r") as file:
    for line in file:
        print(line.strip())

9.6 Writing and Appending FilesCopy Anchor Link

# Writing (overwrites existing content)
with open("output.txt", "w") as file:
    file.write("First line\n")
    file.write("Second line\n")

# Appending (adds to end)
with open("output.txt", "a") as file:
    file.write("Appended line\n")

9.7 Working with File Paths and EncodingCopy Anchor Link

A file path tells Python where the file is located. If only the file name is given, Python searches in the current working directory. For text files, UTF-8 encoding is commonly used because it supports many languages and symbols.

from pathlib import Path

path = Path("data") / "students.txt"

with open(path, "r", encoding="utf-8") as file:
    content = file.read()

print(content)

9.8 File Handling with ExceptionsCopy Anchor Link

try:
    with open("marks.txt", "r") as file:
        marks = file.read()
        print(marks)
except FileNotFoundError:
    print("The file marks.txt was not found.")

9.9 Important File Handling ConceptsCopy Anchor Link

10. Integrated Practical ExampleCopy Anchor Link

The following example combines important concepts: importing modules, reading JSON data, validating email using RegEx, handling exceptions, and writing output to a file.

import json
import re

EMAIL_PATTERN = r"^[\w.-]+@[\w.-]+\.\w+$"

try:
    with open("students.json", "r", encoding="utf-8") as file:
        students = json.load(file)

    valid_students = []

    for student in students:
        email = student.get("email", "")
        if re.fullmatch(EMAIL_PATTERN, email):
            valid_students.append(student)

    with open("valid_students.json", "w", encoding="utf-8") as file:
        json.dump(valid_students, file, indent=4)

    print("Valid student records saved successfully.")

except FileNotFoundError:
    print("Input JSON file not found.")
except json.JSONDecodeError:
    print("Invalid JSON format.")
except Exception as error:
    print("Unexpected error:", error)

Concepts DemonstratedCopy Anchor Link

11. Unit SummaryCopy Anchor Link

PYTHON MODULES AND FILE HANDLING
│
├── Introduction to Modules
│   ├── Definition (.py file with reusable code)
│   ├── Importance (reuse, organisation, maintainability, testing, teamwork)
│   └── Module vs Package vs Library
│
├── Creating and Using Modules
│   ├── Steps to create
│   ├── User-defined module example
│   └── Best practices
│
├── Naming and Renaming Modules
│   ├── Naming rules
│   └── Aliases (as keyword)
│
├── Variables, Built-in Modules, dir()
│   ├── Module-level variables
│   ├── Common built-in modules
│   └── dir() function
│
├── Importing from Modules
│   ├── Import styles
│   └── __name__ == "__main__" pattern
│
├── JSON in Python
│   ├── JSON data types → Python mapping
│   ├── json.loads/dumps/load/dump
│   ├── Nested JSON parsing
│   ├── File read/write
│   └── Error handling
│
├── Regular Expressions
│   ├── Metacharacters
│   ├── re module functions
│   └── Examples (findall, fullmatch, sub)
│
├── Exception Handling
│   ├── try-except
│   ├── Multiple exceptions
│   ├── else, finally
│   └── Raising exceptions
│
└── File Handling
    ├── Modes (r, w, a, x, b, t, +)
    ├── Reading, writing, appending
    ├── File paths and encoding
    └── File handling with exceptions

12. Key Formulas and Syntax — Quick ReferenceCopy Anchor Link

13. Exam-Focused PointsCopy Anchor Link

1. Module definition — A .py file with reusable code.
2. Module vs Package vs Library — Module = file; Package = folder; Library = collection.
3. import vs from ... import — Full module vs specific names.
4. Aliases — import numpy as np; does not rename the file.
5. dir() function — Lists module contents.
6. __name__ == "__main__" — Prevents test code from running on import.
7. JSON functions — loads/dumps for strings; load/dump for files.
8. JSON data type mapping — null → None; true → True.
9. RegEx metacharacters — ., ^, $, , +, ?, [], \d, \w, \s.
10. re functions — search, match, fullmatch, findall, sub, split, compile.
11. Raw strings — Use r"pattern" to avoid escape character issues.
12. Exception types — ValueError, ZeroDivisionError, FileNotFoundError, KeyError, IndexError, TypeError.
13. else vs finally — else runs if no exception; finally always runs.
14. File modes — r (read), w (write/overwrite), a (append), x (create), b (binary), t (text), + (read/write).
15. with statement — Automatically closes files.
16. Encoding — UTF-8 for multilingual text.
17. Avoid bare except: — Catch specific exceptions.
18. Integrated example — Combines modules, JSON, RegEx, exceptions, and file handling.

14. Glossary of Key TermsCopy Anchor Link