Python 매직 메서드 개념 정리

1️⃣ 기본 매직 메서드

객체의 기본 동작을 정의하는 특별한 메서드들이다.

class Number:
    def __init__(self, value):  # 초기화
        self.value = value
    
    def __str__(self):         # 문자열 표현
        return f"Number({self.value})"
    
    def __repr__(self):        # 개발자를 위한 문자열 표현
        return f"Number({self.value})"
    
    def __bool__(self):        # bool() 함수나 조건문에서 평가
        return self.value != 0
    
    def __hash__(self):        # 해시값 반환 (딕셔너리 키로 사용 가능)
        return hash(self.value)
    
    def __format__(self, format_spec):  # format() 함수 및 f-문자열에서 사용
        if format_spec == 'hex':
            return f"0x{self.value:x}"
        return str(self)

num = Number(42)
print(str(num))       # Number(42)
print(repr(num))      # Number(42)
print(bool(num))      # True
print(bool(Number(0))) # False
print(f"{num:hex}")   # 0x2a

# 해시테이블(딕셔너리) 키로 사용
d = {num: "answer"}
print(d[num])         # answer

✅ 특징:

객체 초기화
문자열 변환
디버깅 표현
진리값 평가
해시 가능 객체
형식화 제어

2️⃣ 연산자 오버로딩

Python의 연산자 동작을 사용자 정의 클래스에 맞게 재정의할 수 있다.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):      # + 연산자
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):      # - 연산자
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):     # * 연산자 (Vector * scalar)
        return Vector(self.x * scalar, self.y * scalar)
    
    def __rmul__(self, scalar):    # * 연산자 (scalar * Vector)
        return self.__mul__(scalar)
    
    def __truediv__(self, scalar): # / 연산자
        return Vector(self.x / scalar, self.y / scalar)
    
    def __eq__(self, other):       # == 연산자
        return self.x == other.x and self.y == other.y
    
    def __lt__(self, other):       # < 연산자
        return (self.x**2 + self.y**2) < (other.x**2 + other.y**2)
    
    def __abs__(self):             # abs() 함수
        return (self.x**2 + self.y**2) ** 0.5
    
    def __neg__(self):             # -벡터 (부호 반전)
        return Vector(-self.x, -self.y)
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

# 연산자 사용 예시
v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2           # Vector(4, 6)
v4 = v1 * 2            # Vector(2, 4)
v5 = 3 * v1            # Vector(3, 6) - __rmul__ 덕분에 가능
v6 = v2 / 2            # Vector(1.5, 2.0)
print(abs(v1))         # 2.23606... (벡터의 크기)
print(v1 < v2)         # True (v1의 크기 < v2의 크기)
print(-v1)             # Vector(-1, -2)

✅ 특징:

산술 연산자 (add, sub, mul, truediv, 등)
역방향 연산자 (radd, rsub, rmul, 등)
복합 할당 연산자 (iadd, isub, 등)
비교 연산자 (eq, ne, lt, gt, 등)
단항 연산자 (pos, neg, abs, 등)
직관적인 객체 연산 구현
연산자 우선순위 유지

3️⃣ 컨테이너 동작 정의

리스트나 딕셔너리 같은 컨테이너처럼 동작하는 사용자 정의 클래스를 만들 수 있다.

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __len__(self):            # len() 함수
        return len(self.items)
    
    def __getitem__(self, index): # 인덱싱 및 슬라이싱
        return self.items[index]
    
    def __setitem__(self, index, value): # 항목 설정
        self.items[index] = value
    
    def __delitem__(self, index): # del 연산자
        del self.items[index]
    
    def __contains__(self, item): # in 연산자
        return item in self.items
    
    def __iter__(self):           # for문에서 반복
        return iter(self.items)
    
    def __reversed__(self):       # reversed() 함수
        return reversed(self.items)

# 컨테이너 동작 사용 예시
lst = MyList([1, 2, 3, 4, 5])
print(len(lst))        # 5
print(lst[0])          # 1
print(lst[1:3])        # [2, 3] - 슬라이싱 지원
lst[0] = 10            # 항목 설정
print(lst[0])          # 10
print(3 in lst)        # True
del lst[0]             # 첫 번째 항목 삭제
print(lst[0])          # 2

