# 수학 관련
abs(-3)         # 절댓값: 3
round(3.7)      # 반올림: 4
round(3.14159, 2)  # 소수점 2자리까지 반올림: 3.14
max([1,2,3])    # 최댓값: 3
min([1,2,3])    # 최솟값: 1
sum([1,2,3])    # 합계: 6
pow(2, 3)       # 거듭제곱: 8
divmod(7, 3)    # 몫과 나머지: (2, 1)

# 형변환
int("3")        # 정수로 변환: 3
int("FF", 16)   # 16진수 문자열을 정수로: 255
float("3.14")   # 실수로 변환: 3.14
str(123)        # 문자열로 변환: "123"
list("abc")     # 리스트로 변환: ['a','b','c']
tuple([1,2,3])  # 튜플로 변환: (1,2,3)
set([1,2,2,3])  # 집합으로 변환: {1,2,3}
dict(a=1, b=2)  # 딕셔너리로 변환: {'a':1, 'b':2}

# 길이와 범위
len([1,2,3])    # 길이: 3
range(5)        # 범위: 0,1,2,3,4
range(1, 10, 2) # 시작, 종료, 스텝: 1,3,5,7,9

# 반복 처리
enumerate(['a','b'])     # 인덱스-값 쌍: (0,'a'),(1,'b')
enumerate(['a','b'], 1)  # 시작 인덱스 지정: (1,'a'),(2,'b')
zip([1,2], [3,4])        # 쌍으로 묶기: (1,3),(2,4)
zip(*[[1,3], [2,4]])     # 언패킹으로 전치: (1,2),(3,4)

# 데이터 처리
list(filter(lambda x: x>0, [-1,0,1]))  # 필터링: [1]
list(map(lambda x: x*2, [1,2,3]))      # 변환: [2,4,6]
from functools import reduce
reduce(lambda x,y: x+y, [1,2,3])  # 누적 연산: 6

# 컬렉션 생성
all([True, True, False])  # 모두 참인지: False
any([True, False, False]) # 하나라도 참인지: True

# 타입 확인
type(123)               # 타입 확인: <class 'int'>
isinstance(123, int)    # 타입 검사: True
isinstance(123, (int, float))  # 여러 타입 중 하나인지: True
issubclass(bool, int)   # 상속 관계 확인: True

# 속성/메서드 확인
dir([])                 # 객체의 속성/메서드 목록
hasattr(obj, 'attr')    # 속성 존재 여부
getattr(obj, 'attr')    # 속성 값 가져오기
setattr(obj, 'attr', value)  # 속성 값 설정
delattr(obj, 'attr')    # 속성 삭제

# 속성 이름/값
vars(obj)               # 객체의 __dict__ 반환
globals()              # 전역 심볼 테이블
locals()               # 지역 심볼 테이블

# 입출력
print("Hello")           # 출력
print("A", "B", sep=",") # 구분자 지정: "A,B"
print("End", end="")     # 끝문자 지정 (줄바꿈 방지)
input("입력: ")          # 입력 받기

# 파일
open('file.txt', 'r')    # 파일 열기
with open('file.txt', 'r') as f:  # 컨텍스트 관리자 사용
    data = f.read()

# 시스템
id(obj)                 # 객체의 고유 ID
hash(obj)               # 해시값
help(print)             # 도움말 표시
exit()                  # 프로그램 종료
__import__('math')      # 동적 모듈 임포트

# 메모리 관리
repr(obj)               # 객체의 문자열 표현
format(12.3, '.2f')     # 형식 지정: "12.30"

# 객체 변환 및 검사
ascii('한글')           # ASCII로 표현: '\ud55c\uae00'
ord('A')               # 문자의 유니코드 코드포인트: 65
chr(65)                # 코드포인트에 해당하는 문자: 'A'
callable(func)         # 호출 가능 여부 확인: True/False

# 클래스 관련
@classmethod           # 클래스 메서드 데코레이터
@staticmethod          # 정적 메서드 데코레이터
@property              # 속성 데코레이터
super()                # 부모 클래스 참조

