Native Python Programing

메타클래스를 사용하여 사용자 정의 예외 클래스를 생성하면, 공통적인 동작이나 속성을 예외 클래스에 자동으로 추가할 수 있습니다. 이를 통해 예외 메시지 형식을 통일하거나, 추가적인 메타데이터를 포함하는 예외 클래스를 손쉽게 관리할 수 있습니다.

사용자 정의 예외 메타클래스 코드

class ExceptionMeta(type):
    """메타클래스를 사용하여 공통 동작을 추가하는 사용자 정의 예외 클래스"""
    def __new__(cls, name, bases, dct):
        # 공통 속성 추가
        dct.setdefault("default_message", "An error occurred.")
        dct.setdefault("error_code", 1000)
        return super().__new__(cls, name, bases, dct)

    def __call__(cls, *args, **kwargs):
        """인스턴스 생성 시 메시지 형식을 통일"""
        instance = super().__call__(*args, **kwargs)
        if not hasattr(instance, "formatted_message"):
            instance.formatted_message = f"[{cls.error_code}] {instance.args[0] if instance.args else cls.default_message}"
        return instance

class CustomException(Exception, metaclass=ExceptionMeta):
    """기본 사용자 정의 예외 클래스"""
    pass

class ValidationError(CustomException):
    """검증 오류"""
    default_message = "Validation failed."
    error_code = 2001

class DatabaseError(CustomException):
    """데이터베이스 오류"""
    default_message = "A database error occurred."
    error_code = 3001

# 사용 예제
if __name__ == "__main__":
    try:
        raise ValidationError("Invalid data provided.")
    except ValidationError as e:
        print(f"ValidationError caught: {e.formatted_message}")

    try:
        raise DatabaseError()
    except DatabaseError as e:
        print(f"DatabaseError caught: {e.formatted_message}")

    try:
        raise CustomException()
    except CustomException as e:
        print(f"CustomException caught: {e.formatted_message}")

코드 설명

1. ExceptionMeta 메타클래스:
   • **default_message**와 **error_code**를 기본적으로 예외 클래스에 추가.
   • __call__ 메서드를 재정의하여 예외 인스턴스를 생성할 때 메시지 형식을 통일.
   • 각 예외 클래스에서 별도로 정의하지 않으면 default_message와 error_code가 기본값으로 사용됨.
2. CustomException:
   • 모든 사용자 정의 예외 클래스의 기본 클래스.
   • ExceptionMeta 메타클래스를 사용하여 공통 속성과 동작을 상속받음.
3. 파생 클래스 (ValidationError, DatabaseError):
   • 각 예외 클래스는 default_message와 error_code를 재정의하여 고유한 정보를 제공.
4. 사용 예제:
   • ValidationError와 DatabaseError를 각각 생성하며 메시지를 출력.
   • 기본 CustomException도 동일한 방식으로 동작.

실행 결과 (예시):

ValidationError caught: [2001] Invalid data provided.
DatabaseError caught: [3001] A database error occurred.
CustomException caught: [1000] An error occurred.

주요 기능

• 공통 속성 관리: default_message와 error_code를 메타클래스를 통해 자동으로 추가.
• 통일된 메시지 형식: 예외 메시지가 자동으로 포맷팅되어 관리 용이.
• 확장성: 새로운 예외 클래스가 메타클래스의 공통 동작을 쉽게 상속받을 수 있음.

이 코드는 애플리케이션의 다양한 예외 상황을 통일된 방식으로 처리하고, 개발 및 디버깅을 쉽게 하는 데 유용합니다.

데이터 카드에 푸터 카드를 생성하기 위한 메타클래스를 작성하여 클래스가 정의될 때 자동으로 공통 푸터 정보를 설정하도록 할 수 있습니다. 푸터는 일반적으로 데이터에 대한 요약 정보나 최종 수정 기록을 포함하는 데 사용됩니다.

푸터 카드 메타클래스 코드

from datetime import datetime

