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

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

다음은 파이썬에서 데이터 카드(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. 관련 데이터셋: 관련 데이터셋 목록을 저장.

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

게임에서 퀘스트와 관련된 데이터를 관리하기 위해 데이터 카드 자료구조를 사용할 수 있습니다. 퀘스트 맵 데이터 카드 자료구조는 각 퀘스트를 카드 형태로 저장하며, 이를 통해 퀘스트의 세부 정보를 체계적으로 관리할 수 있습니다. 카드에는 퀘스트의 ID, 이름, 설명, 보상, 상태 등을 포함하여 게임 플레이 중 퀘스트 정보를 쉽게 조회하고 업데이트할 수 있습니다.

퀘스트 맵 데이터 카드 자료구조 설명

퀘스트 데이터 카드는 다음과 같은 필드를 포함합니다.

1. 퀘스트 ID (quest_id): 퀘스트를 구분하는 고유 식별자
2. 퀘스트 이름 (name): 퀘스트의 이름
3. 퀘스트 설명 (description): 퀘스트의 목적과 수행 방법을 설명
4. 보상 (rewards): 퀘스트 완료 시 제공되는 보상 (경험치, 아이템 등)
5. 퀘스트 상태 (status): 현재 퀘스트의 상태 (예: Not Started, In Progress, Completed)
6. 메타데이터 (metadata): 퀘스트에 대한 추가 정보 (예: 퀘스트 난이도, 퀘스트 위치 등)

데이터 카드 관리 클래스

퀘스트 데이터를 카드 형태로 관리하는 클래스를 정의하고, 퀘스트를 추가, 업데이트, 필터링, 조회하는 기능을 추가합니다.

예제 코드: 퀘스트 맵 데이터 카드 자료구조

from typing import List, Dict

# 퀘스트 데이터 카드 모델 정의
class QuestMap(list):
    def add_quest(self, quest_id: str, name: str, description: str, rewards: Dict, status: str = "Not Started", metadata: Dict = None):
        # 퀘스트 카드 생성
        quest_card = {
            "quest_id": quest_id,
            "name": name,
            "description": description,
            "rewards": rewards,
            "status": status,
            "metadata": metadata or {}
        }
        self.append(quest_card)  # 리스트에 퀘스트 카드 추가

    def update_quest_status(self, quest_id: str, new_status: str):
        # 특정 퀘스트의 상태 업데이트
        for quest in self:
            if quest["quest_id"] == quest_id:
                quest["status"] = new_status
                return quest  # 업데이트된 퀘스트 카드 반환
        return None  # 해당 퀘스트가 없을 때 None 반환

    def filter_by_status(self, status: str) -> List[Dict]:
        # 특정 상태에 해당하는 퀘스트만 필터링하여 반환
        return [quest for quest in self if quest["status"] == status]

    def get_quest(self, quest_id: str) -> Dict:
        # 특정 ID의 퀘스트 카드 조회
        for quest in self:
            if quest["quest_id"] == quest_id:
                return quest
        return None  # 해당 ID의 퀘스트가 없을 때 None 반환

# 퀘스트 맵 인스턴스 생성
quest_map = QuestMap()

# 퀘스트 추가
quest_map.add_quest(
    quest_id="Q001",
    name="Find the Lost Sword",
    description="Retrieve the legendary sword lost in the Forbidden Forest.",
    rewards={"experience": 500, "items": ["Legendary Sword"]},
    metadata={"difficulty": "Hard", "location": "Forbidden Forest"}
)

quest_map.add_quest(
    quest_id="Q002",
    name="Defend the Village",
    description="Help the villagers defend their homes from the goblin invasion.",
    rewards={"experience": 300, "items": ["Healing Potion"]},
    metadata={"difficulty": "Medium", "location": "East Village"}
)

# 퀘스트 상태 업데이트
updated_quest = quest_map.update_quest_status("Q001", "In Progress")
print("Updated Quest:", updated_quest)

# 특정 상태의 퀘스트 필터링 (예: In Progress 상태)
in_progress_quests = quest_map.filter_by_status("In Progress")
print("In Progress Quests:", in_progress_quests)

# 특정 ID의 퀘스트 조회
quest_details = quest_map.get_quest("Q002")
print("Details of Quest Q002:", quest_details)

출력 예시

Updated Quest: {
    'quest_id': 'Q001', 'name': 'Find the Lost Sword', 'description': 'Retrieve the legendary sword lost in the Forbidden Forest.',
    'rewards': {'experience': 500, 'items': ['Legendary Sword']},
    'status': 'In Progress', 'metadata': {'difficulty': 'Hard', 'location': 'Forbidden Forest'}
}

In Progress Quests: [
    {'quest_id': 'Q001', 'name': 'Find the Lost Sword', 'description': 'Retrieve the legendary sword lost in the Forbidden Forest.',
     'rewards': {'experience': 500, 'items': ['Legendary Sword']}, 'status': 'In Progress', 'metadata': {'difficulty': 'Hard', 'location': 'Forbidden Forest'}}
]

Details of Quest Q002: {
    'quest_id': 'Q002', 'name': 'Defend the Village', 'description': 'Help the villagers defend their homes from the goblin invasion.',
    'rewards': {'experience': 300, 'items': ['Healing Potion']},
    'status': 'Not Started', 'metadata': {'difficulty': 'Medium', 'location': 'East Village'}
}

코드 설명

• add_quest 메서드: 새로운 퀘스트 카드를 생성하여 퀘스트 맵에 추가합니다.
• update_quest_status 메서드: quest_id를 통해 퀘스트를 찾고, new_status로 상태를 업데이트합니다.
• filter_by_status 메서드: 특정 상태에 해당하는 모든 퀘스트를 필터링하여 반환합니다.
• get_quest 메서드: 특정 quest_id에 해당하는 퀘스트 카드를 반환합니다.

이 구조의 장점

• 퀘스트 관리 효율성: 퀘스트 상태를 일괄 관리하고 필터링할 수 있어 관리가 용이합니다.
• 가독성: 퀘스트 데이터가 각각의 카드로 구성되어 있어 코드를 읽고 이해하기가 쉽습니다.
• 확장성: 새로운 필드를 추가하거나 필터링 조건을 다양하게 확장할 수 있어 게임 설계에 유연하게 대응할 수 있습니다.

이 구조는 게임 내 다양한 퀘스트를 효과적으로 관리하고, 플레이어가 진행 상황을 쉽게 파악할 수 있도록 돕습니다.

사용자 액션 히스토리를 저장하고 관리하기 위한 데이터 카드 자료구조를 만들어, 사용자 활동을 체계적으로 기록하고 조회할 수 있는 구조를 설계할 수 있습니다. 데이터 카드는 각 사용자 활동을 하나의 카드로 저장하며, 각각의 액션 카드에는 사용자 ID, 액션 유형, 타임스탬프, 메타데이터 등의 필수 정보를 포함합니다. 이를 통해 사용자 액션 데이터를 효율적으로 관리하고 분석할 수 있습니다.

사용자 액션 히스토리 데이터 카드 모델 설명

1. 데이터 카드 구조:

   • user_id: 사용자 식별 ID
   • action_type: 사용자가 수행한 동작의 유형 (예: 로그인, 로그아웃, 페이지 조회 등)
   • timestamp: 액션이 발생한 시간
   • metadata: 해당 액션에 대한 추가 정보 (예: 페이지 URL, 디바이스 정보, 위치 등)

2. 데이터 카드 관리 클래스:

   • 데이터를 카드 형식으로 관리하는 클래스입니다.
   • 각 카드에 필요한 필드를 포함하고, 액션 데이터를 필터링하거나 정렬하여 쉽게 조회할 수 있도록 합니다.

3. 조회 및 필터 기능:

   • 사용자의 특정 시간대나 액션 유형을 기준으로 히스토리를 필터링하는 메서드를 추가하여 유연한 조회를 지원합니다.

예제 코드: 사용자 액션 히스토리 저장을 위한 데이터 카드 구조

다음은 사용자 액션 히스토리를 카드로 관리하는 UserActionHistory 클래스를 정의하고, 액션 추가와 필터링 기능을 구현한 예제입니다.

from datetime import datetime
from typing import List, Dict

# 사용자 액션 히스토리 데이터 카드 모델 정의
class UserActionHistory(list):
    def add_action(self, user_id: str, action_type: str, timestamp: str, metadata: Dict = None):
        # 액션 카드 생성
        action_card = {
            "user_id": user_id,
            "action_type": action_type,
            "timestamp": datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"),
            "metadata": metadata or {}
        }
        self.append(action_card)  # 리스트에 액션 카드 추가

    def filter_by_user(self, user_id: str) -> List[Dict]:
        # 특정 사용자의 액션만 필터링하여 반환
        return [action for action in self if action["user_id"] == user_id]

    def filter_by_action_type(self, action_type: str) -> List[Dict]:
        # 특정 액션 유형에 해당하는 카드만 필터링하여 반환
        return [action for action in self if action["action_type"] == action_type]

    def filter_by_time_range(self, start_time: str, end_time: str) -> List[Dict]:
        # 특정 시간 범위 내의 카드만 반환
        start = datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S")
        end = datetime.strptime(end_time, "%Y-%m-%d %H:%M:%S")
        return [action for action in self if start <= action["timestamp"] <= end]

# 사용자 액션 히스토리 인스턴스 생성
user_actions = UserActionHistory()

# 액션 추가
user_actions.add_action("user001", "login", "2024-10-21 10:15:00", {"device": "mobile", "location": "Seoul"})
user_actions.add_action("user002", "view_page", "2024-10-21 11:00:00", {"page_url": "/home"})
user_actions.add_action("user001", "logout", "2024-10-21 11:30:00", {"device": "mobile"})
user_actions.add_action("user003", "login", "2024-10-22 09:00:00", {"device": "desktop", "location": "Busan"})

# 필터링 예제: 특정 사용자의 모든 액션
user1_actions = user_actions.filter_by_user("user001")
print("Actions for user001:", user1_actions)

# 필터링 예제: 특정 액션 유형 (페이지 조회)
view_page_actions = user_actions.filter_by_action_type("view_page")
print("View Page Actions:", view_page_actions)

# 필터링 예제: 특정 시간 범위 내 액션
time_filtered_actions = user_actions.filter_by_time_range("2024-10-21 09:00:00", "2024-10-21 12:00:00")
print("Actions between 2024-10-21 09:00:00 and 2024-10-21 12:00:00:", time_filtered_actions)

출력 예시

Actions for user001: [
    {'user_id': 'user001', 'action_type': 'login', 'timestamp': datetime.datetime(2024, 10, 21, 10, 15), 'metadata': {'device': 'mobile', 'location': 'Seoul'}},
    {'user_id': 'user001', 'action_type': 'logout', 'timestamp': datetime.datetime(2024, 10, 21, 11, 30), 'metadata': {'device': 'mobile'}}
]

View Page Actions: [
    {'user_id': 'user002', 'action_type': 'view_page', 'timestamp': datetime.datetime(2024, 10, 21, 11, 0), 'metadata': {'page_url': '/home'}}
]

Actions between 2024-10-21 09:00:00 and 2024-10-21 12:00:00: [
    {'user_id': 'user001', 'action_type': 'login', 'timestamp': datetime.datetime(2024, 10, 21, 10, 15), 'metadata': {'device': 'mobile', 'location': 'Seoul'}},
    {'user_id': 'user002', 'action_type': 'view_page', 'timestamp': datetime.datetime(2024, 10, 21, 11, 0), 'metadata': {'page_url': '/home'}},
    {'user_id': 'user001', 'action_type': 'logout', 'timestamp': datetime.datetime(2024, 10, 21, 11, 30), 'metadata': {'device': 'mobile'}}
]

코드 설명

• UserActionHistory 클래스: list를 상속하여 사용자 액션 히스토리 카드를 저장하고 관리하는 클래스를 생성합니다.
• add_action 메서드: 사용자 액션 정보를 포함하는 카드를 생성하고 리스트에 추가합니다.
• filter_by_user 메서드: 특정 user_id에 해당하는 모든 액션 카드를 필터링합니다.
• filter_by_action_type 메서드: 특정 action_type에 해당하는 모든 액션 카드를 필터링합니다.
• filter_by_time_range 메서드: 지정된 시간 범위 내에 발생한 모든 액션 카드를 필터링합니다.

이 구조의 장점

• 필터링 및 검색 기능 강화: 사용자별, 액션 유형별, 시간대별로 액션을 조회할 수 있어 사용자 행동을 유연하게 분석할 수 있습니다.
• 확장성: 새로운 필터 조건이 필요할 때 쉽게 추가할 수 있어 확장성이 뛰어납니다.
• 유연한 관리: metadata 필드를 통해 액션별 추가 정보를 쉽게 저장할 수 있습니다.

이 구조는 사용자 행동 분석, 웹사이트 방문 기록 분석, 사용자 활동 로그 관리 등 여러 상황에 적용할 수 있는 유연한 데이터 카드 모델을 제공합니다.

데이터 카드 목록에서 필터 기능을 효율적으로 구현하기 위해 어댑터 디자인 패턴을 사용할 수 있습니다. 어댑터 패턴을 사용하면 기존 데이터 카드 구조에 영향을 주지 않고도, 필터링 기능을 다양한 형태로 확장하여 일관성 있게 사용할 수 있습니다. 이를 통해 필터 조건을 유연하게 조합하거나 새로운 필터를 추가하기가 수월해집니다.

어댑터 패턴을 활용한 필터 모델 설명

어댑터 패턴은 호환되지 않는 인터페이스를 일관된 인터페이스로 변환하여 사용자가 같은 방식으로 다양한 객체를 활용할 수 있도록 해줍니다.

1. 데이터 카드 모델: 필터링할 데이터 카드 리스트를 포함한 클래스입니다. 이를 통해 특정 조건에 맞는 필터 결과를 얻습니다.

2. 필터 인터페이스(Filter Interface): 필터 조건을 정의한 기본 인터페이스입니다. 각 필터는 특정 조건을 만족하는 카드를 필터링하기 위해 이 인터페이스를 구현합니다.

3. 구체적인 필터 클래스: 특정 조건을 구현하는 클래스입니다. 예를 들어, ScoreFilter는 점수 조건 필터링을, DateFilter는 날짜 조건 필터링을 구현합니다.

4. 어댑터 클래스: 데이터 카드 모델의 필터 기능을 어댑터로 감싸어, 필터 인터페이스의 구현체를 통해 카드 리스트를 필터링하는 역할을 합니다.

이 구조를 사용하면 필터 조건을 새롭게 추가하거나 조합하여 사용할 수 있습니다.

예제 코드: 어댑터 패턴을 활용한 필터 모델 구현

from typing import List, Protocol

# 데이터 카드 필터 인터페이스 정의
class FilterInterface(Protocol):
    def apply(self, data_card: dict) -> bool:
        ...

# 데이터 카드 모델 정의
class GamePlayDataCardModel(list):
    def add_card(self, player_id, player_name, level, score, date):
        card = {
            "player_id": player_id,
            "player_name": player_name,
            "level": level,
            "score": score,
            "date": date
        }
        self.append(card)

# 구체적인 필터 클래스 정의
class ScoreFilter:
    def __init__(self, min_score: int):
        self.min_score = min_score

    def apply(self, data_card: dict) -> bool:
        return data_card["score"] >= self.min_score

class DateFilter:
    def __init__(self, play_date: str):
        self.play_date = play_date

    def apply(self, data_card: dict) -> bool:
        return data_card["date"] == self.play_date

class LevelRangeFilter:
    def __init__(self, min_level: int, max_level: int):
        self.min_level = min_level
        self.max_level = max_level

    def apply(self, data_card: dict) -> bool:
        return self.min_level <= data_card["level"] <= self.max_level

# 필터 어댑터 클래스 정의
class FilterAdapter:
    def __init__(self, data_model: GamePlayDataCardModel):
        self.data_model = data_model

    def filter(self, filters: List[FilterInterface]) -> List[dict]:
        # 모든 필터 조건을 충족하는 카드만 필터링
        return [
            card for card in self.data_model
            if all(f.apply(card) for f in filters)
        ]

# 데이터 카드 모델 인스턴스 생성
game_data = GamePlayDataCardModel()

# 데이터 카드 추가
game_data.add_card("player123", "GamerOne", level=5, score=1500, date="2024-10-21")
game_data.add_card("player456", "GamerTwo", level=3, score=1200, date="2024-10-21")
game_data.add_card("player123", "GamerOne", level=6, score=1800, date="2024-10-22")
game_data.add_card("player789", "GamerThree", level=4, score=900, date="2024-10-22")

# 어댑터를 통한 필터링
adapter = FilterAdapter(game_data)

# 필터 설정: 점수가 1300 이상이고, 날짜가 2024-10-21인 카드
filters = [ScoreFilter(min_score=1300), DateFilter(play_date="2024-10-21")]
filtered_cards = adapter.filter(filters)
print("Filtered Cards with score >= 1300 and date 2024-10-21:", filtered_cards)

# 다른 필터 조합: 레벨이 3에서 5 사이인 카드
filters = [LevelRangeFilter(min_level=3, max_level=5)]
filtered_cards = adapter.filter(filters)
print("Filtered Cards with level between 3 and 5:", filtered_cards)

출력 예시

Filtered Cards with score >= 1300 and date 2024-10-21: [
    {'player_id': 'player123', 'player_name': 'GamerOne', 'level': 5, 'score': 1500, 'date': '2024-10-21'}
]

Filtered Cards with level between 3 and 5: [
    {'player_id': 'player456', 'player_name': 'GamerTwo', 'level': 3, 'score': 1200, 'date': '2024-10-21'},
    {'player_id': 'player789', 'player_name': 'GamerThree', 'level': 4, 'score': 900, 'date': '2024-10-22'}
]

코드 설명

• FilterInterface: 필터 조건을 정의한 프로토콜로, 필터 클래스는 apply 메서드를 구현하여 조건에 맞는지 여부를 판별합니다.
• 구체적인 필터 클래스: ScoreFilter, DateFilter, LevelRangeFilter는 각각 점수, 날짜, 레벨 범위를 기준으로 필터링합니다.
• FilterAdapter 클래스: 필터 어댑터가 데이터 모델을 감싸고, 여러 필터 조건을 적용하여 데이터 카드를 필터링하는 역할을 합니다. filter 메서드는 전달받은 필터 리스트를 모두 적용해 모든 조건을 만족하는 카드만 반환합니다.

이 구조의 장점

• 유연한 필터링 조건 추가: 필터를 클래스로 정의하고 어댑터를 통해 관리하므로, 새로운 필터 조건을 쉽게 추가할 수 있습니다.
• 조합 가능성: 여러 필터 조건을 동시에 사용할 수 있어 복잡한 필터링 조건도 적용할 수 있습니다.
• 확장성: 필터 인터페이스만 구현하면 새로운 필터를 쉽게 적용할 수 있어 구조 확장이 용이합니다.

어댑터 디자인 패턴을 통해 필터 조건을 일관되게 적용할 수 있으며, 필터링 조건 추가와 조합이 용이해 다양한 데이터 관리와 분석에 활용할 수 있습니다.