# 숫자형(Numeric)
x = 10                # 정수(int)
pi = 3.14             # 실수(float)
z = 3 + 4j            # 복소수(complex)

# 문자열(String)
name = "Python"       # 큰따옴표
desc = 'Language'     # 작은따옴표
text = """여러 줄의   # 여러 줄 문자열
문자열을 작성할 수
있습니다."""

# 불리언(Boolean)
is_valid = True
is_active = False

# None 타입
empty_value = None    # 값이 없음을 표현

# 리스트(List) - 순서가 있고, 변경 가능한 컬렉션
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", True, 3.14]

# 튜플(Tuple) - 순서가 있고, 변경 불가능한 컬렉션
coordinates = (10, 20)
person = ("John", 25, "New York")
single_item = (42,)  # 단일 아이템 튜플은 콤마 필요

# 딕셔너리(Dictionary) - 키-값 쌍의 컬렉션
user = {"name": "John", "age": 30, "city": "New York"}
scores = {1: "Gold", 2: "Silver", 3: "Bronze"}

# 집합(Set) - 중복이 없는 컬렉션
unique_numbers = {1, 2, 3, 4, 5}
unique_chars = set("hello")  # {'h', 'e', 'l', 'o'}

# 불변 집합(Frozenset) - 변경 불가능한 집합
immutable_set = frozenset([1, 2, 3, 4, 5])

# 문자열 -> 숫자
num_str = "123"
num_int = int(num_str)    # 123
num_float = float("3.14") # 3.14

# 숫자 -> 문자열
str_num = str(123)        # "123"

# 불리언 변환
bool(1)      # True
bool("")     # False
bool([])     # False
bool(0)      # False

# 컬렉션 간 변환
list((1, 2, 3))        # [1, 2, 3]
tuple([1, 2, 3])       # (1, 2, 3)
set([1, 2, 2, 3, 3])   # {1, 2, 3}
dict([("a", 1), ("b", 2)])  # {"a": 1, "b": 2}

# type() 함수 사용
type(123)     # <class 'int'>
type("text")  # <class 'str'>
type(3.14)    # <class 'float'>

# isinstance() 함수 사용
x = 100
isinstance(x, int)    # True
isinstance(x, str)    # False

# 다중 타입 확인
isinstance(x, (int, float))  # True (x가 int나 float 중 하나인지)

# 클래스 계층 확인
issubclass(bool, int)  # True (bool은 int의 하위 클래스)

# 불변(immutable) 타입
str_value = "hello"
num_value = 42
tuple_value = (1, 2, 3)
frozenset_value = frozenset([1, 2, 3])

# 가변(mutable) 타입
list_value = [1, 2, 3]
dict_value = {"key": "value"}
set_value = {1, 2, 3}

# 바이트(불변)
b = b'hello'  # 바이트 리터럴
b2 = bytes([104, 101, 108, 108, 111])  # ASCII 값으로 생성
print(b)  # b'hello'

# 바이트 배열(가변)
ba = bytearray(b'hello')
ba[0] = 72  # 첫 바이트 변경 (ASCII 'H')
print(ba)  # bytearray(b'Hello')

# 인코딩/디코딩
text = "안녕하세요"
encoded = text.encode('utf-8')  # 문자열 -> 바이트
decoded = encoded.decode('utf-8')  # 바이트 -> 문자열

# 열거형(Enum)
from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

print(Color.RED)  # Color.RED
print(Color.RED.name)  # 'RED'
print(Color.RED.value)  # 1

# 네임드 튜플(NamedTuple)
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(11, 22)
print(p.x, p.y)  # 11 22
print(p[0], p[1])  # 11 22

# 데이터 클래스(Python 3.7+)
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    city: str = "Unknown"

person = Person("John", 30)
print(person)  # Person(name='John', age=30, city='Unknown')

# 기본 타입 힌트 (Python 3.5+)
def greeting(name: str) -> str:
    return f"Hello, {name}"

# 복합 타입 힌트
from typing import List, Dict, Tuple, Optional, Union, Any

# 리스트 타입
def process_items(items: List[int]) -> List[str]:
    return [str(item) for item in items]

# 딕셔너리 타입
def get_user_data(user_id: int) -> Dict[str, Any]:
    return {"name": "John", "age": 30}

# 옵셔널 타입
def find_user(name: str) -> Optional[Dict[str, Any]]:
    if name == "John":
        return {"name": "John", "age": 30}
    return None

# 유니온 타입
def process_input(data: Union[str, int, float]) -> str:
    return str(data)

# 클래스 정의를 통한 사용자 정의 타입
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, my name is {self.name}"

# 인스턴스 생성
person = Person("John", 30)
print(type(person))  # <class '__main__.Person'>
print(person.greet())  # "Hello, my name is John"

# 타입 체크
print(isinstance(person, Person))  # True