[ENAI607] 연습문제 Set C — 중첩 데이터, 함수 객체, 날짜 클래스 풀이

Set C의 문제 7·8·9를 코드와 함께 읽는 풀이 노트다. 각 문제는 영어 원문 → 한국어 전체 번역 → 전체 코드와 실행 결과 → 요구사항별 코드 해설 → 실수와 변형 순서로 정리했다. 문제 본문은 일반 문단으로 읽을 수 있고, 코드와 출력 예시만 코드 블록으로 표시했다.

코드의 [P7.2-A], [P8.4-C], [P9.3-B] 주석은 원문의 요구사항 번호와 연결된다. 예를 들어 “실패한 날짜 변경은 원본을 유지해야 한다”는 요구사항은 [P9.3-B]의 검증 전에는 필드를 수정하지 않는 순서로 구현했다. 설명을 읽을 때 그 코드로 돌아가 확인하면 된다.

PDF의 영어 문구·점수·예시를 보존하되 반복 머리글과 쪽 번호는 제외했다. 한국어 번역에는 세부 제한과 예시도 포함했다. 원문의 출제 참고 범위는 번역해 남겼지만, 풀이 이해를 위해 슬라이드를 대조할 필요는 없다.

빠른 목차 — 막힌 개념에서 코드로 바로 찾기

0. 파일을 준비하고 실행하기

전체 풀이·테스트 ZIP을 같은 폴더에 풀면 된다. 세 문제 모두 Python 표준 라이브러리만 사용하므로 별도 패키지 설치가 필요 없다. VS Code·PyCharm에서 해당 폴더를 열고 같은 Python 인터프리터를 선택한다.

practice_set_c/
    student_records.py    # 문제 7: 중첩 자료구조와 복사 실험
    complex_samples.py    # 문제 8: 복소수와 함수 전달
    date_validation.py    # 문제 9: Date 클래스와 필수 예외 테스트
    test_set_c.py         # 19개 자동 테스트
    README.md

python student_records.py
python complex_samples.py
python date_validation.py
python test_set_c.py

터미널의 현재 위치가 파일을 푼 폴더인지 확인한다. PowerShell에서 따옴표로 감싼 Python 실행 파일 경로를 쓸 때는 앞에 &를 붙인다. 각 파일의 if __name__ == "__main__":는 직접 실행할 때만 main을 호출하도록 하는 부분이다. 테스트에서 import하면 시연 코드가 자동으로 실행되지 않는다.

문제 7. 학생 기록, 중첩 복사와 튜플 키

7-1. 문제 원문과 한국어 전체 번역

students = [
    {"name": "Jodie",   "grades": ["A", "A-", "B"]},
    {"name": "Paul",    "grades": ["C", "B", "B"]},
    {"name": "Krissie", "grades": ["A-", "A", "B", "A+", "A"]},
    {"name": "Peter",   "grades": ["D", "XF"]}
]
# After the three operations, students[2]["name"] is "Joel".
# After the operations, len(students) is 5.

accounts = {
    ("joe",  786): 123456,
    ("jill", 545): 444567,
    ("ted",  346): 578345,
    ("gwen", 172): 771988
}
# Expected: accounts[("jill", 545)] == 444567
# Expected: ("joe", 172) is absent.

products = [("widget", 5.28), ("gadget", 10.44),
            ("widget", 5.55), ("cool stuff", 6.87)]
# Expected sorted order starts with ("cool stuff", 6.87).

students = [
    {"name": "Jodie",   "grades": ["A", "A-", "B"]},
    {"name": "Paul",    "grades": ["C", "B", "B"]},
    {"name": "Krissie", "grades": ["A-", "A", "B", "A+", "A"]},
    {"name": "Peter",   "grades": ["D", "XF"]}
]
# 세 작업 후 students[2]["name"]은 "Joel"이다.
# 작업 후 len(students)는 5다.

accounts = {
    ("joe",  786): 123456,
    ("jill", 545): 444567,
    ("ted",  346): 578345,
    ("gwen", 172): 771988
}
# 예상: accounts[("jill", 545)] == 444567
# 예상: ("joe", 172)는 없다.

products = [("widget", 5.28), ("gadget", 10.44),
            ("widget", 5.55), ("cool stuff", 6.87)]
# 정렬된 결과의 시작은 ("cool stuff", 6.87)이다.

7-2. 전체 정답 코드와 실제 실행 결과

파일 이름: student_records.py. 아래 본문 코드와 다운로드 파일은 같다.

"""문제 7: 중첩 자료구조, 얕은 복사, 튜플 키와 기본 정렬."""


def create_students():
    students = [
        {"name": "Jodie", "grades": ["A", "A-", "B"]},
        {"name": "Paul", "grades": ["C", "B", "B"]},
        {"name": "Krissie", "grades": ["A-", "A", "B", "A+", "A"]},
        {"name": "Peter", "grades": ["D", "XF"]},
    ]
    # [P7.1-A] 리스트 -> 딕셔너리 -> 성적 리스트 순서로 찾아간다.
    students[2]["grades"].append("A")
    # [P7.1-B] 오른쪽 두 값을 먼저 구한 뒤 왼쪽 두 자리에 교환한다.
    grades = students[1]["grades"]
    grades[0], grades[1] = grades[1], grades[0]
    # [P7.1-C] 삽입 전 Krissie의 인덱스는 2다. 삽입 후에는 3이 된다.
    students.insert(2, {"name": "Joel", "grades": ["A", "C", "B", "B"]})
    return students