class FooterMeta(type):
    """푸터 카드를 생성하는 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 푸터 정보 기본값 추가
        dct.setdefault("__footer__", {
            "last_updated": datetime.now(),
            "summary": f"Default footer for {name}.",
        })
        return super().__new__(cls, name, bases, dct)

    def update_footer(cls, key, value):
        """푸터 정보 업데이트"""
        if "__footer__" in cls.__dict__:
            cls.__footer__[key] = value
            cls.__footer__["last_updated"] = datetime.now()  # 마지막 업데이트 시간 갱신
        else:
            raise AttributeError("Footer not defined in the class.")

    def get_footer(cls):
        """푸터 정보 가져오기"""
        return cls.__footer__

class DataCard(metaclass=FooterMeta):
    """푸터 카드를 포함하는 데이터 카드"""
    def __init__(self, name, data):
        self.name = name
        self.data = data

    def display(self):
        """데이터 카드 정보 출력"""
        print(f"Data Card: {self.name}")
        print(f"Data: {self.data}")

    @classmethod
    def display_footer(cls):
        """푸터 정보 출력"""
        print("Footer Information:")
        for key, value in cls.__footer__.items():
            print(f"  {key}: {value}")

# 사용 예제
if __name__ == "__main__":
    # 기본 푸터 확인
    print("Default Footer:")
    DataCard.display_footer()

    # 푸터 업데이트
    DataCard.update_footer("summary", "This is a summary of the data card.")
    DataCard.update_footer("notes", "Footer metadata added.")

    print("\nUpdated Footer:")
    DataCard.display_footer()

    # 데이터 카드 생성
    card = DataCard(name="Sample Data", data={"key": "value"})
    print("\nCard Details:")
    card.display()

코드 설명

1. FooterMeta 메타클래스:
   • 클래스 정의 시 __footer__라는 공통 푸터를 자동으로 생성.
   • 기본 푸터는 마지막 업데이트 시간(last_updated)과 간단한 요약(summary)을 포함.
   • update_footer 메서드: 푸터의 특정 항목을 수정하고, 마지막 업데이트 시간을 자동 갱신.
   • get_footer 메서드: 현재 클래스의 푸터 정보를 반환.
2. DataCard 클래스:
   • FooterMeta 메타클래스를 기반으로 작성된 데이터 카드 클래스.
   • 클래스 수준에서 푸터 정보를 관리하며, 인스턴스 데이터와는 분리.
3. 사용 예제:
   • 기본 푸터를 확인하고, update_footer 메서드를 사용하여 푸터 값을 수정.
   • 데이터 카드를 생성하여 데이터와 푸터를 각각 출력.

실행 결과 (예시):

Default Footer:
Footer Information:
  last_updated: 2025-01-07 12:00:00.123456
  summary: Default footer for DataCard.

Updated Footer:
Footer Information:
  last_updated: 2025-01-07 12:01:00.123456
  summary: This is a summary of the data card.
  notes: Footer metadata added.

Card Details:
Data Card: Sample Data
Data: {'key': 'value'}

주요 기능

• 푸터 자동 생성: 클래스 정의 시 기본 푸터가 자동으로 설정.
• 푸터 업데이트 가능: 클래스 수준에서 푸터 정보를 동적으로 수정 가능.
• 자동 갱신: 푸터가 업데이트될 때 마지막 수정 시간이 자동으로 갱신.
• 클래스와 인스턴스 데이터 분리: 푸터는 클래스 수준에서 관리하며, 인스턴스 데이터와 독립적.

이 메타클래스는 데이터 카드에 공통적인 요약 정보나 변경 기록을 추가하여 관리하는 데 적합하며, 클래스의 관리 효율성을 높여줍니다.

데이터 카드에 헤더 카드를 생성하기 위한 메타클래스를 작성하여, 클래스가 정의될 때 자동으로 공통 헤더 정보를 설정하도록 할 수 있습니다. 아래는 헤더 카드 목적의 메타클래스를 구현한 샘플 코드입니다.

헤더 카드 메타클래스 코드

from datetime import datetime

class HeaderMeta(type):
    """헤더 카드를 생성하는 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 헤더 정보 기본값 추가
        dct.setdefault("__header__", {
            "author": "Unknown",
            "version": "1.0",
            "created_at": datetime.now(),
            "description": f"{name} description not provided.",
        })
        return super().__new__(cls, name, bases, dct)

    def set_header(cls, key, value):
        """헤더 정보 설정"""
        if "__header__" in cls.__dict__:
            cls.__header__[key] = value
        else:
            raise AttributeError("Header not defined in the class.")

    def get_header(cls):
        """헤더 정보 가져오기"""
        return cls.__header__

class DataCard(metaclass=HeaderMeta):
    """헤더 카드를 포함하는 데이터 카드"""
    def __init__(self, name, data):
        self.name = name
        self.data = data

    def display(self):
        """데이터 카드 정보 출력"""
        print(f"Data Card: {self.name}")
        print(f"Data: {self.data}")

    @classmethod
    def display_header(cls):
        """헤더 정보 출력"""
        print("Header Information:")
        for key, value in cls.__header__.items():
            print(f"  {key}: {value}")

# 사용 예제
if __name__ == "__main__":
    # 기본 헤더 자동 설정
    print("Default Header:")
    DataCard.display_header()

    # 헤더 수정
    DataCard.set_header("author", "John Doe")
    DataCard.set_header("description", "A general-purpose data card.")
    DataCard.set_header("version", "2.0")

    print("\nUpdated Header:")
    DataCard.display_header()

    # 데이터 카드 생성
    card = DataCard(name="Sample Data", data={"key": "value"})
    print("\nCard Details:")
    card.display()

코드 설명

1. HeaderMeta 메타클래스:
   • 클래스 정의 시 __header__라는 공통 헤더를 자동으로 생성.
   • __header__ 기본값에는 작성자, 버전, 생성 시간, 설명 등을 포함.
   • set_header 메서드: 헤더 값을 업데이트할 수 있음.
   • get_header 메서드: 현재 클래스의 헤더 정보를 반환.
