Practice Questions — Modules and Packages in Python

import math

def explore_module(module):
    public_names = [n for n in dir(module) if not n.startswith('_')]
    functions = [n for n in public_names if callable(getattr(module, n))]
    return {
        'name': module.__name__,
        'count': len(public_names),
        'functions': functions
    }

result = explore_module(math)
print(f"Module: {result['name']}")
print(f"Public names: {result['count']}")
print(f"First 5 callable: {result['functions'][:5]}")

import json

def save_config(filename, config_dict):
    with open(filename, 'w') as f:
        json.dump(config_dict, f, indent=2)
    print(f"Saved config to {filename}")

def load_config(filename, defaults=None):
    if defaults is None:
        defaults = {}
    try:
        with open(filename, 'r') as f:
            config = json.load(f)
    except FileNotFoundError:
        config = {}
    merged = {**defaults, **config}
    return merged

defaults = {'theme': 'light', 'font_size': 12, 'language': 'en', 'auto_save': True}
user_config = {'theme': 'dark', 'font_size': 14}

save_config('settings.json', user_config)
result = load_config('settings.json', defaults)
print(f"Loaded: {result}")

import random
import string

def generate_password(length=12, include_digits=True, include_symbols=True):
    if length < 4:
        length = 4
    
    password = []
    password.append(random.choice(string.ascii_lowercase))
    password.append(random.choice(string.ascii_uppercase))
    
    pool = string.ascii_letters
    if include_digits:
        password.append(random.choice(string.digits))
        pool += string.digits
    if include_symbols:
        password.append(random.choice('!@#$%&*'))
        pool += '!@#$%&*'
    
    remaining = length - len(password)
    for _ in range(remaining):
        password.append(random.choice(pool))
    
    random.shuffle(password)
    return ''.join(password)

random.seed(42)
print(f"Password (12 chars): {generate_password(12)}")
print(f"Password (8, no symbols): {generate_password(8, include_symbols=False)}")
print(f"Password (6, letters only): {generate_password(6, include_digits=False, include_symbols=False)}")

from datetime import datetime, timedelta

class DateCalculator:
    DATE_FORMAT = '%Y-%m-%d'
    
    def _parse(self, date_str):
        try:
            return datetime.strptime(date_str, self.DATE_FORMAT)
        except ValueError:
            raise ValueError(f"Invalid date format: {date_str}. Expected YYYY-MM-DD")
    
    def days_between(self, date_str1, date_str2):
        d1 = self._parse(date_str1)
        d2 = self._parse(date_str2)
        return abs((d2 - d1).days)
    
    def add_days(self, date_str, days):
        d = self._parse(date_str)
        new_date = d + timedelta(days=days)
        return new_date.strftime(self.DATE_FORMAT)
    
    def day_of_week(self, date_str):
        d = self._parse(date_str)
        return d.strftime('%A')

calc = DateCalculator()
print(f"Days between 2026-01-01 and 2026-04-06: {calc.days_between('2026-01-01', '2026-04-06')}")
print(f"Add 30 days to 2026-04-06: {calc.add_days('2026-04-06', 30)}")
print(f"Day of week for 2026-04-06: {calc.day_of_week('2026-04-06')}")

try:
    calc.days_between('2026-13-01', '2026-01-01')
except ValueError as e:
    print(f"Error: {e}")

import os.path

def organize_files(file_list):
    categories = {
        'images': {'.jpg', '.jpeg', '.png', '.gif', '.bmp'},
        'documents': {'.pdf', '.docx', '.doc', '.txt', '.xlsx'},
        'code': {'.py', '.js', '.html', '.css', '.java', '.cpp'}
    }
    
    result = {'images': [], 'documents': [], 'code': [], 'other': []}
    
    for filename in file_list:
        _, ext = os.path.splitext(filename)
        ext = ext.lower()
        
        placed = False
        for category, extensions in categories.items():
            if ext in extensions:
                result[category].append(filename)
                placed = True
                break
        
        if not placed:
            result['other'].append(filename)
    
    return result

files = ['photo.jpg', 'main.py', 'report.pdf', 'logo.png', 'notes.txt', 'index.html', 'data.csv']
organized = organize_files(files)

for category, file_list in organized.items():
    if file_list:
        print(f"{category}: {file_list}")

summary = ', '.join(f"{k}={len(v)}" for k, v in organized.items())
print(f"Summary: {summary}")

import math

class Statistics:
    @staticmethod
    def mean(data):
        if not data:
            return 0
        return sum(data) / len(data)
    
    @staticmethod
    def median(data):
        if not data:
            return 0
        sorted_data = sorted(data)
        n = len(sorted_data)
        mid = n // 2
        if n % 2 == 0:
            return (sorted_data[mid - 1] + sorted_data[mid]) / 2
        return sorted_data[mid]
    
    @staticmethod
    def mode(data):
        if not data:
            return None
        freq = {}
        for x in data:
            freq[x] = freq.get(x, 0) + 1
        return max(freq, key=freq.get)
    
    @staticmethod
    def std_dev(data):
        if len(data) < 2:
            return 0
        avg = sum(data) / len(data)
        variance = sum((x - avg) ** 2 for x in data) / len(data)
        return round(math.sqrt(variance), 2)
    
    @staticmethod
    def describe(data):
        stats = Statistics
        return {
            'count': len(data),
            'mean': stats.mean(data),
            'median': stats.median(data),
            'min': min(data),
            'max': max(data),
            'std_dev': stats.std_dev(data)
        }

