18. Python 데이터와 객체 모델: 참조, 비교, 복사

# 서로 다른 타입의 객체 생성하기
number = 42
text = "Hello"
items = [1, 2, 3]
 
# 이 변수들 각각은 메모리의 어떤 객체를 가리킵니다
print(number)  # Output: 42
print(text)    # Output: Hello
print(items)   # Output: [1, 2, 3]

# 정수는 메서드를 가진 객체입니다
number = 42
print(number.bit_length())  # Output: 6
 
# 문자열은 메서드를 가진 객체입니다
text = "hello"
print(text.upper())  # Output: HELLO
 
# 리스트는 메서드를 가진 객체입니다
items = [3, 1, 2]
items.sort()
print(items)  # Output: [1, 2, 3]

# 리스트 객체 생성하기
original = [1, 2, 3]
 
# 이것은 새 리스트를 만들지 않습니다 - 또 다른 참조를 만들 뿐입니다
# 동일한 리스트 객체를 가리키도록 합니다
another_name = original
 
# 한 참조를 통해 수정하면 다른 쪽에도 영향을 줍니다
another_name.append(4)
 
print(original)      # Output: [1, 2, 3, 4]
print(another_name)  # Output: [1, 2, 3, 4]

# 객체 생성 후 동일성 확인하기
x = [1, 2, 3]
y = [1, 2, 3]
z = x
 
print(id(x))  # Output: 140234567890123 (example - actual number varies)
print(id(y))  # Output: 140234567890456 (different from x)
print(id(z))  # Output: 140234567890123 (same as x)

# 같은 성적을 가진 두 학생
student1_grades = [85, 90, 92]
student2_grades = [85, 90, 92]
 
# 이들은 서로 다른 객체입니다(동일성이 다름)
print(id(student1_grades))  # Output: 140234567890123 (example)
print(id(student2_grades))  # Output: 140234567890456 (different)
 
# 하나를 수정해도 다른 하나에는 영향을 주지 않습니다
student1_grades.append(88)
print(student1_grades)  # Output: [85, 90, 92, 88]
print(student2_grades)  # Output: [85, 90, 92]

# 한 학생의 성적을 두 변수가 추적하는 경우
original_grades = [85, 90, 92]
backup_reference = original_grades
 
# 이들은 같은 객체를 가리킵니다(동일성이 같음)
print(id(original_grades))    # Output: 140234567890123 (example)
print(id(backup_reference))   # Output: 140234567890123 (same!)
 
# 어느 이름으로 수정하든 둘 다 영향을 받습니다
backup_reference.append(88)
print(original_grades)     # Output: [85, 90, 92, 88]
print(backup_reference)    # Output: [85, 90, 92, 88]

# 서로 다른 타입의 객체
number = 42
text = "Hello"
items = [1, 2, 3]
mapping = {"name": "Alice"}
 
print(type(number))   # Output: <class 'int'>
print(type(text))     # Output: <class 'str'>
print(type(items))    # Output: <class 'list'>
print(type(mapping))  # Output: <class 'dict'>

# 타입은 생성 시 고정됩니다
x = 42
print(type(x))  # Output: <class 'int'>
 
# 이것은 x의 타입을 바꾸지 않습니다 - 새로운 문자열 객체를 만들고
# 대신 x가 그 새 객체를 가리키게 합니다
x = str(x)
# 원래 정수 객체(42)는 가비지 컬렉션될 때까지 메모리에 존재합니다
# 이제 x는 완전히 다른 객체, 즉 문자열 "42"를 가리킵니다
 
print(type(x))  # Output: <class 'str'>
print(x)        # Output: 42 (이제는 정수가 아니라 문자열)

# 리스트는 append를 지원합니다
grades = [85, 90]
grades.append(92)
print(grades)  # Output: [85, 90, 92]
 
# 문자열에는 append가 없습니다 - 불변(immutable)입니다
text = "Hello"
# text.append(" World")  # AttributeError: 'str' object has no attribute 'append'
 