def demonstrate_copies(students):
    # [P7.2-A] 바깥 리스트만 새로 만든다. 내부 딕셔너리는 공유한다.
    backup = students.copy()
    backup[0]["grades"][0] = "B+"
    print("Original first grade after nested edit:", students[0]["grades"][0])
    # 공유 딕셔너리 안의 공유 성적 리스트를 수정했으므로 원본에도 보인다.
    old_name = students[0]["name"]
    # [P7.2-B] 이번에는 backup의 0번 칸이 가리키는 대상을 바꾼다.
    backup[0] = {"name": "Replacement", "grades": ["C"]}
    print("Original name changed:", students[0]["name"] != old_name)
    # [P7.2-C] 매번 새 딕셔너리와 새 성적 리스트를 만들어 공유를 끊는다.
    independent = [
        {"name": record["name"], "grades": record["grades"].copy()}
        for record in students
    ]
    independent[0]["grades"][0] = "A+"
    print("Independent first grade:", independent[0]["grades"][0])
    print("Original first grade:", students[0]["grades"][0])
    print("students is backup:", students is backup)
    # is는 같은 객체인지, ==는 값이 같은지를 비교한다.
    return backup, independent


def create_accounts():
    accounts = {
        ("joe", 786): 123456,
        ("jill", 545): 444567,
        ("ted", 346): 578345,
        ("gwen", 172): 771988,
    }
    # [P7.3] 키는 문자열 두 개가 아니라 (문자열, 정수) 튜플 하나다.
    print("Jill account:", accounts[("jill", 545)])
    print("(joe, 172) present:", ("joe", 172) in accounts)
    accounts[("ted", 346)] = 576644
    accounts[("sasha", 988)] = 111111
    del accounts[("gwen", 172)]
    print("Remaining accounts:", len(accounts))
    return accounts


def sort_products():
    products = [("widget", 5.28), ("gadget", 10.44),
                ("widget", 5.55), ("cool stuff", 6.87)]
    # [P7.4] 첫 원소(이름)부터 비교하고, 같으면 다음 원소(가격)를 비교한다.
    products.sort()
    return products


def main():
    students = create_students()
    print("Student count:", len(students))
    third = students[2]  # 세 번째 학생은 인덱스 2: 원문의 Joel 예시와 일치한다.
    print("Third student:", third["name"], "grade count:", len(third["grades"]))
    print("Paul grades:", students[1]["grades"])
    print("Krissie grades:", students[3]["grades"])
    demonstrate_copies(students)
    create_accounts()
    print("Sorted products:", sort_products())


if __name__ == "__main__":
    main()

실제 실행 결과:

Student count: 5
Third student: Joel grade count: 4
Paul grades: ['B', 'C', 'B']
Krissie grades: ['A-', 'A', 'B', 'A+', 'A', 'A']
Original first grade after nested edit: B+
Original name changed: False
Independent first grade: A+
Original first grade: B+
students is backup: False
Jill account: 444567
(joe, 172) present: False
Remaining accounts: 4
Sorted products: [('cool stuff', 6.87), ('gadget', 10.44), ('widget', 5.28), ('widget', 5.55)]

7-3. 코드를 읽는 해설 — 같은 내부 객체를 보고 있는가?

P7.1: 대괄호를 왼쪽부터 하나씩 해석한다

students[2]["grades"].append("A")

[2]는 리스트의 위치, ["grades"]는 딕셔너리의 키다. 대괄호 모양이 같아도 왼쪽 객체의 타입에 따라 의미가 달라진다. 첫 번째 성적까지 내려가려면 students[2]["grades"][0]이다. students[2][0]은 성적을 뜻하지 않는다. 딕셔너리에서 숫자 키 0을 찾으려다 KeyError가 난다.

append()는 성적 리스트를 직접 수정한다. students[2]["grades"] = students[2]["grades"].append("A")처럼 쓰면 반환값 None이 저장되어 성적 리스트를 잃는다. 수정 메서드의 실행 결과를 다시 대입하지 않는다.

grades = students[1]["grades"]도 복사는 아니다. 두 이름이 같은 성적 리스트를 가리키므로 grades[0], grades[1] = grades[1], grades[0]이 Paul의 실제 성적을 바꾼다. 오른쪽의 원래 두 값을 먼저 구하므로 임시 변수 없이 교환할 수 있다.

insert(i, value)는 기존 i번 원소 앞에 삽입한다. 따라서 성적 추가는 Krissie가 2번일 때 먼저 하고, Joel을 삽입한 뒤 Krissie를 출력할 때는 3번을 사용한다. 세 번째 학생은 students[2]인 Joel이다. 원문의 “third student (counting from index 0)” 표현은 뒤에 주어진 students[2]["name"] == "Joel" 예시와 함께 읽으면 된다. 인덱스 3 학생을 요구한 것으로 해석하지 않았다.

