Free Python Programming Course: Learn Python from Scratch

def convert_celsius_to_fahrenheit(celsius):
    """
    Converts temperature from Celsius to Fahrenheit with precision rounding.
    Formula: F = (C * 9/5) + 32
    """
    if not isinstance(celsius, (int, float)):
        raise TypeError(f"Expected numeric input (int or float), got {type(celsius).__name__}")
    
    fahrenheit = (celsius * 9 / 5) + 32
    return round(fahrenheit, 2)

# --- Test Cases ---
print(convert_celsius_to_fahrenheit(0))       # Output: 32.0
print(convert_celsius_to_fahrenheit(100))     # Output: 212.0
print(convert_celsius_to_fahrenheit(37))      # Output: 98.6
print(convert_celsius_to_fahrenheit(-40))     # Output: -40.0

Detailed Explanation: In Python, division with / always produces a float. We use isinstance(celsius, (int, float)) to validate inputs gracefully before performing calculation. The built-in round(value, 2) guarantees precision down to two decimal digits, ensuring clean output.

def is_palindrome(text):
    """
    Verifies if a string is a palindrome, ignoring casing, spaces, and punctuation.
    """
    if not isinstance(text, str):
        raise TypeError("Input must be a string.")
    
    # Filter only alphanumeric characters and normalize to lowercase
    cleaned = ''.join(char.lower() for char in text if char.isalnum())
    
    # Slicing with step -1 creates an inverted copy
    return cleaned == cleaned[::-1]

# --- Test Cases ---
print(is_palindrome("racecar"))                            # Output: True
print(is_palindrome("A man, a plan, a canal: Panama"))    # Output: True
print(is_palindrome("Was it a car or a cat I saw?"))       # Output: True
print(is_palindrome("Hello, World!"))                      # Output: False

Detailed Explanation: Python's str.isalnum() method checks if each character is an alphanumeric letter or digit. Using a generator expression with ''.join(...) provides an efficient way to clean the string in $O(N)$ time. Then, cleaned[::-1] reverses the string using Python's stride slicing.

def is_leap_year(year):
    """
    Evaluates whether a calendar year is a leap year according to Gregorian rules.
    """
    if not isinstance(year, int) or year < 1:
        raise ValueError("Year must be a positive integer.")
    
    # Rule: Divisible by 400 OR (divisible by 4 AND NOT divisible by 100)
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

# --- Test Cases ---
print(is_leap_year(2024))  # Output: True  (divisible by 4 and not 100)
print(is_leap_year(1900))  # Output: False (divisible by 100 but not 400)
print(is_leap_year(2000))  # Output: True  (divisible by 400)
print(is_leap_year(2026))  # Output: False

Detailed Explanation: The Boolean expression short-circuits efficiently. Years divisible by 400 immediately evaluate to True. For other years, the check confirms divisibility by 4 while excluding century milestone years that fail the 400-year cycle.

def count_vowels_and_consonants(phrase):
    """
    Counts vowel and consonant occurrences in a text string.
    """
    vowels = set('aeiou')
    counts = {'vowels': 0, 'consonants': 0}
    
    for char in phrase.lower():
        if char.isalpha():
            if char in vowels:
                counts['vowels'] += 1
            else:
                counts['consonants'] += 1
                
    return counts

# --- Test Cases ---
print(count_vowels_and_consonants("Python Programming")) 
# Output: {'vowels': 4, 'consonants': 13}
print(count_vowels_and_consonants("Fun Koding 2026!"))    
# Output: {'vowels': 3, 'consonants': 6}

Detailed Explanation: Using a Python set for vowel membership testing provides $O(1)$ constant-time lookup. Iterating over the lowercase string and verifying char.isalpha() ensures numbers, punctuation marks, and whitespace are safely filtered out.

