[PYTHON] 가변 객체와 불변 객체의 인자 전달 차이점 및 사이드 이펙트 해결 방법 7가지

가변 (Mutable) vs 불변 (Immutable) 객체의 구조적 차이

 

파이썬을 다루는 많은 개발자들이 겪는 가장 당혹스러운 순간 중 하나는 "함수 내부에서 수정한 적 없는 변수값이 함수 밖에서 변해버리는 상황"일 것입니다. 이는 파이썬의 핵심 설계 원칙인 '객체 참조에 의한 호출(Call by Object Reference)'과 가변(Mutable) vs 불변(Immutable) 객체의 특성 차이에서 기인합니다. 이러한 원리를 정확히 이해하지 못하면 대규모 시스템에서 추적하기 어려운 버그(사이드 이펙트)를 양산하게 됩니다. 본 포스팅에서는 객체 유형에 따른 메모리 관리 방식의 근본적인 차이를 분석하고, 실무에서 흔히 발생하는 예상치 못한 데이터 변조 문제를 안전하게 해결하는 7가지 전문적인 방법을 제시합니다.

---

1. 가변(Mutable) vs 불변(Immutable) 객체의 구조적 차이 비교

파이썬의 모든 데이터는 객체로 취급됩니다. 하지만 그 객체가 생성된 후 상태를 변경할 수 있는지 여부에 따라 메모리 할당 방식이 완전히 달라집니다.

특성	불변 객체 (Immutable)	가변 객체 (Mutable)
해당 데이터 타입	int, float, str, tuple, bool, frozenset	list, dict, set, bytearray, 사용자 정의 클래스
값 변경 시 동작	새로운 객체를 생성하고 참조를 변경	기존 객체의 내부 메모리 상태를 수정
함수 인자 전달 시	원본 값 보호됨 (재할당 전까지)	원본 데이터 직접 수정 가능 (위험)
메모리 ID (id())	변경 시 ID가 바뀜	변경 시에도 ID가 동일하게 유지됨
주요 용도	상수, 딕셔너리 키, 안전한 데이터 공유	동적 데이터 관리, 버퍼링, 누적 연산

---

2. 실무 사이드 이펙트 방지를 위한 7가지 해결 패턴 Sample Examples

파이썬 실무 개발 과정에서 리스트나 딕셔너리를 함수 인자로 넘길 때 발생할 수 있는 데이터 오염 문제를 해결하는 전문적인 예제입니다.

Example 1: 가변 객체 기본값 인자(Default Argument)의 함정 해결

파이썬에서 함수의 기본값은 정의 시점에 한 번만 평가됩니다. 리스트를 기본값으로 사용하면 모든 함수 호출이 동일한 리스트를 공유하게 됩니다.

# 위험한 방식: 호출마다 리스트가 누적됨
def add_item_bad(item, items=[]):
    items.append(item)
    return items

# 해결 방법: None을 활용한 지연 할당 패턴
def add_item_good(item, items=None):
    if items is None:
        items = [] # 함수 호출 시마다 새로운 리스트 생성
    items.append(item)
    return items

print(add_item_good("A")) # ['A']
print(add_item_good("B")) # ['B'] (누적되지 않음)

Example 2: 얕은 복사(Shallow Copy)의 한계와 해결 방법

단순 리스트 복사는 내부의 중첩된 객체(리스트 내의 리스트)까지 복사하지 못해 사이드 이펙트가 전이됩니다.

import copy

def process_nested_data(data_list):
    # 얕은 복사는 내부 리스트 참조를 공유함
    # deepcopy를 사용하여 계층 구조 전체를 독립적으로 분리
    safe_data = copy.deepcopy(data_list)
    safe_data[0][0] = "MODIFIED"
    return safe_data

original = [[1, 2], [3, 4]]
processed = process_nested_data(original)
print(original[0][0]) # 1 (원본 보호 성공)

Example 3: 불변 객체(Tuple)를 활용한 의도적 데이터 잠금

수정되어서는 안 되는 환경 설정값이나 상수 집합은 리스트 대신 튜플로 전달하여 런타임 에러를 유도, 실수 방지를 꾀합니다.

