# 기본 while문 구조
while 조건:
    수행할_문장1
    수행할_문장2
    ...

# 예제: 1부터 5까지 출력
number = 1
while number <= 5:
    print(number)
    number += 1

# break: 반복문 종료
coffee = 10
while True:
    if coffee == 0:
        print("커피가 모두 소진되었습니다.")
        break
    print(f"남은 커피: {coffee}잔")
    coffee -= 1

# continue: 현재 반복을 건너뛰고 다음 반복으로
number = 0
while number < 10:
    number += 1
    if number % 2 == 0:
        continue    # 짝수면 출력하지 않음
    print(number)  # 홀수만 출력

# 무한 루프 기본 구조
while True:
    user_input = input("종료하려면 'q'를 입력하세요: ")
    if user_input == 'q':
        break
    print("입력값:", user_input)

# 실제 응용 예제
def calculator():
    while True:
        command = input("계산할 식을 입력하세요 (종료: q): ")
        if command == 'q':
            break
        try:
            result = eval(command)
            print(f"결과: {result}")
        except:
            print("올바른 수식을 입력하세요")

# 사용자 입력 처리
def menu_system():
    while True:
        print("\n1. 파일 열기")
        print("2. 파일 저장")
        print("3. 종료")
        choice = input("선택하세요: ")
        
        if choice == '1':
            print("파일을 엽니다.")
        elif choice == '2':
            print("파일을 저장합니다.")
        elif choice == '3':
            print("프로그램을 종료합니다.")
            break
        else:
            print("잘못된 선택입니다.")

# 조건부 반복
def countdown(n):
    while n > 0:
        print(n)
        n -= 1
    print("발사!")

# 기본 구조
while 조건:
    # 조건이 참인 동안 실행
    수행할_문장
else:
    # 조건이 거짓이 되어 루프가 종료되면 실행
    종료_후_수행할_문장

# 소수 찾기 예제
def is_prime(n):
    if n <= 1:
        return False
    
    i = 2
    while i * i <= n:
        if n % i == 0:
            print(f"{n}은 {i}로 나누어떨어집니다.")
            break
        i += 1
    else:
        print(f"{n}은 소수입니다.")
        return True
    
    return False

# 사용 예시
is_prime(17)  # 출력: 17은 소수입니다.
is_prime(25)  # 출력: 25은 5로 나누어떨어집니다.

# 기본 중첩 while문
i = 1
while i <= 5:
    j = 1
    while j <= i:
        print("*", end="")
        j += 1
    print()  # 줄바꿈
    i += 1

# 중첩 루프에서 특정 루프만 종료하기
i = 1
while i <= 5:
    j = 1
    while j <= 5:
        print(f"({i}, {j})", end=" ")
        if j == 3:
            break  # 내부 루프만 종료
        j += 1
    print()
    i += 1

# 중첩 루프에서 모든 루프 종료하기
found = False
i = 1
while i <= 5 and not found:
    j = 1
    while j <= 5:
        if i * j > 10:
            print(f"첫 번째 10보다 큰 곱: {i} * {j} = {i*j}")
            found = True
            break  # 내부 루프 종료
        j += 1
    i += 1

import time

# 최적화 전
def compute_factorial_unoptimized(n):
    result = 1
    while n > 0:
        result *= n
        n -= 1
    return result

# 최적화 1: 조건 검사 최소화
def compute_factorial_optimized1(n):
    result = 1
    while n > 1:  # n > 0 대신 n > 1 사용 (불필요한 곱셈 회피)
        result *= n
        n -= 1
    return result

# 최적화 2: 지역 변수 활용
def compute_factorial_optimized2(n):
    result = 1
    i = 2  # 1부터 시작하지 않고 2부터 시작
    while i <= n:
        result *= i
        i += 1
    return result

# 최적화 3: 계산 줄이기
def compute_factorial_optimized3(n):
    if n <= 1:
        return 1
    
    result = 1
    i = n
    while i > 1:
        result *= i
        i -= 1
    return result

# 최적화 전: 루프 내부에서 조건 매번 계산
def find_in_sorted_list(sorted_list, target):
    i = 0
    while i < len(sorted_list):  # 매번 len() 호출
        if sorted_list[i] == target:
            return i
        elif sorted_list[i] > target:  # 정렬된 리스트에서 타겟보다 큰 값을 만나면 종료
            break
        i += 1
    return -1

# 최적화 후: 조건을 미리 계산
def find_in_sorted_list_optimized(sorted_list, target):
    i = 0
    length = len(sorted_list)  # 한 번만 계산
    while i < length:
        value = sorted_list[i]  # 반복적 인덱싱 방지
        if value == target:
            return i
        elif value > target:
            break
        i += 1
    return -1