def fizz_buzz(n):
    """
    Generates standard FizzBuzz sequence up to n as a list of strings.
    """
    result = []
    for i in range(1, n + 1):
        if i % 15 == 0:
            result.append("FizzBuzz")
        elif i % 3 == 0:
            result.append("Fizz")
        elif i % 5 == 0:
            result.append("Buzz")
        else:
            result.append(str(i))
    return result

# --- Test Cases ---
print(fizz_buzz(15))
# Output: ['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

Detailed Explanation: Because an integer divisible by 15 satisfies both conditions, placing i % 15 == 0 at the top of the if/elif ladder prevents premature matching of the individual 3 or 5 branches.

def reverse_integer_and_sum(n):
    """
    Reverses an integer and computes the sum of its digits using pure arithmetic.
    """
    if n < 0:
        raise ValueError("Input must be a non-negative integer.")
    if n == 0:
        return (0, 0)
        
    reversed_num = 0
    digit_sum = 0
    temp = n
    
    while temp > 0:
        digit = temp % 10
        reversed_num = (reversed_num * 10) + digit
        digit_sum += digit
        temp //= 10
        
    return (reversed_num, digit_sum)

# --- Test Cases ---
print(reverse_integer_and_sum(12345))  # Output: (54321, 15)
print(reverse_integer_and_sum(4090))   # Output: (904, 13)
print(reverse_integer_and_sum(7))      # Output: (7, 7)

Detailed Explanation: Mathematical digit extraction avoids string memory allocations. Each iteration pops the least-significant digit with modulo 10 and shifts the accumulator by multiplying by 10, running in logarithmic $O(\log_{10} N)$ time complexity.

def format_multiplication_grid(size):
    """
    Produces an aligned grid string representing a multiplication table of size x size.
    """
    lines = []
    # Header row
    header = "   *" + "".join(f"{col:>5}" for col in range(1, size + 1))
    lines.append(header)
    lines.append("   -" + "-----" * size)
    
    for row in range(1, size + 1):
        row_str = f"{row:>3} |" + "".join(f"{row * col:>5}" for col in range(1, size + 1))
        lines.append(row_str)
        
    return "\n".join(lines)

# --- Test Cases ---
print(format_multiplication_grid(5))
# Output:
#    *    1    2    3    4    5
#    --------------------------
#    1 |    1    2    3    4    5
#    2 |    2    4    6    8   10
#    3 |    3    6    9   12   15
#    4 |    4    8   12   16   20
#    5 |    5   10   15   20   25

Detailed Explanation: Python's f-string format specification {val:>5} right-justifies text within a width of 5 characters. This guarantees column uniformity regardless of single or multi-digit numbers.

def factorial_iterative(n):
    if not isinstance(n, int) or n < 0:
        raise ValueError("Factorial is only defined for non-negative integers.")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

def factorial_recursive(n):
    if not isinstance(n, int) or n < 0:
        raise ValueError("Factorial is only defined for non-negative integers.")
    if n <= 1:
        return 1
    return n * factorial_recursive(n - 1)

# --- Test Cases ---
print(factorial_iterative(5))   # Output: 120
print(factorial_recursive(5))   # Output: 120
print(factorial_iterative(0))   # Output: 1

Detailed Explanation: The iterative approach operates in $O(N)$ time and $O(1)$ auxiliary memory space, avoiding stack frames. The recursive approach illustrates direct mathematical definition with a base case at $n \le 1$.

def is_prime(n):
    """
    Checks if integer n is prime using optimized trial division up to sqrt(n).
    """
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
        
    # Check potential factors of the form 6k +/- 1 up to sqrt(n)
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
        
    return True

# --- Test Cases ---
print(is_prime(2))    # Output: True
print(is_prime(17))   # Output: True
print(is_prime(49))   # Output: False
print(is_prime(997))  # Output: True

Detailed Explanation: All primes greater than 3 can be expressed as $6k \pm 1$. Limiting our search to $\sqrt{n}$ reduces comparisons from $1,000,000$ to just $\approx 1,000$ iterations when checking large numbers.