성적 개수는 len(students[2]["grades"])다. len(students[2])는 딕셔너리 키 개수인 2를 센다. 이 자료의 성적 개수는 학생 순서대로 3·3·4·6·2다.

P7.2: copy()는 어디까지 새로 만드는가?

backup = students.copy()
backup[0]["grades"][0] = "B+"

copy()로 바깥 리스트는 새로 생겼다. 그러나 각 칸에는 기존 딕셔너리를 가리키는 참조가 복사된다. students[0]과 backup[0]은 여전히 같은 딕셔너리이며, 그 안의 성적 리스트도 같다.

“내부 객체를 바꾸기”와 “내 리스트의 한 칸을 다른 객체로 교체하기”를 구분하면 된다. backup[0]["name"] = "Replacement"였다면 공유 딕셔너리의 이름을 바꾸므로 원본 이름도 바뀐다. 실제 풀이의 backup[0] = {...}와는 다른 동작이다.

independent = [
    {"name": record["name"], "grades": record["grades"].copy()}
    for record in students
]

이 컴프리헨션의 반복 대상은 학생 딕셔너리다. 한 번 반복할 때마다 {...}로 새 딕셔너리를 만들고, .copy()로 새 성적 리스트를 만든다. 이름과 성적 문자열은 불변이므로 문자열 자체까지 복제할 필요는 없다. 그래서 independent[0]["grades"][0] = "A+"는 원본의 B+를 유지한다.

[record.copy() for record in students]만으로는 부족하다. 딕셔너리는 새로 만들지만 그 안의 성적 리스트는 공유한다. 현재 스키마는 “딕셔너리 안에 문자열 리스트 하나”이므로 풀이의 복사가 충분하다. 성적 원소까지 리스트·딕셔너리인 더 깊은 구조로 바뀌면 그 깊이도 따로 복사해야 한다. 이 코드를 임의의 깊이에 대응하는 범용 깊은 복사로 외우면 안 된다.

is는 객체 동일성, ==는 값의 동등성이다. “값이 같으니까 같은 객체”도 아니고 “객체가 다르니까 값도 다름”도 아니다. 예를 들어 [1, 2] == [1, 2]는 참이지만 따로 만든 두 리스트는 별개다.

P7.3: 튜플 두 항목이 합쳐져 키 하나다

accounts[("jill", 545)]       # 444567
("joe", 172) in accounts     # False
accounts[("ted", 346)] = 576644
del accounts[("gwen", 172)]

accounts[("jill", 545)]는 키 두 개를 차례대로 조회하는 코드가 아니다. ("jill", 545)라는 튜플 하나를 키로 조회한다. accounts["jill"][545]였다면 바깥 딕셔너리에서 "jill"을 찾은 뒤 다시 인덱싱하는 전혀 다른 구조다.

키가 ("joe", 786)인 항목이 있어도 ("joe", 172)는 없다. 두 원소가 모두 일치해야 같은 키다. in accounts는 기본적으로 값이 아닌 키를 검사하며, 키가 없어도 예외 없이 False를 준다. 없는 키를 바로 accounts[("joe", 172)]로 읽으면 KeyError가 난다.

딕셔너리 대입은 키가 이미 있으면 값 수정, 없으면 새 항목 추가다. 따라서 Ted 수정으로 개수가 늘지는 않는다. 처음 4개 → Sasha 추가로 5개 → Gwen 삭제로 4개다.

키는 해시 가능한 객체여야 한다. 이 문제의 튜플 원소인 문자열과 정수는 해시 가능하다. 리스트 자체는 키가 될 수 없고, 튜플이어도 안에 리스트가 들어 있으면 키로 사용할 수 없다. “튜플이면 언제나 딕셔너리 키가 가능하다”로 외우지 않는다.

P7.4: key가 없으면 튜플 자체를 왼쪽부터 비교한다

products.sort()
# [('cool stuff', 6.87), ('gadget', 10.44),
#  ('widget', 5.28), ('widget', 5.55)]

먼저 이름을 비교하여 cool stuff → gadget → widget 순이다. 이름이 같은 widget 두 개는 두 번째 원소 가격을 비교하여 5.28 → 5.55가 된다. 가격 전체를 기준으로 정렬한 결과가 아니다. 그래서 더 저렴한 widget 5.28보다 gadget 10.44가 앞선다.

products.sort()는 원본 리스트를 정렬하고 None을 반환한다. products = products.sort()라고 쓰지 않는다. 앞선 Set A는 sorted(..., key=lambda ...)가 요구사항이었지만, 이번 문제는 key 없는 .sort() 자체가 요구사항이다.

7-4. 실수와 변형 — 자료구조에서 어느 층을 바꿀까?

복사 문제를 풀 때는 값 출력만 보지 말고 independent[i] is students[i], independent[i]["grades"] is students[i]["grades"]도 확인해 보자. 둘 다 False여야 이 문제의 내부 리스트 독립성까지 증명된다.

문제 8. 복소수와 함수 객체 전달

8-1. 문제 원문과 한국어 전체 번역