# 평가/실행
eval("1 + 2")           # 문자열 수식 계산: 3
exec("x = 1")           # 문자열 코드 실행
compile("x+y", "<string>", "eval")  # 코드 컴파일

# 정렬
sorted([3,1,2])         # 정렬: [1,2,3]
sorted([3,1,2], reverse=True)  # 역순 정렬: [3,2,1]
sorted([(1,'b'), (2,'a')], key=lambda x: x[1])  # 키 기준: [(2,'a'), (1,'b')]

# 진법 변환
bin(42)                 # 2진수: '0b101010'
oct(42)                 # 8진수: '0o52'
hex(42)                 # 16진수: '0x2a'
int('0b101010', 2)      # 2진수 문자열에서 정수로: 42

# 복소수
complex(1, 2)           # 복소수 생성: (1+2j)
abs(3+4j)               # 복소수 절댓값(크기): 5.0

# 이터레이터
iter([1, 2, 3])         # 이터레이터 생성
next(iterator)          # 다음 항목 가져오기

# 슬라이싱과 인덱싱
slice(1, 10, 2)         # 슬라이스 객체 생성
array[slice(1, 10, 2)]  # [1:10:2]와 동일

# 비교 함수
cmp_to_key(func)        # 비교 함수를 키 함수로 변환
sorted([3,1,2], key=cmp_to_key(lambda a, b: a - b))

# 함수형 프로그래밍
from functools import partial
add5 = partial(lambda x, y: x + y, 5)  # 부분 적용: add5(3) == 8

# 메모리 뷰
memoryview(bytes(10))   # 메모리 효율적인 바이트 조작

# 객체 크기
import sys
sys.getsizeof([1, 2, 3])  # 객체 메모리 사용량 (바이트)

# 성능 측정
from timeit import timeit
timeit("'-'.join(str(n) for n in range(100))", number=10000)

# 데이터 처리 파이프라인
data = [1, -2, 3, -4, 5]
result = sum(map(abs, filter(lambda x: x % 2 == 1, data)))
print(result)  # 홀수 값들의 절댓값 합: 9

# 사전의 키-값 교체
inverted_dict = dict(map(reversed, original_dict.items()))

# 중첩 리스트 평탄화
nested = [[1, 2], [3, 4]]
flattened = list(sum(nested, []))  # [1, 2, 3, 4]
# 더 효율적인 방법 (itertools 사용)
from itertools import chain
flattened = list(chain.from_iterable(nested))

# Python 3.8+
breakpoint()           # 디버거 진입점
# Python 3.7+
from time import time_ns
time_ns()              # 나노초 단위 시간 측정
# Python 3.5+
from math import isclose
isclose(1.0, 1.0001, rel_tol=1e-3)  # 부동소수점 근사 비교: True

# 큰 파일 효율적으로 읽기
with open('large_file.txt', 'r') as f:
    # 한 번에 모두 읽는 대신 라인 단위로 처리
    for line in f:
        process(line.strip())

# 대용량 리스트 생성 시 리스트 컴프리헨션 활용
squares = [x**2 for x in range(1000)]  # map() 함수보다 빠를 수 있음

# 딕셔너리 컴프리헨션
word_lengths = {word: len(word) for word in words}

# 불필요한 전체 리스트 생성 방지
def process_large_data():
    data = get_data_source()  # 이터레이터 반환
    filtered = filter(is_valid, data)
    transformed = map(transform, filtered)
    
    # 필요한 부분만 계산(처음 10개만)
    for i, item in enumerate(transformed):
        if i >= 10:
            break
        process_item(item)

class CustomCollection:
    def __init__(self, items):
        self.items = items
    
    def __len__(self):
        return len(self.items)
    
    def __iter__(self):
        return iter(self.items)
    
    def __contains__(self, item):
        return item in self.items
    
    def __bool__(self):
        return bool(self.items)
    
    def __getitem__(self, idx):
        return self.items[idx]

# 내장 함수와 연동
collection = CustomCollection([1, 2, 3])
print(len(collection))  # 3
print(2 in collection)  # True
print(bool(collection)) # True
print(list(collection)) # [1, 2, 3]