def find_second_largest(numbers):
    """
    Finds the second largest distinct element in O(N) time with O(1) extra memory.
    """
    if not numbers or len(numbers) < 2:
        return None
        
    first = float('-inf')
    second = float('-inf')
    
    for num in numbers:
        if num > first:
            second = first
            first = num
        elif num < first and num > second:
            second = num
            
    return second if second != float('-inf') else None

# --- Test Cases ---
print(find_second_largest([12, 35, 1, 10, 34, 1]))  # Output: 34
print(find_second_largest([10, 10, 10]))            # Output: None
print(find_second_largest([5, 9, 2]))               # Output: 5

Detailed Explanation: By tracking first and second in a single linear scan, we achieve optimal $O(N)$ time and $O(1)$ space complexity, whereas sorting would require $O(N \log N)$ time.

def remove_duplicates_ordered(items):
    """
    Deduplicates a list in O(N) time while strictly maintaining initial element order.
    """
    seen = set()
    deduped = []
    for item in items:
        if item not in seen:
            seen.add(item)
            deduped.append(item)
    return deduped

# Pythonic one-liner alternative (Python 3.7+):
def remove_duplicates_dict(items):
    return list(dict.fromkeys(items))

# --- Test Cases ---
sample = [4, 5, 1, 2, 4, 1, 6, 5, 8]
print(remove_duplicates_ordered(sample)) # Output: [4, 5, 1, 2, 6, 8]
print(remove_duplicates_dict(sample))    # Output: [4, 5, 1, 2, 6, 8]

Detailed Explanation: A standard set(items) loses original sequence ordering. Combining a hash set for $O(1)$ membership checks with an output list provides both order preservation and linear runtime.

def two_sum(nums, target):
    """
    Finds pair indices adding up to target in O(N) time using a hash map lookup.
    """
    seen = {} # Maps value -> index
    for index, value in enumerate(nums):
        complement = target - value
        if complement in seen:
            return (seen[complement], index)
        seen[value] = index
    return None

# --- Test Cases ---
print(two_sum([2, 7, 11, 15], 9))  # Output: (0, 1)  (2 + 7 = 9)
print(two_sum([3, 2, 4], 6))       # Output: (1, 2)  (2 + 4 = 6)
print(two_sum([3, 3], 6))          # Output: (0, 1)  (3 + 3 = 6)

Detailed Explanation: A naive nested loop takes $O(N^2)$ time. Storing visited numbers in a dictionary enables $O(1)$ complement lookups, solving the problem in a single linear pass.

from collections import defaultdict

def group_anagrams(words):
    """
    Groups words by their canonical sorted-character signature.
    """
    anagram_map = defaultdict(list)
    
    for word in words:
        # Canonical key: alphabetically sorted characters
        key = ''.join(sorted(word))
        anagram_map[key].append(word)
        
    return list(anagram_map.values())

# --- Test Cases ---
words = ["eat", "tea", "tan", "ate", "nat", "bat"]
print(group_anagrams(words))
# Output: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Detailed Explanation: By sorting each word's characters in $O(K \log K)$ time (where $K$ is word length), all anagrams collapse into the same dictionary key, allowing effortless grouping via defaultdict.

def transpose_matrix(matrix):
    """
    Transposes a rectangular matrix using list comprehensions.
    """
    if not matrix or not matrix[0]:
        return []
    
    rows = len(matrix)
    cols = len(matrix[0])
    
    # Construct columns as new rows
    return [[matrix[r][c] for r in range(rows)] for c in range(cols)]

def transpose_pythonic(matrix):
    """
    Idiomatic one-liner using argument unpacking and zip.
    """
    return [list(col) for col in zip(*matrix)]

# --- Test Cases ---
mat = [
    [1, 2, 3],
    [4, 5, 6]
]
print(transpose_matrix(mat))   # Output: [[1, 4], [2, 5], [3, 6]]
print(transpose_pythonic(mat)) # Output: [[1, 4], [2, 5], [3, 6]]