print(rec_to_pol(1 + 1j))
# approximately (1.4142135623730951, 0.7853981633974483)
print(rec_to_pol(3 + 4j))
# approximately (5.0, 0.9272952180016122)

names = ["S1", "S2", "S3", "EXTRA"]
samples = [1 + 1j, 3 + 4j, -1 + 1j]
print(create_tuple(names, samples, 2))
# (('S1', (1+1j)), ('S2', (3+4j)))
print(create_tuple(names, samples, 4))  # None

print(apply_gain(3 + 4j))
print(apply_gain(3 + 4j, 2))
print(apply_gain(3 + 4j, gain=0.5))

print(rec_to_pol(1 + 1j))
# 대략 (1.4142135623730951, 0.7853981633974483)
print(rec_to_pol(3 + 4j))
# 대략 (5.0, 0.9272952180016122)

names = ["S1", "S2", "S3", "EXTRA"]
samples = [1 + 1j, 3 + 4j, -1 + 1j]
print(create_tuple(names, samples, 2))
# (('S1', (1+1j)), ('S2', (3+4j)))
print(create_tuple(names, samples, 4))  # None

print(apply_gain(3 + 4j))
print(apply_gain(3 + 4j, 2))
print(apply_gain(3 + 4j, gain=0.5))

8-2. 전체 정답 코드와 실제 실행 결과

파일 이름: complex_samples.py. 아래 본문 코드와 다운로드 파일은 같다.

"""문제 8: 복소수, 튜플, 인자 전달과 일급 함수."""
import math

# [P8.4-A] 함수 바깥, 모듈 전체에서 사용하는 누적 카운터다.
conversion_count = 0


def rec_to_pol(x):
    global conversion_count
    # [P8.1] atan2의 순서는 (허수부, 실수부)이며 각도 단위는 라디안이다.
    magnitude = abs(x)
    phase = math.atan2(x.imag, x.real)
    # 계산이 성공한 뒤에만 횟수를 증가시킨다.
    conversion_count += 1
    # magnitude와 phase는 이 호출 안에서만 사용하는 지역 변수다.
    return magnitude, phase  # 쉼표로 두 값을 묶으면 튜플이다.


def create_tuple(names, samples, num):
    # [P8.2-A] zip이 짧은 쪽에서 멈추기 전에 요청 개수를 검증한다.
    if len(names) < num or len(samples) < num:
        return None
    # [P8.2-B] 필요한 앞부분만 짝짓고, 바깥 결과를 튜플로 만든다.
    return tuple(zip(names[:num], samples[:num]))


def apply_gain(x, gain=1.0):
    # [P8.3] complex는 불변이다. 곱의 결과를 반환하며 x 자체를 수정하지 않는다.
    return x * gain


def apply_function(samples, operation):
    # [P8.4-B] operation에는 abs나 rec_to_pol 같은 함수 자체가 들어온다.
    result = []
    for value in samples:
        result.append(operation(value))
    return result


def main():
    # 음의 실수부까지 검사한다. 이 직접 호출들도 카운터에 포함된다.
    for x in (1 + 1j, 3 + 4j, -1 + 1j):
        print("Polar:", x, rec_to_pol(x))
    names = ["S1", "S2", "S3", "EXTRA"]
    samples = [1 + 1j, 3 + 4j, -1 + 1j]
    print("Paired samples:", create_tuple(names, samples, 2))
    print("Too many requested:", create_tuple(names, samples, 4))
    print("Zero requested:", create_tuple(names, samples, 0))
    x = 3 + 4j
    # [P8.3] 각각 기본 인자, 위치 인자, 키워드 인자 사용이다.
    gained = [apply_gain(x), apply_gain(x, 2), apply_gain(x, gain=0.5)]
    for value in gained:
        print(f"Gain result: {value.real:.2f}{value.imag:+.2f}j")
    print("Original complex:", x)
    print("Magnitudes:", apply_function(samples, abs))
    # [P8.4-C] 괄호 없이 함수를 전달한다. 반복문 안에서 세 번 호출된다.
    before = conversion_count
    print("Polar samples:", apply_function(samples, rec_to_pol))
    print("Conversions in this batch:", conversion_count - before)
    print("Total conversions:", conversion_count)
    print("Original samples:", samples)


if __name__ == "__main__":
    main()

실제 실행 결과:

Polar: (1+1j) (1.4142135623730951, 0.7853981633974483)
Polar: (3+4j) (5.0, 0.9272952180016122)
Polar: (-1+1j) (1.4142135623730951, 2.356194490192345)
Paired samples: (('S1', (1+1j)), ('S2', (3+4j)))
Too many requested: None
Zero requested: ()
Gain result: 3.00+4.00j
Gain result: 6.00+8.00j
Gain result: 1.50+2.00j
Original complex: (3+4j)
Magnitudes: [1.4142135623730951, 5.0, 1.4142135623730951]
Polar samples: [(1.4142135623730951, 0.7853981633974483), (5.0, 0.9272952180016122), (1.4142135623730951, 2.356194490192345)]
Conversions in this batch: 3
Total conversions: 6
Original samples: [(1+1j), (3+4j), (-1+1j)]

