15. 튜플과 range: 단순한 불변 시퀀스

# 학생 시험 점수 튜플
scores = (85, 92, 78, 95)
print(scores)  # Output: (85, 92, 78, 95)
print(type(scores))  # Output: <class 'tuple'>
 
# 여러 데이터 타입이 섞인 튜플
student_info = ("Alice", 20, "Computer Science", 3.8)
print(student_info)  # Output: ('Alice', 20, 'Computer Science', 3.8)
 
# 빈 튜플
empty = ()
print(empty)  # Output: ()
print(len(empty))  # Output: 0

# 아래는 모두 같은 튜플을 만듭니다
coordinates_1 = (10, 20)
coordinates_2 = 10, 20  # 괄호가 필요 없습니다!
print(coordinates_1)  # Output: (10, 20)
print(coordinates_2)  # Output: (10, 20)
print(coordinates_1 == coordinates_2)  # Output: True
 
# 중요한 것은 쉼표입니다
x = (42)  # 이것은 괄호로 감싼 정수 42일 뿐입니다
y = (42,)  # 이것은 요소가 1개인 튜플입니다
print(type(x))  # Output: <class 'int'>
print(type(y))  # Output: <class 'tuple'>
print(y)  # Output: (42,)

# 괄호가 없으면 혼란스러울 수 있습니다
def get_dimensions():
    return 1920, 1080  # 튜플을 반환합니다
 
width, height = get_dimensions()
print(f"Screen: {width}x{height}")  # Output: Screen: 1920x1080
 
# 튜플을 함수 인자로 전달할 때는 괄호가 필요합니다
print((1, 2, 3))  # Output: (1, 2, 3)
# 괄호가 없으면 Python은 세 개의 별도 인자로 인식합니다
 
# 복잡한 표현식에서는 괄호가 필요합니다
result = (10, 20) + (30, 40)  # 튜플 연결(concatenation)
print(result)  # Output: (10, 20, 30, 40)

# 흔한 실수: 쉼표를 빼먹기
not_a_tuple = ("Python")
print(type(not_a_tuple))  # Output: <class 'str'>
print(not_a_tuple)  # Output: Python
 
# 올바른 방법: 끝의 쉼표를 포함
is_a_tuple = ("Python",)
print(type(is_a_tuple))  # Output: <class 'tuple'>
print(is_a_tuple)  # Output: ('Python',)
 
# 괄호 없이도 쉼표는 동작합니다
also_a_tuple = "Python",
print(type(also_a_tuple))  # Output: <class 'tuple'>
print(also_a_tuple)  # Output: ('Python',)

# 학생 정보 튜플
student = ("Bob", 22, "Physics", 3.6)
 
# 개별 요소 접근(0부터 시작)
name = student[0]
age = student[1]
major = student[2]
gpa = student[3]
 
print(f"{name} is {age} years old")  # Output: Bob is 22 years old
print(f"Major: {major}, GPA: {gpa}")  # Output: Major: Physics, GPA: 3.6
 
# 음수 인덱싱도 동작합니다
last_item = student[-1]
print(f"Last item: {last_item}")  # Output: Last item: 3.6
 
# 슬라이싱은 새 튜플을 추출합니다
first_two = student[:2]
print(first_two)  # Output: ('Bob', 22)
print(type(first_two))  # Output: <class 'tuple'>

# 값을 튜플로 패킹
coordinates = 10, 20, 30
print(coordinates)  # Output: (10, 20, 30)
 
# 서로 다른 타입을 패킹
user_data = "Alice", 25, "alice@example.com"
print(user_data)  # Output: ('Alice', 25, 'alice@example.com')
 
# 함수 반환값 패킹
def get_statistics(numbers):
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    return total, count, average  # 세 값을 튜플로 패킹합니다
 
stats = get_statistics([85, 90, 78, 92, 88])
print(stats)  # Output: (433, 5, 86.6)

# 기본 언패킹
point = (100, 200)
x, y = point
print(f"x = {x}, y = {y}")  # Output: x = 100, y = 200
 
# 언패킹은 튜플뿐 아니라 모든 시퀀스에서 동작합니다
name, age, email = ["Bob", 30, "bob@example.com"]
print(f"{name} is {age} years old")  # Output: Bob is 30 years old
 
# 함수의 반환값을 바로 언패킹
total, count, average = get_statistics([95, 88, 92, 85])
print(f"Average of {count} scores: {average}")  # Output: Average of 4 scores: 90.0

# 이것은 에러를 발생시킵니다
coordinates = (10, 20, 30)
# x, y = coordinates  # ValueError: too many values to unpack (expected 2)
 
# 이것도 에러를 발생시킵니다
point = (5, 10)
# x, y, z = point  # ValueError: not enough values to unpack (expected 3, got 2)

# 임시 변수를 사용한 전통적인 교환
a = 10
b = 20
temp = a
a = b
b = temp
print(f"a = {a}, b = {b}")  # Output: a = 20, b = 10
 
