Native Python Programing

게임에서 퀘스트와 관련된 데이터를 관리하기 위해 데이터 카드 자료구조를 사용할 수 있습니다. 퀘스트 맵 데이터 카드 자료구조는 각 퀘스트를 카드 형태로 저장하며, 이를 통해 퀘스트의 세부 정보를 체계적으로 관리할 수 있습니다. 카드에는 퀘스트의 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에 해당하는 퀘스트 카드를 반환합니다.

이 구조의 장점

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

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

파이썬에서 리스트를 상속하여 데이터 카드 모델을 만드는 것은, 카드 형태의 데이터를 저장하고 관리할 수 있는 커스텀 리스트 클래스를 만드는 것을 의미합니다. 이를 통해 리스트와 같은 유연성을 유지하면서도, 데이터 카드 전용 메서드를 추가해 데이터 관리를 더 효율적으로 할 수 있습니다.

예를 들어, 게임 플레이 데이터를 카드 모델에 저장하고 관리하거나, 사용자 프로필 데이터를 카드 형태로 관리하는 데 유용하게 활용할 수 있습니다.

리스트 상속 데이터 카드 모델 설명

1. 리스트 상속: 파이썬의 list 클래스를 상속하여 커스텀 리스트 클래스를 만듭니다. 이를 통해 기본적인 리스트의 기능을 유지하면서도, 데이터 카드 전용 기능을 추가할 수 있습니다.

2. 데이터 카드 모델: 각 카드가 특정 구조를 가지도록 데이터 모델을 설계하고, 카드 추가나 검색 등의 메서드를 추가하여 관리의 편의성을 높입니다.

3. 커스텀 메서드 추가: 데이터 카드 리스트에 필터링, 검색 등과 같은 전용 메서드를 추가하여 특정 조건을 만족하는 데이터를 쉽게 관리할 수 있습니다.

예제 코드: 파이썬 리스트 상속 데이터 카드 모델

아래 예제에서는 list 클래스를 상속한 GamePlayDataCardModel 클래스를 만들고, 카드 데이터를 추가하고 검색하는 메서드를 추가합니다.

# 리스트를 상속한 데이터 카드 모델 정의
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)  # 리스트에 카드 추가

    def get_cards_by_player(self, player_id):
        # 특정 플레이어의 카드만 필터링하여 반환
        return [card for card in self if card["player_id"] == player_id]

    def get_top_scores(self, top_n=3):
        # 스코어 순으로 정렬된 상위 N개의 카드 반환
        return sorted(self, key=lambda card: card["score"], reverse=True)[:top_n]

# 데이터 카드 모델 인스턴스 생성
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")

# 특정 플레이어의 데이터 카드 검색
player_cards = game_data.get_cards_by_player("player123")
print("Player Cards for player123:", player_cards)

# 상위 3개의 스코어 데이터 카드 검색
top_scores = game_data.get_top_scores(top_n=3)
print("Top 3 Scores:", top_scores)

출력 예시

Player Cards for player123: [
    {'player_id': 'player123', 'player_name': 'GamerOne', 'level': 5, 'score': 1500, 'date': '2024-10-21'},
    {'player_id': 'player123', 'player_name': 'GamerOne', 'level': 6, 'score': 1800, 'date': '2024-10-22'}
]

Top 3 Scores: [
    {'player_id': 'player123', 'player_name': 'GamerOne', 'level': 6, 'score': 1800, 'date': '2024-10-22'},
    {'player_id': 'player123', 'player_name': 'GamerOne', 'level': 5, 'score': 1500, 'date': '2024-10-21'},
    {'player_id': 'player456', 'player_name': 'GamerTwo', 'level': 3, 'score': 1200, 'date': '2024-10-21'}
]

코드 설명

1. GamePlayDataCardModel 클래스: list를 상속하여 커스텀 리스트 클래스를 생성합니다.
2. add_card 메서드: 새로운 플레이 데이터 카드를 리스트에 추가하는 기능을 합니다.
3. get_cards_by_player 메서드: 특정 player_id에 해당하는 모든 카드를 필터링하여 반환합니다.
4. get_top_scores 메서드: 상위 top_n개의 스코어가 높은 카드를 반환합니다.