# 하지만 문자열은 연결(concatenation)을 지원합니다
text = text + " World"
print(text)  # Output: Hello World

# 가변 객체는 값이 바뀔 수 있습니다
shopping_cart = ["milk", "bread"]
print(shopping_cart)  # Output: ['milk', 'bread']
 
shopping_cart.append("eggs")
print(shopping_cart)  # Output: ['milk', 'bread', 'eggs']
# 같은 객체(같은 동일성), 다른 값
 
# 불변 객체는 값이 바뀔 수 없습니다
count = 5
print(count)  # Output: 5
 
count = count + 1
print(count)  # Output: 6
# 이는 새로운 동일성을 가진 새 객체를 생성했습니다

# 리스트 객체 생성하기
data = [10, 20, 30]
 
print("Identity:", id(data))      # Output: Identity: 140234567890123 (example)
print("Type:", type(data))        # Output: Type: <class 'list'>
print("Value:", data)             # Output: Value: [10, 20, 30]
 
# 값 수정하기(동일성과 타입은 그대로 유지됨)
data.append(40)
 
print("Identity:", id(data))      # Output: Identity: 140234567890123 (unchanged)
print("Type:", type(data))        # Output: Type: <class 'list'> (unchanged)
print("Value:", data)             # Output: Value: [10, 20, 30, 40] (changed)

# 정수 생성하기
x = 100
print("Original x:", x)           # Output: Original x: 100
print("Identity of x:", id(x))    # Output: Identity of x: 140234567890123 (example)
 
# x를 수정하는 것처럼 보이지만, 실제로는 새 객체를 생성합니다
x = x + 1
print("Modified x:", x)           # Output: Modified x: 101
print("Identity of x:", id(x))    # Output: Identity of x: 140234567890456 (different!)

# 문자열 생성하기
message = "Hello"
print("Original:", message)        # Output: Original: Hello
print("Identity:", id(message))    # Output: Identity: 140234567890789 (example)
 
# 문자열 메서드는 원본을 수정하지 않고 새 문자열을 반환합니다
uppercase = message.upper()
print("Original:", message)        # Output: Original: Hello (unchanged)
print("Uppercase:", uppercase)     # Output: Uppercase: HELLO
print("Identity of original:", id(message))    # Output: Identity of original: 140234567890789 (same)
print("Identity of uppercase:", id(uppercase)) # Output: Identity of uppercase: 140234567891012 (different)

# 연결(concatenation)로 문자열 만들기
text = "Python"
print("Before:", text, "- ID:", id(text))  # Output: Before: Python - ID: 140234567891234 (example)
 
text = text + " Programming"
print("After:", text, "- ID:", id(text))   # Output: After: Python Programming - ID: 140234567891567 (different)

# 리스트 생성하기
numbers = [1, 2, 3]
print("Original:", numbers)        # Output: Original: [1, 2, 3]
print("Identity:", id(numbers))    # Output: Identity: 140234567892345 (example)
 
# 리스트 수정하기 - 같은 객체, 다른 값
numbers.append(4)
print("Modified:", numbers)        # Output: Modified: [1, 2, 3, 4]
print("Identity:", id(numbers))    # Output: Identity: 140234567892345 (same!)

# 딕셔너리 예시
student = {"name": "Alice", "grade": 85}
print("Before:", student, "- ID:", id(student))  # Output: Before: {'name': 'Alice', 'grade': 85} - ID: 140234567893012 (example)
 
student["grade"] = 90  # 딕셔너리 수정하기
print("After:", student, "- ID:", id(student))   # Output: After: {'name': 'Alice', 'grade': 90} - ID: 140234567893012 (same)
 
# 집합 예시
unique_numbers = {1, 2, 3}
print("Before:", unique_numbers, "- ID:", id(unique_numbers))  # Output: Before: {1, 2, 3} - ID: 140234567893345 (example)
 