import time

def retry_operation(max_attempts=3, timeout=10):
    start_time = time.time()
    attempts = 0
    
    while attempts < max_attempts and (time.time() - start_time) < timeout:
        attempts += 1
        try:
            # 실행할 작업
            print(f"시도 {attempts}...")
            if attempts == 2:  # 성공 시뮬레이션
                print("작업 성공!")
                return True
        except Exception as e:
            print(f"오류 발생: {e}")
            time.sleep(1)  # 재시도 전 대기
    
    print("최대 시도 횟수 초과 또는 시간 초과")
    return False

# 사용 예시
retry_operation()

import queue
import threading
import time
import random

# 공유 큐
buffer = queue.Queue(maxsize=10)
RUNNING = True

def producer():
    """데이터를 생성하여 버퍼에 추가"""
    count = 0
    while RUNNING:
        if not buffer.full():
            item = f"아이템-{count}"
            buffer.put(item)
            print(f"생산: {item}")
            count += 1
        time.sleep(random.uniform(0.1, 0.5))

def consumer():
    """버퍼에서 데이터를 가져와 처리"""
    while RUNNING:
        if not buffer.empty():
            item = buffer.get()
            print(f"소비: {item}")
            buffer.task_done()
        time.sleep(random.uniform(0.2, 0.7))

# 스레드 시작
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

producer_thread.start()
consumer_thread.start()

# 10초 동안 실행 후 종료
time.sleep(10)
RUNNING = False
producer_thread.join()
consumer_thread.join()

def wait_for_resource(resource_check_fn, timeout=30, check_interval=1):
    """리소스가 준비될 때까지 주기적으로 확인"""
    start_time = time.time()
    
    while (time.time() - start_time) < timeout:
        if resource_check_fn():
            print("리소스 준비 완료!")
            return True
        
        print("리소스 준비 중...")
        time.sleep(check_interval)
    
    print("리소스 준비 시간 초과")
    return False

# 사용 예시
def is_database_ready():
    # 실제로는 데이터베이스 연결 확인
    import random
    return random.random() > 0.7

wait_for_resource(is_database_ready)

# 기본 제너레이터
def fibonacci_generator(limit):
    a, b = 0, 1
    count = 0
    
    while count < limit:
        yield a
        a, b = b, a + b
        count += 1

# 사용 예시
for num in fibonacci_generator(10):
    print(num)  # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

# 무한 제너레이터
def infinite_counter(start=0, step=1):
    """무한히 값을 생성하는 제너레이터"""
    n = start
    while True:
        yield n
        n += step

# 필요한 만큼만 소비
for i, num in enumerate(infinite_counter(10, 5)):
    print(num)
    if i >= 5:  # 처음 6개 값만 가져옴
        break

# 제너레이터 표현식
def evens_under(n):
    """n 미만의 짝수를 생성하는 제너레이터 표현식"""
    return (i for i in range(n) if i % 2 == 0)

# 지연 평가(Lazy Evaluation) 활용
def search_in_large_file(file_path, search_term):
    """대용량 파일에서 특정 단어가 포함된 줄 찾기"""
    with open(file_path, 'r') as file:
        line_number = 0
        while True:
            line = file.readline()
            if not line:  # 파일 끝
                break
            
            line_number += 1
            if search_term in line:
                yield (line_number, line.strip())

import asyncio

# 비동기 while 루프
async def async_counter(limit):
    count = 0
    while count < limit:
        print(f"카운트: {count}")
        await asyncio.sleep(0.5)  # 비차단 대기
        count += 1
    return count

# 비동기 이벤트 처리
async def event_processor(queue, timeout=None):
    start_time = asyncio.get_event_loop().time()
    
    while timeout is None or (asyncio.get_event_loop().time() - start_time) < timeout:
        try:
            # 0.1초 동안 큐에서 항목 대기
            event = await asyncio.wait_for(queue.get(), 0.1)
            print(f"이벤트 처리: {event}")
            queue.task_done()
        except asyncio.TimeoutError:
            print("이벤트 대기 중...")
            # 큐가 비어있어도 루프 계속 실행
            continue

# 비동기 작업 동시 실행
async def concurrent_tasks():
    # 이벤트 큐 생성
    event_queue = asyncio.Queue()
    
    # 이벤트 생성자 함수
    async def event_generator():
        for i in range(10):
            event = f"이벤트-{i}"
            await event_queue.put(event)
            print(f"이벤트 생성: {event}")
            await asyncio.sleep(0.7)
    
    # 두 작업 동시 실행
    await asyncio.gather(
        event_generator(),
        event_processor(event_queue, timeout=10)
    )