이 구조의 장점

• 리스트 상속의 유연성: 리스트의 기본 기능을 그대로 사용하면서 필요한 메서드를 추가할 수 있어 유연하게 데이터를 관리할 수 있습니다.
• 효율적 관리: 여러 카드 데이터를 구조화하여 필요할 때 특정 카드만 빠르게 검색하거나, 정렬된 데이터를 쉽게 조회할 수 있습니다.
• 확장 가능성: 데이터를 확장하거나, 추가적인 메서드를 통해 다양한 데이터 처리를 손쉽게 수행할 수 있습니다.

게임 플레이, 사용자 프로필, 판매 데이터 등 다양한 형태의 데이터를 관리할 때 적합한 구조로, 필터링이나 검색이 필요한 경우 유용하게 사용할 수 있습니다.

스택(Stack)은 LIFO(Last In, First Out) 방식으로 작동하는 자료구조입니다. 즉, 가장 마지막에 추가된 요소가 가장 먼저 제거됩니다. 파이썬에서 기본적으로 제공하는 리스트(list)는 스택의 기능을 구현하는 데 적합한 자료구조입니다. 리스트를 상속하여 스택을 구현하면 리스트의 모든 기능을 활용하면서, 스택의 push, pop 기능을 쉽게 구현할 수 있습니다.

스택의 주요 동작:

1. push(item): 스택의 가장 위에 요소를 추가합니다.
2. pop(): 스택의 가장 위에 있는 요소를 제거하고 반환합니다.
3. peek(): 스택의 가장 위에 있는 요소를 제거하지 않고 반환합니다.
4. is_empty(): 스택이 비어 있는지 확인합니다.

파이썬 리스트를 상속한 스택 구현

class Stack(list):
    def __init__(self):
        super().__init__()  # 리스트 초기화

    def push(self, item):
        """스택에 요소를 추가"""
        self.append(item)  # 리스트의 append()를 사용해 스택의 push 기능 구현

    def pop(self):
        """스택의 가장 위에 있는 요소를 제거하고 반환"""
        if not self.is_empty():
            return super().pop()  # 리스트의 pop()을 사용해 스택의 pop 기능 구현
        else:
            raise IndexError("pop from empty stack")

    def peek(self):
        """스택의 가장 위에 있는 요소를 반환 (제거하지 않음)"""
        if not self.is_empty():
            return self[-1]  # 리스트의 마지막 요소를 반환
        else:
            raise IndexError("peek from empty stack")

    def is_empty(self):
        """스택이 비어 있는지 확인"""
        return len(self) == 0

    def size(self):
        """스택의 크기 반환"""
        return len(self)

# 스택 사용 예제
stack = Stack()

# 스택에 요소 추가 (push)
stack.push(10)
stack.push(20)
stack.push(30)

print("Current Stack:", stack)  # 출력: [10, 20, 30]

# 스택의 가장 위 요소 확인 (peek)
top = stack.peek()
print("Top element:", top)  # 출력: 30

# 스택에서 요소 제거 (pop)
popped = stack.pop()
print("Popped element:", popped)  # 출력: 30

# 스택 상태 확인
print("Stack after pop:", stack)  # 출력: [10, 20]

# 스택이 비어 있는지 확인
print("Is stack empty?", stack.is_empty())  # 출력: False

# 스택 크기 확인
print("Stack size:", stack.size())  # 출력: 2

예제 설명:

1. push(item): 리스트의 append() 메서드를 사용하여 스택의 맨 위에 요소를 추가합니다.
2. pop(): 리스트의 pop() 메서드를 사용하여 스택의 맨 위 요소를 제거하고 반환합니다. 스택이 비어 있으면 IndexError를 발생시킵니다.
3. peek(): 리스트의 마지막 요소(스택의 맨 위)를 반환하지만 제거하지 않습니다. 스택이 비어 있으면 IndexError를 발생시킵니다.
4. is_empty(): 스택이 비어 있는지 확인합니다.
5. size(): 스택에 있는 요소의 개수를 반환합니다.