2. DataCard 클래스:
   • HeaderMeta 메타클래스를 기반으로 작성된 데이터 카드 클래스.
   • 클래스 수준에서 헤더 정보를 관리하며, 인스턴스 수준의 데이터와는 분리.
3. 사용 예제:
   • 기본 헤더를 확인하고, set_header 메서드를 사용하여 헤더 값을 수정.
   • 데이터 카드를 생성하여 데이터와 헤더를 각각 출력.

실행 결과 (예시):

Default Header:
Header Information:
  author: Unknown
  version: 1.0
  created_at: 2025-01-07 12:00:00.123456
  description: DataCard description not provided.

Updated Header:
Header Information:
  author: John Doe
  version: 2.0
  created_at: 2025-01-07 12:00:00.123456
  description: A general-purpose data card.

Card Details:
Data Card: Sample Data
Data: {'key': 'value'}

주요 기능

• 헤더 자동 생성: 클래스 정의 시 기본 헤더가 자동으로 설정.
• 헤더 수정 가능: 클래스 수준에서 헤더 정보를 동적으로 수정 가능.
• 클래스와 인스턴스 데이터 분리: 헤더는 클래스 수준에서 관리하며, 인스턴스 데이터와 독립적.

이 메타클래스는 데이터 카드와 같은 객체의 공통 메타데이터(헤더 정보)를 관리하는 데 적합하며, 코드의 일관성을 유지하면서도 유연한 확장을 가능하게 합니다.

히스토리 메타클래스는 클래스의 모든 메서드 호출과 속성 변경을 추적하여 히스토리를 기록하는 데 사용할 수 있습니다. 아래는 히스토리 기록을 위해 메타클래스를 사용하는 샘플 코드입니다.

히스토리 메타클래스 코드

from datetime import datetime
from functools import wraps

