# 파이썬 클래스(Class) 완벽 가이드

파이썬 클래스는 객체 지향 프로그래밍(OOP)의 핵심 구성 요소로, 데이터(속성)와 동작(메서드)를 하나의 단위로 캡슐화하여 코드의 재사용성과 유지보수성을 높이는 템플릿입니다. 클래스는 객체를 생성하는 청사진이자, 생성된 객체의 타입을 정의하는 네임스페이스입니다.

## 클래스와 객체의 기본 개념

클래스(Class)는 객체(Object)를 생성하기 위한 청사진이나 템플릿이며, 객체는 클래스에서 실제로 생성된 구체적인 인스턴스(Instance)입니다. 객체 지향 프로그래밍에서 클래스는 변수(속성, Attribute)와 함수(메서드, Method)를 결합한 구조를 가집니다. 이 구조는 데이터와 로직을 밀접하게 묶어 상태 무결성을 보호하고, 복잡한 시스템을 모듈화하여 관리하기 쉽게 합니다.

## 클래스 정의 및 인스턴스 생성

파이썬에서 클래스는 `class` 키워드를 사용하여 정의합니다. 클래스가 인스턴스화될 때 자동으로 호출되는 초기화 메서드인 `__init__`는 생성자(Constructor) 역할을 하며, 새로 생성된 객체의 초기 상태를 설정하는 데 필수적입니다.

### `self`의 의미와 용도
`self`는 인스턴스 메서드가 호출될 때, 해당 메서드가 속한 객체 자체를 가리키는 참조 변수입니다. 이는 파이썬이 메서드 호출 시 암묵적으로 첫 번째 인자로 전달합니다. `self`를 통해 인스턴스의 속성에 접근하거나 다른 메서드를 호출할 수 있으며, 이는 해당 메서드가 특정 객체의 데이터를 다루고 있음을 명확히 합니다.

### 생성자(`__init__`)와 소멸자(`__del__`)의 차이
클래스 라이프사이클에서 중요한 두 메서드는 생성자와 소멸자입니다.
*   **생성자 (`__init__`)**: 인스턴스가 메모리에 할당될 때 한 번 호출되어 초기화를 담당합니다.
*   **소멸자 (`__del__`)**: 인스턴스가 가비지 컬렉터(Garbage Collector)에 의해 메모리에서 제거되기 직전 호출됩니다. 하지만 파이썬의 가비지 컬렉션은 시점이 명확하지 않으며, 참조 순환(Reference Cycle)이 발생하면 `__del__`이 호출되지 않을 수 있습니다. 따라서 파일 닫기나 네트워크 연결 해제 등 자원 정리에는 `with` 문이나 명시적인 cleanup 메서드를 사용하는 것이 권장됩니다.

```python
class Dog:
    def __init__(self, name, age):
        self.name = name  # 인스턴스 속성 할당
        self.age = age

    def __del__(self):
        print(f"{self.name}이(가) 메모리에서 제거됩니다.")

    def bark(self):
        return f"{self.name}이(가) 멍멍!"

# 인스턴스 생성
my_dog = Dog("초코", 3)
print(my_dog.bark())  # 출력: 초코이(가) 멍멍!
```

## 속성과 메서드의 접근 제어

파이썬은 자바나 C++와 같은 언어처럼 엄격한 접근 제어자(public, protected, private)를 문법적으로 강제하지 않습니다. 대신 관례(Convention)와 데코레이터를 통해 접근 권한을 관리합니다.

### 클래스 변수와 인스턴스 변수의 구분
클래스 내에서 변수는 **클래스 변수(Class Variable)**와 **인스턴스 변수(Instance Variable)**로 구분됩니다.
*   **인스턴스 변수**: `self`를 통해 정의되며, 각 객체마다 독립적인 값을 가집니다.
*   **클래스 변수**: 클래스 본문에서 직접 정의되며, 모든 인스턴스가 공유합니다. 클래스 이름으로 직접 접근하거나 수정할 수 있습니다.

```python
class Counter:
    count = 0  # 클래스 변수: 모든 인스턴스가 공유

    def __init__(self):
        self.value = 0  # 인스턴스 변수: 각 인스턴스 고유의 값

    def increment(self):
        self.value += 1
        Counter.count += 1  # 클래스 변수는 클래스 이름으로 접근

c1 = Counter()
c2 = Counter()
c1.increment()
c2.increment()

print(c1.value)  # 1 (인스턴스별 값)
print(c2.value)  # 1 (인스턴스별 값)
print(Counter.count)  # 2 (공유된 값)
```