# 튜플 언패킹을 사용한 Python식 우아한 교환
x = 100
y = 200
x, y = y, x  # 한 줄로 교환!
print(f"x = {x}, y = {y}")  # Output: x = 200, y = 100
 
# 두 개보다 많은 변수 교환
first = "A"
second = "B"
third = "C"
first, second, third = third, first, second
print(first, second, third)  # Output: C A B

# "나머지" 변수를 사용한 언패킹
scores = (95, 88, 92, 85, 90, 87)
first, second, *rest = scores
print(f"Top two: {first}, {second}")  # Output: Top two: 95, 88
print(f"Others: {rest}")  # Output: Others: [92, 85, 90, 87]
print(type(rest))  # Output: <class 'list'>
 
# 별 표시는 어디에나 올 수 있습니다
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(f"First: {first}")  # Output: First: 1
print(f"Middle: {middle}")  # Output: Middle: [2, 3, 4]
print(f"Last: {last}")  # Output: Last: 5
 
# 앞부분을 담기
*beginning, second_last, last = numbers
print(f"Beginning: {beginning}")  # Output: Beginning: [1, 2, 3]
print(f"Last two: {second_last}, {last}")  # Output: Last two: 4, 5

# 담을 것이 없을 때
a, b, *rest = (10, 20)
print(rest)  # Output: []
 
# 언패킹에서 별은 하나만 허용됩니다
# first, *middle, *end = (1, 2, 3, 4)  # SyntaxError: multiple starred expressions

# 날짜 문자열 파싱
date_string = "2024-03-15"
year, month, day = date_string.split("-")
print(f"Month: {month}")  # Output: Month: 03
 
# 월만 신경 쓴다면
_, month, _ = date_string.split("-")
print(f"Month: {month}")  # Output: Month: 03
 
# 확장 언패킹과 함께 사용
data = ("Alice", 25, "Engineer", "New York", "alice@example.com")
name, age, *_, email = data
print(f"{name} ({age}): {email}")  # Output: Alice (25): alice@example.com

# 계산 결과로 여러 값을 반환
def calculate_rectangle_properties(width, height):
    """직사각형의 넓이와 둘레를 계산합니다."""
    area = width * height
    perimeter = 2 * (width + height)
    return area, perimeter  # 패킹
 
# 결과 언패킹
rect_area, rect_perimeter = calculate_rectangle_properties(5, 3)
print(f"Area: {rect_area}, Perimeter: {rect_perimeter}")  # Output: Area: 15, Perimeter: 16
 
# 언패킹으로 반복하기
students = [
    ("Alice", 85),
    ("Bob", 92),
    ("Carol", 78)
]
 
for name, score in students:  # 반복문에서 언패킹
    print(f"{name}: {score}")
# Output:
# Alice: 85
# Bob: 92
# Carol: 78

# 튜플 만들기
coordinates = (10, 20, 30)
print(coordinates)  # Output: (10, 20, 30)
 
# 수정 시도는 에러를 발생시킵니다
# coordinates[0] = 15  # TypeError: 'tuple' object does not support item assignment
 
# 요소 추가 시도는 에러를 발생시킵니다
# coordinates.append(40)  # AttributeError: 'tuple' object has no attribute 'append'
 
# 요소 제거 시도는 에러를 발생시킵니다
# del coordinates[1]  # TypeError: 'tuple' object doesn't support item deletion

# 리스트는 가변입니다 - 변경할 수 있습니다
shopping_list = ["milk", "bread", "eggs"]
shopping_list[1] = "butter"  # 요소 수정
shopping_list.append("cheese")  # 요소 추가
print(shopping_list)  # Output: ['milk', 'butter', 'eggs', 'cheese']
 
# 튜플은 불변입니다 - 변경할 수 없습니다
product_dimensions = (10, 20, 5)  # width, height, depth in cm
# product_dimensions[0] = 12  # TypeError: cannot modify
# product_dimensions.append(3)  # AttributeError: no append method
 
# 튜플을 "변경"하려면 새 튜플을 만들어야 합니다
new_dimensions = (12, 20, 5)  # 완전히 새로운 튜플 생성
print(new_dimensions)  # Output: (12, 20, 5)

def calculate_distance(point1, point2):
    """2D 두 점 사이의 거리를 계산합니다."""
    x1, y1 = point1
    x2, y2 = point2
 
    dx = x2 - x1
    dy = y2 - y1
    
    # 원한다 하더라도 입력 튜플은 수정할 수 없습니다
 
    return (dx**2 + dy**2) ** 0.5
 
start = (0, 0)
end = (3, 4)
distance = calculate_distance(start, end)
print(f"Distance: {distance}")  # Output: Distance: 5.0
print(f"Start point unchanged: {start}")  # Output: Start point unchanged: (0, 0)