class HistoryMeta(type):
    """히스토리를 기록하는 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 히스토리 저장용 리스트 추가
        dct.setdefault('__history__', [])

        # 기존 메서드 래핑
        for attr_name, attr_value in dct.items():
            if callable(attr_value) and not attr_name.startswith("__"):
                dct[attr_name] = cls.wrap_method(attr_name, attr_value)

        # 속성 설정 감시
        dct['__setattr__'] = cls.wrap_setattr(dct.get('__setattr__', object.__setattr__))
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def wrap_method(method_name, method):
        """메서드를 래핑하여 호출 기록 추가"""
        @wraps(method)
        def wrapped_method(self, *args, **kwargs):
            # 히스토리 추가
            entry = {
                "timestamp": datetime.now(),
                "action": "method_call",
                "method": method_name,
                "args": args,
                "kwargs": kwargs,
            }
            self.__history__.append(entry)
            return method(self, *args, **kwargs)
        return wrapped_method

    @staticmethod
    def wrap_setattr(original_setattr):
        """속성 설정을 래핑하여 변경 기록 추가"""
        def wrapped_setattr(self, key, value):
            if not key.startswith("__history__") and hasattr(self, '__history__'):
                entry = {
                    "timestamp": datetime.now(),
                    "action": "attribute_change",
                    "attribute": key,
                    "new_value": value,
                }
                self.__history__.append(entry)
            original_setattr(self, key, value)
        return wrapped_setattr

    def get_history(cls):
        """클래스의 히스토리 반환"""
        return cls.__dict__.get('__history__', [])

class HistoryEnabledClass(metaclass=HistoryMeta):
    """히스토리 메타클래스를 사용하는 클래스"""
    def __init__(self, name):
        self.name = name

    def update_name(self, new_name):
        self.name = new_name

    def display_name(self):
        print(f"Name: {self.name}")

# 사용 예제
if __name__ == "__main__":
    obj = HistoryEnabledClass("Initial Name")
    obj.display_name()

    obj.update_name("Updated Name")
    obj.display_name()

    # 속성 직접 변경
    obj.name = "Directly Updated Name"

    # 히스토리 출력
    print("\nHistory:")
    for entry in obj.__history__:
        print(entry)

코드 설명

1. HistoryMeta 메타클래스:
   • __new__: 클래스의 모든 메서드와 속성 설정 메서드를 래핑하여 히스토리를 기록할 수 있도록 수정.
   • wrap_method: 메서드를 래핑하여 호출 시 호출 정보(메서드 이름, 인수 등)를 히스토리에 기록.
   • wrap_setattr: 속성 설정을 감지하여 속성 변경 정보를 히스토리에 기록.
2. HistoryEnabledClass:
   • HistoryMeta 메타클래스를 사용하는 클래스.
   • 메서드 호출 및 속성 변경이 자동으로 기록됨.
3. 사용 예제:
   • display_name 및 update_name 메서드를 호출하고 속성을 직접 수정한 뒤, 히스토리를 출력.

실행 결과 (예시):

Name: Initial Name
Name: Updated Name

History:
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 0, 123456), 'action': 'method_call', 'method': 'display_name', 'args': (), 'kwargs': {}}
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 1, 123456), 'action': 'method_call', 'method': 'update_name', 'args': ('Updated Name',), 'kwargs': {}}
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 2, 123456), 'action': 'method_call', 'method': 'display_name', 'args': (), 'kwargs': {}}
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 3, 123456), 'action': 'attribute_change', 'attribute': 'name', 'new_value': 'Directly Updated Name'}

주요 기능

• 메서드 호출 기록: 메서드 이름, 인수, 호출 시간 등을 기록.
• 속성 변경 기록: 변경된 속성 이름, 새 값, 변경 시간 등을 기록.
• 중앙화된 히스토리 관리: 클래스 수준에서 모든 변경 사항을 추적 가능.

이 코드는 디버깅, 로깅, 변경 추적 등을 자동화하는 데 유용하며, 클래스의 동작 이력을 투명하게 관리할 수 있습니다.

히스토리 보조 카드는 데이터 카드의 변경 이력을 기록하여 추적할 수 있는 구조입니다. 이를 구현하기 위해 각 데이터 카드의 변경 사항(예: 설명 변경, 태그 추가/삭제)을 기록하고 조회할 수 있는 기능을 포함한 클래스를 작성했습니다.

히스토리 보조 카드 샘플 코드

from datetime import datetime
from typing import List, Dict, Any

class HistoryEntry:
    """히스토리 항목 클래스"""
    def __init__(self, action: str, details: Dict[str, Any]):
        self.timestamp = datetime.now()
        self.action = action
        self.details = details

    def __str__(self):
        details_str = ", ".join(f"{key}={value}" for key, value in self.details.items())
        return f"[{self.timestamp}] Action: {self.action}, Details: {details_str}"

class DataCardWithHistory:
    """히스토리 기능을 가진 데이터 카드"""
    def __init__(self, name: str, description: str, tags: List[str] = None):
        self.name = name
        self.description = description
        self.tags = tags or []
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.history: List[HistoryEntry] = []  # 히스토리 리스트
        self._add_history("create", {"name": self.name, "description": self.description, "tags": self.tags})

    def _add_history(self, action: str, details: Dict[str, Any]):
        """히스토리 추가"""
        self.history.append(HistoryEntry(action, details))

    def update_description(self, new_description: str):
        """설명 업데이트"""
        old_description = self.description
        self.description = new_description
        self.updated_at = datetime.now()
        self._add_history("update_description", {"old": old_description, "new": new_description})

    def add_tag(self, tag: str):
        """태그 추가"""
        if tag not in self.tags:
            self.tags.append(tag)
            self.updated_at = datetime.now()
            self._add_history("add_tag", {"tag": tag})

    def remove_tag(self, tag: str):
        """태그 삭제"""
        if tag in self.tags:
            self.tags.remove(tag)
            self.updated_at = datetime.now()
            self._add_history("remove_tag", {"tag": tag})

    def display_history(self):
        """히스토리 출력"""
        print(f"History for Data Card '{self.name}':")
        for entry in self.history:
            print(entry)

    def display(self):
        """데이터 카드 정보 출력"""
        print(f"Data Card: {self.name}")
        print(f"Description: {self.description}")
        print(f"Created At: {self.created_at}")
        print(f"Updated At: {self.updated_at}")
        print(f"Tags: {', '.join(self.tags)}")

# 사용 예제
if __name__ == "__main__":
    # 데이터 카드 생성
    card = DataCardWithHistory(name="Customer Data", description="Contains customer demographics.", tags=["customer", "demographics"])
    
    # 데이터 카드 업데이트
    card.update_description("Updated customer demographic data.")
    card.add_tag("analytics")
    card.remove_tag("demographics")

    # 데이터 카드 정보 출력
    print("Current Data Card:")
    card.display()

    # 히스토리 출력
    print("\nChange History:")
    card.display_history()

코드 설명

1. HistoryEntry 클래스:
   • 각 변경 사항을 기록하는 클래스.
   • action: 변경 작업의 이름(예: update_description, add_tag).
   • details: 변경 작업에 대한 추가 정보(예: 이전 값과 새 값).
2. DataCardWithHistory 클래스:
   • 히스토리를 기록하고 관리하는 데이터 카드.
   • _add_history: 히스토리 항목을 추가하는 내부 메서드.
   • 주요 메서드(update_description, add_tag, remove_tag)에서 변경 사항을 히스토리에 자동으로 기록.
3. 사용 예제:
   • 데이터 카드 생성 후 설명 업데이트, 태그 추가/삭제.
   • 현재 데이터 카드 상태와 히스토리 출력.

실행 결과 (예시):

Current Data Card:
Data Card: Customer Data
Description: Updated customer demographic data.
Created At: 2025-01-07 12:00:00.123456
Updated At: 2025-01-07 12:01:00.123456
Tags: customer, analytics

Change History:
[2025-01-07 12:00:00.123456] Action: create, Details: name=Customer Data, description=Contains customer demographics., tags=['customer', 'demographics']
[2025-01-07 12:01:00.123456] Action: update_description, Details: old=Contains customer demographics., new=Updated customer demographic data.
[2025-01-07 12:01:10.123456] Action: add_tag, Details: tag=analytics
[2025-01-07 12:01:20.123456] Action: remove_tag, Details: tag=demographics

주요 기능

• 데이터 카드의 변경 내역을 자동으로 기록.
• 변경 내역을 손쉽게 출력 가능.
• 데이터 변경이 언제, 어떻게 이루어졌는지 추적 가능.

이 코드는 변경 이력을 저장하여 데이터 카드의 투명성을 높이고, 데이터 변경의 추적 가능성을 보장합니다.

아래는 데이터 카드를 관리하기 위한 데이터 카드 컨테이너를 구현한 사용자 정의 클래스의 샘플 코드입니다. 이 클래스는 여러 데이터 카드를 저장하고, 검색 및 필터링 등의 기능을 제공합니다.

from datetime import datetime
from typing import List, Optional, Dict

class DataCard:
    """데이터 카드 클래스"""
    def __init__(self, name: str, description: str, tags: Optional[List[str]] = None):
        self.name = name
        self.description = description
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.tags = tags or []

    def update_description(self, new_description: str):
        self.description = new_description
        self.updated_at = datetime.now()

    def add_tag(self, tag: str):
        if tag not in self.tags:
            self.tags.append(tag)
            self.updated_at = datetime.now()

    def remove_tag(self, tag: str):
        if tag in self.tags:
            self.tags.remove(tag)
            self.updated_at = datetime.now()

    def display(self):
        print(f"Data Card: {self.name}")
        print(f"Description: {self.description}")
        print(f"Created At: {self.created_at}")
        print(f"Updated At: {self.updated_at}")
        print(f"Tags: {', '.join(self.tags)}")

class DataCardContainer:
    """데이터 카드 컨테이너 클래스"""
    def __init__(self):
        self.cards: List[DataCard] = []

    def add_card(self, card: DataCard):
        """컨테이너에 데이터 카드 추가"""
        if any(existing_card.name == card.name for existing_card in self.cards):
            raise ValueError(f"A card with the name '{card.name}' already exists.")
        self.cards.append(card)

    def remove_card(self, card_name: str):
        """컨테이너에서 데이터 카드 삭제"""
        self.cards = [card for card in self.cards if card.name != card_name]

    def get_card(self, card_name: str) -> Optional[DataCard]:
        """이름으로 데이터 카드 검색"""
        for card in self.cards:
            if card.name == card_name:
                return card
        return None

    def filter_by_tag(self, tag: str) -> List[DataCard]:
        """특정 태그를 포함한 데이터 카드 필터링"""
        return [card for card in self.cards if tag in card.tags]

    def display_all(self):
        """모든 데이터 카드 출력"""
        if not self.cards:
            print("No data cards available.")
        for card in self.cards:
            card.display()
            print("-" * 40)

# 사용 예제
if __name__ == "__main__":
    # 데이터 카드 생성
    card1 = DataCard(name="Customer Data", description="Contains customer demographics.", tags=["customer", "demographics"])
    card2 = DataCard(name="Sales Data", description="Sales performance data.", tags=["sales", "performance"])
    card3 = DataCard(name="Survey Data", description="Customer feedback survey results.", tags=["survey", "feedback"])

    # 컨테이너 생성 및 카드 추가
    container = DataCardContainer()
    container.add_card(card1)
    container.add_card(card2)
    container.add_card(card3)

    # 모든 카드 출력
    print("All Data Cards:")
    container.display_all()

    # 특정 카드 검색
    print("\nSearching for 'Sales Data':")
    sales_card = container.get_card("Sales Data")
    if sales_card:
        sales_card.display()

    # 특정 태그로 필터링
    print("\nFiltering cards with tag 'customer':")
    customer_cards = container.filter_by_tag("customer")
    for card in customer_cards:
        card.display()

코드 설명

1. DataCard 클래스:
   • 각 데이터 카드를 표현하며 이름, 설명, 태그, 생성/수정 시간을 포함.
   • 태그 추가/삭제 및 설명 업데이트 기능 제공.
2. DataCardContainer 클래스:
   • 여러 데이터를 관리할 컨테이너로, 다음 주요 기능 포함:
     • 카드 추가: 이름이 중복되지 않도록 확인.
     • 카드 삭제: 이름으로 특정 카드를 삭제.
     • 카드 검색: 이름으로 특정 카드 반환.
     • 태그 필터링: 특정 태그를 포함한 카드 목록 반환.
     • 전체 출력: 저장된 모든 데이터 카드를 출력.
3. 사용 예제:
   • 세 개의 데이터 카드를 생성하고 컨테이너에 추가.
   • 모든 카드 출력, 특정 카드 검색, 특정 태그로 필터링.

실행 결과 (예시):

All Data Cards:
Data Card: Customer Data
Description: Contains customer demographics.
Created At: 2025-01-07 12:00:00.123456
Updated At: 2025-01-07 12:00:00.123456
Tags: customer, demographics
----------------------------------------
Data Card: Sales Data
Description: Sales performance data.
Created At: 2025-01-07 12:00:01.123456
Updated At: 2025-01-07 12:00:01.123456
Tags: sales, performance
----------------------------------------
Data Card: Survey Data
Description: Customer feedback survey results.
Created At: 2025-01-07 12:00:02.123456
Updated At: 2025-01-07 12:00:02.123456
Tags: survey, feedback
----------------------------------------

Searching for 'Sales Data':
Data Card: Sales Data
Description: Sales performance data.
Created At: 2025-01-07 12:00:01.123456
Updated At: 2025-01-07 12:00:01.123456
Tags: sales, performance

Filtering cards with tag 'customer':
Data Card: Customer Data
Description: Contains customer demographics.
Created At: 2025-01-07 12:00:00.123456
Updated At: 2025-01-07 12:00:00.123456
Tags: customer, demographics

이 클래스 구조는 여러 데이터 카드를 체계적으로 관리하고 쉽게 검색, 필터링, 업데이트할 수 있도록 설계되었습니다.

통계 정보를 포함하는 메타클래스를 만들어 클래스의 사용 현황(예: 인스턴스 생성 횟수, 메서드 호출 횟수 등)을 자동으로 추적하는 샘플 코드를 작성해 보았습니다.

from collections import defaultdict
from functools import wraps

class StatsMeta(type):
    """통계 정보를 포함한 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 통계를 저장할 딕셔너리 추가
        dct.setdefault('__stats__', {
            'instance_count': 0,  # 생성된 인스턴스 수
            'method_calls': defaultdict(int),  # 메서드 호출 횟수
        })
        # 메서드를 래핑하여 호출 횟수 추적
        for key, value in dct.items():
            if callable(value) and not key.startswith("__"):
                dct[key] = cls.wrap_method(value, key)
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def wrap_method(method, method_name):
        """메서드 호출 횟수를 추적하기 위한 래핑 함수"""
        @wraps(method)
        def wrapped_method(self, *args, **kwargs):
            # 호출 횟수 증가
            self.__class__.__stats__['method_calls'][method_name] += 1
            return method(self, *args, **kwargs)
        return wrapped_method

    def __call__(cls, *args, **kwargs):
        # 인스턴스 생성 횟수 증가
        cls.__stats__['instance_count'] += 1
        return super().__call__(*args, **kwargs)

    def get_stats(cls):
        """현재 클래스의 통계 정보 반환"""
        return cls.__stats__