8-3. 코드를 읽는 해설 — 함수를 넘기고, 안에서 호출한다

P8.1: 복소수의 실수부·허수부로 크기와 각도를 구한다

3 + 4j는 실수부 3, 허수부 4인 복소수다. Python에서 허수 단위는 j로 적는다. x.real과 x.imag는 속성이므로 x.real()처럼 호출하지 않는다.

크기는 실수부²+허수부²의 제곱근이다. abs()는 복소수에서도 이 크기를 계산한다. math.atan2(y, x)는 세로 좌표가 먼저 들어간다. 순서를 반대로 쓰면 각도가 달라진다.

왜 math.atan(x.imag / x.real)로 쓰면 안 될까? 1+1j와 -1-1j는 그 비율이 모두 1이지만 실제 방향은 다르다. 실수부 0에서는 나눗셈도 불가능하다. atan2는 두 좌표의 부호를 함께 사용해 사분면을 구분한다. 예를 들어 -1+1j의 위상은 약 2.3562 라디안이다.

반환값은 튜플이므로 magnitude, phase = rec_to_pol(x)로 풀어 받을 수 있다. return [magnitude, phase]는 리스트여서 요구사항과 다르다. 함수 내부에서 print()만 하면 호출자에게 결과가 전달되지 않는다. 풀이에서는 반환은 함수 안에서, 출력은 호출한 곳에서 한다.

문제가 각도를 도 단위로 바꾸라고 하면 math.degrees(phase)를 사용할 수 있다. 그러나 현재 반환 단위는 반드시 라디안이다. 0j는 크기 0이며 방향은 수학적으로 정해지지 않는다. 이 구현은 요구한 atan2의 동작에 따라 각도 0.0을 반환한다.

P8.2: zip의 자동 종료가 이 문제에서는 함정이다

if len(names) < num or len(samples) < num:
    return None
return tuple(zip(names[:num], samples[:num]))

이 코드는 검증 → 잘라내기 → 짝짓기 → 튜플로 확정 순서다.

1. 둘 중 하나라도 요청 개수보다 짧으면 None이다. 따라서 and가 아니라 or를 사용한다.
2. names[:num]과 samples[:num]은 각각 앞에서 num개다. 끝 인덱스는 포함하지 않는다.
3. zip()이 같은 위치의 원소를 (이름, 복소수) 튜플로 묶는다.
4. tuple()이 zip 반복자를 소비하여 바깥 튜플을 만든다.

슬라이싱은 범위를 넘겨도 보통 오류를 내지 않고, zip은 짧은 쪽에 맞춰 끝난다. 길이 검사 없이 tuple(zip(names[:4], samples[:4]))만 쓰면 4개를 요청했는데도 3개짜리를 반환한다. 바로 이 상황을 문제에서 금지했다.

반환값 None과 빈 튜플 ()도 구분하자. None은 요청을 충족할 수 없다는 실패 신호, ()는 0개 요청을 정상적으로 처리한 결과다. num이 음수가 아닌 정수라는 조건은 문제에서 보장하므로 추가 검증을 요구하지 않는다.

P8.3: 위치 인자·키워드 인자·기본값은 같은 매개변수에 도착한다

def apply_gain(x, gain=1.0):
    return x * gain

gain=1.0은 함수 정의에서 생략했을 때 쓸 기본값이고, 호출의 gain=0.5는 어느 매개변수에 넣을지 지정한 키워드 인자다. 모양은 비슷해도 사용 위치에 따라 역할이 다르다.

complex는 불변이다. 곱셈은 계산된 값을 돌려주며 원래 x를 변경하지 않는다. 리스트 복사와 달리 x.copy()를 할 필요도, 그런 메서드도 없다. gain이 1일 때조차 “반드시 별도 객체인가”를 is로 검사할 필요는 없다. 요구사항의 핵심은 결과 값과 원본 불변성이다.

표시만 소수점 두 자리로 만들 때는 f"{value.real:.2f}{value.imag:+.2f}j"를 사용했다. .2f는 소수점 두 자리, +는 허수부가 양수여도 + 부호를 표시한다. 함수의 실제 반환값을 문자열로 바꾸거나 반올림한 것은 아니다.

P8.4: rec_to_pol과 rec_to_pol(x)는 전혀 다른 인자다

apply_function(samples, rec_to_pol)

이때 operation = rec_to_pol처럼 함수 자체가 매개변수에 들어온다. apply_function 내부의 operation(value)에서 비로소 호출된다.

함수를 전달할 때는 이름, 함수를 실행할 때는 이름(인자)로 읽자. 함수도 변수에 담고 다른 함수에 넘길 수 있는 객체라는 것이 일급 함수의 핵심이다. 이 문제에서는 lambda를 새로 만들 필요가 없다.

result = []
for value in samples:
    result.append(operation(value))
return result

첫 표본 1+1j에 operation이 abs라면 약 1.4142가 추가된다. operation이 rec_to_pol이면 (1.4142..., 0.7854...) 튜플이 추가된다. 같은 반복문에서 전달한 함수에 따라 결과 타입이 달라진다. 앞의 것은 숫자 리스트, 뒤의 것은 튜플 리스트다. 원본 samples에는 대입하거나 append하지 않으므로 그대로 남는다.