# 튜플은 딕셔너리 키가 될 수 있습니다
locations = {
    (0, 0): "Origin",
    (10, 20): "Point A",
    (30, 40): "Point B"
}
print(locations[(10, 20)])  # Output: Point A
 
# 리스트는 딕셔너리 키가 될 수 없습니다
# locations_bad = {
#     [0, 0]: "Origin"  # TypeError: unhashable type: 'list'
# }

# RGB 색상 값 - 절대 변하면 안 됩니다
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
 
# 데이터베이스 연결 파라미터 - 고정된 설정
DB_CONFIG = ("localhost", 5432, "myapp", "production")
 
# 지리 좌표 - 위치는 변하지 않습니다
EIFFEL_TOWER = (48.8584, 2.2945)  # latitude, longitude

import sys
 
# 튜플은 동등한 리스트보다 메모리를 덜 사용합니다
tuple_data = (1, 2, 3, 4, 5)
list_data = [1, 2, 3, 4, 5]
 
print(f"Tuple size: {sys.getsizeof(tuple_data)} bytes")  # Output: Tuple size: 80 bytes (may vary by Python version)
print(f"List size: {sys.getsizeof(list_data)} bytes")    # Output: List size: 104 bytes (may vary by Python version)
 
# 튜플 생성이 더 빠릅니다
import timeit
 
tuple_time = timeit.timeit("(1, 2, 3, 4, 5)", number=1000000)
list_time = timeit.timeit("[1, 2, 3, 4, 5]", number=1000000)
 
print(f"Tuple creation: {tuple_time:.4f} seconds")
print(f"List creation: {list_time:.4f} seconds")
# Example output: Tuple creation: 0.0055 seconds, List creation: 0.0292 seconds

# 리스트를 포함하는 튜플
student_data = ("Alice", 20, [85, 90, 78])  # name, age, scores
print(student_data)  # Output: ('Alice', 20, [85, 90, 78])
 
# 튜플 요소를 재할당할 수는 없습니다
# student_data[0] = "Bob"  # TypeError: 'tuple' object does not support item assignment
 
# 하지만 튜플 안의 리스트는 수정할 수 있습니다
student_data[2].append(92)  # 새 점수 추가
print(student_data)  # Output: ('Alice', 20, [85, 90, 78, 92])
 
student_data[2][0] = 88  # 기존 점수 수정
print(student_data)  # Output: ('Alice', 20, [88, 90, 78, 92])

# 튜플 구조는 고정입니다
data = ("Python", [1, 2, 3])
 
# 이것은 튜플이 참조하는 대상을 바꾸려는 시도입니다 - 허용되지 않습니다
# data[1] = [4, 5, 6]  # TypeError
 
# 이것은 튜플이 참조하는 리스트를 수정하는 것입니다 - 허용됩니다
data[1].append(4)
print(data)  # Output: ('Python', [1, 2, 3, 4])
 
# 튜플은 여전히 같은 리스트 객체를 참조합니다
# 리스트의 내용만 바뀌었고, 튜플이 가리키는 리스트 자체는 바뀌지 않았습니다

# 딕셔너리를 포함하는 튜플
user_profile = ("alice", {"email": "alice@example.com", "age": 25})
print(user_profile)  # Output: ('alice', {'email': 'alice@example.com', 'age': 25})
 
# 튜플이 참조하는 딕셔너리 자체를 바꿀 수는 없습니다
# user_profile[1] = {"email": "newemail@example.com"}  # TypeError
 
# 하지만 딕셔너리 자체는 수정할 수 있습니다
user_profile[1]["age"] = 26
user_profile[1]["city"] = "New York"
print(user_profile)  # Output: ('alice', {'email': 'alice@example.com', 'age': 26, 'city': 'New York'})

# 이것은 동작하지만 위험합니다
tuple_with_list = ("key", [1, 2, 3])
# data = {tuple_with_list: "value"}  # TypeError: unhashable type: 'list'

# 완전히 불변인 튜플 - 불변 타입만 포함
point_3d = (10, 20, 30)  # 모두 정수
rgb_color = (255, 128, 0)  # 모두 정수
coordinates = ((10, 20), (30, 40))  # 튜플의 튜플
 
# 이것들은 딕셔너리 키로 안전합니다
color_names = {
    (255, 0, 0): "Red",
    (0, 255, 0): "Green",
    (0, 0, 255): "Blue"
}
 
# 중첩 튜플도 불변입니다
nested = ((1, 2), (3, 4))
# nested[0][0] = 5  # TypeError: 'tuple' object does not support item assignment

# 신원은 고정이고 성적은 변하는 학생 레코드
def create_student(name, student_id):
    """빈 성적 리스트를 가진 학생 레코드를 생성합니다."""
    return (name, student_id, [])  # name과 ID는 고정, grades는 변경 가능
 
student = create_student("Alice", "S12345")
print(student)  # Output: ('Alice', 'S12345', [])
 