### 언더스코어(_) 관례
*   **공개 (Public)**: `_` 없음. 외부에서 자유롭게 접근 가능.
*   **보호 (Protected)**: `_` 접두사 (예: `_name`). 내부 구현 세부사항임을 나타내는 관례. 하위 클래스에서도 접근 가능하지만, 외부 API로 간주되어선 안 됩니다.
*   **사적 (Private)**: `__` 접두사 (예: `__secret`). 이름 변형(Name Mangling)이 발생하여 외부에서의 직접 접근이 어렵게 만듦.

### `@property` 데코레이터
속성 값의 유효성을 검증하거나 계산된 값을 반환해야 할 때 `@property`를 사용합니다. 이를 통해 마치 일반 속성처럼 접근하면서도 내부적으로 메서드 로직을 실행할 수 있습니다.

| 접근 수준 | 이름 규칙 | 접근 권한 | 설명 |
| :--- | :--- | :--- | :--- |
| 공개 | `attribute` | 전체 | 모든 곳에서 접근 가능 |
| 보호 | `_attribute` | 제한적 | 내부 구현 세부사항. 외부 API로 간주되어선 안 됨 |
| 사적 | `__attribute` | 제한적 | 이름 변형으로 외부 직접 접근 차단 |

```python
class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 사적 속성

    @property
    def balance(self):
        return self.__balance

    @balance.setter
    def balance(self, value):
        if value < 0:
            raise ValueError("잔고는 음수가 될 수 없습니다.")
        self.__balance = value

# 테스트 코드
account = BankAccount(1000)
print(account.balance)  # 1000

account.balance = 1500  # setter 호출
print(account.balance)  # 1500

# account.balance = -500  # ValueError 발생
```

## 상속(Inheritance)과 다형성(Polymorphism)

상속은 기존 클래스(부모 클래스)의 속성과 메서드를 새로운 클래스(자식 클래스)가 물려받아 재사용할 수 있게 하는 기법입니다. 이를 통해 코드 중복을 줄이고 계층적 구조를 형성합니다.

### 메서드 오버라이딩과 `super()`
자식 클래스가 부모 클래스의 메서드를 재정의(오버라이딩)하여 고유한 동작을 구현할 수 있습니다. 이때 `super()` 함수를 사용하면 부모 클래스의 메서드를 호출하여 기존 기능을 확장하거나 보완할 수 있습니다.

### 다중 상속과 MRO(Method Resolution Order)
파이썬은 다중 상속(Multiple Inheritance)을 지원합니다. 즉, 하나의 클래스가 여러 부모 클래스를 가질 수 있습니다. 이때 메서드 호출 순서를 결정하는 것이 **MRO(Method Resolution Order)**입니다. 파이썬은 C3 선형화 알고리즘을 사용하여 MRO를 계산하며, `__mro__` 속성이나 `mro()` 메서드를 통해 확인 가능합니다. 이는 모순 없는 메서드 탐색 순서를 보장합니다.

```python
class Animal:
    def speak(self):
        return "소리"

class Dog(Animal):
    def speak(self):
        return super().speak() + " (멍멍!)"

# 다중 상속 예시
class Flyable:
    def fly(self):
        return "날다"

class Bird(Animal, Flyable):
    def speak(self):
        return "짹짹"  # Animal의 speak를 오버라이딩

dog = Dog()
print(dog.speak())  # 소리 (멍멍!)

bird = Bird()
print(bird.speak())  # 짹짹
print(bird.fly())    # 날다 - Flyable 상속
```

## 특수 메서드(Dunder Methods) 활용

두 밑줄(Dunder, Double Underscore)로 둘러싸인 메서드는 파이썬의 내장 동작을 커스터마이징하는 특수 메서드입니다.

*   `__str__`: 객체의 문자열 표현을 반환 (사용자 친화적)
*   `__repr__`: 객체의 공식적인 문자열 표현 (개발자 디버깅용)
*   `__eq__`: 동등 연산자(`==`)의 동작 정의

```python
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __eq__(self, other):
        if isinstance(other, Point):
            return self.x == other.x and self.y == other.y
        return False
```

## 실제 프로젝트 활용: 데이터 클래스(@dataclass)

현대 파이썬(3.7+)에서는 `dataclasses` 모듈을 사용하여 데이터 저장에 특화된 클래스를 간결하게 정의할 수 있습니다. `@dataclass` 데코레이터를 붙이면 `__init__`, `__repr__`, `__eq__` 등이 자동으로 생성되어 boilerplate 코드를 대폭 줄여줍니다.

```python
from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0  # 기본값 제공

    def total_price(self):
        return self.price * self.quantity

# 인스턴스 생성 시 __init__이 자동으로 생성됨
item = Product("키보드", 15000, 2)
print(item)  # Product(name='키보드', price=15000, quantity=2)
print(item.total_price())  # 30000
```

이처럼 데이터 클래스는 설정 객체, API 응답 모델, 도메인 엔티티 등 구조화된 데이터를 다룰 때 가독성과 개발 효율성을 극대화하는 강력한 도구입니다.