출력 결과:

Current Stack: [10, 20, 30]
Top element: 30
Popped element: 30
Stack after pop: [10, 20]
Is stack empty? False
Stack size: 2

장점:

• 리스트 상속: 파이썬 리스트는 동적 배열로 동작하기 때문에, 추가적인 메모리 관리 없이 스택의 요소를 쉽게 추가하거나 제거할 수 있습니다.
• 단순 구현: 리스트의 기본 기능을 그대로 사용하면서, 스택의 동작을 간단하게 구현할 수 있습니다.

스택 사용 사례:

1. 수식의 괄호 검증: 수학 또는 프로그래밍 수식에서 괄호의 짝을 맞출 때 스택을 사용하여 유효성을 검증할 수 있습니다.
2. 재귀 호출의 관리: 재귀 호출 과정에서 함수 호출 스택을 관리하는데 스택 자료구조가 유용합니다.
3. Undo/Redo 기능: 텍스트 편집기와 같은 프로그램에서 이전 상태로 돌아가거나 다시 앞으로 이동할 때 스택을 사용합니다.

이와 같이 파이썬 리스트를 상속하여 스택 자료구조를 구현하면, 간단한 코드로 스택의 주요 기능을 쉽게 사용할 수 있습니다.

파이썬에서 리스트를 상속하여 원형 큐(Circular Queue)를 구현하면, 파이썬 리스트의 기본 기능을 활용하면서 원형 큐의 동작 원리를 추가할 수 있습니다. 이를 통해 리스트의 크기를 고정하고, 끝에 도달하면 다시 처음으로 돌아가는 원형 큐의 특성을 구현할 수 있습니다.

원형 큐의 주요 개념:

1. 크기 제한: 큐의 크기는 고정됩니다. 큐가 가득 차면 더 이상 요소를 추가할 수 없습니다.
2. 순환 구조: rear 포인터가 끝에 도달하면 다시 리스트의 처음으로 이동해 새로운 값을 저장할 수 있습니다.
3. FIFO: 먼저 들어간 데이터가 먼저 나오는 구조로 동작합니다.

파이썬 리스트 상속을 통한 원형 큐 구현

class CircularQueue(list):
    def __init__(self, size):
        """
        고정된 크기의 원형 큐를 초기화
        size: 큐의 최대 크기
        """
        super().__init__([None] * size)  # 고정된 크기의 리스트 생성
        self.size = size  # 큐의 크기
        self.front = -1  # 첫 번째 요소 인덱스
        self.rear = -1   # 마지막 요소 인덱스

    def is_empty(self):
        """큐가 비어 있는지 확인"""
        return self.front == -1

    def is_full(self):
        """큐가 꽉 찼는지 확인"""
        return (self.rear + 1) % self.size == self.front

    def enqueue(self, value):
        """
        큐에 요소 추가
        큐가 꽉 찼으면 OverflowError 발생
        """
        if self.is_full():
            raise OverflowError("Circular Queue is full")

        if self.is_empty():
            self.front = 0  # 첫 번째 요소 추가 시 front를 0으로 설정

        self.rear = (self.rear + 1) % self.size  # rear를 순환시킴
        self[self.rear] = value  # 큐에 요소 추가
        print(f"Enqueued {value} at position {self.rear}")

    def dequeue(self):
        """
        큐에서 요소 제거 후 반환
        큐가 비어 있으면 IndexError 발생
        """
        if self.is_empty():
            raise IndexError("Circular Queue is empty")

        value = self[self.front]
        self[self.front] = None  # 큐에서 요소 제거

        if self.front == self.rear:
            # 큐가 비면 front와 rear를 초기화
            self.front = -1
            self.rear = -1
        else:
            # front 포인터를 순환시킴
            self.front = (self.front + 1) % self.size

        print(f"Dequeued {value} from position {self.front}")
        return value

    def peek(self):
        """
        큐의 첫 번째 요소를 반환
        큐가 비어 있으면 IndexError 발생
        """
        if self.is_empty():
            raise IndexError("Circular Queue is empty")
        return self[self.front]

    def __repr__(self):
        """큐의 현재 상태를 문자열로 표현"""
        return f"CircularQueue({list(self)})"


