7. 튜플과 세트

변수명 = (요소1, 요소2, 요소3, ...)

# 리스트와 튜플 비교
my_list = [1, 2, 3, 4, 5]      # 리스트 (대괄호)
my_tuple = (1, 2, 3, 4, 5)     # 튜플 (소괄호)

print(type(my_list))   # <class 'list'>
print(type(my_tuple))  # <class 'tuple'>

# 튜플 생성 및 요소 접근
fruits = ("사과", "바나나", "오렌지", "포도")

print(fruits[0])    # 사과
print(fruits[1])    # 바나나
print(fruits[-1])   # 포도 (마지막 요소)
print(len(fruits))  # 4 (튜플의 길이)

# 리스트는 수정 가능 (mutable)
my_list = [1, 2, 3, 4, 5]
my_list[0] = 10  # 수정 가능
my_list.append(6)  # 추가 가능
print(my_list)  # [10, 2, 3, 4, 5, 6]

# 튜플은 수정 불가능 (immutable)
my_tuple = (1, 2, 3, 4, 5)
# my_tuple[0] = 10  # TypeError: 'tuple' object does not support item assignment
# my_tuple.append(6)  # AttributeError: 'tuple' object has no attribute 'append'

numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# 기본 슬라이싱
print(numbers[2:5])    # (3, 4, 5)
print(numbers[:3])     # (1, 2, 3)
print(numbers[7:])     # (8, 9, 10)

# 간격을 두고 슬라이싱
print(numbers[::2])    # (1, 3, 5, 7, 9)
print(numbers[1::3])   # (2, 5, 8)

fruits = ("사과", "바나나", "오렌지")

# 존재하지 않는 인덱스 접근 시 에러 발생
# print(fruits[5])  # IndexError: tuple index out of range

# 안전한 접근 방법
if len(fruits) > 5:
    print(fruits[5])
else:
    print("인덱스가 범위를 벗어났습니다.")

튜플.count(찾고자 하는 값)

# count() 메서드 사용 예제
numbers = (1, 2, 3, 2, 4, 2, 5, 2)

print(numbers.count(2))    # 4 (2가 4번 나타남)
print(numbers.count(1))    # 1 (1이 1번 나타남)
print(numbers.count(6))    # 0 (6이 0번 나타남)

# 문자열 튜플에서의 사용
fruits = ("사과", "바나나", "사과", "오렌지", "사과")
print(fruits.count("사과"))  # 3
print(fruits.count("포도"))  # 0

튜플.index(찾고자 하는 값)

# index() 메서드 사용 예제
fruits = ("사과", "바나나", "오렌지", "포도", "바나나")

print(fruits.index("바나나"))  # 1 (첫 번째 바나나의 인덱스)
print(fruits.index("사과"))    # 0 (사과의 인덱스)
print(fruits.index("포도"))    # 3 (포도의 인덱스)

# 존재하지 않는 값 검색 시 에러 발생
# print(fruits.index("체리"))  # ValueError: tuple.index(x): x not in tuple

# 안전한 검색 방법
if "체리" in fruits:
    print(fruits.index("체리"))
else:
    print("체리가 없습니다.")

# 일반적인 변수 교환 방법
x = 10
y = 20

# 임시 변수 사용
temp = x
x = y
y = temp
print(f"x: {x}, y: {y}")  # x: 20, y: 10

# 튜플을 이용한 간편한 교환
x = 10
y = 20

(x, y) = (y, x)  # 또는 x, y = y, x
print(f"x: {x}, y: {y}")  # x: 20, y: 10

# 여러 변수 동시 교환
a, b, c = 1, 2, 3
a, b, c = c, a, b
print(f"a: {a}, b: {b}, c: {c}")  # a: 3, b: 1, c: 2

def get_name_and_age():
    name = "김철수"
    age = 25
    return name, age  # 튜플로 반환

# 함수 호출 및 값 받기
person_name, person_age = get_name_and_age()
print(f"이름: {person_name}, 나이: {person_age}")

# 또는 튜플 전체로 받기
person_info = get_name_and_age()
print(f"정보: {person_info}")  # ('김철수', 25)

변수명 = {요소1, 요소2, 요소3, ...}

set(세트로 바꾸고 싶은 다른 자료형)

# 세트 생성 방법들
my_set1 = {1, 2, 3, 4, 5}           # 중괄호 사용
my_set2 = set([1, 2, 3, 4, 5])      # set() 함수 사용
my_set3 = set("hello")               # 문자열을 세트로 변환

print(my_set1)  # {1, 2, 3, 4, 5}
print(my_set2)  # {1, 2, 3, 4, 5}
print(my_set3)  # {'h', 'e', 'l', 'o'} (중복 제거됨)