# 반복 가능
for item in lst:
    print(item, end=' ')  # 2 3 4 5

# 역순 반복
print()
for item in reversed(lst):
    print(item, end=' ')  # 5 4 3 2

# 딕셔너리 스타일 컨테이너
class SimpleDict:
    def __init__(self):
        self._data = {}
    
    def __getitem__(self, key):
        return self._data[key]
    
    def __setitem__(self, key, value):
        self._data[key] = value
    
    def __delitem__(self, key):
        del self._data[key]
    
    def __contains__(self, key):
        return key in self._data
    
    def __iter__(self):
        return iter(self._data)

d = SimpleDict()
d['name'] = '홍길동'
print(d['name'])       # 홍길동

✅ 특징:

시퀀스/매핑 동작 구현
인덱싱/슬라이싱 지원
항목 수정 및 삭제
멤버십 테스트 (in 연산자)
반복 가능(iterable) 객체
리스트/튜플/딕셔너리 유사 동작
시퀀스 프로토콜 준수

4️⃣ 객체 생명주기 관련

객체의 생성, 사용, 소멸 주기를 관리하는 매직 메서드들이다.

class Resource:
    def __init__(self, name):
        self.name = name
        print(f"{self.name} 리소스 초기화")
    
    def __del__(self):           # 소멸자
        print(f"{self.name} 리소스 정리")
    
    def __enter__(self):         # with 문 시작
        print(f"{self.name} 컨텍스트 시작")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb): # with 문 종료
        print(f"{self.name} 컨텍스트 종료")
        if exc_type is not None:
            print(f"예외 발생: {exc_val}")
        return False  # False면 예외 전파, True면 예외 억제

# 일반 사용
r = Resource("일반")
del r  # 명시적 소멸

# with 문 사용 (정상)
with Resource("정상") as r:
    print("리소스 사용 중")

# with 문 사용 (예외 발생)
try:
    with Resource("예외") as r:
        print("리소스 사용 중")
        raise ValueError("예외 테스트")
except ValueError:
    print("예외 처리됨")

# 새 스타일 컨텍스트 관리자 (Python 3.10+)
from contextlib import contextmanager

class ModernResource:
    def __init__(self, name):
        self.name = name
    
    @contextmanager
    def session(self):
        print(f"{self.name} 세션 시작")
        try:
            yield self
            print(f"{self.name} 세션 정상 종료")
        except Exception as e:
            print(f"{self.name} 세션 예외 종료: {e}")
            raise

mr = ModernResource("현대식")
with mr.session() as session:
    print("세션 사용 중")

✅ 특징:

객체 초기화 (init)
객체 소멸 처리 (del)
컨텍스트 관리자 프로토콜 (enter, exit)
리소스 관리 자동화
예외 처리 및 정리
with 문 활용
안전한 리소스 해제 보장

5️⃣ 속성 접근 제어

객체의 속성 접근을 제어하고 커스터마이징할 수 있다.

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age
        self._protected = {}
    
    def __getattr__(self, name):  # 존재하지 않는 속성 접근
        return f"{name}은 존재하지 않는 속성입니다."
    
    def __getattribute__(self, name):  # 모든 속성 접근
        if name.startswith('_secret_'):
            raise AttributeError(f"{name}은 접근할 수 없습니다.")
        # 무한 재귀 방지를 위해 super() 사용
        return super().__getattribute__(name)
    
    def __setattr__(self, name, value):  # 속성 설정
        if name == 'age' and value < 0:
            raise ValueError("나이는 음수가 될 수 없습니다.")
        print(f"{name} 속성을 {value}로 설정")
        super().__setattr__(name, value)
    
    def __delattr__(self, name):  # 속성 삭제
        if name == '_name':
            raise AttributeError("이름은 삭제할 수 없습니다.")
        print(f"{name} 속성 삭제")
        super().__delattr__(name)
    
    # 프로퍼티 스타일 접근
    @property
    def name(self):
        return self._name
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("나이는 음수가 될 수 없습니다.")
        self._age = value
    
    # 동적 속성 지원
    def __getitem__(self, key):
        return self._protected.get(key, None)
    
    def __setitem__(self, key, value):
        self._protected[key] = value

