# mymath.py
def add(a, b):
    return a + b

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

PI = 3.14159

# 전체 모듈 임포트
import mymath

# 특정 함수/변수만 임포트
from mymath import add, PI

# 모든 요소 임포트 (권장하지 않음)
from mymath import *

# 별칭 사용
import mymath as mm

# test_module.py
def main_function():
    print("메인 기능 실행")

if __name__ == "__main__":
    # 이 파일이 직접 실행될 때만 실행됨
    main_function()

mypackage/
    __init__.py
    module1.py
    module2.py
    subpackage/
        __init__.py
        module3.py

import sys

# 현재 모듈 검색 경로 확인
print(sys.path)

# 검색 경로 추가
sys.path.append('/path/to/my/modules')

import importlib

# 모듈 재로딩
importlib.reload(my_module)

# 파일 시스템 작업
import os
print(os.getcwd())  # 현재 작업 디렉토리 출력

# 경로 조작
import os.path
print(os.path.join('folder', 'file.txt'))  # 'folder/file.txt' (Unix) 또는 'folder\\file.txt' (Windows)

# 정규 표현식
import re
result = re.search(r'\d+', 'abc123def')
print(result.group())  # '123'

# 시간 관련 기능
import time
print(time.time())  # 유닉스 타임스탬프 출력

# 날짜 및 시간 처리
import datetime
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d"))  # 오늘 날짜 출력

# JSON 처리
import json
data = json.dumps({'name': 'John', 'age': 30})
print(data)  # '{"name": "John", "age": 30}'

# 난수 생성
import random
print(random.randint(1, 10))  # 1부터 10 사이의 난수 출력

# module_a.py
var = "모듈 A의 변수"

# module_b.py
var = "모듈 B의 변수"

# main.py
import module_a
import module_b

print(module_a.var)  # "모듈 A의 변수"
print(module_b.var)  # "모듈 B의 변수"

var = "메인의 변수"
print(var)  # "메인의 변수"

# module_info.py
"""
이 모듈은 모듈 속성을 설명하기 위한 예제 모듈입니다.
"""

def example_function():
    return "함수 실행 결과"

class ExampleClass:
    pass

CONSTANT = 42

# 다른 파일에서:
import module_info

# 모듈 문서열(docstring) 접근
print(module_info.__doc__)

# 모듈 파일 경로
print(module_info.__file__)

# 모듈 이름
print(module_info.__name__)

# 모듈 내 정의된 이름 목록
print(dir(module_info))

# 모듈의 특정 속성 확인
print(hasattr(module_info, 'example_function'))

# factory_module.py
def create_adder(increment):
    def add(x):
        return x + increment
    return add

def create_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

# 사용 예:
from factory_module import create_adder, create_multiplier

add_five = create_adder(5)
double = create_multiplier(2)

print(add_five(10))     # 15
print(double(10))       # 20

# singleton_module.py
class Singleton:
    _instance = None
    
    @classmethod
    def get_instance(cls):
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance
    
    def __init__(self):
        if self.__class__._instance is not None:
            raise RuntimeError("이 클래스는 싱글톤입니다!")
        self.value = 0

# 사용 예:
from singleton_module import Singleton

instance1 = Singleton.get_instance()
instance2 = Singleton.get_instance()

print(instance1 is instance2)  # True

# plugin_manager.py
class PluginManager:
    def __init__(self):
        self.plugins = {}
    
    def register_plugin(self, name, plugin):
        self.plugins[name] = plugin
    
    def get_plugin(self, name):
        return self.plugins.get(name)

# plugin1.py
def process(data):
    return f"플러그인 1: {data.upper()}"

# plugin2.py
def process(data):
    return f"플러그인 2: {data.lower()}"

# main.py
from plugin_manager import PluginManager
import plugin1
import plugin2

manager = PluginManager()
manager.register_plugin("upper", plugin1.process)
manager.register_plugin("lower", plugin2.process)

text = "Hello World"
print(manager.get_plugin("upper")(text))  # 플러그인 1: HELLO WORLD
print(manager.get_plugin("lower")(text))  # 플러그인 2: hello world

# 모듈 캐싱 확인
import sys

# 이미 로드된 모듈 확인
print('math' in sys.modules)  # False (아직 로드되지 않음)

import math
print('math' in sys.modules)  # True (이제 로드됨)

# 캐시된 모듈 참조
math_cached = sys.modules['math']
print(math is math_cached)  # True (동일한 객체)

# 모듈 로드 시간 측정
import time
import importlib

# 캐시 비우기 (실제로는 권장하지 않음)
if 'random' in sys.modules:
    del sys.modules['random']

# 첫 번째 로드 시간 측정
start = time.time()
import random
first_load = time.time() - start

# 두 번째 로드 시간 측정
if 'random' in sys.modules:
    del sys.modules['random']

start = time.time()
import random
second_load = time.time() - start

print(f"첫 번째 로드: {first_load:.6f}초")
print(f"두 번째 로드: {second_load:.6f}초")

# 런타임에 모듈 이름 결정
def dynamic_import(module_name):
    try:
        module = __import__(module_name)
        print(f"{module_name} 모듈을 성공적으로 임포트했습니다.")
        return module
    except ImportError:
        print(f"{module_name} 모듈을 찾을 수 없습니다.")
        return None

# 예제:
math = dynamic_import('math')
if math:
    print(math.pi)

# 더 현대적인 방법 (Python 3.4+)
import importlib

def modern_dynamic_import(module_name):
    try:
        module = importlib.import_module(module_name)
        print(f"{module_name} 모듈을 성공적으로 임포트했습니다.")
        return module
    except ImportError:
        print(f"{module_name} 모듈을 찾을 수 없습니다.")
        return None

# plugins/ 디렉토리의 모든 모듈 자동 로드
import os
import importlib

def load_plugins(plugin_dir='plugins'):
    plugins = {}
    
    # 플러그인 디렉토리가 존재하는지 확인
    if not os.path.exists(plugin_dir):
        return plugins
    
    # 플러그인 디렉토리의 모든 Python 파일 탐색
    for filename in os.listdir(plugin_dir):
        if filename.endswith('.py') and not filename.startswith('__'):
            module_name = filename[:-3]  # .py 확장자 제거
            
            # 모듈 로드
            module_path = f"{plugin_dir}.{module_name}"
            try:
                module = importlib.import_module(module_path)
                
                # 모듈이 올바른 인터페이스를 가지고 있는지 확인
                if hasattr(module, 'run'):
                    plugins[module_name] = module
                    print(f"플러그인 '{module_name}' 로드됨")
            except ImportError as e:
                print(f"플러그인 '{module_name}' 로드 실패: {e}")
    
    return plugins

# 모듈의 모든 함수 목록 출력
import inspect

def list_module_functions(module):
    functions = []
    for name, obj in inspect.getmembers(module, inspect.isfunction):
        # 해당 모듈에 직접 정의된 함수만 필터링
        if obj.__module__ == module.__name__:
            functions.append(name)
    return functions

# 예제:
import math
print(list_module_functions(math))

# 모듈 클래스 검사
def list_module_classes(module):
    classes = []
    for name, obj in inspect.getmembers(module, inspect.isclass):
        if obj.__module__ == module.__name__:
            classes.append(name)
    return classes

# 함수 시그니처 검사
def get_function_info(func):
    sig = inspect.signature(func)
    return {
        'name': func.__name__,
        'doc': func.__doc__,
        'parameters': list(sig.parameters.keys()),
        'return_annotation': sig.return_annotation
    }