# 통계 정보를 추적하는 데이터 클래스
class DataClass(metaclass=StatsMeta):
    def method_a(self):
        print("Method A called.")

    def method_b(self):
        print("Method B called.")

# 사용 예제
if __name__ == "__main__":
    # 클래스 인스턴스 생성
    obj1 = DataClass()
    obj2 = DataClass()

    # 메서드 호출
    obj1.method_a()
    obj2.method_a()
    obj1.method_b()

    # 통계 정보 출력
    stats = DataClass.get_stats()
    print(f"Instance Count: {stats['instance_count']}")
    print("Method Calls:")
    for method, count in stats['method_calls'].items():
        print(f"  {method}: {count}")

코드 설명

1. StatsMeta 메타클래스:
   • __stats__: 클래스 수준에서 통계를 저장하는 딕셔너리를 추가.
   • wrap_method: 클래스의 메서드를 래핑하여 호출 시 통계 정보를 업데이트.
   • __call__: 인스턴스 생성 시 instance_count를 증가.
   • get_stats: 통계 정보를 반환하는 클래스 메서드.
2. DataClass:
   • StatsMeta 메타클래스를 사용하여 메서드 호출 및 인스턴스 생성 통계를 자동으로 관리.
3. 사용 예제:
   • DataClass 인스턴스를 생성하고 메서드를 호출한 뒤, 통계 정보를 출력.