# 빈 세트 생성
empty_set = set()  # {}는 빈 딕셔너리이므로 주의!
print(empty_set)   # set()

my_set = {1, 2, 3, 4, 5}

# 세트는 인덱싱이 불가능
# print(my_set[0])  # TypeError: 'set' object is not subscriptable

my_set = {1, 2, 3, 4, 5}

# 세트를 리스트로 변환 후 접근
my_list = list(my_set)
print(my_list[0])  # 1 (순서는 보장되지 않음)

# 세트를 튜플로 변환 후 접근
my_tuple = tuple(my_set)
print(my_tuple[0])  # 1 (순서는 보장되지 않음)

# for문을 이용한 순회
for element in my_set:
    print(element)

# 교집합 구하는 방법들
intersection_AandB = set_a.intersection(set_b)
intersection_AandB = set_a & set_b

# 교집합 연산 예제
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

# 방법 1: intersection() 메서드 사용
intersection1 = set_a.intersection(set_b)
print("교집합 (메서드):", intersection1)  # {4, 5}

# 방법 2: & 연산자 사용
intersection2 = set_a & set_b
print("교집합 (연산자):", intersection2)  # {4, 5}

# 여러 세트의 교집합
set_c = {4, 5, 9, 10}
intersection3 = set_a.intersection(set_b, set_c)
print("세 개 세트 교집합:", intersection3)  # {4, 5}

# 합집합 구하는 방법들
union_AandB = set_a.union(set_b)
union_AandB = set_a | set_b

# 합집합 연산 예제
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

# 방법 1: union() 메서드 사용
union1 = set_a.union(set_b)
print("합집합 (메서드):", union1)  # {1, 2, 3, 4, 5, 6, 7, 8}

# 방법 2: | 연산자 사용
union2 = set_a | set_b
print("합집합 (연산자):", union2)  # {1, 2, 3, 4, 5, 6, 7, 8}

# 여러 세트의 합집합
set_c = {9, 10, 11}
union3 = set_a.union(set_b, set_c)
print("세 개 세트 합집합:", union3)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

# 차집합 구하는 방법들
difference_AminusB = set_a.difference(set_b)
difference_AminusB = set_a - set_b

# 차집합 연산 예제
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

# 방법 1: difference() 메서드 사용
difference1 = set_a.difference(set_b)
print("차집합 A-B (메서드):", difference1)  # {1, 2, 3}

# 방법 2: - 연산자 사용
difference2 = set_a - set_b
print("차집합 A-B (연산자):", difference2)  # {1, 2, 3}

# 반대 차집합
difference3 = set_b - set_a
print("차집합 B-A:", difference3)  # {6, 7, 8}

# 여러 세트의 차집합
set_c = {3, 4, 9, 10}
difference4 = set_a.difference(set_b, set_c)
print("A-(B∪C):", difference4)  # {1, 2}

my_set.add(추가할_요소)

# add() 메서드 사용 예제
fruits = {"사과", "바나나"}

fruits.add("오렌지")
print(fruits)  # {'사과', '바나나', '오렌지'}

fruits.add("사과")  # 중복 요소 추가 시도 (변화 없음)
print(fruits)  # {'사과', '바나나', '오렌지'}

# 숫자 세트에 요소 추가
numbers = {1, 2, 3}
numbers.add(4)
print(numbers)  # {1, 2, 3, 4}

my_set.update(추가할_요소들)

# update() 메서드 사용 예제
fruits = {"사과", "바나나"}

# 리스트로 여러 요소 추가
fruits.update(["오렌지", "포도", "체리"])
print(fruits)  # {'사과', '바나나', '오렌지', '포도', '체리'}

# 튜플로 여러 요소 추가
fruits.update(("키위", "딸기"))
print(fruits)  # {'사과', '바나나', '오렌지', '포도', '체리', '키위', '딸기'}

# 다른 세트와 합치기
more_fruits = {"망고", "파인애플"}
fruits.update(more_fruits)
print(fruits)  # {'사과', '바나나', '오렌지', '포도', '체리', '키위', '딸기', '망고', '파인애플'}

my_set.remove(삭제할_요소)

# remove() 메서드 사용 예제
fruits = {"사과", "바나나", "오렌지", "포도"}

fruits.remove("바나나")
print(fruits)  # {'사과', '오렌지', '포도'}

# 존재하지 않는 요소 삭제 시 에러 발생
# fruits.remove("체리")  # KeyError: '체리'

# 안전한 삭제 방법
if "체리" in fruits:
    fruits.remove("체리")
else:
    print("체리가 세트에 없습니다.")

my_set.discard(삭제할_요소)

# discard() 메서드 사용 예제
fruits = {"사과", "바나나", "오렌지", "포도"}

