Practice Questions — Exception Handling in Python

def safe_calculate(a, op, b):
    try:
        if op == '+':
            return a + b
        elif op == '-':
            return a - b
        elif op == '*':
            return a * b
        elif op == '/':
            return a / b
        else:
            raise ValueError(f"unknown operator '{op}'")
    except ZeroDivisionError:
        return "Error: division by zero"
    except ValueError as e:
        return f"Error: {e}"

test_cases = [(10, '+', 5), (10, '-', 3), (10, '*', 4), (10, '/', 2), (10, '/', 0), (10, '%', 3)]
for a, op, b in test_cases:
    print(f"{a} {op} {b} = {safe_calculate(a, op, b)}")

def convert(value, target_type):
    try:
        result = target_type(value)
        return (True, result)
    except (ValueError, TypeError) as e:
        return (False, f"Cannot convert {value!r} to {target_type.__name__}")

print(convert("42", int))
print(convert("hello", int))
print(convert("3.14", float))
print(convert(100, str))

def safe_get(lst, index):
    try:
        return lst[index]
    except IndexError:
        return None

def safe_pop(lst, index):
    try:
        return lst.pop(index)
    except IndexError:
        return None

def safe_divide_list(lst):
    results = []
    for i in range(len(lst) - 1):
        try:
            results.append(round(lst[i] / lst[i+1], 2))
        except ZeroDivisionError:
            results.append(float('inf'))
    return results

print(f"safe_get([1,2,3], 1) = {safe_get([1,2,3], 1)}")
print(f"safe_get([1,2,3], 5) = {safe_get([1,2,3], 5)}")
lst = [1, 2, 3]
result = safe_pop(lst, 1)
print(f"safe_pop result: {result}, list: {lst}")
print(f"safe_divide: {safe_divide_list([1, 2, 3, 0, 5])}")

def read_numbers(filename):
    result = {'numbers': [], 'invalid_count': 0, 'error': None}
    try:
        with open(filename, 'r') as f:
            for line in f:
                try:
                    result['numbers'].append(float(line.strip()))
                except ValueError:
                    result['invalid_count'] += 1
    except FileNotFoundError:
        result['error'] = f"File '{filename}' not found"
    return result

# Create test file
with open('numbers.txt', 'w') as f:
    f.write('10\n20\nabc\n30\nxyz\n')

print(read_numbers('numbers.txt'))
print(read_numbers('missing.txt'))

class PasswordTooShortError(Exception):
    def __init__(self, length):
        super().__init__(f"minimum 6 characters, got {length}")

class PasswordNoDigitError(Exception):
    def __init__(self):
        super().__init__("must contain at least one digit")

class PasswordNoUpperError(Exception):
    def __init__(self):
        super().__init__("must contain at least one uppercase letter")

def validate_password(password):
    if len(password) < 6:
        raise PasswordTooShortError(len(password))
    if not any(c.isdigit() for c in password):
        raise PasswordNoDigitError()
    if not any(c.isupper() for c in password):
        raise PasswordNoUpperError()
    return True

test_passwords = ["MyP@ss1", "abc", "abcdef", "abcde1"]
for pwd in test_passwords:
    try:
        validate_password(pwd)
        print(f"{pwd} -> Valid")
    except (PasswordTooShortError, PasswordNoDigitError, PasswordNoUpperError) as e:
        print(f"{pwd} -> {type(e).__name__}: {e}")

def retry(func, max_attempts, *args):
    last_error = None
    for attempt in range(1, max_attempts + 1):
        try:
            result = func(*args)
            print(f"Attempt {attempt}: success! Result: {result}")
            return result
        except Exception as e:
            last_error = e
            print(f"Attempt {attempt}: failed")
    raise last_error

import random
random.seed(42)

def unreliable():
    if random.random() < 0.7:
        raise ValueError("simulated failure")
    return 42

try:
    retry(unreliable, 3)
except ValueError:
    pass

print()

def always_fail():
    raise ValueError("simulated failure")

try:
    retry(always_fail, 3)
except ValueError as e:
    print(f"All 3 attempts failed: {e}")

def deep_get(data, path, default=None):
    keys = path.split('.')
    current = data
    try:
        for key in keys:
            if isinstance(current, list):
                current = current[int(key)]
            else:
                current = current[key]
        return current
    except (KeyError, TypeError, IndexError, ValueError):
        return default

data = {
    'user': {
        'name': 'Aarav',
        'age': 16,
        'address': {
            'city': 'Delhi',
            'state': 'Delhi'
        },
        'scores': [85, 92, 78]
    }
}

print(f"user.name -> {deep_get(data, 'user.name')}")
print(f"user.address.city -> {deep_get(data, 'user.address.city')}")
print(f"user.phone -> {deep_get(data, 'user.phone')}")
print(f"user.address.zip.code -> {deep_get(data, 'user.address.zip.code')}")
print(f"user.scores.0 -> {deep_get(data, 'user.scores.0')}")

def test_expressions(expressions):
    stats = {'success': 0}
    
    for expr in expressions:
        try:
            eval(expr)
            stats['success'] += 1
        except Exception as e:
            error_type = type(e).__name__
            if error_type not in stats:
                stats[error_type] = {'count': 0, 'expressions': []}
            stats[error_type]['count'] += 1
            stats[error_type]['expressions'].append(expr)
    
    return stats

expressions = [
    '2 + 3',
    '10 / 0',
    'int("abc")',
    '[1,2][5]',
    'x + 1',
    '3 * 4',
    '{"a":1}["b"]',
    '5 ** 2',
]

result = test_expressions(expressions)
for key, value in result.items():
    print(f"{key}: {value}")