# 학생의 신원은 고정입니다
print(f"Student: {student[0]} (ID: {student[1]})")  # Output: Student: Alice (ID: S12345)
 
# 하지만 성적은 쌓이는 대로 추가할 수 있습니다
student[2].append(85)
student[2].append(92)
student[2].append(78)
print(f"Grades: {student[2]}")  # Output: Grades: [85, 92, 78]
 
# 튜플 구조는 name과 ID를 실수로 바꾸지 못하게 보호하면서
# 성적 리스트는 커질 수 있도록 허용합니다

# 학생 레코드: name, age, major, GPA
student = ("Alice", 20, "Computer Science", 3.8)
 
# 지리 좌표: latitude, longitude
location = (40.7128, -74.0060)  # New York City
 
# RGB 색상: red, green, blue
color = (255, 128, 0)
 
# 데이터베이스 연결: host, port, database, username
db_connection = ("localhost", 5432, "myapp", "admin")
 
# 날짜: year, month, day
date = (2024, 3, 15)

# 장보기 목록 - 같은 타입의 항목(문자열)
shopping_list = ["milk", "bread", "eggs", "butter"]
shopping_list.append("cheese")  # 필요하면 항목 추가
shopping_list.remove("bread")   # 항목 제거
 
# 시험 점수 - 같은 타입의 항목(숫자)
test_scores = [85, 92, 78, 95, 88]
test_scores.append(90)  # 새 점수 추가
test_scores.sort()      # 점수 재정렬
 
# 사용자 이름 - 같은 타입의 항목(문자열)
active_users = ["alice", "bob", "carol"]
active_users.extend(["dave", "eve"])  # 여러 사용자 추가

def get_user_info(user_id):
    """데이터베이스에서 사용자 정보를 가져옵니다."""
    # 데이터베이스 조회 시뮬레이션
    return "Alice", "alice@example.com", 25, "New York"
 
# 반환된 튜플 언패킹
name, email, age, city = get_user_info(101)
print(f"{name} from {city}")  # Output: Alice from New York
 
def calculate_statistics(numbers):
    """숫자 목록의 최솟값, 최댓값, 평균을 계산합니다."""
    if not numbers:
        return None, None, None
    
    minimum = min(numbers)
    maximum = max(numbers)
    average = sum(numbers) / len(numbers)
    return minimum, maximum, average
 
# 결과 언패킹
min_val, max_val, avg_val = calculate_statistics([85, 92, 78, 95, 88])
print(f"Range: {min_val} to {max_val}, Average: {avg_val}")
# Output: Range: 78 to 95, Average: 87.6

# 과목과 학기별 학생 성적
grades = {
    ("CS101", "Fall2023"): 85,
    ("CS101", "Spring2024"): 90,
    ("MATH201", "Fall2023"): 88,
    ("MATH201", "Spring2024"): 92
}
 
# 특정 성적 조회
course = "CS101"
semester = "Spring2024"
grade = grades[(course, semester)]
print(f"Grade in {course} ({semester}): {grade}")  # Output: Grade in CS101 (Spring2024): 90
 
# 격자 좌표를 딕셔너리 키로 사용
grid = {
    (0, 0): "Start",
    (5, 3): "Obstacle",
    (10, 10): "Goal"
}
 
position = (5, 3)
if position in grid:
    print(f"At {position}: {grid[position]}")  # Output: At (5, 3): Obstacle

# 변하지 않아야 하는 애플리케이션 설정
APP_CONFIG = (
    "MyApp",           # Application name
    "1.0.0",          # Version
    "production",     # Environment
    True,             # Debug mode
    8080              # Port
)
 
# UI용 컬러 팔레트 - 이 색들은 고정입니다
COLOR_PALETTE = (
    (255, 0, 0),      # Primary red
    (0, 128, 255),    # Primary blue
    (255, 255, 255),  # White
    (0, 0, 0)         # Black
)
 
# API 엔드포인트 - 이 URL들은 바뀌지 않습니다
API_ENDPOINTS = (
    "https://api.example.com/users",
    "https://api.example.com/products",
    "https://api.example.com/orders"
)

# 다음 경우에 TUPLES를 사용:
# 1. 데이터가 고정 구조를 가진 하나의 레코드를 나타낼 때
employee = ("E001", "Alice", "Engineering", 75000)
 
# 2. 함수에서 여러 값을 반환할 때
def divide_with_remainder(a, b):
    return a // b, a % b
 
# 3. 딕셔너리 키로 사용해야 할 때
cache = {(5, 10): 50, (3, 7): 21}
 
# 4. 데이터가 수정되면 안 될 때
SCREEN_RESOLUTION = (1920, 1080)
 
# 다음 경우에 LISTS를 사용:
# 1. 바뀔 수 있는 유사 항목들의 컬렉션일 때
tasks = ["Write code", "Test code", "Deploy code"]
tasks.append("Document code")
 