# 비동기 타임아웃 패턴
async def with_timeout(coroutine, timeout=5.0):
    try:
        return await asyncio.wait_for(coroutine, timeout)
    except asyncio.TimeoutError:
        print("작업 시간 초과")
        return None

# 사용 예시
async def main():
    # 카운터 실행
    await with_timeout(async_counter(10), 3.0)
    
    # 동시 작업 실행
    await concurrent_tasks()

# 비동기 메인 함수 실행
asyncio.run(main())

class StateMachine:
    def __init__(self, initial_state):
        self.state = initial_state
        self.handlers = {}
        self.end_states = []
    
    def add_state(self, name, handler, end_state=False):
        """상태 추가"""
        self.handlers[name] = handler
        if end_state:
            self.end_states.append(name)
    
    def run(self, cargo):
        """상태 기계 실행"""
        while self.state not in self.end_states:
            # 현재 상태에 대한 핸들러 가져오기
            handler = self.handlers[self.state]
            # 핸들러 실행 및 다음 상태와 화물 받기
            self.state, cargo = handler(cargo)
        
        return cargo

# 예제: 텍스트 처리 상태 기계
def start_state(text):
    """시작 상태: 텍스트 준비"""
    words = text.split()
    return 'process_words', words

def process_words(words):
    """단어 처리 상태"""
    if not words:
        return 'end', []
    
    processed_words = [word.strip('.,!?').lower() for word in words]
    return 'count_length', processed_words

def count_length(words):
    """길이 계산 상태"""
    word_lengths = [(word, len(word)) for word in words]
    return 'end', word_lengths

# 상태 기계 생성 및 실행
def process_text(text):
    sm = StateMachine('start')
    sm.add_state('start', start_state)
    sm.add_state('process_words', process_words)
    sm.add_state('count_length', count_length)
    sm.add_state('end', None, end_state=True)
    
    result = sm.run(text)
    return result

# 사용 예시
text = "Python은 간결하고 읽기 쉬운 프로그래밍 언어입니다!"
word_lengths = process_text(text)
for word, length in word_lengths:
    print(f"'{word}': {length}자")

# 문제: 종료 조건이 충족되지 않음
i = 10
while i > 0:
    print(i)
    # i -= 1  # 주석 해제로 해결

# 해결: 타임아웃 패턴 적용
def with_timeout(func, args=(), timeout=5):
    import threading
    import time
    
    result = [None]
    exception = [None]
    
    def worker():
        try:
            result[0] = func(*args)
        except Exception as e:
            exception[0] = e
    
    thread = threading.Thread(target=worker)
    thread.daemon = True
    thread.start()
    thread.join(timeout)
    
    if thread.is_alive():
        raise TimeoutError(f"함수 실행이 {timeout}초를 초과했습니다.")
    
    if exception[0]:
        raise exception[0]
    
    return result[0]

# 문제: 조건 평가 오류
data = [1, 2, 3]
i = 0
while i < len(data):
    print(data[i])
    data.append(i)  # 매 반복마다 리스트 크기가 증가해 무한 루프 발생
    i += 1

# 해결: 별도 변수에 길이 저장
data = [1, 2, 3]
i = 0
length = len(data)  # 처음 길이만 사용
while i < length:
    print(data[i])
    data.append(i)  # 루프 조건에 영향 없음
    i += 1

# 문제: 한 번 더 반복하거나 한 번 덜 반복
arr = [10, 20, 30, 40, 50]
i = 0
while i <= len(arr):  # 잘못된 조건 (<=)
    # 인덱스 오류 발생
    print(arr[i])
    i += 1

# 해결: 정확한 조건 사용
i = 0
while i < len(arr):  # 올바른 조건 (<)
    print(arr[i])
    i += 1

# 로깅 추가
import logging
logging.basicConfig(level=logging.DEBUG)

def process_with_logging(data):
    i = 0
    while i < len(data):
        logging.debug(f"인덱스: {i}, 값: {data[i]}")
        # 처리 로직
        i += 1

# 상태 스냅샷
def process_with_snapshot(data, max_iterations=1000):
    i = 0
    iterations = 0
    
    while i < len(data) and iterations < max_iterations:
        # 주기적으로 상태 출력
        if iterations % 100 == 0:
            print(f"진행 상황: {i}/{len(data)}")
        
        # 처리 로직
        i += 1
        iterations += 1
    
    if iterations >= max_iterations:
        print("최대 반복 횟수 초과")