파이썬 스페셜(매직) 메소드

1. 스페셜 메서드

더블 언더스코어(__)로 시작하고 끝나는 메서드 이름을 가짐.
이 메서드들은 특정 구문이나 내장 함수를 사용할 때 파이썬 인터프리터에 의해 자동 호출.

1-1. __repr__()

파이썬에서 객체의 “공식적인” 문자열 표현을 정의하는 특별한 메서드.
객체를 문자열로 변환할 때 자동 호출한다.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Dog(name='{self.name}', age={self.age})"

Rucy = Dog('루시', 15)
print(repr(Rucy))
print(Rucy)

Dog(name='루시', age=15)
Dog(name='루시', age=15)

# eval()은 주어진 문자열을 파이썬 표현식으로 평가하고 실행하여 그 결과를 반환하는 내장 함수

x = 10
y = 3
result = x + y
print(result)
result = eval("x + y")
print(result)

Rucy_repr = repr(Rucy)
result = eval(Rucy_repr)

print(result)
print(result == Rucy) # False, 같은 값을 가진 다른 객체

13
13
Dog(name='루시', age=15)
False

result.name

'루시'

type(result), type(rucy)

(__main__.Dog, __main__.Dog)

1-2. __str__()

사용자가 이해하기 쉽고, 읽기 좋은 형태의 문자열 표현을 반환하는 메서드.
주로 객체를 출력할 때 사용.
__str__는 사용자가 보기 쉽도록 설계된 문자열 표현을 반환하며, print()나 str()을 통해 호출된다. __repr__()는 객체의 공식적인 표현을 제공하고, repr() 함수를 통해 호출된다.

class Book:
    def __init__(self, title):
        self.title = title

book = Book('미친듯이 재밌는 파이썬')
print(book)
print(str(book))

class Book:
    def __init__(self, title):
        self.title = title
    def __str__(self):
        return self.title

book = Book('미친듯이 재밌는 파이썬')
print(book)
print(str(book))

<__main__.Book object at 0x7d6842bc3f40>
<__main__.Book object at 0x7d6842bc3f40>
미친듯이 재밌는 파이썬
미친듯이 재밌는 파이썬

1-3. __len__()

파이썬에서 객체의 길이 또는 크기를 반환하는 특별한 메서드.
len() 함수가 호출될 때 자동 호출된다.
객체의 항목 수를 측정하거나, 특정한 크기(예: 리스트, 문자열, 튜플 등)를 나타내고자 할 때 구현한다.

class Queue:
    def __init__(self):
        self.items = [1, 2, 3, 4, 5]

    def __len__(self):
        return len(self.items)

li = [1, 2, 3, 4, 5]
print(len(li))
print(li)

queue = Queue()
print(queue)
print(len(queue))

5
[1, 2, 3, 4, 5]
<__main__.Queue object at 0x7d6842ba0070>
5

1-4. __getitem__()

파이썬에서 인덱싱을 지원하기 위해 사용되는 특별한 메서드.
객체의 특정 항목을 가져오기 위해 대괄호([])를 사용할 때 호출한다.
객체의 특정 인덱스나 키에 해당하는 값을 반환하는 역할을 한다.

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

    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            return -1

pt = Point(5, 3)
print(pt)
print(pt[0])
print(pt[1])
print(pt[-100])

<__main__.Point object at 0x7d6842ba3670>
5
3
-1

class MyList:
    def __init__(self, data):
        self.data = data
    def __getitem__(self, index):
        return self.data[index]

ml = MyList([10, 20, 30, 40])
print(ml[0])
print(ml[1])
print(ml[-1])

10
20
40

1-5.__call__()

파이썬에서 객체를 함수처럼 호출할 수 있게 해주는 특별한 메서드.
해당 클래스의 인스턴스를 함수처럼 사용할 수 있으며, 인스턴스에 대해 괄호(())를 사용하여 값을 전달하고 결과를 반환받을 수 있다.

class CallableObject:
    def __call__(self, *args, **kwargs):
        print(f'args:{args}, kwargs:{kwargs}')

callable_obj = CallableObject()
callable_obj(1, 2, 3, a='A', b='B')

args:(1, 2, 3), kwargs:{'a': 'A', 'b': 'B'}

문법	의미	설명
*args	위치 인자 수집	별 1개는 값을 순서대로 모아서 튜플로 만듦
**kwargs	키워드 인자 수집	별 2개는 값을 이름=값 쌍으로 모아서 딕셔너리로 만듦

• * 하나: 1, 2, 3 → (1, 2, 3)
• ** 두 개: a='A', b='B' → {'a': 'A', 'b': 'B'}

2. 파이썬 객체지향의 4대 패러다임

2-1. 캡슐화

객체 안에 데이터(속성)와 메서드(함수)를 감추고, 외부에 필요한 기능만 제공하는 것

# 캡슐화 : 중요한 데이터는 숨기고, 외부에는 인터페이스만 열어둡니다.

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # __로 시작하면 private 속성

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            print("나이는 양수여야 합니다.")

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)
        self.breed = breed

    def bark(self):
        print(f"{self.name}가 멍멍 짖습니다!")

# 사용 예
dog = Dog("루시", 15, "포메")
dog.bark()  # 루시가 멍멍 짖습니다!

print(dog.name)      # 루시
print(dog.breed)     # 포메
print(dog.get_age())

dog.set_age(15)
print(dog.get_age()) # 15

dog.__age = 100      # 외부에서 수정 시도 (실제 속성은 바뀌지 않음)
print(dog.get_age()) # 여전히 15

루시가 멍멍 짖습니다!
루시
포메
15
15
15

2-2. 상속

기존 클래스(부모)의 속성과 기능을 새로운 클래스(자식)가 물려받아 재사용하는 것

# 상속 : 부모 클래스의 속성과 메서드를 자식 클래스가 물려받아 사용합니다.

class Animal:
    def speak(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def speak(self):
        print("멍멍!")

# 사용 예
a = Animal()
a.speak()  # 동물이 소리를 냅니다.

rucy = Dog()
rucy.speak()  # 멍멍! (부모 메서드를 오버라이딩)

동물이 소리를 냅니다.
멍멍!

2-3. 다형성

동일한 이름의 메서드가 상황에 따라 다르게 동작할 수 있는 것

# 다형성 : 같은 이름의 메서드지만, 호출하는 객체에 따라 다른 동작을 합니다.

class Cat:
    def speak(self):
        print("야옹!")

class Dog:
    def speak(self):
        print("멍멍!")

def make_sound(animal):
    animal.speak()

# 사용 예
c = Cat()
d = Dog()
make_sound(c)  # 야옹!
make_sound(d)  # 멍멍!

야옹!
멍멍!

2-4. 추상화

핵심 개념만 정의하고, 구체적인 내용은 자식 클래스에서 채우도록 설계하는 것 (설계의 틀 제공)

# 추상화 : 공통 틀만 정의하고, 구체적인 내용은 자식 클래스가 채우게 합니다.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod # abstract 기능을 아래 함수에 부여할 수 있음.
    def speak(self):
        pass  # 추상 메서드, 자식이 반드시 구현해야 함

class Dog(Animal):
    def speak(self):
        print("멍멍!")

class Cat(Animal):
    def speak(self):
        print("야옹!")

rucy = Dog()
rucy.speak()  # 멍멍!

멍멍!