# 기본 for문 구조
for 변수 in 시퀀스:
    수행할_문장1
    수행할_문장2
    ...

# 예제
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit)

# range() 기본 사용법
for i in range(5):          # 0부터 4까지
    print(i)

# 시작과 끝 지정
for i in range(1, 6):      # 1부터 5까지
    print(i)

# 스텝 지정
for i in range(0, 10, 2):  # 0부터 9까지 2씩 증가
    print(i)               # 0, 2, 4, 6, 8 출력

# break 사용
for i in range(10):
    if i == 5:
        break
    print(i)

# continue 사용
for i in range(10):
    if i % 2 == 0:
        continue    # 짝수면 건너뛰기
    print(i)       # 홀수만 출력

# 기본 형태
squares = [x**2 for x in range(10)]

# 조건문 포함
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 중첩 반복문
matrix = [[i*j for j in range(3)] for i in range(3)]

# 기존 방식과 비교
# 기존 방식
squares = []
for x in range(10):
    squares.append(x**2)

# 컴프리헨션
squares = [x**2 for x in range(10)]

# 구구단 출력
for i in range(2, 10):
    for j in range(1, 10):
        print(f"{i} x {j} = {i*j}")
    print()

# 리스트 순회하며 처리
scores = [90, 85, 77, 65, 97]
for i, score in enumerate(scores):
    print(f"학생{i+1}: {score}점")

# 딕셔너리 순회
person = {'name': 'John', 'age': 30, 'city': 'Seoul'}
for key, value in person.items():
    print(f"{key}: {value}")

# 딕셔너리 컴프리헨션
word_lengths = {word: len(word) for word in ['apple', 'banana', 'orange']}
# 결과: {'apple': 5, 'banana': 6, 'orange': 6}

# 세트 컴프리헨션
unique_lengths = {len(word) for word in ['apple', 'banana', 'orange', 'pear']}
# 결과: {4, 5, 6}

# 중첩 컴프리헨션과 조건
flattened = [num for row in [[1, 2], [3, 4], [5, 6]] for num in row if num % 2 == 0]
# 결과: [2, 4, 6]

# 조건부 값 할당
scores = [85, 92, 78, 90, 55]
grades = ['A' if score >= 90 else 'B' if score >= 80 else 'C' if score >= 70 else 'F' for score in scores]
# 결과: ['B', 'A', 'C', 'A', 'F']

# 조건부 표현식을 사용한 필터링과 변환
data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 17}, {'name': 'Charlie', 'age': 30}]
adult_names = [person['name'] for person in data if person['age'] >= 18]
# 결과: ['Alice', 'Charlie']

# 이터러블과 이터레이터
iterable = [1, 2, 3]
iterator = iter(iterable)

print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
# print(next(iterator))  # StopIteration 예외 발생

# 간단한 제너레이터 함수
def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

# 제너레이터 사용
counter = count_up_to(5)
for num in counter:
    print(num)  # 1, 2, 3, 4, 5 출력

# 제너레이터 컴프리헨션 (제너레이터 표현식)
gen = (x**2 for x in range(5))
for value in gen:
    print(value)  # 0, 1, 4, 9, 16 출력

# 무한 시퀀스 생성
def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

# 무한 시퀀스에서 일부만 사용
sequence = infinite_sequence()
for i, num in enumerate(sequence):
    print(num)
    if i >= 9:  # 10개만 출력
        break

import time

# 1. 루프 내부 최소화
# 비효율적 방법
start = time.time()
result = []
for i in range(1000000):
    # 루프 내부에서 계산이 반복됨
    result.append(i ** 2 + 2 * i + 1)
print(f"시간: {time.time() - start:.4f}초")

# 최적화 방법
start = time.time()
result = [(i ** 2 + 2 * i + 1) for i in range(1000000)]
print(f"시간: {time.time() - start:.4f}초")

# 2. 불필요한 함수 호출 줄이기
# 비효율적 방법
start = time.time()
data = [1, 2, 3, 4, 5] * 1000000
length = 0
for item in data:
    length += len(str(item))  # 매번 str() 함수 호출
print(f"시간: {time.time() - start:.4f}초")

