함수 하나로 여러 가지 처리하기? Python 오버로딩

소개

안녕하세요! 오늘은 Python에서 오버로딩을 구현하는 방법에 대해 알아보겠습니다. 오버로딩이란 무엇이고, 왜 필요한지부터 차근차근 설명드리겠습니다.

오버로딩이란?

오버로딩은 같은 이름의 함수나 메서드가 다른 매개변수를 받아 다르게 동작하도록 하는 기능입니다. 쉽게 말해서, 하나의 함수가 여러 가지 일을 할 수 있게 만드는 것입니다.

실생활 예시

계산기를 생각해봅시다:

• 두 숫자를 더할 수도 있고
• 세 숫자를 더할 수도 있고
• 숫자와 문자를 연결할 수도 있죠

오버로딩 방법

1. singledispatch 사용하기

from functools import singledispatch

@singledispatch
def greet(arg):
    print(f"무언가를 받았어요: {arg}")

@greet.register(str)
def _(arg):
    print(f"문자열을 받았어요: {arg}")

@greet.register(int)
def _(arg):
    print(f"숫자를 받았어요: {arg}")

# 사용 예시
greet("안녕하세요")  # 출력: 문자열을 받았어요: 안녕하세요
greet(123)         # 출력: 숫자를 받았어요: 123
greet([1, 2, 3])   # 출력: 무언가를 받았어요: [1, 2, 3]

장점	단점
표준 라이브러리에 포함	첫 번째 인자의 타입만 가능
메모리 사용량이 적음	여러 인자의 타입에 따른 오버로딩 불가
성능이이 상대적으로 좋음	제네릭 타입 지원이 제한적
타입 힌트와 잘 통합됨

2.dispatch 사용하기

from multipledispatch import dispatch

@dispatch(str)
def process(arg: str):
    return f"String: {arg}"

@dispatch(int)
def process(arg: int):
    return f"Integer: {arg}"

@dispatch(str, int)
def process(arg1: str, arg2: int):
    return f"String and Integer: {arg1}, {arg2}"

장점	단점
여러 인자의 타이벵 대한 디스패치 가능	외부 라이브러리 설치 필요
더 유연한 타입 매칭	메모리 사용량이 더 많음
복잡한 타입 조합 지원	성능이 상대적으로 낮을 수 있음
제네릭 타입 지원이 더 좋음	표준 라이브러리가 아님

3. 기본 매개변수 사용하기

def calculate(a, b, c=None):
    """두 수 또는 세 수의 합을 계산하는 함수"""
    if c is None:
        return a + b
    return a + b + c

# 사용 예시
result1 = calculate(1, 2)     # 3
result2 = calculate(1, 2, 3)  # 6

4. *args 사용하기

def sum_all(*numbers):
    """여러 숫자의 합을 계산하는 함수"""
    return sum(numbers)

# 사용 예시
result1 = sum_all(1, 2)        # 3
result2 = sum_all(1, 2, 3)     # 6
result3 = sum_all(1, 2, 3, 4)  # 10

5. 타입 검사를 통한 오버로딩

def process_data(data):
    """데이터 타입에 따라 다르게 처리하는 함수"""
    if isinstance(data, str):
        return f"문자열 처리: {data.upper()}"
    elif isinstance(data, int):
        return f"숫자 처리: {data * 2}"
    elif isinstance(data, list):
        return f"리스트 처리: {sorted(data)}"
    else:
        return "알 수 없는 데이터 타입"

# 사용 예시
print(process_data("hello"))     # 문자열 처리: HELLO
print(process_data(5))           # 숫자 처리: 10
print(process_data([3, 1, 2]))   # 리스트 처리: [1, 2, 3]

6. 클래스에서의 오버로딩

class Calculator:
    def add(self, x, y=None, z=None):
        if z is not None:
            return x + y + z
        elif y is not None:
            return x + y
        else:
            return x

# 사용 예시
calc = Calculator()
print(calc.add(1))         # 1
print(calc.add(1, 2))      # 3
print(calc.add(1, 2, 3))   # 6

예제: 다목적 데이터 처리기

class DataProcessor:
    @singledispatch
    def process(self, data):
        raise NotImplementedError("지원하지 않는 데이터 타입입니다.")

    @process.register(str)
    def _(self, data):
        return {
            "type": "text",
            "length": len(data),
            "value": data.strip()
        }

    @process.register(int)
    def _(self, data):
        return {
            "type": "number",
            "is_even": data % 2 == 0,
            "value": data
        }

    @process.register(list)
    def _(self, data):
        return {
            "type": "list",
            "length": len(data),
            "value": sorted(data)
        }

# 사용 예시
processor = DataProcessor()

print(processor.process("Hello World  "))
# {'type': 'text', 'length': 11, 'value': 'Hello World'}

print(processor.process(42))
# {'type': 'number', 'is_even': True, 'value': 42}

print(processor.process([3, 1, 4, 1, 5]))
# {'type': 'list', 'length': 5, 'value': [1, 1, 3, 4, 5]}

주의사항

1. 타입 힌트와 함께 사용하기

   from typing import Union
   
   def process_value(value: Union[str, int, list]) -> str:
       if isinstance(value, str):
           return f"문자열: {value}"
       elif isinstance(value, int):
           return f"숫자: {value}"
       else:
           return f"리스트: {value}"

2. 과도한 오버로딩 피하기
   - 함수 이름을 다르게 하는 것이 더 명확할 수 있습니다
   - 예: add_numbers(), concatenate_strings()

• 자주 하는 실수
  1. 잘못된 타입 체크

# ❌ 잘못된 방법
def process(data):
    if type(data) == str:
        return "문자열"

# ✅ 올바른 방법
def process(data):
    if isinstance(data, str):
        return "문자열"

2. 너무 복잡한 오버로딩

# ❌ 피해야 할 방법
def do_something(a, b=None, c=None, d=None, e=None):
    # 복잡한 조건문들...
    pass

# ✅ 더 나은 방법
def do_something(*args):
    if len(args) == 2:
        # 두 인자 처리
        pass
    elif len(args) == 3:
        # 세 인자 처리
        pass

마치며

오버로딩은 코드의 재사용성과 가독성을 높여주는 유용한 기능입니다. 하지만 과도하게 사용하면 오히려 코드가 복잡해질 수 있으니, 적절한 상황에서만 사용하는 것이 좋습니다.