unique_numbers.add(4)  # 집합 수정하기
print("After:", unique_numbers, "- ID:", id(unique_numbers))   # Output: After: {1, 2, 3, 4} - ID: 140234567893345 (same)

# 불변 예시 - 안전한 공유
x = "Hello"
y = x  # y는 같은 문자열 객체를 가리킵니다
 
# x를 "수정"하면 새 객체가 만들어집니다
x = x + " World"
 
print(x)  # Output: Hello World
print(y)  # Output: Hello (unchanged - y still refers to the original)

# 가변 예시 - 공유된 수정
list1 = [1, 2, 3]
list2 = list1  # list2는 동일한 리스트 객체를 가리킵니다
 
# list1을 통해 수정하면 list2에도 영향을 줍니다
list1.append(4)
 
print(list1)  # Output: [1, 2, 3, 4]
print(list2)  # Output: [1, 2, 3, 4] (also changed!)

# 정수(불변)로 대입하기
a = 100
b = a  # 이제 b는 a와 같은 정수 객체를 가리킵니다
 
print("a:", a)           # Output: a: 100
print("b:", b)           # Output: b: 100
print("Same object?", id(a) == id(b))  # Output: Same object? True
 
# a를 "수정"하면 새 객체가 생성됩니다
a = a + 1
 
print("a:", a)           # Output: a: 101
print("b:", b)           # Output: b: 100 (unchanged)
print("Same object?", id(a) == id(b))  # Output: Same object? False

# 리스트(가변)로 대입하기
list1 = [1, 2, 3]
list2 = list1  # list2는 list1과 같은 리스트 객체를 가리킵니다
 
print("list1:", list1)   # Output: list1: [1, 2, 3]
print("list2:", list2)   # Output: list2: [1, 2, 3]
print("Same object?", id(list1) == id(list2))  # Output: Same object? True
 
# list1을 통해 수정하면 list2에도 영향을 줍니다
list1.append(4)
 
print("list1:", list1)   # Output: list1: [1, 2, 3, 4]
print("list2:", list2)   # Output: list2: [1, 2, 3, 4] (also changed!)
print("Same object?", id(list1) == id(list2))  # Output: Same object? True

# 학생 성적 관리하기
alice_grades = [85, 90, 92]
backup_grades = alice_grades  # 백업을 만들려고 시도함
 
print("Original:", alice_grades)  # Output: Original: [85, 90, 92]
print("Backup:", backup_grades)   # Output: Backup: [85, 90, 92]
 
# 새 성적 추가하기
alice_grades.append(88)
 
# "백업"도 함께 수정되었습니다!
print("Original:", alice_grades)  # Output: Original: [85, 90, 92, 88]
print("Backup:", backup_grades)   # Output: Backup: [85, 90, 92, 88]

# 불변 매개변수를 갖는 함수
def increment(number):
    number = number + 1  # 새 객체를 생성함
    return number
 
value = 5
result = increment(value)
 
print("Original value:", value)    # Output: Original value: 5 (unchanged)
print("Returned result:", result)  # Output: Returned result: 6

# 가변 매개변수를 갖는 함수
def add_item(items, new_item):
    items.append(new_item)  # 원본 리스트를 수정함
 
shopping_list = ["milk", "bread"]
add_item(shopping_list, "eggs")
 
print("Original list:", shopping_list)  # Output: Original list: ['milk', 'bread', 'eggs']

# 실수: 원본을 의도치 않게 수정함
def process_grades(grades):
    grades.append(100)  # 원본을 수정함!
    return grades
 
student_grades = [85, 90, 92]
processed = process_grades(student_grades)
 
print("Original:", student_grades)  # Output: Original: [85, 90, 92, 100] (modified!)
print("Processed:", processed)      # Output: Processed: [85, 90, 92, 100]
 
# 올바른 방법: 원본을 수정하고 싶지 않다면 복사본을 만듭니다
def process_grades_safely(grades):
    # 같은 요소를 가진 새 리스트를 생성하기
    result = grades + [100]  # 연결은 새 리스트를 생성합니다
    return result
 