# 2. 항목을 추가/삭제/재정렬해야 할 때
scores = [85, 90, 78]
scores.sort()
scores.append(92)
 
# 3. 모든 항목이 같은 목적을 가질 때
usernames = ["alice", "bob", "carol"]
 
# 4. 컬렉션 크기를 미리 알 수 없을 때
results = []
for i in range(10):
    results.append(i * 2)

# 인자 1개: range(stop)
# 0부터 stop 직전까지 숫자를 생성합니다
numbers = range(5)
print(list(numbers))  # Output: [0, 1, 2, 3, 4]
 
# 인자 2개: range(start, stop)
# start부터 stop 직전까지 숫자를 생성합니다
numbers = range(2, 7)
print(list(numbers))  # Output: [2, 3, 4, 5, 6]
 
# 인자 3개: range(start, stop, step)
# start부터 stop 직전까지 step만큼 증가시키며 숫자를 생성합니다
numbers = range(0, 10, 2)
print(list(numbers))  # Output: [0, 2, 4, 6, 8]
 
# 음수 step으로 역으로 카운트
numbers = range(10, 0, -1)
print(list(numbers))  # Output: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

r = range(5)
print(r)  # Output: range(0, 5)
print(type(r))  # Output: <class 'range'>

import sys
 
# 100만 개 숫자를 나타내는 range
large_range = range(1000000)
print(f"Range size: {sys.getsizeof(large_range)} bytes")  # Output: Range size: 48 bytes (may vary by Python version)
 
# 100만 개 숫자를 담은 리스트
large_list = list(range(1000000))
print(f"List size: {sys.getsizeof(large_list)} bytes")  # Output: List size: 8000056 bytes (approximately 8MB)
 
# range는 작고, 리스트는 큽니다!

# 0부터 4까지 세기
for i in range(5):
    print(f"Count: {i}")
# Output:
# Count: 0
# Count: 1
# Count: 2
# Count: 3
# Count: 4
 
# 1부터 10까지 세기
for i in range(1, 11):
    print(i, end=" ")
print()  # Output: 1 2 3 4 5 6 7 8 9 10
 
# 2씩 증가하며 세기
for i in range(0, 20, 2):
    print(i, end=" ")
print()  # Output: 0 2 4 6 8 10 12 14 16 18
 
# 거꾸로 세기
for i in range(5, 0, -1):
    print(f"T-minus {i}")
# Output:
# T-minus 5
# T-minus 4
# T-minus 3
# T-minus 2
# T-minus 1

# range 만들기
numbers = range(10, 50, 5)  # 10, 15, 20, 25, 30, 35, 40, 45
 
# 인덱싱
print(numbers[0])   # Output: 10
print(numbers[3])   # Output: 25
print(numbers[-1])  # Output: 45
 
# 슬라이싱은 새 range를 반환합니다
subset = numbers[2:5]
print(subset)  # Output: range(20, 35, 5)
print(list(subset))  # Output: [20, 25, 30]
 
# 길이
print(len(numbers))  # Output: 8

# 0부터 20까지의 짝수
evens = range(0, 21, 2)
 
print(10 in evens)  # Output: True
print(15 in evens)  # Output: False
print(20 in evens)  # Output: True
 
# 매우 효율적입니다 - Python은 모든 숫자를 생성하지 않습니다
# 해당 숫자가 시퀀스에 속하는지 계산합니다
large_range = range(0, 1000000, 3)
print(999999 in large_range)  # Output: True (instant, no iteration needed)

# 빈 range - stop이 start와 같습니다
empty = range(5, 5)
print(list(empty))  # Output: []
print(len(empty))   # Output: 0
 
# 빈 range - 주어진 step으로 stop에 도달할 수 없습니다
impossible = range(1, 10, -1)  # 음수 step으로는 증가할 수 없습니다
print(list(impossible))  # Output: []
 
# 역방향 range
backwards = range(10, 0, -1)
print(list(backwards))  # Output: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
 
# 음수 범위 역방향
negative_range = range(-5, -15, -2)
print(list(negative_range))  # Output: [-5, -7, -9, -11, -13]

# 다음 경우에 range를 사용:
# 1. 반복(iteration)을 위한 숫자 시퀀스가 필요할 때
for i in range(100):
    # 무언가를 100번 처리
    pass
 
# 2. 시퀀스의 인덱스가 필요할 때
items = ["a", "b", "c", "d"]
for i in range(len(items)):
    print(f"Index {i}: {items[i]}")
 
# 3. 큰 시퀀스에서 메모리 효율이 중요할 때
# 최소한의 메모리를 사용합니다
for i in range(1000000):
    if i % 100000 == 0:
        print(i)
 
# 다음 경우에 리스트를 사용:
# 1. 실제 값을 저장해야 할 때
squares = [1, 3, 5, 7, 10]
 