전역 카운터: 왜 3번 처리했는데 누적값은 6일까?

conversion_count = 0

def rec_to_pol(x):
    global conversion_count
    magnitude = abs(x)
    phase = math.atan2(x.imag, x.real)
    conversion_count += 1
    return magnitude, phase

magnitude와 phase는 매 호출 안에서 쓰는 지역 변수다. conversion_count는 함수 바깥에서 정의한 전역 변수다. += 1은 값을 읽기만 하는 것이 아니라 새 정수 값을 전역 이름에 다시 대입한다. 그래서 global conversion_count가 필요하다. 선언을 빼면 이 이름을 지역 변수로 판단한 채 초기값을 읽으려 하므로 UnboundLocalError가 난다.

함수 안에서 카운터를 0으로 초기화하면 매번 다시 시작하므로 안 된다. 또한 계산이 성공한 뒤 증가시켜야 실패한 호출을 세지 않는다.

따라서 batch 직전의 before = conversion_count를 저장하고 conversion_count - before로 이번 처리 횟수 3을 출력한다. 전체 누적값은 6이다. 둘을 함께 표시해 직접 호출까지 누적된다는 요구사항을 드러냈다. 확인하려고 rec_to_pol을 한 번 더 실행하는 것조차 카운터를 바꾼다.

8-4. 실수와 변형 — 반환 타입·인자·호출 횟수 점검

테스트에서 전역 카운터를 보고 싶으면 import complex_samples as cs 후 cs.conversion_count를 읽으면 된다. from complex_samples import conversion_count로 정수 값을 가져온 뒤 모듈의 이름이 새 정수로 갱신되어도, 가져온 쪽 이름이 자동으로 같은 값으로 재대입되지는 않는다.

문제 9. 윤년 검증과 안전한 Date 클래스

9-1. 문제 원문과 한국어 전체 번역

# Leap-year cases that your logic must distinguish:
# 1600: leap year       1700: not a leap year
# 1900: not a leap year 2000: leap year
# 2024: leap year       2023: not a leap year

# Selected expected outcomes:
# str(Date(2000, 2, 29)) == "February 29, 2000"
# set_date(2023, 2, 29) on a valid 2024-02-29 object -> False
# The object still represents February 29, 2024.
# set_date(2023, 3, 1) -> True; date is March 1, 2023.

# 윤년 로직이 구분해야 하는 경우:
# 1600: 윤년       1700: 평년
# 1900: 평년       2000: 윤년
# 2024: 윤년       2023: 평년

# 예상 결과 일부:
# str(Date(2000, 2, 29)) == "February 29, 2000"
# 유효한 2024-02-29 객체에서 set_date(2023, 2, 29) -> False
# 객체는 여전히 February 29, 2024를 나타낸다.
# set_date(2023, 3, 1) -> True; 날짜는 March 1, 2023이다.

9-2. 전체 정답 코드와 실제 실행 결과

파일 이름: date_validation.py. 아래 본문 코드와 다운로드 파일은 같다.

"""문제 9: 윤년 검사와 검증 후에만 변경하는 Date 클래스."""


class Date:
    # [P9.1-A] 모든 객체가 함께 참조하는 조회표다. 튜플로 두어 실수로 바꾸지 않는다.
    DAYS_PER_MONTH = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
    MONTH_NAMES = ("January", "February", "March", "April", "May", "June",
                   "July", "August", "September", "October", "November", "December")

    def __init__(self, year, month, day):
        # [P9.1-B] 잘못된 날짜로 객체가 생성되지 않게 먼저 검증한다.
        if not self.__valid_date(year, month, day):
            raise ValueError("Invalid date")
        self.__year = year
        self.__month = month
        self.__day = day

    def __valid_date(self, year, month, day):
        # [P9.2-A] bool도 isinstance(..., int)는 True이므로 여기서는 정확한 int만 허용한다.
        if type(year) is not int or type(month) is not int or type(day) is not int:
            return False
        # 월을 인덱스로 쓰기 전에 범위를 확인해야 한다.
        if year <= 0 or not 1 <= month <= 12:
            return False
        # [P9.2-B] 월 1~12를 조회표 인덱스 0~11로 바꾼다.
        max_day = self.DAYS_PER_MONTH[month - 1]
        leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
        if month == 2 and leap:
            max_day = 29  # 지역 변수만 바꾼다. 공유 조회표는 그대로 둔다.
        return 1 <= day <= max_day

    def get_year(self):
        return self.__year

    def get_month(self):
        return self.__month

    def get_day(self):
        return self.__day

    def __str__(self):
        # [P9.3-A] 화면에 출력하지 말고 문자열을 반환한다.
        name = self.MONTH_NAMES[self.__month - 1]
        return f"{name} {self.__day}, {self.__year}"

    def set_date(self, year, month, day):
        # [P9.3-B] 세 값 전체를 검증하기 전에는 어떤 필드도 수정하지 않는다.
        if not self.__valid_date(year, month, day):
            print("Invalid date")
            return False
        self.__year = year
        self.__month = month
        self.__day = day
        return True