Detailed Explanation: The unpacking operator *matrix passes each row as an individual argument to zip(). zip() aggregates elements from each row pairwise, producing the mathematical matrix transpose.

class BankAccount:
    """
    Models a bank account with encapsulated state and validated transactions.
    """
    def __init__(self, account_number: str, initial_deposit: float = 0.0):
        if initial_deposit < 0:
            raise ValueError("Initial deposit cannot be negative.")
        self._account_number = account_number
        self._balance = float(initial_deposit)

    @property
    def account_number(self):
        return self._account_number

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount: float):
        if amount <= 0:
            raise ValueError("Deposit amount must be strictly positive.")
        self._balance += amount
        return self._balance

    def withdraw(self, amount: float):
        if amount <= 0:
            raise ValueError("Withdrawal amount must be strictly positive.")
        if amount > self._balance:
            raise ValueError("Insufficient balance for withdrawal.")
        self._balance -= amount
        return self._balance

# --- Test Cases ---
acc = BankAccount("FK-101", 500.0)
acc.deposit(250.0)
print(f"Current Balance: ${acc.balance}") # Output: Current Balance: $750.0
acc.withdraw(100.0)
print(f"Post-Withdrawal: ${acc.balance}") # Output: Post-Withdrawal: $650.0

Detailed Explanation: Encapsulation safeguards internal state. Using @property allows callers to inspect acc.balance like a clean attribute while preventing direct accidental mutations like acc.balance = -999.

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

    @abstractmethod
    def perimeter(self) -> float:
        pass

class Circle(Shape):
    def __init__(self, radius: float):
        if radius <= 0:
            raise ValueError("Radius must be positive.")
        self.radius = radius

    def area(self) -> float:
        return math.pi * (self.radius ** 2)

    def perimeter(self) -> float:
        return 2 * math.pi * self.radius

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        if width <= 0 or height <= 0:
            raise ValueError("Dimensions must be positive.")
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

# --- Test Cases ---
shapes = [Circle(radius=5), Rectangle(width=4, height=6)]
for s in shapes:
    print(f"{type(s).__name__} -> Area: {s.area():.2f}, Perimeter: {s.perimeter():.2f}")
# Output:
# Circle -> Area: 78.54, Perimeter: 31.42
# Rectangle -> Area: 24.00, Perimeter: 20.00

Detailed Explanation: Abstract Base Classes enforce an interface contract. Any subclass failing to implement area() or perimeter() cannot be instantiated, preventing runtime missing method errors.

import math

class Vector2D:
    def __init__(self, x: float, y: float):
        self.x = float(x)
        self.y = float(y)

    def __add__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return Vector2D(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):
        if not isinstance(scalar, (int, float)):
            return NotImplemented
        return Vector2D(self.x * scalar, self.y * scalar)

    def __abs__(self):
        return math.hypot(self.x, self.y)

    def __eq__(self, other):
        if not isinstance(other, Vector2D):
            return False
        return math.isclose(self.x, other.x) and math.isclose(self.y, other.y)

    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"

# --- Test Cases ---
v1 = Vector2D(3, 4)
v2 = Vector2D(1, 2)
print(v1 + v2)     # Output: Vector2D(4.0, 6.0)
print(v1 * 2)      # Output: Vector2D(6.0, 8.0)
print(abs(v1))     # Output: 5.0 (Pythagorean 3-4-5)
print(v1 == Vector2D(3, 4)) # Output: True

Detailed Explanation: Python's data model allows user-defined classes to hook into native syntax. Implementing dunder methods produces objects that seamlessly integrate with standard language operators.

def parse_integers(raw_values, fallback=0):
    """
    Safely converts heterogeneous inputs to integers with exception isolation.
    """
    parsed = []
    error_count = 0
    
    for val in raw_values:
        try:
            parsed.append(int(val))
        except (ValueError, TypeError):
            parsed.append(fallback)
            error_count += 1
            
    return parsed, error_count

