Unit 13: Advanced Python Concepts

# 1. List Comprehension: Filter even numbers and square them
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print("List Comprehension (Even Squares):", even_squares)

# 2. Set Comprehension: Extract unique word lengths (eliminates duplicate lengths)
words = ["apple", "cat", "banana", "dog", "fig", "apple"]
unique_lengths = {len(w) for w in words}
print("Set Comprehension (Unique Word Lengths):", unique_lengths)

# 3. Dictionary Comprehension: Map student names to letter grades
raw_scores = {"Aman": 88, "Pooja": 94, "Rahul": 62, "Sneha": 78}
grades = {name: ("A+" if score >= 90 else "A" if score >= 75 else "B") 
          for name, score in raw_scores.items()}
print("Dict Comprehension (Student Grades):", grades)

# Building a Custom Countdown Iterator implementing the protocol
class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self  # An iterator must return itself

    def __next__(self):
        if self.current <= 0:
            raise StopIteration  # Mandatory protocol signal when finished
        val = self.current
        self.current -= 1
        return val

print("Running custom Countdown iterator:")
counter = Countdown(3)
for count in counter:
    print(f"  T-minus {count}...")
print("  🚀 Liftoff!")

import sys

# Generator function using yield
def fibonacci_stream(limit):
    a, b = 0, 1
    count = 0
    while count < limit:
        yield a              # Pauses and returns current number!
        a, b = b, a + b      # Resumes here on next call
        count += 1

fib_gen = fibonacci_stream(6)

print("Type of fib_gen:", type(fib_gen).__name__)
print("Values produced one by one:")
for val in fib_gen:
    print(f"  Generated -> {val}")

# RAM Comparison Proof: List vs Generator Expression
huge_list = [x for x in range(100000)]
huge_gen = (x for x in range(100000))

print("\nRAM Footprint for 100,000 items:")
print(f"  List Memory Size      : {sys.getsizeof(huge_list):,} bytes")
print(f"  Generator Memory Size : {sys.getsizeof(huge_gen)} bytes (Microscopic!)")

import time
import functools

# Building an execution benchmark decorator
def execution_timer(func):
    @functools.wraps(func)  # Preserves original function name and docstrings
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)  # Call the original function
        duration = time.perf_counter() - start_time
        print(f"⏱️ [BENCHMARK] Function '{func.__name__}' took {duration:.6f} seconds.")
        return result
    return wrapper

# Applying the decorator using @ syntax
@execution_timer
def calculate_sum_of_squares(n):
    return sum(i**2 for i in range(n))

ans = calculate_sum_of_squares(500000)
print(f"Calculation Result: {ans}")

import re

sample_text = "Contact support at dev@devascent.me or admissions@academy.edu by 2026-10-15."

# 1. re.findall(): Extract all email addresses matching regex
email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
found_emails = re.findall(email_pattern, sample_text)
print("Extracted Emails:", found_emails)

# 2. re.search(): Find and parse date pattern (YYYY-MM-DD)
date_pattern = r'(\d{4})-(\d{2})-(\d{2})'
match = re.search(date_pattern, sample_text)
if match:
    year, month, day = match.groups()
    print(f"Found Date -> Year: {year}, Month: {month}, Day: {day}")

import copy

original = [["A", "B"], [1, 2]]

shallow = copy.copy(original)
deep = copy.deepcopy(original)

# Modify a nested item inside the original list
original[0][0] = "CORRUPTED"

print("Original List :", original)
print("Shallow Copy  :", shallow, "<- Mutated! (Shares inner reference)")
print("Deep Copy     :", deep, "<- Protected! (Completely independent clone)")

import sys
import gc

# 1. Reference Counting Inspection
sample_obj = [10, 20, 30]
print("Initial Reference Count:", sys.getrefcount(sample_obj) - 1)

alias_ref = sample_obj  # Create another reference
print("Ref Count after alias :", sys.getrefcount(sample_obj) - 1)

del alias_ref           # Delete reference
print("Ref Count after del   :", sys.getrefcount(sample_obj) - 1)

# 2. Inspecting Generational Garbage Collection counts
print("\nGarbage Collector Generation Thresholds (Gen0, Gen1, Gen2):", gc.get_threshold())
print("Current Uncollected Object Counts in Generations     :", gc.get_count())

import re
import time
import copy
import datetime

# 1. Benchmark Decorator
def timed_pipeline(func):
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        res = func(*args, **kwargs)
        duration = time.perf_counter() - t0
        print(f"\n[AUDIT] Engine '{func.__name__}' completed in {duration:.6f}s")
        return res
    return wrapper

# 2. Generator Function for Lazy Log Streaming
def raw_log_stream():
    logs = [
        '192.168.1.10 - [GET /api/v1/students] 200 OK',
        '10.0.0.52 - [POST /api/v1/auth] 401 UNAUTHORIZED',
        '192.168.1.10 - [GET /api/v1/reports] 200 OK',
        '172.16.0.4 - [GET /favicon.ico] 404 NOT_FOUND'
    ]
    for entry in logs:
        yield entry

# 3. Processing Pipeline integrating Regex & Dict Comprehension
@timed_pipeline
def analyze_server_logs():
    ip_pattern = r'^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
    status_pattern = r'\] (\d{3})'
    
    records = []
    for line in raw_log_stream():
        ip_match = re.search(ip_pattern, line)
        status_match = re.search(status_pattern, line)
        if ip_match and status_match:
            records.append({"ip": ip_match.group(1), "status": int(status_match.group(1))})

    # Dict Comprehension: Count occurrences of each HTTP status
    status_counts = {code: sum(1 for r in records if r["status"] == code) 
                     for code in {r["status"] for r in records}}
    
    # Deep copy to preserve snapshot
    snapshot = copy.deepcopy(status_counts)
    return snapshot

summary = analyze_server_logs()
print("Parsed HTTP Status Summary:", summary)