# 속성 접근 예시
p = Person("홍길동", 30)
print(p.name)         # 홍길동
p.age = 35            # age 속성을 35로 설정
print(p.age)          # 35

try:
    p.age = -5        # ValueError: 나이는 음수가 될 수 없습니다.
except ValueError as e:
    print(e)

print(p.address)      # address은 존재하지 않는 속성입니다.

try:
    print(p._secret_data)  # AttributeError
except AttributeError as e:
    print(e)

# 딕셔너리 스타일 액세스
p['location'] = '서울'
print(p['location'])  # 서울

✅ 특징:

속성 접근 제어
속성 존재 여부 확인
동적 속성 처리
접근 제한 및 유효성 검증
프로퍼티 스타일 액세스
딕셔너리 스타일 액세스
내부 속성 보호

6️⃣ 호출 가능 객체와 설명자

함수처럼 호출할 수 있는 객체와 속성 접근을 사용자화하는 설명자 패턴이다.

# 호출 가능 객체 (Callable)
class Adder:
    def __init__(self, n):
        self.n = n
    
    def __call__(self, x):  # 객체를 함수처럼 호출
        return self.n + x

add5 = Adder(5)
print(add5(10))       # 15 - 객체를 함수처럼 호출
print(callable(add5))  # True

# 설명자 (Descriptor)
class Validator:
    def __init__(self, min_value=None, max_value=None):
        self.min_value = min_value
        self.max_value = max_value
        self.name = None
    
    def __set_name__(self, owner, name):  # Python 3.6+
        self.name = name
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]
    
    def __set__(self, instance, value):
        if self.min_value is not None and value < self.min_value:
            raise ValueError(f"{self.name}은(는) {self.min_value} 이상이어야 합니다.")
        if self.max_value is not None and value > self.max_value:
            raise ValueError(f"{self.name}은(는) {self.max_value} 이하여야 합니다.")
        instance.__dict__[self.name] = value

class Person:
    age = Validator(min_value=0, max_value=150)
    height = Validator(min_value=0)
    
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

# 설명자 사용 예시
p = Person("홍길동", 30, 175)
print(p.age)      # 30

try:
    p.age = -5    # ValueError
except ValueError as e:
    print(e)

try:
    p.age = 200   # ValueError
except ValueError as e:
    print(e)

# 함수 장식자와 매직 메서드 결합
def debug_calls(cls):
    original_methods = {}
    
    # 모든 매직 메서드 찾기
    for name, method in vars(cls).items():
        if callable(method) and name.startswith('__') and name.endswith('__'):
            original_methods[name] = method
    
    # 매직 메서드 래핑
    def wrap_method(name, method):
        def wrapper(self, *args, **kwargs):
            print(f"호출: {cls.__name__}.{name}({args}, {kwargs})")
            result = method(self, *args, **kwargs)
            print(f"결과: {result}")
            return result
        return wrapper
    
    # 래핑된 메서드로 교체
    for name, method in original_methods.items():
        setattr(cls, name, wrap_method(name, method))
    
    return cls

@debug_calls
class DebuggableVector(Vector):
    pass

# 디버깅 래퍼 테스트
dv1 = DebuggableVector(1, 2)
dv2 = DebuggableVector(3, 4)
result = dv1 + dv2  # 호출 및 결과 로깅이 출력됨

✅ 특징:

호출 가능 객체 (call)
함수형 객체 구현
설명자 프로토콜 (get, set, delete)
속성 접근 사용자화
속성 유효성 검사
재사용 가능한 속성 로직
데이터 캡슐화
메타프로그래밍 기법

7️⃣ 고급 매직 메서드

덜 자주 사용되지만 강력한 기능을 제공하는 매직 메서드들이다.

# 피클링 지원
import pickle