# 2. 시퀀스를 수정해야 할 때
numbers = list(range(5))
numbers[2] = 100  # 값 수정
numbers.append(200)  # 값 추가
 
# 3. 서로 다른 연산으로 시퀀스를 여러 번 사용해야 할 때
data = list(range(10))
print(sum(data))
print(max(data))
print(sorted(data, reverse=True))

# 튜플 -> 리스트
student_tuple = ("Alice", 20, "CS")
student_list = list(student_tuple)
print(student_list)  # Output: ['Alice', 20, 'CS']
print(type(student_list))  # Output: <class 'list'>
 
# 이제 수정할 수 있습니다
student_list[1] = 21
student_list.append(3.8)
print(student_list)  # Output: ['Alice', 21, 'CS', 3.8]
 
# range -> 리스트
numbers = range(5)
numbers_list = list(numbers)
print(numbers_list)  # Output: [0, 1, 2, 3, 4]
 
# 문자열 -> 리스트(각 문자가 요소가 됩니다)
text = "Python"
chars = list(text)
print(chars)  # Output: ['P', 'y', 't', 'h', 'o', 'n']

# 리스트 -> 튜플
scores_list = [85, 90, 78, 92]
scores_tuple = tuple(scores_list)
print(scores_tuple)  # Output: (85, 90, 78, 92)
print(type(scores_tuple))  # Output: <class 'tuple'>
 
# 이제 불변입니다
# scores_tuple[0] = 88  # TypeError: 'tuple' object does not support item assignment
 
# range -> 튜플
numbers = range(1, 6)
numbers_tuple = tuple(numbers)
print(numbers_tuple)  # Output: (1, 2, 3, 4, 5)
 
# 문자열 -> 튜플
text = "Hi"
chars_tuple = tuple(text)
print(chars_tuple)  # Output: ('H', 'i')

# 문자열
text = "Python"
print(len(text))  # Output: 6
print(min(text))  # Output: P (유니코드 값 기준 가장 작은 문자)
print(max(text))  # Output: y (유니코드 값 기준 가장 큰 문자)
 
# 리스트
numbers = [45, 12, 78, 23, 56]
print(len(numbers))  # Output: 5
print(min(numbers))  # Output: 12
print(max(numbers))  # Output: 78
 
# 튜플
scores = (85, 92, 78, 95, 88)
print(len(scores))  # Output: 5
print(min(scores))  # Output: 78
print(max(scores))  # Output: 95
 
# range
nums = range(10, 50, 5)
print(len(nums))  # Output: 8
print(min(nums))  # Output: 10
print(max(nums))  # Output: 45

mixed = [1, "hello", 3]
# print(min(mixed))  # TypeError: '<' not supported between instances of 'str' and 'int'

# 양수 인덱싱(0부터 시작)
text = "Python"
numbers = [10, 20, 30, 40, 50]
coords = (5, 10, 15)
values = range(0, 100, 10)
 
print(text[0])      # Output: P
print(numbers[2])   # Output: 30
print(coords[1])    # Output: 10
print(values[3])    # Output: 30
 
# 음수 인덱싱(끝에서부터)
print(text[-1])     # Output: n (마지막 문자)
print(numbers[-2])  # Output: 40 (끝에서 두 번째)
print(coords[-3])   # Output: 5 (끝에서 세 번째, 즉 첫 번째)
print(values[-1])   # Output: 90 (range의 마지막 값)

# 문자열 - 부분 문자열(substring) 확인
text = "Python Programming"
print("Python" in text)      # Output: True
print("Java" in text)        # Output: False
print("gram" in text)        # Output: True (부분 문자열)
print("PYTHON" not in text)  # Output: True (대소문자 구분)
 
# 리스트
fruits = ["apple", "banana", "cherry", "date"]
print("banana" in fruits)    # Output: True
print("grape" in fruits)     # Output: False
print("apple" not in fruits) # Output: False
 
# 튜플
coordinates = (10, 20, 30, 40)
print(20 in coordinates)     # Output: True
print(25 in coordinates)     # Output: False
print(50 not in coordinates) # Output: True
 
# range - 매우 효율적이며 반복이 필요 없습니다
numbers = range(0, 100, 2)  # Even numbers 0 to 98
print(50 in numbers)         # Output: True
print(51 in numbers)         # Output: False (odd number)
print(100 in numbers)        # Output: False (stop은 포함되지 않습니다)

# +로 연결
text1 = "Hello"
text2 = " World"
print(text1 + text2)  # Output: Hello World
 
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2)  # Output: [1, 2, 3, 4, 5, 6]
 
tuple1 = (10, 20)
tuple2 = (30, 40)
print(tuple1 + tuple2)  # Output: (10, 20, 30, 40)
 
# *로 반복
print("Ha" * 3)           # Output: HaHaHa
print([0] * 5)            # Output: [0, 0, 0, 0, 0]
print((1, 2) * 3)         # Output: (1, 2, 1, 2, 1, 2)

