import json
student = json.loads('{"name": "Ravi", "age": 21}')
print(student["name"])  # Ravi

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

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

try:
    print(10 / 0)
except ZeroDivisionError:
    print("Cannot divide by zero.")

with open("log.txt", "a") as file:
    file.write("New log entry\n")

# 1. import module
import math
print(math.sqrt(81))      # 9.0
print(math.pi)            # 3.14159...

# 2. import module as alias
import math as m
print(m.factorial(5))     # 120

# 3. from module import name
from math import sqrt, pi
print(sqrt(81))           # 9.0
print(pi)                 # 3.14159...

import json

# 1. json.loads() — parse JSON string
student_json = '{"name": "Ravi", "age": 21, "marks": 88}'
student = json.loads(student_json)
print(student["name"])    # Ravi
print(student["marks"])   # 88

# 2. json.dumps() — convert Python object to JSON string
student = {"name": "Ravi", "age": 21, "marks": 88}
json_string = json.dumps(student, indent=4)
print(json_string)

# 3. json.dump() — write Python object to JSON file
student = {"name": "Meena", "semester": 5, "skills": ["Python", "SQL"]}
with open("student.json", "w") as file:
    json.dump(student, file, indent=4)

# 4. json.load() — read JSON from file
with open("student.json", "r") as file:
    data = json.load(file)
print(data["skills"])     # ['Python', 'SQL']

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

import re

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

# 2. Validate email using ^, $, \w, . and +
email = "student@example.com"
pattern = r"^[\w.-]+@[\w.-]+\.\w+$"
if re.fullmatch(pattern, email):
    print("Valid email")

# 3. Clean multiple spaces using \s+
sentence = "Python    is   easy"
cleaned = re.sub(r"\s+", " ", sentence)
print(cleaned)  # Python is easy

# 4. Optional character using ?
print(re.findall(r"colou?r", "color colour"))  # ['color', 'colour']

# 5. Repetition using *
print(re.findall(r"ab*", "a ab abb abbb"))  # ['a', 'ab', 'abb', 'abbb']

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

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)

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

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

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

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

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

# 4. Create mode (x) — fails if file exists
try:
    with open("newfile.txt", "x") as file:
        file.write("Created safely\n")
except FileExistsError:
    print("File already exists.")

# 5. Binary mode (b) — read image
with open("photo.jpg", "rb") as file:
    data = file.read()

# 6. Read and write mode (+)
with open("data.txt", "r+") as file:
    content = file.read()
    file.write("\nNew line appended.")

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

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

# File name: calculator_tools.py
def add(a, b):
    return a + b

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

PI = 3.14159

# File name: 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

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)

# File name: college_info.py
college_name = "ABC Institute"
course = "Python Programming"
semester = 5

# File name: main.py
import college_info

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

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

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

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

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

# File name: greetings.py
def welcome(name):
    return "Welcome, " + name

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

Create → Test → Package → Distribute → Import & Reuse
   ↑                                          │
   └──────────── Iterate & Improve ───────────┘

import json

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

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

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

import json

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

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

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

import json

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

print(data["skills"])

import json

student = {
    "name": "Meena",
    "semester": 5,
    "skills": ["Python", "SQL"]
}

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

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

import json

try:
    with open("students.json", "r", encoding="utf-8") as file:
        students = json.load(file)
    print(f"Loaded{len(students)} records.")
except FileNotFoundError:
    print("Input JSON file not found.")
except json.JSONDecodeError:
    print("Invalid JSON format.")
except Exception as error:
    print("Unexpected error:", error)

Define Pattern → Compile → Search/Match → Process/Extract → Validate/Output

import re
text = "Python is easy"
match = re.search(r"is", text)
if match:
    print("Found at position:", match.start())  # Found at position: 7

import re
print(re.match(r"Python", "Python is easy"))  # Match
print(re.match(r"easy", "Python is easy"))    # None (not at start)

import re
email = "student@example.com"
pattern = r"^[\w.-]+@[\w.-]+\.\w+$"
if re.fullmatch(pattern, email):
    print("Valid email")  # Valid email

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

import re
text = "apple,banana,orange"
fruits = re.split(r",", text)
print(fruits)  # ['apple', 'banana', 'orange']

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