fruits.discard("바나나")
print(fruits)  # {'사과', '오렌지', '포도'}

# 존재하지 않는 요소 삭제 시도 (에러 없음)
fruits.discard("체리")
print(fruits)  # {'사과', '오렌지', '포도'} (변화 없음)

removed_element = my_set.pop()

# pop() 메서드 사용 예제
fruits = {"사과", "바나나", "오렌지", "포도"}

removed = fruits.pop()
print(f"삭제된 요소: {removed}")  # 임의의 요소 (예: '사과')
print(f"남은 세트: {fruits}")     # {'바나나', '오렌지', '포도'}

# 빈 세트에서 pop() 호출 시 에러 발생
empty_set = set()
# empty_set.pop()  # KeyError: 'pop from an empty set'

my_set.clear()

# clear() 메서드 사용 예제
fruits = {"사과", "바나나", "오렌지", "포도"}

print("clear() 전:", fruits)  # {'사과', '바나나', '오렌지', '포도'}
fruits.clear()
print("clear() 후:", fruits)  # set()

# 학생들의 취미를 관리하는 시스템
students_hobbies = {
    "김철수": {"축구", "영화감상", "독서"},
    "이영희": {"음악", "요리", "독서"},
    "박민수": {"축구", "게임", "영화감상"},
    "최지영": {"음악", "요리", "게임"}
}

def find_common_hobbies():
    """모든 학생이 공통으로 가지고 있는 취미 찾기"""
    all_hobbies = set.intersection(*students_hobbies.values())
    return all_hobbies

def find_unique_hobbies(student_name):
    """특정 학생만의 고유한 취미 찾기"""
    if student_name not in students_hobbies:
        return set()
    
    student_hobbies = students_hobbies[student_name]
    other_hobbies = set()
    for name, hobbies in students_hobbies.items():
        if name != student_name:
            other_hobbies.update(hobbies)
    
    return student_hobbies - other_hobbies

def recommend_friends(student_name):
    """취미가 비슷한 친구 추천"""
    if student_name not in students_hobbies:
        return []
    
    student_hobbies = students_hobbies[student_name]
    recommendations = []
    
    for name, hobbies in students_hobbies.items():
        if name != student_name:
            common_count = len(student_hobbies & hobbies)
            if common_count > 0:
                recommendations.append((name, common_count))
    
    return sorted(recommendations, key=lambda x: x[1], reverse=True)

# 사용 예제
print("공통 취미:", find_common_hobbies())
print("김철수의 고유 취미:", find_unique_hobbies("김철수"))
print("김철수와 비슷한 취미를 가진 친구:", recommend_friends("김철수"))

# 중복이 포함된 데이터를 정리하는 시스템
def clean_data(data_list):
    """리스트에서 중복을 제거하고 정렬된 리스트 반환"""
    unique_data = list(set(data_list))
    return sorted(unique_data)

def find_duplicates(data_list):
    """중복된 요소들 찾기"""
    seen = set()
    duplicates = set()
    
    for item in data_list:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    
    return list(duplicates)

# 사용 예제
scores = [85, 92, 78, 85, 96, 92, 78, 88, 85]
print("원본 데이터:", scores)
print("중복 제거 후:", clean_data(scores))
print("중복된 점수:", find_duplicates(scores))

# 2D 좌표를 관리하는 시스템
class Point:
    def __init__(self, x, y):
        self.coords = (x, y)
    
    def __str__(self):
        return f"Point({self.coords[0]}, {self.coords[1]})"
    
    def distance_from_origin(self):
        """원점으로부터의 거리 계산"""
        x, y = self.coords
        return (x**2 + y**2)**0.5
    
    def move(self, dx, dy):
        """좌표 이동 (새로운 튜플 반환)"""
        new_x = self.coords[0] + dx
        new_y = self.coords[1] + dy
        return Point(new_x, new_y)

# 사용 예제
point1 = Point(3, 4)
print(f"원점: {point1}")
print(f"원점으로부터의 거리: {point1.distance_from_origin():.2f}")

point2 = point1.move(2, -1)
print(f"이동 후: {point2}")

# 효율적인 중복 제거
unique_items = list(set(original_list))

# 효율적인 교집합 찾기
common_elements = set1 & set2

# 효율적인 차집합 찾기
unique_to_first = set1 - set2

# 튜플 디버깅
my_tuple = (1, 2, 3, 4, 5)
print(f"튜플 내용: {my_tuple}")
print(f"튜플 길이: {len(my_tuple)}")
print(f"튜플 타입: {type(my_tuple)}")

# 세트 디버깅
my_set = {1, 2, 3, 4, 5}
print(f"세트 내용: {my_set}")
print(f"세트 길이: {len(my_set)}")
print(f"세트 타입: {type(my_set)}")