student_grades = [85, 90, 92]
processed = process_grades_safely(student_grades)
 
print("Original:", student_grades)  # Output: Original: [85, 90, 92] (unchanged)
print("Processed:", processed)      # Output: Processed: [85, 90, 92, 100]

# 리스트와 별칭 생성하기
original = [1, 2, 3]
alias = original  # alias는 original과 같은 리스트를 가리킵니다
 
print("Original:", original)  # Output: Original: [1, 2, 3]
print("Alias:", alias)        # Output: Alias: [1, 2, 3]
print("Same object?", id(original) == id(alias))  # Output: Same object? True
 
# 별칭을 통해 수정하기
alias.append(4)
 
# 두 이름 모두에서 변경이 보입니다
print("Original:", original)  # Output: Original: [1, 2, 3, 4]
print("Alias:", alias)        # Output: Alias: [1, 2, 3, 4]

# 별칭이 있는 학생 데이터베이스
students = {
    "alice": {"name": "Alice", "grade": 85},
    "bob": {"name": "Bob", "grade": 90}
}
 
# Alice의 레코드에 대한 별칭 만들기
alice_record = students["alice"]
 
print("Alice's grade:", alice_record["grade"])  # Output: Alice's grade: 85
 
# 별칭을 통해 수정하기
alice_record["grade"] = 95
 
# 원래 딕셔너리에서도 변경이 보입니다
print("Updated grade:", students["alice"]["grade"])  # Output: Updated grade: 95

# 별칭 확인하기
list1 = [1, 2, 3]
list2 = list1      # 별칭
list3 = [1, 2, 3]  # 값은 같지만 다른 객체
 
print("list1 is list2:", list1 is list2)  # Output: list1 is list2: True (aliases)
print("list1 is list3:", list1 is list3)  # Output: list1 is list3: False (different objects)
print("list1 == list3:", list1 == list3)  # Output: list1 == list3: True (same value)

# 리스트의 리스트 만들기
row = [0, 0, 0]
grid = [row, row, row]  # 세 요소 모두 같은 리스트에 대한 별칭입니다!
 
print("Grid:")
for r in grid:
    print(r)
# Output:
# [0, 0, 0]
# [0, 0, 0]
# [0, 0, 0]
 
# 하나를 수정하면 모든 행에 영향을 줍니다
grid[0][0] = 1
 
print("\nAfter modification:")
for r in grid:
    print(r)
# Output:
# [1, 0, 0]
# [1, 0, 0]
# [1, 0, 0]

# 독립적인 행 만들기
grid = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]  # 각 행은 별도의 리스트입니다
 
print("Grid:")
for r in grid:
    print(r)
# Output:
# [0, 0, 0]
# [0, 0, 0]
# [0, 0, 0]
 
# 이제 하나를 수정해도 해당 행에만 영향을 줍니다
grid[0][0] = 1
 
print("\nAfter modification:")
for r in grid:
    print(r)
# Output:
# [1, 0, 0]
# [0, 0, 0]
# [0, 0, 0]

# ==로 값 비교하기
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
 
print(list1 == list2)  # Output: True (same values)
print(list1 == list3)  # Output: True (same values)

# 서로 다른 타입에서의 동등성
print(42 == 42)              # Output: True (same integer value)
print(42 == 42.0)            # Output: True (integer equals float with same value)
print("hello" == "hello")    # Output: True (same string value)
print([1, 2] == [1, 2])      # Output: True (same list contents)
print({"a": 1} == {"a": 1})  # Output: True (same dictionary contents)
 
# 다른 값
print(42 == 43)              # Output: False
print("hello" == "Hello")    # Output: False (case-sensitive)
print([1, 2] == [2, 1])      # Output: False (order matters)

# 중첩 구조에서의 깊은 비교
list1 = [[1, 2], [3, 4]]
list2 = [[1, 2], [3, 4]]
 