# --- Test Cases ---
raw_data = ["42", "100", "invalid", None, 3.14, "99px", 12]
clean, errors = parse_integers(raw_data, fallback=-1)
print("Cleaned:", clean)
# Output: Cleaned: [42, 100, -1, -1, 3, -1, 12]
print("Errors isolated:", errors)
# Output: Errors isolated: 3

Detailed Explanation: Targeting specific exceptions (ValueError, TypeError) ensures unexpected bugs (like KeyboardInterrupt or system errors) are not masked, adhering to robust Python debugging practices.

def analyze_log_file(file_path, keyword):
    """
    Memory-efficient stream analysis of text files.
    """
    total_lines = 0
    matched_lines = 0
    
    # Context manager automatically guarantees file handle closure
    with open(file_path, mode='r', encoding='utf-8') as f:
        # File object acts as a generator yielding lines one at a time
        for line in f:
            total_lines += 1
            if keyword.lower() in line.lower():
                matched_lines += 1
                
    return (total_lines, matched_lines)

# --- Simulated Demonstration ---
# In production, file_path refers to an on-disk file:
# total, matches = analyze_log_file("server.log", "ERROR")

Detailed Explanation: The Python file object implements the iterator protocol. Reading with for line in f: streams lines on demand, allowing processing of files larger than available physical RAM.

import copy

def copy_behavior_experiment():
    original = [[1, 2], [3, 4]]
    
    assigned = original            # Reference alias
    shallow = copy.copy(original)  # New outer container, shared inner references
    deep = copy.deepcopy(original) # Completely independent clone
    
    # Mutate inner list
    original[0][0] = 999
    
    return {
        "original": original,
        "assigned": assigned,
        "shallow": shallow,
        "deep": deep
    }

# --- Test Cases ---
results = copy_behavior_experiment()
print("Original:", results["original"]) # [[999, 2], [3, 4]]
print("Assigned:", results["assigned"]) # [[999, 2], [3, 4]] (shares pointer)
print("Shallow: ", results["shallow"])  # [[999, 2], [3, 4]] (inner list mutated!)
print("Deep:    ", results["deep"])     # [[1, 2], [3, 4]]   (immune!)

Detailed Explanation: In shallow copying, nested structures retain shared memory references. Only copy.deepcopy() recursively creates duplicates of all nested objects, isolating mutations completely.

def deep_flatten(nested):
    """
    Recursively unpacks arbitrarily nested lists/tuples/sets into a flat generator stream.
    """
    for item in nested:
        if isinstance(item, (list, tuple, set)):
            # Delegate sub-generator evaluation to flatten nested levels
            yield from deep_flatten(item)
        else:
            # Yield atomic leaf value directly
            yield item

# --- Test Cases ---
nested_tree = [1, [2, [3, 4], 5], [[6]], [7, 8, [9, [10]]]]
flattened = list(deep_flatten(nested_tree))
print("Flattened Result:", flattened)
# Output: Flattened Result: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Works with heterogeneous types
mixed_tree = ["root", ("branch_1", ["leaf_a", "leaf_b"]), {"branch_2": "val"}]
print("Mixed Leaves:", list(deep_flatten(mixed_tree)))
# Output: Mixed Leaves: ['root', 'branch_1', 'leaf_a', 'leaf_b', 'branch_2']

Detailed Explanation: Python 3.3 introduced the yield from <sub-iterator> syntax. Instead of writing a manual loop like for sub in deep_flatten(item): yield sub, yield from establishes a direct two-way transparent channel between the caller and the sub-generator. It eliminates stack recursion overhead, optimizes interpreter bytecode, and correctly forwards values, exceptions, and returns across arbitrarily deep tree structures.

import time
import functools

def time_it(func):
    """
    Performance profiling decorator measuring execution duration in milliseconds.
    """
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed_ms = (time.perf_counter() - start_time) * 1000
        print(f"[BENCHMARK] {func.__name__}() executed in {elapsed_ms:.4f} ms")
        return result
    return wrapper