def main():
    print(Date(2000, 2, 29))
    print(Date(2024, 2, 29))
    # [P9.4-A] 예외를 잡아야 다음 테스트까지 계속 실행할 수 있다.
    for year, month, day in [(1900, 2, 29), (2023, 2, 29), (2024, 4, 31)]:
        try:
            Date(year, month, day)
        except ValueError as error:
            print(f"Rejected {year}-{month:02d}-{day:02d}: {error}")
    date = Date(2024, 2, 29)
    print("Invalid update accepted:", date.set_date(2023, 2, 29))
    print("After invalid update:", date)
    print("Valid update accepted:", date.set_date(2023, 3, 1))
    print("After valid update:", date)


if __name__ == "__main__":
    main()

실제 실행 결과:

February 29, 2000
February 29, 2024
Rejected 1900-02-29: Invalid date
Rejected 2023-02-29: Invalid date
Rejected 2024-04-31: Invalid date
Invalid date
Invalid update accepted: False
After invalid update: February 29, 2024
Valid update accepted: True
After valid update: March 1, 2023

9-3. 코드를 읽는 해설 — 먼저 검증하고, 통과하면 저장한다

P9.1: 공통 조회표와 객체마다 다른 날짜를 나눈다

조회표는 클래스 본문에 한 번 정의하고, 인스턴스 필드는 생성자의 self에 저장한다. 예를 들어 Date(2000, 2, 29)와 Date(2024, 2, 29)는 같은 월 이름 표를 보지만 연도 필드는 다르다.

문제는 조회표가 리스트인지 튜플인지 지정하지 않았다. 풀이에서는 수정할 필요 없는 공통 표를 튜플로 정의했다. 각 객체에서 표를 바꾸는 대신 필요한 일수만 지역 변수로 계산한다.

__year처럼 앞에 밑줄 두 개를 붙이면 클래스 이름을 포함하도록 이름이 변환되는 name mangling이 적용된다. 외부에서 date.__year로 바로 읽는 방식을 피하고 getter를 사용한다. 이것은 보안 장벽이라기보다 의도치 않은 접근·이름 충돌을 줄이는 장치다. __str__처럼 앞뒤에 두 개가 있는 특수 메서드는 같은 방식으로 생각하지 않는다.

P9.2: 타입 → 범위 → 월별 일수 순서가 중요하다

if type(year) is not int or type(month) is not int or type(day) is not int:
    return False
if year <= 0 or not 1 <= month <= 12:
    return False
max_day = self.DAYS_PER_MONTH[month - 1]

문자열 연도를 정수와 비교하거나 실수 월을 리스트 인덱스로 사용하기 전에 타입을 확인한다. 이번 구현은 bool도 정수 날짜로 받지 않는 정책이다. Python에서 isinstance(True, int)는 참이므로 정확한 int를 확인했다. 숫자 문자열 "2024"나 정수와 값이 같은 2024.0을 임의로 변환해서 허용하지 않는다.

월은 112지만 표의 인덱스는 011이다. 그래서 month - 1이다. 2월은 인덱스 1에서 28을 가져온다. 월 범위를 먼저 검사하지 않으면 월 0이 인덱스 -1로 바뀌어 12월을 읽는 오류가 생긴다. 13월은 인덱스 범위 오류가 날 수 있다.

leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
if month == 2 and leap:
    max_day = 29
return 1 <= day <= max_day

%는 나머지다. year % 4 == 0은 “4로 나누어떨어진다”라는 뜻이다. “4의 배수” 조건 하나만으로는 1900년을 잘못 받아들인다.

왼쪽 묶음은 “4의 배수이면서 100의 배수는 아니다”, 오른쪽은 “400의 배수다”다. 둘 중 하나가 참이면 된다. 괄호로 논리 묶음을 드러내면 시험 때 읽기 쉽다. 단순히 year % 4 == 0 and year % 100 != 0로 끝내면 2000년을 잘못 거부한다.

윤년이어도 4월은 여전히 30일이다. 2월이면서 윤년일 때만 max_day를 29로 바꾼다. self.DAYS_PER_MONTH를 수정하지 않으므로 윤년 객체를 만든 뒤 평년 날짜를 검사해도 2월 기준이 28로 유지된다.

__valid_date()는 전달받은 year·month·day를 검사해야 한다. self.__year 같은 기존 필드를 읽어서 검사하면 아직 필드가 없는 생성자에서는 오류가 나고, setter에서는 새 제안이 아닌 예전 날짜를 검사하게 된다.

P9.3: 생성 실패와 갱신 실패의 규칙이 다르다

둘 다 self.__valid_date(...)를 호출한다. 같은 검증을 복제하면 생성자에서 고친 윤년 로직이 setter에는 빠지는 문제가 생길 수 있다.

생성자가 실패할 때 return False로 처리하면 안 된다. __init__()는 별도 값을 반환하는 일반 함수가 아니며, None 이외를 반환하면 오류다. 잘못된 객체의 생성을 막기 위해 예외를 발생시키라는 문제 규칙을 따른다.

반대로 setter는 이미 존재하는 유효한 객체를 대상으로 한다. 실패해도 이전 날짜가 유효하게 남아 있어야 한다. 아래와 같은 순서는 잘못이다.