실행 결과 (예시):

Method A called.
Method A called.
Method B called.
Instance Count: 2
Method Calls:
  method_a: 2
  method_b: 1

이 메타클래스는 클래스의 동작을 자동으로 감시하고, 개발 및 디버깅 단계에서 클래스의 사용 통계를 확인하는 데 유용합니다.

파이썬에서 메타클래스는 클래스를 생성하는 데 사용되는 "클래스의 클래스"입니다. 메타데이터와 관련된 용도로 메타클래스를 활용하면 클래스 정의 시 자동으로 메타데이터를 추가하거나 검증 로직을 삽입할 수 있습니다.

다음은 메타데이터 관리 목적의 메타클래스 샘플 코드입니다:

# 메타데이터를 자동으로 추가하는 메타클래스
class MetaDataMeta(type):
    def __new__(cls, name, bases, dct):
        # 메타데이터를 클래스에 자동 추가
        dct.setdefault('__metadata__', {})
        dct['__metadata__']['created_at'] = datetime.now()
        dct['__metadata__']['author'] = dct.get('__author__', 'Unknown')
        dct['__metadata__']['version'] = dct.get('__version__', '1.0')
        return super().__new__(cls, name, bases, dct)

    def update_metadata(cls, key, value):
        """메타데이터 업데이트 메서드"""
        if '__metadata__' not in cls.__dict__:
            cls.__metadata__ = {}
        cls.__metadata__[key] = value

