# 기본 산술 연산자
x = 10
y = 3

print(x + y)    # 13  (덧셈)
print(x - y)    # 7   (뺄셈)
print(x * y)    # 30  (곱셈)
print(x / y)    # 3.333... (나눗셈)
print(x // y)   # 3   (몫)
print(x % y)    # 1   (나머지)
print(x ** y)   # 1000 (거듭제곱)

x = 5
y = 3

print(x == y)   # False (같음)
print(x != y)   # True  (다름)
print(x > y)    # True  (크다)
print(x < y)    # False (작다)
print(x >= y)   # True  (크거나 같다)
print(x <= y)   # False (작거나 같다)

x = True
y = False

print(x and y)  # False (논리곱)
print(x or y)   # True  (논리합)
print(not x)    # False (논리부정)

x = 10          # 기본 할당
x += 5          # x = x + 5
x -= 3          # x = x - 3
x *= 2          # x = x * 2
x /= 4          # x = x / 4
x //= 2         # x = x // 2
x %= 3          # x = x % 3
x **= 2         # x = x ** 2

x = 60  # 0011 1100
y = 13  # 0000 1101

print(x & y)    # 12  (AND)
print(x | y)    # 61  (OR)
print(x ^ y)    # 49  (XOR)
print(~x)       # -61 (NOT)
print(x << 2)   # 240 (왼쪽 시프트)
print(x >> 2)   # 15  (오른쪽 시프트)

lst = [1, 2, 3, 4, 5]

print(3 in lst)     # True
print(6 not in lst) # True

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a is c)     # True (같은 객체)
print(a is b)     # False (다른 객체)
print(a is not b) # True (다른 객체)

# 주의: == vs is
print(a == b)     # True (값이 같음)
print(a is b)     # False (다른 객체)

# 우선순위 예시
result = 2 + 3 * 4  # 14 (곱셈 먼저)

# and 연산자의 단락 평가
x = False
y = print("y가 평가됨") or True  # y가 평가됨

result = x and y  # y는 평가되지 않음
print(result)     # False

# or 연산자의 단락 평가
x = True
y = print("y가 평가됨") or True  # y가 평가되지 않음

result = x or y   # y는 평가되지 않음
print(result)     # True

# 실용적인 활용
def get_user():
    print("사용자 정보 가져오기")
    return {"name": "홍길동"}

# 기존 사용자가 있으면 가져오고, 없으면 새로 생성
user = existing_user or get_user()

# 안전한 속성 접근
name = user and user.get('name')

# 기본값 설정
default_config = {"timeout": 30, "retries": 3}
config = user_config or default_config

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    # + 연산자 오버로딩
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    # - 연산자 오버로딩
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    # * 연산자 오버로딩 (스칼라 곱)
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    # == 연산자 오버로딩
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    
    # 문자열 표현
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(1, 2)
v2 = Vector(3, 4)

v3 = v1 + v2       # Vector(4, 6)
v4 = v1 - v2       # Vector(-2, -2)
v5 = v1 * 3        # Vector(3, 6)

print(v3)
print(v4)
print(v5)
print(v1 == Vector(1, 2))  # True

# 조건에 따라 다른 값 할당
x = 10
result = "짝수" if x % 2 == 0 else "홀수"
print(result)  # 짝수

# 중첩 삼항 연산자
score = 85
grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D"
print(grade)  # B

# 리스트 풀기
a, b, c = [1, 2, 3]
print(a, b, c)  # 1 2 3

# 나머지 요소 모으기 (Python 3.x)
first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# 딕셔너리 풀기
person = {'name': '홍길동', 'age': 30}
print("{name}님은 {age}세입니다.".format(**person))  # 홍길동님은 30세입니다.

# 기존 방식
numbers = [1, 2, 3, 4, 5]
filtered = []
for num in numbers:
    squared = num ** 2
    if squared > 10:
        filtered.append(squared)
print(filtered)  # [16, 25]

# 월즈 연산자 사용 (Python 3.8+)
numbers = [1, 2, 3, 4, 5]
filtered = [squared for num in numbers if (squared := num ** 2) > 10]
print(filtered)  # [16, 25]

# while 루프에서 활용
while (line := input("입력하세요 (종료하려면 'q'): ")) != 'q':
    print(f"입력값: {line}")

# 비트 플래그 사용
READ = 1      # 0001
WRITE = 2     # 0010
EXECUTE = 4   # 0100
DELETE = 8    # 1000

# 권한 부여
permission = READ | WRITE  # 0011 (3)

# 권한 확인
has_read = permission & READ  # 0001 (1) - 있음
has_execute = permission & EXECUTE  # 0000 (0) - 없음

print(f"Read 권한: {bool(has_read)}")  # True
print(f"Execute 권한: {bool(has_execute)}")  # False

# 권한 추가
permission |= EXECUTE  # 0111 (7)
print(f"Execute 권한 추가 후: {bin(permission)}")  # 0b111

# 권한 제거
permission &= ~DELETE  # 0111 & ~1000 = 0111 (7)
print(f"Delete 권한 제거 확인: {bin(permission)}")  # 0b111

# 특정 비트만 토글(변경)
permission ^= WRITE  # 0111 ^ 0010 = 0101 (5)
print(f"Write 권한 토글 후: {bin(permission)}")  # 0b101

from functools import reduce
from operator import add, mul, itemgetter, attrgetter

# 리스트 합계 계산
numbers = [1, 2, 3, 4, 5]
sum_result = reduce(add, numbers)
print(f"합계: {sum_result}")  # 15

# 리스트 곱 계산
product_result = reduce(mul, numbers, 1)
print(f"곱: {product_result}")  # 120

# 객체 리스트 정렬
people = [
    {'name': '홍길동', 'age': 20},
    {'name': '김철수', 'age': 35},
    {'name': '이영희', 'age': 25}
]

# 나이순 정렬
age_sorted = sorted(people, key=itemgetter('age'))
print("나이순 정렬:", [p['name'] for p in age_sorted])  # ['홍길동', '이영희', '김철수']

# 이름순 정렬
name_sorted = sorted(people, key=itemgetter('name'))
print("이름순 정렬:", [p['name'] for p in name_sorted])  # ['김철수', '이영희', '홍길동']

# 클래스 속성으로 정렬
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

people_objs = [
    Person('홍길동', 20),
    Person('김철수', 35),
    Person('이영희', 25)
]

age_sorted_objs = sorted(people_objs, key=attrgetter('age'))
print("나이순 정렬(객체):", age_sorted_objs)

# with 문은 내부적으로 __enter__와 __exit__ 연산자를 사용

class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        self.end = time.time()
        self.interval = self.end - self.start
        print(f"실행 시간: {self.interval:.6f}초")
        return False  # 예외 전파
    
# 사용 예시
with Timer() as timer:
    # 시간 측정할 코드
    total = sum(range(1000000))