# 원형 큐 사용 예제
cq = CircularQueue(5)

# 큐에 요소 추가
cq.enqueue(10)
cq.enqueue(20)
cq.enqueue(30)
cq.enqueue(40)

print(cq)  # 출력: CircularQueue([10, 20, 30, 40, None])

# 큐에서 요소 제거
cq.dequeue()  # 10 제거
cq.dequeue()  # 20 제거

print(cq)  # 출력: CircularQueue([None, None, 30, 40, None])

# 다시 요소 추가
cq.enqueue(50)
cq.enqueue(60)

print(cq)  # 출력: CircularQueue([60, None, 30, 40, 50])

# 큐가 꽉 차는 상황
try:
    cq.enqueue(70)  # 큐가 가득 찼으므로 오류 발생
except OverflowError as e:
    print(e)  # 출력: Circular Queue is full

# 큐에서 첫 번째 요소 확인 (peek)
print(f"Front of queue: {cq.peek()}")  # 출력: Front of queue: 30

설명

1. 리스트 상속: CircularQueue 클래스는 파이썬의 기본 list를 상속받아 고정된 크기의 큐를 관리합니다.
2. 큐 초기화: __init__에서 큐의 크기를 지정하고 고정된 크기의 리스트를 생성합니다. 리스트를 초기화할 때는 None 값으로 채워둡니다.
3. 포인터 관리:
   • front와 rear는 큐의 첫 번째와 마지막 요소를 가리키는 포인터입니다.
   • enqueue에서는 rear 포인터가 리스트의 끝에 도달하면 처음으로 돌아가고, dequeue에서는 front 포인터가 리스트의 끝에 도달하면 순환합니다.
4. 빈 큐 및 꽉 찬 큐 확인:
   • is_empty()는 front가 -1이면 큐가 비어 있다고 판단합니다.
   • is_full()는 (rear + 1) % size == front 조건을 통해 큐가 꽉 찬 상태임을 확인합니다.
5. 추가/삭제 연산:
   • enqueue는 큐가 가득 차면 OverflowError를 발생시키고, 그렇지 않으면 요소를 추가합니다.
   • dequeue는 큐가 비어 있을 때 IndexError를 발생시키고, 그렇지 않으면 요소를 제거하고 반환합니다.
6. 상태 출력: __repr__()는 큐의 현재 상태를 출력하여 디버깅을 쉽게 할 수 있습니다.

장점

• 리스트의 기본 기능 활용: 파이썬 리스트의 동적 배열 관리 기능을 상속받아 사용하기 때문에, 추가적인 배열 동작을 구현할 필요가 없습니다.
• 원형 구조: 리스트 끝에 도달했을 때 다시 처음으로 돌아가는 원형 구조가 구현되어 메모리 효율성이 높아집니다.

이러한 원형 큐는 제한된 크기의 데이터 구조에서 효율적으로 데이터를 관리하고, 메모리를 고정된 크기로 사용해야 하는 상황에서 유용합니다.

파이썬에서 리스트를 상속받아 다차원 자료구조를 구현하면, 리스트의 기본 기능을 확장하여 더 복잡한 자료구조를 만들 수 있습니다. 상속을 통해 리스트에 새로운 메서드를 추가하거나 기존 메서드를 수정할 수 있어 다차원 데이터를 다루기에 적합한 구조를 만들 수 있습니다.

리스트 상속을 사용하면, 파이썬의 기본 리스트처럼 작동하는 동시에 다차원 데이터에 맞게 커스터마이징된 자료구조를 만들 수 있습니다.

1. 리스트 상속 다차원 자료구조 구현

여기서 2차원 배열을 상속받아 다차원 행렬을 쉽게 다룰 수 있도록 기능을 확장한 예제를 살펴보겠습니다. 예를 들어, 기본 리스트처럼 작동하면서 행과 열을 쉽게 접근할 수 있도록 메서드를 추가할 수 있습니다.

예제 코드: 리스트 상속을 활용한 2차원 행렬 클래스