# 메타클래스를 사용하는 데이터 클래스
class DataClass(metaclass=MetaDataMeta):
    __author__ = "John Doe"
    __version__ = "2.0"

    def display_metadata(self):
        """현재 클래스의 메타데이터 출력"""
        metadata = getattr(self.__class__, '__metadata__', {})
        print(f"Metadata for {self.__class__.__name__}:")
        for key, value in metadata.items():
            print(f"  {key}: {value}")

# 사용 예제
class MyData(DataClass):
    pass

if __name__ == "__main__":
    # MyData 클래스 생성 시 자동 메타데이터 삽입
    my_data = MyData()
    my_data.display_metadata()

    # 메타데이터 업데이트
    MyData.update_metadata('last_accessed', '2025-01-07')
    my_data.display_metadata()

코드 설명

1. MetaDataMeta 메타클래스:
   • 클래스 정의 시 __metadata__라는 딕셔너리를 추가하여 기본 메타데이터를 설정.
   • created_at, author, version 같은 기본 메타데이터를 자동으로 삽입.
   • update_metadata 메서드를 통해 동적으로 메타데이터를 업데이트할 수 있음.
2. DataClass 기반 클래스:
   • 메타클래스로 MetaDataMeta를 사용하여 메타데이터 관리 기능을 상속.
3. 사용 예제:
   • MyData 클래스를 정의하면 MetaDataMeta가 자동으로 메타데이터를 삽입.
   • update_metadata를 통해 메타데이터를 동적으로 업데이트 가능.

실행 결과 (예시):

Metadata for MyData:
  created_at: 2025-01-07 12:00:00.123456
  author: John Doe
  version: 2.0
Metadata for MyData:
  created_at: 2025-01-07 12:00:00.123456
  author: John Doe
  version: 2.0
  last_accessed: 2025-01-07

이 메타클래스는 클래스 정의 시점에 메타데이터를 관리하고, 클래스의 공통적인 속성을 중앙에서 통제하기 위한 구조를 제공합니다.

다음은 파이썬에서 데이터 카드(Data Card) 자료구조를 구현하고 메타정보를 표현하는 샘플 코드입니다. 이 코드는 데이터 카드의 주요 속성(예: 이름, 설명, 생성 날짜, 업데이트 날짜, 태그, 관련 데이터셋 정보 등)을 포함한 클래스를 정의하고 메타정보를 표현하는 방법을 보여줍니다.

from datetime import datetime
from typing import List, Dict, Optional

class DataCard:
    def __init__(
        self, 
        name: str, 
        description: str, 
        tags: Optional[List[str]] = None, 
        related_datasets: Optional[List[str]] = None, 
        metadata: Optional[Dict[str, str]] = None
    ):
        self.name = name
        self.description = description
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.tags = tags or []
        self.related_datasets = related_datasets or []
        self.metadata = metadata or {}

    def update_description(self, new_description: str):
        self.description = new_description
        self.updated_at = datetime.now()

    def add_tag(self, tag: str):
        if tag not in self.tags:
            self.tags.append(tag)
            self.updated_at = datetime.now()

    def remove_tag(self, tag: str):
        if tag in self.tags:
            self.tags.remove(tag)
            self.updated_at = datetime.now()

    def add_related_dataset(self, dataset_name: str):
        if dataset_name not in self.related_datasets:
            self.related_datasets.append(dataset_name)
            self.updated_at = datetime.now()

    def update_metadata(self, key: str, value: str):
        self.metadata[key] = value
        self.updated_at = datetime.now()

    def display(self):
        print(f"Data Card: {self.name}")
        print(f"Description: {self.description}")
        print(f"Created At: {self.created_at}")
        print(f"Updated At: {self.updated_at}")
        print(f"Tags: {', '.join(self.tags)}")
        print(f"Related Datasets: {', '.join(self.related_datasets)}")
        print(f"Metadata: {self.metadata}")

# Example Usage
if __name__ == "__main__":
    # Create a new data card
    card = DataCard(
        name="Customer Demographics",
        description="Contains customer demographic information for analysis.",
        tags=["demographics", "customer", "analytics"],
        related_datasets=["sales_data", "survey_results"],
        metadata={"owner": "Data Science Team", "source": "Internal Database"}
    )

    # Update description
    card.update_description("Updated demographic data for customer analysis.")

    # Add a new tag
    card.add_tag("updated")

    # Update metadata
    card.update_metadata("last_reviewed", "2025-01-07")

    # Display the data card
    card.display()