# 최적화 방법
start = time.time()
data = [1, 2, 3, 4, 5] * 1000000
str_data = [str(item) for item in data]  # 먼저 변환
length = 0
for s in str_data:
    length += len(s)
print(f"시간: {time.time() - start:.4f}초")

# 비효율적 방법 (전역 함수를 반복 참조)
def process_data(items):
    result = []
    for item in items:
        result.append(len(item))
    return result

# 최적화 방법 (지역 변수에 함수 바인딩)
def process_data_optimized(items):
    result = []
    _len = len  # 지역 변수에 함수 바인딩
    _append = result.append
    for item in items:
        _append(_len(item))
    return result

# 비효율적 방법 (리스트에서 검색)
data = list(range(10000))
count = 0
for i in range(1000):
    if i in data:  # O(n) 검색
        count += 1

# 최적화 방법 (세트에서 검색)
data_set = set(range(10000))  # O(1) 검색
count = 0
for i in range(1000):
    if i in data_set:
        count += 1

import concurrent.futures
import time

# 처리할 작업
def process_item(item):
    time.sleep(0.1)  # 시간이 걸리는 작업 시뮬레이션
    return item * item

# 기본적인 for 반복문
def sequential_process():
    start = time.time()
    items = list(range(100))
    results = []
    for item in items:
        results.append(process_item(item))
    print(f"순차 처리 시간: {time.time() - start:.2f}초")
    return results

# ThreadPoolExecutor를 사용한 병렬 처리
def parallel_process_threads():
    start = time.time()
    items = list(range(100))
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        results = list(executor.map(process_item, items))
    print(f"스레드 병렬 처리 시간: {time.time() - start:.2f}초")
    return results

# ProcessPoolExecutor를 사용한 병렬 처리
def parallel_process_processes():
    start = time.time()
    items = list(range(100))
    with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(process_item, items))
    print(f"프로세스 병렬 처리 시간: {time.time() - start:.2f}초")
    return results

# 비교 실행
sequential_results = sequential_process()  # 약 10초
thread_results = parallel_process_threads()  # CPU 바운드가 아니면 더 빠름
process_results = parallel_process_processes()  # CPU 바운드 작업에 적합

def process_in_chunks(items, chunk_size=100):
    """대용량 데이터를 청크 단위로 처리"""
    for i in range(0, len(items), chunk_size):
        chunk = items[i:i + chunk_size]
        # 청크 단위 처리
        process_chunk(chunk)
        print(f"청크 {i//chunk_size + 1} 처리 완료 ({len(chunk)} 항목)")

def find_first_match(items, condition):
    """조건에 맞는 첫 번째 항목 찾기"""
    for item in items:
        if condition(item):
            return item
    return None

# 사용 예시
first_even = find_first_match(range(1, 100), lambda x: x % 2 == 0 and x > 10)

def sliding_window(items, window_size):
    """슬라이딩 윈도우 패턴으로 항목 처리"""
    for i in range(len(items) - window_size + 1):
        yield items[i:i + window_size]

# 사용 예시
text = "ABCDEFGHIJ"
for window in sliding_window(text, 3):
    print(window)  # "ABC", "BCD", "CDE", ...

def track_state_changes(items):
    """항목 상태 변화 추적"""
    if not items:
        return []
    
    changes = []
    previous = items[0]
    
    for current in items[1:]:
        if current != previous:
            changes.append((previous, current))
            previous = current
    
    return changes

# 사용 예시
temps = [22, 22, 23, 23, 23, 24, 25, 25, 24, 24]
print(track_state_changes(temps))  # [(22, 23), (23, 24), (24, 25), (25, 24)]

# 비효율적인 중첩 루프
def find_pairs_naive(items1, items2, target_sum):
    """합이 target_sum인 두 리스트의 항목 쌍 찾기 (O(n²))"""
    pairs = []
    for x in items1:
        for y in items2:
            if x + y == target_sum:
                pairs.append((x, y))
    return pairs

# 최적화된 방법
def find_pairs_optimized(items1, items2, target_sum):
    """합이 target_sum인 두 리스트의 항목 쌍 찾기 (O(n))"""
    complements = set(target_sum - x for x in items1)
    return [(target_sum - y, y) for y in items2 if y in complements]