class PickleableClass:
    def __init__(self, value):
        self.value = value
        self._cache = {}  # 피클링되지 않을 캐시
    
    def __getstate__(self):  # 피클링 시 호출
        # _cache는 제외하고 피클링
        state = self.__dict__.copy()
        del state['_cache']
        return state
    
    def __setstate__(self, state):  # 언피클링 시 호출
        self.__dict__ = state
        self._cache = {}  # 캐시 초기화

obj = PickleableClass(42)
obj._cache['temp'] = 'temporary data'

# 피클링 및 언피클링
serialized = pickle.dumps(obj)
deserialized = pickle.loads(serialized)

print(deserialized.value)       # 42
print(hasattr(deserialized, '_cache'))  # True
print(deserialized._cache)      # {} (비어있음)

# 사용자 정의 숫자 타입
class Fraction:
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator
        self._simplify()
    
    def _simplify(self):
        # 최대공약수 계산
        def gcd(a, b):
            while b:
                a, b = b, a % b
            return a
        
        g = gcd(abs(self.numerator), abs(self.denominator))
        self.numerator //= g
        self.denominator //= g
    
    def __int__(self):  # int() 변환
        return self.numerator // self.denominator
    
    def __float__(self):  # float() 변환
        return self.numerator / self.denominator
    
    def __round__(self, ndigits=0):  # round() 함수
        return round(float(self), ndigits)
    
    def __complex__(self):  # complex() 변환
        return complex(float(self), 0)
    
    def __str__(self):
        return f"{self.numerator}/{self.denominator}"

frac = Fraction(22, 7)  # 파이의 근사값
print(str(frac))        # 22/7
print(int(frac))        # 3
print(float(frac))      # 3.142857...
print(round(frac, 2))   # 3.14
print(complex(frac))    # (3.142857...+0j)

# __slots__ 사용으로 메모리 최적화
class Point:
    __slots__ = ('x', 'y')  # 허용된 속성 제한
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)
p.x = 5  # 정상 작동
try:
    p.z = 10  # AttributeError: 'Point' object has no attribute 'z'
except AttributeError as e:
    print(e)

✅ 특징:

객체 직렬화 (getstate, setstate)
타입 변환 메서드 (int, float, complex, 등)
메모리 최적화 (slots)
수치 연산 지원
객체 분류 및 등록
하위 클래스 확인
메타클래스 프로토콜
사용자 정의 컨테이너 동작

주요 팁

✅ 모범 사례:

__init__과 __str__ 기본 구현하기
__repr__은 가능하면 객체 재생성 코드 반환
연산자 오버로딩은 직관적이고 일관되게 구현
컨테이너 타입은 __len__과 __getitem__ 구현
리소스 관리는 __enter__와 __exit__ 사용
속성 접근 제어는 신중하게 설계
__eq__를 구현할 때 __hash__도 함께 구현
메모리 및 성능 최적화를 위해 __slots__ 사용 고려
일관성 있는 동작 유지하기
표준 라이브러리 규약 따르기
매직 메서드 호출 시 내장 함수 사용하기 (직접 호출 피하기)
설명자와 프로퍼티 활용하여 속성 로직 재사용
오류 처리 및 예외 발생 명확히 하기
매직 메서드 사용법은 표준 라이브러리 코드 참조
과도한 커스터마이징 피하고 직관적인 인터페이스 유지

KR_MagicMethod - somaz94/python-study GitHub Wiki

Python 매직 메서드 개념 정리

1️⃣ 기본 매직 메서드

2️⃣ 연산자 오버로딩

3️⃣ 컨테이너 동작 정의

4️⃣ 객체 생명주기 관련

5️⃣ 속성 접근 제어

6️⃣ 호출 가능 객체와 설명자

7️⃣ 고급 매직 메서드

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_MagicMethod - somaz94/python-study GitHub Wiki

Python 매직 메서드 개념 정리

1️⃣ 기본 매직 메서드

2️⃣ 연산자 오버로딩

3️⃣ 컨테이너 동작 정의

4️⃣ 객체 생명주기 관련

5️⃣ 속성 접근 제어

6️⃣ 호출 가능 객체와 설명자

7️⃣ 고급 매직 메서드

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️