주요 기능

1. 메타정보 관리: metadata 딕셔너리를 통해 키-값 쌍으로 메타정보를 저장.
2. 업데이트 관리: created_at과 updated_at으로 생성 및 수정 시간을 기록.
3. 태그 관리: 태그 추가/삭제 기능 포함.
4. 관련 데이터셋: 관련 데이터셋 목록을 저장.

이 코드는 데이터 카드의 구조를 간단히 표현하며, 실제 구현에서는 사용자 정의 예외 처리, 데이터 검증 등이 추가될 수 있습니다.

Excel과 Access를 연동하여 데이터를 공유하거나 분석하는 방법은 매우 유용합니다. 아래에 Excel 시트와 Access 데이터베이스(DB)를 연동하는 일반적인 방법을 단계별로 설명합니다.

1. Excel 데이터를 Access로 가져오기

방법:

1. Access에서 데이터 가져오기
   • Access를 열고 새로운 데이터베이스를 생성하거나 기존 데이터베이스를 엽니다.
   • 메뉴에서 "외부 데이터" → "새 데이터 소스" → "파일에서" → **"Excel"**을 선택합니다.
   • Excel 파일을 선택한 후 가져올 데이터를 테이블로 변환합니다.
   • 마법사에 따라 Excel 데이터를 Access 테이블로 가져옵니다.
2. Excel 데이터를 링크로 연결하기
   • Access에서 "외부 데이터" → **"Excel"**을 선택합니다.
   • **"데이터 원본 연결"**을 선택하여 Excel 데이터를 Access에서 링크 테이블로 연결합니다.
   • 링크된 데이터를 Access에서 실시간으로 조회하거나 쿼리를 실행할 수 있습니다.

2. Access 데이터를 Excel로 가져오기

방법:

1. Access 쿼리나 테이블을 Excel로 내보내기
   • Access에서 내보낼 테이블이나 쿼리를 선택합니다.
   • 메뉴에서 "외부 데이터" → "내보내기" → **"Excel"**을 선택합니다.
   • Excel 파일 이름과 위치를 설정한 후 데이터를 저장합니다.
2. Excel에서 Access 데이터 가져오기
   • Excel에서 "데이터" → "데이터 가져오기" → **"데이터 원본에서"**를 선택합니다.
   • Access 파일을 선택하고 가져올 테이블 또는 쿼리를 선택합니다.

3. ODBC 연결을 사용하여 연동

Access 데이터베이스와 Excel 시트를 동적으로 연결하려면 ODBC 연결을 설정할 수 있습니다.

설정 방법:

1. ODBC 데이터 원본 설정
   • Windows에서 ODBC 데이터 원본 관리자를 엽니다.
   • 새 데이터 원본 추가 → **Microsoft Access Driver (*.mdb, *.accdb)**를 선택합니다.
   • 데이터베이스 파일(.accdb)을 연결하고 이름을 설정합니다.
2. Excel에서 ODBC 데이터 원본 연결
   • Excel에서 "데이터" → "새 쿼리" → **"ODBC DSN"**을 선택합니다.
   • 설정한 ODBC 데이터 원본을 선택하고 Access 테이블 데이터를 가져옵니다.

4. VBA 코드로 자동화

Excel과 Access 연동 작업을 자동화하려면 VBA(Visual Basic for Applications)를 사용할 수 있습니다.

Access 데이터를 Excel로 가져오는 VBA 코드 예시:

Sub ImportAccessData()
    Dim cn As Object
    Dim rs As Object
    Dim ws As Worksheet
    Dim strConn As String
    Dim sqlQuery As String

    ' Access 파일 경로 및 쿼리
    strConn = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Path\To\YourDatabase.accdb;"
    sqlQuery = "SELECT * FROM YourTableName"

    ' Excel 시트 설정
    Set ws = ThisWorkbook.Sheets("Sheet1")

    ' 데이터 가져오기
    Set cn = CreateObject("ADODB.Connection")
    cn.Open strConn
    Set rs = cn.Execute(sqlQuery)

    ' 데이터 삽입
    ws.Range("A1").CopyFromRecordset rs

    ' 연결 닫기
    rs.Close
    cn.Close
    Set rs = Nothing
    Set cn = Nothing
End Sub

5. 참고 및 추가 팁

• Excel과 Access 파일 포맷 호환성: Access는 .accdb 및 .mdb 형식을 지원하며, Excel은 .xlsx 또는 .xls 형식을 지원합니다. 서로 다른 포맷이 필요할 경우 변환을 고려하세요.
• 자동화 솔루션 고려: 데이터 동기화가 자주 필요한 경우 Power Automate, Python, 또는 기타 스크립트를 사용하여 연동을 자동화할 수 있습니다.

위 방법 중 작업 목적에 가장 적합한 방식을 선택하세요! 추가적인 질문이 있으면 말씀해 주세요. 😊