if __name__ == "__main__":
    data = [1, 2, 3, 3, 4, 5, 6, 7, 8, 10]
    stats = Statistics
    print(f"Mean: {stats.mean(data)}")
    print(f"Median: {stats.median(data)}")
    print(f"Mode: {stats.mode(data)}")
    print(f"Std Dev: {stats.std_dev(data)}")
    print(f"Summary: {stats.describe(data)}")

import sys

def validate_package(structure, path="", stdlib_modules=None):
    if stdlib_modules is None:
        stdlib_modules = {'os', 'sys', 'math', 'random', 'json', 'datetime',
                         'collections', 'itertools', 'functools', 'string',
                         'io', 'time', 're', 'pathlib', 'typing', 'abc'}
    
    issues = []
    
    for name, contents in structure.items():
        current_path = f"{path}{name}/" if path else f"{name}/"
        
        if isinstance(contents, dict):
            if name in stdlib_modules:
                issues.append(f"Package name '{name}' conflicts with standard library")
            
            if '__init__.py' not in contents:
                issues.append(f"Missing __init__.py in '{current_path}'")
            
            sub_items = {k: v for k, v in contents.items() if k != '__init__.py'}
            if not sub_items:
                issues.append(f"Empty package '{current_path}'")
            
            sub_dirs = {k: v for k, v in contents.items() if isinstance(v, dict)}
            for sub_name, sub_contents in sub_dirs.items():
                issues.extend(validate_package(
                    {sub_name: sub_contents}, current_path, stdlib_modules
                ))
    
    return issues

package_structure = {
    'mypackage': {
        '__init__.py': None,
        'core.py': None,
        'utils': {
            'helpers.py': None
        },
        'random': {
            '__init__.py': None,
            'generator.py': None
        },
        'empty': {
            '__init__.py': None
        }
    }
}

issues = validate_package(package_structure)
if issues:
    print("Issues found:")
    for issue in issues:
        print(f"- {issue}")
else:
    print("Package structure is valid!")

def analyze_imports(code_string):
    stdlib = {'os', 'sys', 'math', 'random', 'json', 'datetime', 'collections',
              'itertools', 'functools', 'string', 'io', 'time', 're', 'pathlib',
              'typing', 'abc', 'csv', 'hashlib', 'logging', 'unittest', 'copy',
              'pprint', 'textwrap', 'enum', 'dataclasses', 'contextlib'}
    third_party = {'requests', 'numpy', 'pandas', 'flask', 'django', 'pytest',
                   'scipy', 'matplotlib', 'sqlalchemy', 'pillow', 'beautifulsoup4'}
    
    imports = {'standard': [], 'third_party': [], 'local': []}
    
    for line in code_string.strip().split('\n'):
        line = line.strip()
        module = None
        
        if line.startswith('import '):
            parts = line.replace('import ', '').split(',')
            for part in parts:
                module = part.strip().split(' as ')[0].split('.')[0]
                if module in stdlib:
                    imports['standard'].append(module)
                elif module in third_party:
                    imports['third_party'].append(module)
                else:
                    imports['local'].append(module)
        elif line.startswith('from '):
            module = line.split(' ')[1].split('.')[0]
            if module in stdlib:
                imports['standard'].append(module)
            elif module in third_party:
                imports['third_party'].append(module)
            elif not module.startswith('.'):
                imports['local'].append(module)
    
    for key in imports:
        imports[key] = sorted(set(imports[key]))
    
    return imports

def find_circular_risks(modules_code):
    module_imports = {}
    for name, code in modules_code.items():
        result = analyze_imports(code)
        module_imports[name] = result['local']
    
    risks = []
    checked = set()
    for mod_a, deps_a in module_imports.items():
        for mod_b, deps_b in module_imports.items():
            if mod_a != mod_b and (mod_b, mod_a) not in checked:
                if mod_b in deps_a and mod_a in deps_b:
                    risks.append((mod_a, mod_b))
                    checked.add((mod_a, mod_b))
    return risks

code = """import math
import os
import json
import requests
import numpy as np
from datetime import datetime
from my_utils import helper
import config"""

result = analyze_imports(code)
for category, modules in result.items():
    print(f"{category}: {modules}")

modules = {
    'module_a': 'import module_b\nimport math',
    'module_b': 'import module_a\nimport os',
    'module_c': 'import module_a'
}

risks = find_circular_risks(modules)
for a, b in risks:
    print(f"Circular risk: {a} <-> {b}")