class Matrix(list):
    def __init__(self, rows):
        # 리스트를 초기화하고 각 행을 Matrix로 만듦
        super().__init__(rows)
        self.rows = len(rows)
        self.cols = len(rows[0]) if rows else 0

    def get_row(self, index):
        """행 인덱스로 특정 행 반환"""
        if index < 0 or index >= self.rows:
            raise IndexError("행 인덱스가 범위를 벗어났습니다.")
        return self[index]

    def get_col(self, index):
        """열 인덱스로 특정 열 반환"""
        if index < 0 or index >= self.cols:
            raise IndexError("열 인덱스가 범위를 벗어났습니다.")
        return [row[index] for row in self]

    def transpose(self):
        """행렬을 전치하여 반환 (행과 열을 바꿈)"""
        return Matrix([[self[i][j] for i in range(self.rows)] for j in range(self.cols)])

# 2차원 리스트(행렬) 생성
matrix = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 특정 행과 열 출력
print("1번째 행:", matrix.get_row(0))  # [1, 2, 3]
print("2번째 열:", matrix.get_col(1))  # [2, 5, 8]

# 전치 행렬(transpose)
transposed_matrix = matrix.transpose()
print("전치 행렬:", transposed_matrix)

2. 설명

• Matrix 클래스는 list 클래스를 상속받아 2차원 행렬을 표현하는 자료구조로 구현되었습니다.
• get_row() 메서드는 특정 행을, get_col() 메서드는 특정 열을 반환합니다.
• transpose() 메서드는 행렬의 행과 열을 전치한 새로운 행렬을 반환합니다.

3. 실행 결과

1번째 행: [1, 2, 3]
2번째 열: [2, 5, 8]
전치 행렬: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

이처럼 리스트를 상속받아 다차원 자료구조를 구현하면, 파이썬의 기본 리스트 기능을 확장하고 새로운 메서드를 추가하여 다차원 데이터에 맞는 커스터마이징된 행렬을 만들 수 있습니다.

4. 확장 예제: 리스트 상속을 활용한 3차원 텐서

2차원 행렬을 넘어서 3차원 이상의 다차원 자료구조(예: 텐서)를 구현하려면 같은 방식을 적용할 수 있습니다.

class Tensor(list):
    def __init__(self, layers):
        super().__init__(layers)
        self.layers = len(layers)
        self.rows = len(layers[0]) if layers else 0
        self.cols = len(layers[0][0]) if self.rows else 0

    def get_layer(self, index):
        """레이어 인덱스로 특정 2D 레이어 반환"""
        if index < 0 or index >= self.layers:
            raise IndexError("레이어 인덱스가 범위를 벗어났습니다.")
        return self[index]

    def get_element(self, layer, row, col):
        """3차원 인덱스로 특정 요소 반환"""
        if layer < 0 or layer >= self.layers:
            raise IndexError("레이어 인덱스가 범위를 벗어났습니다.")
        if row < 0 or row >= self.rows or col < 0 or col >= self.cols:
            raise IndexError("행 또는 열 인덱스가 범위를 벗어났습니다.")
        return self[layer][row][col]

# 3차원 리스트(텐서) 생성
tensor = Tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]]
])

# 특정 레이어와 요소 출력
print("1번째 레이어:", tensor.get_layer(0))  # [[1, 2, 3], [4, 5, 6]]
print("1번째 레이어, 1번째 행, 2번째 열 요소:", tensor.get_element(0, 1, 2))  # 6

5. 확장성 및 응용

• 다차원 데이터: 리스트를 상속받아 다차원 행렬(2D)뿐만 아니라 텐서(3D)까지 쉽게 확장할 수 있습니다.
• 데이터 처리: 이 구조는 데이터 분석, 컴퓨터 그래픽스, 머신러닝 등 다양한 분야에서 유용합니다.

이처럼 파이썬의 리스트 상속을 활용하면, 원하는 기능을 추가하고 복잡한 데이터를 다루기 쉽게 만들 수 있습니다. 추가적인 질문이나 확장된 예제가 필요하다면 말씀해 주세요!