print(list1 == list2)  # Output: True (all nested elements are equal)
 
# 내부 리스트가 서로 다른 객체여도
print(id(list1[0]) == id(list2[0]))  # Output: False (different objects)
print(list1[0] == list2[0])          # Output: True (same values)

# is로 동일성 비교하기
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
 
print(list1 is list2)  # Output: False (different objects)
print(list1 is list3)  # Output: True (same object)
 
# id()로 확인하기
print(id(list1) == id(list2))  # Output: False
print(id(list1) == id(list3))  # Output: True

# None 확인하기(올바른 방법)
def find_student(name, students):
    """Return student record or None if not found."""
    for student in students:
        if student["name"] == name:
            return student
    return None
 
students = [
    {"name": "Alice", "grade": 85},
    {"name": "Bob", "grade": 90}
]
 
result = find_student("Charlie", students)
 
# None 확인에는 'is'를 사용합니다
if result is None:
    print("Student not found")  # Output: Student not found
else:
    print(f"Found: {result}")

# 다양한 타입에서의 멤버십
print(2 in [1, 2, 3])           # Output: True
print("hello" in "hello world")  # Output: True
print("x" in {"x": 10, "y": 20}) # Output: True (checks keys)
print(5 in {1, 2, 3, 4, 5})     # Output: True

# 딕셔너리 멤버십 확인하기
student = {"name": "Alice", "grade": 85, "age": 20}
 
print("name" in student)    # Output: True (key exists)
print("Alice" in student)   # Output: False (value, not key)
print("grade" in student)   # Output: True (key exists)
 
# 값 확인은 .values()에 접근해야 합니다
print("Alice" in student.values())  # Output: True

# 부재 확인하기
shopping_list = ["milk", "bread", "eggs"]
 
if "butter" not in shopping_list:
    print("Don't forget to buy butter!")  # Output: Don't forget to buy butter!

# 중첩 리스트 비교하기
list1 = [[1, 2], [3, 4]]
list2 = [[1, 2], [3, 4]]
 
print(list1 == list2)  # Output: True
 
# 내부 리스트가 서로 다른 객체여도
print(id(list1[0]) == id(list2[0]))  # Output: False
print(list1[0] == list2[0])          # Output: True

# 여러 단계의 중첩 구조
data1 = {
    "students": [
        {"name": "Alice", "grades": [85, 90, 92]},
        {"name": "Bob", "grades": [88, 91, 87]}
    ],
    "class": "Python 101"
}
 
data2 = {
    "students": [
        {"name": "Alice", "grades": [85, 90, 92]},
        {"name": "Bob", "grades": [88, 91, 87]}
    ],
    "class": "Python 101"
}
 
print(data1 == data2)  # Output: True

# 리스트에서는 순서가 중요합니다
list1 = [[1, 2], [3, 4]]
list2 = [[3, 4], [1, 2]]
 
print(list1 == list2)  # Output: False (different order)
 
# 하지만 집합에서는 순서가 중요하지 않습니다
set1 = {frozenset([1, 2]), frozenset([3, 4])}
set2 = {frozenset([3, 4]), frozenset([1, 2])}
 
print(set1 == set2)  # Output: True (sets are unordered)

# 서로 다른 타입 비교하기
print([1, 2, 3] == (1, 2, 3))  # Output: False (list vs tuple)
print([1, 2, 3] == {1, 2, 3})  # Output: False (list vs set)
 
# 요소가 같아도 마찬가지입니다
list_version = [1, 2, 3]
tuple_version = (1, 2, 3)
set_version = {1, 2, 3}
 
print(list_version == tuple_version)  # Output: False
print(list_version == set_version)    # Output: False
print(tuple_version == set_version)   # Output: False

# 단순 리스트의 얕은 복사 만들기
original = [1, 2, 3]
copy = original.copy()  # 얕은 복사 생성
 
print("Original:", original)  # Output: Original: [1, 2, 3]
print("Copy:", copy)          # Output: Copy: [1, 2, 3]
 