import re
pattern = re.compile(r"\d+")
print(pattern.findall("a1b2c3"))  # ['1', '2', '3']
print(pattern.findall("x10y20"))  # ['10', '20']

import re
email = "student@example.com"
pattern = r"^[\w.-]+@[\w.-]+\.\w+$"
if re.fullmatch(pattern, email):
    print("Valid email")
else:
    print("Invalid email")

import re
text = "Call 123-456-7890 or 987-654-3210"
phones = re.findall(r"\d{3}-\d{3}-\d{4}", text)
print(phones)  # ['123-456-7890', '987-654-3210']

import re
messy = "Too     many    spaces"
clean = re.sub(r"\s+", " ", messy)
print(clean)  # Too many spaces

import re
data = "apple;banana,orange|grape"
items = re.split(r"[;,|]", data)
print(items)  # ['apple', 'banana', 'orange', 'grape']

# Correct
pattern = r"\d+"

# Incorrect (may cause issues)
pattern = "\d+"

Open File → Read/Write → Process Data → Close Safely → Handle Errors

def process_marks(input_file, output_file):
    """
    Read marks from input_file, compute average,
    and write results to output_file.
    Handles missing files and invalid data.
    """
    try:
        # Step 1: Open and read the input file
        with open(input_file, "r", encoding="utf-8") as file:
            lines = file.readlines()

        # Step 2: Process data
        results = []
        for line in lines:
            parts = line.strip().split(",")
            if len(parts) != 2:
                print(f"Skipping invalid line:{line.strip()}")
                continue

            name, marks_str = parts
            try:
                marks = float(marks_str)
                results.append((name, marks))
            except ValueError:
                print(f"Invalid marks for{name}:{marks_str}")

        # Step 3: Compute average
        if results:
            total = sum(m for _, m in results)
            average = total / len(results)
        else:
            average = 0
            print("No valid records found.")

        # Step 4: Write output safely
        with open(output_file, "w", encoding="utf-8") as file:
            file.write(f"Total students:{len(results)}\n")
            file.write(f"Average marks:{average:.2f}\n")
            file.write("\nDetailed Results:\n")
            for name, marks in results:
                file.write(f"{name}:{marks}\n")

        print(f"Results saved to{output_file}")

    except FileNotFoundError:
        print(f"Error: '{input_file}' not found.")
    except PermissionError:
        print(f"Error: Permission denied for '{input_file}'.")
    except Exception as error:
        print("Unexpected error:", error)
    finally:
        print("Processing finished.")

# Usage
process_marks("marks.txt", "results.txt")

Ravi,85
Meena,92
Arjun,invalid
Priya,78

Total students: 3
Average marks: 85.00

Detailed Results:
Ravi: 85.0
Meena: 92.0
Priya: 78.0

Invalid marks for Arjun: invalid
Results saved to results.txt
Processing finished.

import json
import re

# Step 1: Define email validation pattern
EMAIL_PATTERN = r"^[\w.-]+@[\w.-]+\.\w+$"

def is_valid_email(email):
    """Check if email matches the pattern."""
    if not email:
        return False
    return re.fullmatch(EMAIL_PATTERN, email) is not None

def validate_student(student):
    """Check if a student record has all required fields with valid email."""
    required_fields = ["name", "register_number", "email", "marks"]
    for field in required_fields:
        if field not in student:
            return False
    return is_valid_email(student.get("email", ""))

def process_student_records(input_file, output_file):
    """Read, validate, and save student records."""
    try:
        # Step 2: Read JSON file
        with open(input_file, "r", encoding="utf-8") as file:
            students = json.load(file)

        if not isinstance(students, list):
            print("Error: JSON root must be a list of students.")
            return

        # Step 3: Validate and filter records
        valid_students = []
        invalid_count = 0

        for student in students:
            if validate_student(student):
                valid_students.append(student)
            else:
                invalid_count += 1
                print(f"Invalid record skipped:{student.get('name', 'Unknown')}")

        # Step 4: Write valid records to new file
        with open(output_file, "w", encoding="utf-8") as file:
            json.dump(valid_students, file, indent=4)

        # Step 5: Summary
        print(f"\nProcessing complete.")
        print(f"Total records:{len(students)}")
        print(f"Valid records:{len(valid_students)}")
        print(f"Invalid records:{invalid_count}")
        print(f"Saved to:{output_file}")

    except FileNotFoundError:
        print(f"Error: Input file '{input_file}' not found.")
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON format -{e}")
    except PermissionError:
        print(f"Error: Permission denied for '{input_file}' or '{output_file}'.")
    except Exception as error:
        print(f"Unexpected error:{error}")

