[다차원 자료구조 생성 및 방법] 리스트 상속 다차원 자료구조 1

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

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

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)까지 쉽게 확장할 수 있습니다.
• 데이터 처리: 이 구조는 데이터 분석, 컴퓨터 그래픽스, 머신러닝 등 다양한 분야에서 유용합니다.

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