r1 = range(5)
r2 = range(5, 10)
# combined = r1 + r2  # TypeError: unsupported operand type(s) for +: 'range' and 'range'
 
# range를 결합하려면 먼저 리스트나 튜플로 변환해야 합니다
combined = list(r1) + list(r2)
print(combined)  # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 문자열 - 부분 문자열 등장 횟수 세기
text = "Mississippi"
print(text.count("s"))   # Output: 4
print(text.count("ss"))  # Output: 2
print(text.count("i"))   # Output: 4
 
# 리스트
numbers = [1, 2, 3, 2, 4, 2, 5]
print(numbers.count(2))  # Output: 3
print(numbers.count(6))  # Output: 0
 
# 튜플
grades = (85, 90, 85, 92, 85, 88)
print(grades.count(85))  # Output: 3
print(grades.count(95))  # Output: 0
 
# range에는 count() 메서드가 없지만, 먼저 변환할 수 있습니다
nums = range(0, 20, 2)
nums_list = list(nums)
print(nums_list.count(10))  # Output: 1

# 문자열
text = "Python Programming"
print(text.index("P"))      # Output: 0 (첫 번째 P)
print(text.index("Pro"))    # Output: 7 (부분 문자열 위치)
# print(text.index("Java"))  # ValueError: substring not found
 
# 리스트
fruits = ["apple", "banana", "cherry", "banana"]
print(fruits.index("banana"))  # Output: 1 (첫 번째 등장)
print(fruits.index("cherry"))  # Output: 2
# print(fruits.index("grape"))  # ValueError: 'grape' is not in list
 
# 튜플
coordinates = (10, 20, 30, 20, 40)
print(coordinates.index(20))  # Output: 1 (첫 번째 등장)
print(coordinates.index(40))  # Output: 4
 
# range에는 index() 메서드가 없지만, 먼저 변환할 수 있습니다
nums = range(10, 50, 5)
nums_list = list(nums)
print(nums_list.index(25))  # Output: 3

fruits = ["apple", "banana", "cherry"]
search_fruit = "grape"
 
if search_fruit in fruits:
    position = fruits.index(search_fruit)
    print(f"{search_fruit} found at position {position}")
else:
    print(f"{search_fruit} not found")
# Output: grape not found

# 문자열 - 문자 단위로 순회
for char in "Python":
    print(char, end=" ")
print()  # Output: P y t h o n
 
# 리스트
for fruit in ["apple", "banana", "cherry"]:
    print(f"I like {fruit}")
# Output:
# I like apple
# I like banana
# I like cherry
 
# 튜플
for score in (85, 90, 78):
    print(f"Score: {score}")
# Output:
# Score: 85
# Score: 90
# Score: 78
 
# range
for i in range(1, 6):
    print(f"Count: {i}")
# Output:
# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

# 동등 비교
print([1, 2, 3] == [1, 2, 3])      # Output: True
print((1, 2, 3) == (1, 2, 3))      # Output: True
print("abc" == "abc")               # Output: True
 
# 부등 비교
print([1, 2, 3] != [1, 2, 4])      # Output: True
print((1, 2) != (1, 2))            # Output: False
 
# 사전식(lexicographic) 비교(요소별로 비교)
print([1, 2, 3] < [1, 2, 4])       # Output: True (3 < 4)
print([1, 2, 3] < [1, 3, 0])       # Output: True (2 < 3)
print("apple" < "banana")           # Output: True (알파벳 순)
print((1, 2) < (1, 2, 3))          # Output: True (앞이 같으면 더 짧은 쪽이 더 작습니다)
 
# 서로 다른 타입 비교
print([1, 2, 3] == (1, 2, 3))      # Output: False (타입이 다릅니다)

# 문자열 기본 슬라이싱
text = "Python Programming"
print(text[0:6])    # Output: Python
print(text[7:18])   # Output: Programming
print(text[7:])     # Output: Programming (인덱스 7부터 끝까지)
print(text[:6])     # Output: Python (처음부터 인덱스 6까지)
 
# 리스트 기본 슬라이싱
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:7])   # Output: [2, 3, 4, 5, 6]
print(numbers[:5])    # Output: [0, 1, 2, 3, 4]
print(numbers[5:])    # Output: [5, 6, 7, 8, 9]
 
# 튜플 기본 슬라이싱
coordinates = (10, 20, 30, 40, 50, 60)
print(coordinates[1:4])  # Output: (20, 30, 40)
print(coordinates[:3])   # Output: (10, 20, 30)
print(coordinates[3:])   # Output: (40, 50, 60)
 
# range 기본 슬라이싱
nums = range(0, 100, 10)
print(list(nums[2:5]))   # Output: [20, 30, 40]

# 두 번째 요소마다
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[::2])     # Output: [0, 2, 4, 6, 8]
print(numbers[1::2])    # Output: [1, 3, 5, 7, 9]
 
