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

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)

 

# 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, 같은 값을 가진 다른 객체

 

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))

 

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))

 

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])

 

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])

 

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')

 

 

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

캡슐화	객체 안에 데이터(속성)와 메서드(함수)를 감추고, 외부에 필요한 기능만 제공하는 것
상속	기존 클래스(부모)의 속성과 기능을 새로운 클래스(자식)가 물려받아 재사용하는 것
다형성	동일한 이름의 메서드가 상황에 따라 다르게 동작할 수 있는 것
추상화	핵심 개념만 정의하고, 구체적인 내용은 자식 클래스에서 채우도록 설계하는 것 (설계의 틀 제공)

 

1. 캡슐화 (Encapsulation)

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

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(14)
print(dog.get_age()) # 14

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

 

2. 상속 (Inheritance)

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

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

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

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

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

 

3.다형성 (Polymorphism)

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

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)  # 멍멍!

 

4. 추상화 (Abstraction)

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

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass  # 추상 메서드, 자식이 반드시 구현해야 함

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

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

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