# Usage
process_student_records("students.json", "valid_students.json")

[
    {
        "name": "Ravi",
        "register_number": "R001",
        "email": "ravi@college.edu",
        "marks": 85
    },
    {
        "name": "Meena",
        "register_number": "R002",
        "email": "invalid-email",
        "marks": 92
    },
    {
        "name": "Arjun",
        "register_number": "R003",
        "email": "arjun@college.edu",
        "marks": 78
    },
    {
        "name": "Priya",
        "register_number": "R004",
        "email": "priya@college",
        "marks": 88
    }
]

Invalid record skipped: Meena
Invalid record skipped: Priya

Processing complete.
Total records: 4
Valid records: 2
Invalid records: 2
Saved to: valid_students.json

[
    {
        "name": "Ravi",
        "register_number": "R001",
        "email": "ravi@college.edu",
        "marks": 85
    },
    {
        "name": "Arjun",
        "register_number": "R003",
        "email": "arjun@college.edu",
        "marks": 78
    }
]

import re
import json
from collections import Counter

def analyze_logs(log_file, output_file):
    """Analyze log file, extract errors, and save report."""
    try:
        # Step 1: Read log file
        with open(log_file, "r", encoding="utf-8") as file:
            lines = file.readlines()

        # Step 2: Extract error patterns using RegEx
        error_pattern = r"ERROR:\s+(.+)"
        errors = []
        for line in lines:
            match = re.search(error_pattern, line)
            if match:
                errors.append(match.group(1).strip())

        # Step 3: Count occurrences
        error_counts = Counter(errors)

        # Step 4: Build report
        report = {
            "total_lines": len(lines),
            "total_errors": len(errors),
            "unique_errors": len(error_counts),
            "top_errors": error_counts.most_common(5)
        }

        # Step 5: Write JSON report
        with open(output_file, "w", encoding="utf-8") as file:
            json.dump(report, file, indent=4)

        print(f"Report saved to{output_file}")

    except FileNotFoundError:
        print(f"Log file '{log_file}' not found.")
    except Exception as error:
        print(f"Unexpected error:{error}")

# Usage
analyze_logs("server.log", "error_report.json")

import json
import re

EMAIL_PATTERN = r"^[\w.-]+@[\w.-]+\.\w+$"
PHONE_PATTERN = r"^\d{3}-\d{3}-\d{4}$"

def validate_student(student):
    """Validate email and phone."""
    email = student.get("email", "")
    phone = student.get("phone", "")
    return (re.fullmatch(EMAIL_PATTERN, email) and
            re.fullmatch(PHONE_PATTERN, phone))

def manage_students(input_file, output_file):
    """Read, validate, and save student records."""
    try:
        with open(input_file, "r", encoding="utf-8") as file:
            students = json.load(file)

        valid = [s for s in students if validate_student(s)]

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

        print(f"Saved{len(valid)} valid records.")

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

# Usage
manage_students("students.json", "valid_students.json")

import json
import re

def process_api_response(response_text, output_file):
    """Parse API response, validate, and save."""
    try:
        data = json.loads(response_text)
        valid_entries = []

        for entry in data.get("results", []):
            email = entry.get("email", "")
            if re.fullmatch(r"^[\w.-]+@[\w.-]+\.\w+$", email):
                valid_entries.append(entry)

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

        print(f"Saved{len(valid_entries)} valid entries.")

    except json.JSONDecodeError:
        print("Invalid JSON response.")
    except Exception as error:
        print(f"Unexpected error:{error}")

Modules (tools) → File Handling (I/O) → JSON (structure) → RegEx (validation) → Exception Handling (safety)