# 세 번째 요소마다
text = "abcdefghijklmnop"
print(text[::3])        # Output: adgjmp
 
# start와 stop을 포함한 step
print(numbers[2:8:2])   # Output: [2, 4, 6]
print(text[1:10:2])     # Output: bdfhj

# 전체 시퀀스 뒤집기
text = "Python"
print(text[::-1])       # Output: nohtyP
 
numbers = [1, 2, 3, 4, 5]
print(numbers[::-1])    # Output: [5, 4, 3, 2, 1]
 
coordinates = (10, 20, 30, 40)
print(coordinates[::-1])  # Output: (40, 30, 20, 10)
 
# step을 두고 뒤집기
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[::-2])    # Output: [9, 7, 5, 3, 1] (두 개마다, 역방향)
 
# 일부만 뒤집기
text = "Python Programming"
print(text[7:18][::-1])  # Output: gnimmargorP ("Programming" 뒤집기)

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
# 음수 step에서는 start가 stop보다 커야 합니다
print(numbers[7:2:-1])   # Output: [7, 6, 5, 4, 3] (7부터 3까지 내려감)
print(numbers[8:3:-2])   # Output: [8, 6, 4] (8부터 4까지 내려감, step -2)
 
# 음수 step에서 start/stop 생략
print(numbers[:5:-1])    # Output: [9, 8, 7, 6] (끝에서 6까지 내려감)
print(numbers[5::-1])    # Output: [5, 4, 3, 2, 1, 0] (5에서 시작까지 내려감)

text = "Python Programming"
# 마지막 11글자
print(text[-11:])        # Output: Programming
 
# 마지막 11글자를 제외한 나머지
print(text[:-11])        # Output: Python
 
# -15부터 -5까지
print(text[-15:-5])      # Output: hon Progra
 
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 마지막 5개 요소
print(numbers[-5:])      # Output: [5, 6, 7, 8, 9]
 
# 마지막 3개를 제외한 나머지
print(numbers[:-3])      # Output: [0, 1, 2, 3, 4, 5, 6]
 
# -7부터 -2까지
print(numbers[-7:-2])    # Output: [3, 4, 5, 6, 7]

# range 슬라이싱
numbers = range(0, 100, 5)  # 0, 5, 10, 15, ..., 95
print(numbers)  # Output: range(0, 100, 5)
 
# 슬라이스는 새 range를 반환합니다
subset = numbers[5:10]
print(subset)  # Output: range(25, 50, 5)
print(list(subset))  # Output: [25, 30, 35, 40, 45]
 
# step 포함
every_other = numbers[::2]
print(list(every_other))  # Output: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
 
# 음수 step
reversed_range = numbers[::-1]
print(list(reversed_range))  # Output: [95, 90, 85, ..., 5, 0]

numbers = [1, 2, 3, 4, 5]
 
# 빈 슬라이스(양수 step에서 start >= stop)
print(numbers[3:3])    # Output: []
print(numbers[5:10])   # Output: [] (stop이 길이를 넘어감)
print(numbers[10:20])  # Output: [] (둘 다 길이를 넘어감)
 
# 시퀀스 범위를 넘어가는 슬라이스는 안전합니다
print(numbers[-100:100])  # Output: [1, 2, 3, 4, 5] (전체 시퀀스)
print(numbers[2:100])     # Output: [3, 4, 5] (2부터 끝까지)
 
# 음수 step에서 호환되지 않는 start/stop
print(numbers[2:7:-1])    # Output: [] (음수 step으로 앞으로 갈 수 없음)
 
# step은 0이 될 수 없습니다
# print(numbers[::0])  # ValueError: slice step cannot be zero

# 슬라이싱으로 복사
original = [1, 2, 3, 4, 5]
copy = original[:]  # 처음부터 끝까지 슬라이싱
print(copy)  # Output: [1, 2, 3, 4, 5]
 
# 복사본을 수정해도 원본에는 영향이 없습니다
copy[0] = 100
print(f"Original: {original}")  # Output: Original: [1, 2, 3, 4, 5]
print(f"Copy: {copy}")          # Output: Copy: [100, 2, 3, 4, 5]
 
# 튜플에서도 동작합니다(새 튜플 생성)
original_tuple = (1, 2, 3, 4, 5)
copy_tuple = original_tuple[:]
print(copy_tuple)  # Output: (1, 2, 3, 4, 5)
 
# 문자열에서도
text = "Python"
text_copy = text[:]
print(text_copy)  # Output: Python

# 얕은 복사의 한계
original = [[1, 2], [3, 4]]
copy = original[:]
 
# 중첩 리스트를 수정하면 둘 다 영향을 받습니다
copy[0][0] = 100
print(f"Original: {original}")  # Output: Original: [[100, 2], [3, 4]]
print(f"Copy: {copy}")          # Output: Copy: [[100, 2], [3, 4]]