# 잘못된 순서: 새 날짜를 검증하기 전에 원래 연도를 잃는다.
self.__year = year
if not self.__valid_date(year, month, day):
    return False

2024-02-29에 2023-02-29를 제안하면 연도만 2023으로 바뀌어, 거부했는데 객체 안에는 유효하지 않은 날짜가 남는다. 풀이에서는 실패 경로에 필드 대입이 하나도 없다.

“연도는 유효하니까 먼저 저장”처럼 한 필드씩 검증·갱신하지 말고, 전체 날짜 검증이 끝난 뒤 세 필드를 저장한다. 2월의 허용 일수는 연도와 함께 결정되므로 필드들이 서로 독립적이지 않다.

__str__는 출력문이 아니라 문자열을 돌려주는 메서드다

name = self.MONTH_NAMES[self.__month - 1]
return f"{name} {self.__day}, {self.__year}"

2월이면 MONTH_NAMES의 인덱스 1에서 "February"를 얻는다. 반환 형식은 월 이름 + 공백 + 일 + 쉼표 + 공백 + 연도다. print(date)나 str(date)가 이 문자열을 사용한다. 메서드 내부에서 print(...)만 하면 기본 반환값은 None이므로 __str__ returned non-string 오류가 난다.

getter는 단순히 자기 필드를 반환한다. get_year()에 유효성 검사 전체를 다시 넣을 필요는 없다. 생성과 갱신을 통과한 객체의 값을 읽는 역할이다.

P9.4: 예외를 잡아야 거부된 다음 경우도 테스트한다

try:
    Date(1900, 2, 29)
except ValueError as error:
    print(error)  # Invalid date

try 안에서 생성자가 ValueError를 발생시키면 그 아래 코드를 건너뛰고 except로 간다. 예외를 처리한 뒤 다음 테스트를 진행한다. 잘못된 날짜 세 개를 한 try 안에 연속으로 만들면 첫 실패 뒤의 두 호출은 실행되지 않는다. 그래서 풀이에서는 반복문 안에 try/except를 두어 각각 검사한다.

print("Invalid update accepted:", date.set_date(...))는 인자를 계산하는 과정에서 setter를 먼저 실행한다. setter의 Invalid date가 먼저 출력되고, 그 뒤 바깥 print가 Invalid update accepted: False를 출력한다. 실행 결과의 두 줄 순서는 이 때문이다.

9-4. 실수와 변형 — 경계와 상태 보존이 점수다

유효하지 않은 입력을 막는 것만으로 충분하지 않다. 실패 이후 객체의 세 필드가 원래 그대로인지 확인해야 안전한 갱신을 증명할 수 있다.

10. 검증 — 예제 외에 확인한 것

test_set_c.py의 19개 테스트가 모두 통과했다. 각 테스트 안에서 여러 입력과 경계값을 추가로 확인했다. 프로그램의 출력만 비교하지 않고, 객체가 실제로 공유·분리됐는지와 실패 뒤의 상태까지 검사했다.

테스트의 unittest, patch 등은 검증 도구다. 풀이의 핵심으로 외울 부분은 본문의 일반 Python 코드다. 현재 구현은 날짜에서 bool을 거부하고, 문제 8의 num은 문제에서 보장한 비음수 정수라는 전제를 따른다.

11. 코드로 되짚는 마지막 확인

• P7.1: 지금 사용하는 인덱스가 Joel 삽입 전인가, 후인가? len()이 성적 리스트를 세고 있는가?
• P7.2: 바깥 리스트만 새로 생겼는가? 내부 dict와 grades 리스트도 새로 생겼는가? 내부 수정과 바깥 칸 재대입을 구분했는가?
• P7.3: 키가 (문자열, 정수) 튜플 하나인가? 없는 키는 in으로 검사했는가?
• P7.4: .sort()에 key를 넣지 않았는가? 이름이 같으면 가격을 비교한다는 사실을 설명할 수 있는가?
• P8.1: atan2(허수부, 실수부)이고 크기·라디안 위상 순서의 튜플인가?
• P8.2: zip 전에 양쪽 길이를 검사했는가? 0개는 (), 부족한 요청은 None인가?
• P8.3: 기본·위치·키워드 인자를 각각 시연하고, 원래 복소수는 유지되는가?
• P8.4: 전달은 rec_to_pol, 내부 호출은 operation(value)인가? 직접 호출도 누적 카운터에 포함했는가?
• P9.1–2: 타입·월 범위 검사 전에 조회표를 읽지 않는가? 1900년과 2000년 결과가 다른가? 같은 private helper를 사용하는가?
• P9.3–4: 검증 전에 필드를 하나라도 바꾸지 않는가? 생성 실패는 ValueError, 갱신 실패는 출력·False·상태 유지인가?

관련 개념을 더 찾아보려면 리스트·튜플·슬라이싱, 딕셔너리·함수·인자와 전역 범위, 예외 처리·모듈, 클래스·private·클래스 변수 글로 이어진다. Set A와 Set B는 다른 요구사항을 같은 방식으로 코드에 연결한다.