def configure_server(configs):
    try:
        # 튜플은 수정을 시도할 경우 TypeError 발생
        configs[0] = "127.0.0.1" 
    except TypeError:
        print("Safety Catch: Cannot modify immutable configs.")

# 리스트를 튜플로 변환하여 함수에 전달
server_settings = ("192.168.0.1", 8080)
configure_server(server_settings)

Example 4: 함수 내부에서의 지역적 재할당 vs 가변 수정 차이

할당 연산자(=)와 가변 메서드(.append, .update)의 차이를 명확히 인지해야 합니다.

def shadow_update(my_dict):
    # 이 방식은 새로운 지역 변수를 생성할 뿐 원본에 영향 없음
    my_dict = {"new_key": "new_val"} 

def real_update(my_dict):
    # 이 방식은 메모리 주소를 타고 들어가 원본을 수정함
    my_dict.update({"real_key": "real_val"})

data = {"initial": 1}
shadow_update(data) # 원본 그대로
real_update(data)   # 원본 수정됨

Example 5: 리스트 슬라이싱을 이용한 간편한 독립 복사 전달

가장 파이썬스러운(Pythonic) 방법으로 가변 객체의 복사본을 함수에 전달하는 방법입니다.

def sort_and_extract(input_list):
    # 슬라이싱 [:]은 1차원 리스트의 새로운 복사본을 만듦
    working_list = input_list[:]
    working_list.sort()
    return working_list[0]

scores = [90, 20, 50, 80]
top = sort_and_extract(scores)
print(scores) # [90, 20, 50, 80] (정렬 전 순서 유지)

Example 6: 문자열 결합 시의 성능 저하 해결 방법 (Join vs +)

불변 객체인 문자열을 '+'로 계속 더하면 매번 새로운 객체가 생성되어 메모리 오버헤드가 발생합니다.

# 나쁜 예: 불변 객체 특성상 매번 메모리 재할당 발생
raw_str = ""
for i in range(1000):
    raw_str += str(i)

# 좋은 예: 가변 리스트에 담았다가 한 번에 결합
list_buffer = []
for i in range(1000):
    list_buffer.append(str(i))
final_str = "".join(list_buffer)

Example 7: dataclasses를 활용한 Frozen 객체 생성 방법

사용자 정의 객체도 불변(Immutable) 속성을 부여하여 사이드 이펙트로부터 원천 봉쇄할 수 있습니다.

from dataclasses import dataclass

@dataclass(frozen=True)
class ImmutableUser:
    user_id: int
    username: str

user = ImmutableUser(1, "admin")
# user.username = "hacker" # FrozenInstanceError 발생

---

3. 사이드 이펙트를 방지하기 위한 아키텍처 가이드

함수가 인자로 받은 데이터를 수정하는 것은 '명령(Command)'과 '조회(Query)'의 분리 원칙에 어긋나는 경우가 많습니다. 데이터의 무결성을 지키기 위해 다음 규칙을 준수하십시오.

• Pure Function 지향: 입력 인자를 직접 수정하지 않고, 항상 새로운 결과값을 반환하는 함수를 작성하십시오.
• 명시적 복사: 가변 객체를 다룰 때는 함수 도입부에서 복사본을 만들거나, 호출부에서 복사본을 넘기십시오.
• 타입 힌트 활용: typing.Sequence나 typing.Mapping을 사용하여 읽기 전용 의도를 코드에 명시하십시오.

---

4. 결론

파이썬의 가변성과 불변성은 언어의 유연성을 극대화하지만, 동시에 Call by Object Reference라는 특징과 결합되어 예기치 못한 사이드 이펙트를 만들어냅니다. 리스트와 딕셔너리 같은 가변 객체를 다룰 때 복사 전략을 세우고, 상수성 데이터에는 튜플이나 프로즌세트를 사용하는 습관만으로도 시스템의 안정성을 2배 이상 높일 수 있습니다.

 

[내용 출처 및 참고 문헌]

• Python Official Documentation: "Data Model - Objects, values and types."
• Luciano Ramalho, "Fluent Python: Clear, Concise, and Effective Programming."
• Real Python, "Python's Mutable vs Immutable Types: What's the Difference?"
• Brett Slatkin, "Effective Python: 90 Specific Ways to Write Better Python."