# 서로 다른 객체입니다
print("Same object?", original is copy)  # Output: Same object? False
 
# 복사본을 수정해도 원본에는 영향을 주지 않습니다
copy.append(4)
 
print("Original:", original)  # Output: Original: [1, 2, 3]
print("Copy:", copy)          # Output: Copy: [1, 2, 3, 4]

# 중첩 리스트에서의 얕은 복사
original = [[1, 2], [3, 4]]
copy = original.copy()
 
print("Original:", original)  # Output: Original: [[1, 2], [3, 4]]
print("Copy:", copy)          # Output: Copy: [[1, 2], [3, 4]]
 
# 바깥 리스트는 서로 다른 객체입니다
print("Same outer list?", original is copy)  # Output: Same outer list? False
 
# 하지만 중첩 리스트는 같은 객체입니다
print("Same nested list?", original[0] is copy[0])  # Output: Same nested list? True
 
# 중첩 리스트를 수정하면 둘 다 영향을 받습니다
copy[0].append(99)
 
print("Original:", original)  # Output: Original: [[1, 2, 99], [3, 4]]
print("Copy:", copy)          # Output: Copy: [[1, 2, 99], [3, 4]]

# 방법 1: copy() 메서드 사용
original = [[1, 2], [3, 4]]
copy1 = original.copy()
 
# 방법 2: 리스트 슬라이싱 사용
copy2 = original[:]
 
# 방법 3: list() 생성자 사용
copy3 = list(original)
 
# 세 가지 모두 얕은 복사입니다
print(copy1)  # Output: [[1, 2], [3, 4]]
print(copy2)  # Output: [[1, 2], [3, 4]]
print(copy3)  # Output: [[1, 2], [3, 4]]
 
# 바깥 리스트는 다릅니다
print(original is copy1)  # Output: False
print(original is copy2)  # Output: False
print(original is copy3)  # Output: False
 
# 하지만 내부 리스트는 공유됩니다
print(original[0] is copy1[0])  # Output: True
print(original[0] is copy2[0])  # Output: True
print(original[0] is copy3[0])  # Output: True

# 방법 1: copy() 메서드 사용
original = {"name": "Alice", "grade": 85}
copy1 = original.copy()
 
# 방법 2: dict() 생성자 사용
copy2 = dict(original)
 
# 둘 다 얕은 복사입니다
print(copy1)  # Output: {'name': 'Alice', 'grade': 85}
print(copy2)  # Output: {'name': 'Alice', 'grade': 85}
 
# 서로 다른 객체입니다
print(original is copy1)  # Output: False
print(original is copy2)  # Output: False
 
# 복사본을 수정해도 원본에는 영향을 주지 않습니다
copy1["grade"] = 90
 
print("Original:", original)  # Output: Original: {'name': 'Alice', 'grade': 85}
print("Copy:", copy1)         # Output: Copy: {'name': 'Alice', 'grade': 90}

# 중첩 딕셔너리에서의 얕은 복사
original = {
    "name": "Alice",
    "grades": [85, 90, 92]
}
 
copy = original.copy()
 
print("Original:", original)  # Output: Original: {'name': 'Alice', 'grades': [85, 90, 92]}
print("Copy:", copy)          # Output: Copy: {'name': 'Alice', 'grades': [85, 90, 92]}
 
# 딕셔너리는 서로 다른 객체입니다
print("Same dict?", original is copy)  # Output: Same dict? False
 
# 하지만 grades 리스트는 같은 객체입니다
print("Same grades list?", original["grades"] is copy["grades"])  # Output: Same grades list? True
 
# grades 리스트를 수정하면 둘 다 영향을 받습니다
copy["grades"].append(88)
 
print("Original:", original)  # Output: Original: {'name': 'Alice', 'grades': [85, 90, 92, 88]}
print("Copy:", copy)          # Output: Copy: {'name': 'Alice', 'grades': [85, 90, 92, 88]}