# --- Test Cases ---
@time_it
def compute_sum_of_squares(n):
    """Computes sum of squares up to n."""
    return sum(i * i for i in range(n))

val = compute_sum_of_squares(500000)
print(f"Function Name Preserved: {compute_sum_of_squares.__name__}")
print(f"Docstring Preserved: {compute_sum_of_squares.__doc__}")

Detailed Explanation: Without @functools.wraps, introspecting func.__name__ returns 'wrapper', breaking debuggers, logging frameworks, and sphinx documentation generators.

def fibonacci_stream():
    """
    Yields Fibonacci numbers indefinitely using O(1) memory space.
    """
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

def take(n, generator):
    """
    Collects the first n elements from any finite or infinite generator stream.
    """
    results = []
    for _, item in zip(range(n), generator):
        results.append(item)
    return results

# --- Test Cases ---
fib_gen = fibonacci_stream()
first_10 = take(10, fib_gen)
print("First 10 Fibonacci numbers:", first_10)
# Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Detailed Explanation: Because generators are lazily evaluated, infinite sequences consume zero extra memory. State is persisted across yield statements within the generator frame object.

import functools

def memoize(func):
    """
    Custom function call memoization decorator using hash dictionary caching.
    """
    cache = {}
    
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # Create a hashable composite cache key
        key = (args, tuple(sorted(kwargs.items())))
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
        
    wrapper.cache_info = lambda: f"Cache size: {len(cache)} entries"
    return wrapper

@memoize
def fib_memoized(n):
    if n < 2:
        return n
    return fib_memoized(n - 1) + fib_memoized(n - 2)

# --- Test Cases ---
print("Fib(50):", fib_memoized(50)) # Computes instantly!
print(fib_memoized.cache_info())   # Cache size: 51 entries

Detailed Explanation: Memoization eliminates redundant subproblem recalculations. Without caching, $Fib(50)$ performs over 2 trillion calls. With caching, every subproblem is evaluated once in linear $O(N)$ time.

from collections import defaultdict

def invert_multimap(original_dict):
    """
    Inverts key-value relationships, collecting duplicate values into lists.
    """
    inverted = defaultdict(list)
    for key, value in original_dict.items():
        inverted[value].append(key)
        
    # Sort lists for predictable output
    return {k: sorted(v) for k, v in inverted.items()}

# --- Test Cases ---
roles = {
    "Alice": "Admin",
    "Bob": "Developer",
    "Charlie": "Developer",
    "Dave": "Admin",
    "Eve": "Designer"
}
print(invert_multimap(roles))
# Output:
# {'Admin': ['Alice', 'Dave'], 'Developer': ['Bob', 'Charlie'], 'Designer': ['Eve']}

Detailed Explanation: Simple dictionary comprehensions like {v: k for k, v in d.items()} discard collisions silently. Grouping collisions into lists prevents critical data loss during inversion.

import time

class TimerContext:
    def __init__(self, label: str, suppress_exceptions: bool = False):
        self.label = label
        self.suppress = suppress_exceptions
        self.start_time = None
        self.elapsed = None

    def __enter__(self):
        self.start_time = time.perf_counter()
        print(f"[{self.label}] Entering context block...")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.elapsed = (time.perf_counter() - self.start_time) * 1000
        print(f"[{self.label}] Exited in {self.elapsed:.3f} ms")
        
        if exc_type is not None:
            print(f"[{self.label}] Exception caught: {exc_val}")
            return self.suppress # If True, exception will not propagate

# --- Test Cases ---
with TimerContext("Database Simulation"):
    time.sleep(0.05) # Simulated latency

# Suppressing exception demonstration
with TimerContext("Safe Division", suppress_exceptions=True):
    val = 10 / 0 # Will be caught and suppressed!
print("Code continues uninterrupted!")

Detailed Explanation: The Python context manager protocol guarantees deterministic resource release. Returning True from __exit__ suppresses the active exception, enabling elegant resilience patterns.

from functools import reduce

employees = [
    {"name": "Alice", "dept": "Engineering", "salary": 95000},
    {"name": "Bob", "dept": "Marketing", "salary": 85000},
    {"name": "Charlie", "dept": "Engineering", "salary": 78000},
    {"name": "Diana", "dept": "Engineering", "salary": 110000},
]

# Step 1: Filter qualifying engineers
qualified = filter(lambda e: e["dept"] == "Engineering" and e["salary"] > 80000, employees)

# Step 2: Map cost of living adjustment (8%)
adjusted_salaries = map(lambda e: e["salary"] * 1.08, qualified)

# Step 3: Reduce to total payroll
total_payroll = reduce(lambda acc, salary: acc + salary, adjusted_salaries, 0.0)

print(f"Total Adjusted Payroll: ${total_payroll:,.2f}")
# Output: Total Adjusted Payroll: $221,400.00

Detailed Explanation: Pure functional pipelines process streams without mutating input collections. map and filter generate lazy iterators in Python 3, making the pipeline memory-efficient.

import inspect
import functools

def enforce_types(func):
    """
    Enforces runtime type validation based on PEP 484 type hints.
    """
    signature = inspect.signature(func)
    annotations = func.__annotations__

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        bound_args = signature.bind(*args, **kwargs)
        bound_args.apply_defaults()

        for name, value in bound_args.arguments.items():
            if name in annotations:
                expected_type = annotations[name]
                if not isinstance(value, expected_type):
                    raise TypeError(
                        f"Argument '{name}' must be of type {expected_type.__name__}, "
                        f"got {type(value).__name__} instead."
                    )
        return func(*args, **kwargs)
    return wrapper

# --- Test Cases ---
@enforce_types
def register_user(username: str, age: int) -> str:
    return f"User {username} registered at age {age}."

print(register_user("Alice", 28)) # Success

try:
    register_user("Bob", "twenty-five") # Fails type enforcement!
except TypeError as e:
    print("Enforcement Caught:", e)
    # Output: Enforcement Caught: Argument 'age' must be of type int, got str instead.

Detailed Explanation: Python type hints are not enforced by the interpreter at runtime by default. Using inspect.signature allows developers to enforce strong type contracts in critical enterprise domains.

import itertools

def chunked_stream(iterable, chunk_size):
    """
    Yields successive fixed-size chunks from an iterator without buffering the whole sequence.
    """
    if chunk_size < 1:
        raise ValueError("chunk_size must be at least 1.")
        
    iterator = iter(iterable)
    while True:
        chunk = list(itertools.islice(iterator, chunk_size))
        if not chunk:
            break
        yield chunk

# --- Test Cases ---
data = range(1, 12) # 1 through 11
for batch in chunked_stream(data, 3):
    print("Batch:", batch)
# Output:
# Batch: [1, 2, 3]
# Batch: [4, 5, 6]
# Batch: [7, 8, 9]
# Batch: [10, 11]

Detailed Explanation: By combining iter() with itertools.islice(), elements are pulled strictly on demand. This pattern is essential when batching records for database bulk inserts or API pagination.

import threading

class DatabaseConnectionPool:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        # Double-checked locking optimization
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance

    def __init__(self, pool_size: int = 10):
        # Ensure __init__ runs only once
        if getattr(self, '_initialized', False):
            return
        self.pool_size = pool_size
        self._initialized = True
        print(f"[INIT] Connection pool initialized with {pool_size} slots.")

# --- Test Cases ---
pool1 = DatabaseConnectionPool(20)
pool2 = DatabaseConnectionPool(50)

print(f"Same Instance: {pool1 is pool2}") # Output: True
print(f"Pool Size: {pool1.pool_size}")      # Output: 20 (initialized once)

Detailed Explanation: The double-checked locking idiom prevents expensive lock acquisition on subsequent instantiations. Because __new__ returns the existing instance, all consumers share the same resource pool safely.