while 반복문 - 42H: 파이썬

Updated: 23 apr 2026

for 반복문은 리스트 또는 range() 함수처럼 일정 구간에서 규칙성 있게 변하는 값들을 대상으로 동일한 명령문을 반복 수행할 때 사용한다. 반면에 while 반복문은 일정 구간이나 규칙이 없어도 특정 조건이 만족되는 동안 계속해서 동일한 명령문을 반복 실행하고자 할 때 사용한다.

while 반복문의 형식은 다음과 같다.

while 논리식:
    본문

while 논리식이 쓰인 행의 끝에 콜론(:)이 위치하고, 그 아래에 있는 본문(body)은 들여쓰기 된다. 이렇게 들여쓰기된 본문의 명령문은 논리식이 참으로 유지되는 동안 반복 실행된다.

7.1숫자 맞히기 게임¶

"숫자 맞히기 게임"은 게임 참가자가 예를 들어 1부터 100 사이의 정수 하나를 입력하면 입력된 값이 17인지 여부를 판별해서 경우에 따라 적절한 문장을 화면에 출력한다. 예를 들어, 33을 입력하면 맞혀야 하는 17보다 큰 숫자가 입력되었다는 의미의 '너무 커요!'를 출력한다.

print("숫자 맞히기 게임에 환영합니다.")

secret = 17
guess = int(input("1부터 100 사이의 정수 하나를 입력하세요: "))
print(f"입력값: {guess}")

if guess == secret:
    print("맞았습니다!")
elif guess > secret:
    print("너무 커요!")
else:
    print("너무 작아요!")

print("게임 종료!")

숫자 맞히기 게임에 환영합니다.
입력값: 33
너무 커요!
게임 종료!

위 코드는 입력한 값이 17이든 아니든 게임 참가자에게 한 번만 질문한다. 그런데 비밀 숫자를 입력할 때까지 반복해서 게임 참가자로부터 입력을 받도록 만들려면?

for 반복문은 사용하기 어렵다. 이유는 비밀 숫자가 17인지를 모른다면 숫자 맞히기를 몇 번 시도해야 답을 맞힐 수 있는지 미리 알 수 없기 때문이다. 1부터 100 사이의 정수가 100개인데 그 중에 하나를 무작위로 맞힐 가능성이 상당히 낮다.

guess != secret 논리식

숫자 입력과 비교를 반복해서 실행하도록 하되 정해진 횟수만 허용하는 게 아니라 비밀 숫자를 맞힐 때까지 반복하도록 해야 하는 경우에 while 반복문을 아래 논리식과 함께 사용하면 된다.

guess != secret

위 논리식은 비밀 숫자(secret)와 입력값(guess)가 다를 때 참이다. 따라서 while guess != secret은 ‘입력값이 17이 아닌 동안’, 즉 '답을 맞힐 때까지’를 의미한다.

아래 코드에서 while guess != secret이 실행되기 전에 guess = -1로 변수 할당문을 선언하는 이유는 while 반복문이 최소 한 번은 실행되도록 하기 위함이다.

첫 입력값으로 예를 들어 50을 입력한 다음에 secret 보다 큰지 작은지 여부에 따라 적절한 값을 입력하면 언젠가는 답을 맞히게 된다.

print("숫자 맞히기 게임에 환영합니다.")

secret = 17
guess = -1   # 이어지는 while 반복문이 최소 한 번은 실행되도록 함

while guess != secret:
    guess = int(input("1부터 100 사이의 정수 하나를 입력하세요: "))
    print(f"입력값: {guess}")

    if guess == secret:
        print("맞았습니다!")
    elif guess > secret:
        print("너무 커요!")
    else:
        print("너무 작아요!")

print("게임 종료!")

숫자 맞히기 게임에 환영합니다.
입력값: 50
너무 커요!
입력값: 25
너무 커요!
입력값: 12
너무 작아요!
입력값: 18
너무 커요!
입력값: 15
너무 작아요!
입력값: 17
맞았습니다!
게임 종료!

random.randint() 함수 활용

이전 코드는 비밀 숫자를 맞힐 때까지 반복 실행되기는 하지만 한 번 비밀 숫자를 맞힌 다음에는 더 이상 게임을 진행할 이유가 없다. 왜냐하면 답이 고정되어 있기 때문이다.

이에 대한 해결책으로, secret 변수에 할당되는 숫자를 게임을 실행할 때마다 다르게, 심지어 코드를 작성한 사람도 모르게 지정하도록 한다. 이를 위해 random.randint() 함수를 활용한다.

random.randint() 함수는 실행될 때마다 두 인자로 지정된 구간에서 무작위로 하나의 정수를 반환한다. 다만, print(), round() 함수 등과는 다르게 아래 명령문을 이용하여 random 모듈을 먼저 불러온 다음에 사용할 수 있다.

import random

아래 코드에서 secret 변수에 할당되는 값이 random.randint() 함수에 의해 임의로 1과 100 사이의 값으로 지정된다. 그 이외에 비밀 숫자를 맞추는 과정은 동일하다.

import random

print("숫자 맞히기 게임에 환영합니다.")

secret = random.randint(1, 100)
guess = -1   # 이어지는 while 반복문이 최소 한 번은 실행되도록 함

while guess != secret:
    guess = int(input("1부터 100 사이의 정수 하나를 입력하세요: "))
    print(f"입력값: {guess}")

    if guess == secret:
        print("맞았습니다!")
    elif guess > secret:
        print("너무 커요!")
    else:
        print("너무 작아요!")

print("게임 종료!")

숫자 맞히기 게임에 환영합니다.
입력값: 50
너무 작아요!
입력값: 75
너무 커요!
입력값: 63
너무 커요!
입력값: 56
너무 커요!
입력값: 53
너무 작아요!
입력값: 54
맞았습니다!
게임 종료!

7.1.1예제¶

예제 1

0부터 100까지의 숫자 중에서 3 또는 7의 배수를 모두 더한 결과를 다음과 같이 출력하는 프로그램을 작성하라.

0~100의 숫자 중 3의 배수와 7의 배수들의 합: 2208

힌트: while 반복문 활용

답:

0부터 100까지의 정수들의 구간은 range(0, 101)로 표현한다. 그리고 num 하나의 정수를 가리킬 때 num이 3의 배수이거나 7의 배수인지 여부는 다음 표현식이 판단한다.

num % 3 == 0 or num % 7 == 0

이를 정리하여 0부터 100까지의 정수들 중에서 3의 배수이거나 7의 배수의 합을 계산하는 코드는 다음과 같다. sum 변수는 3 또는 7의 배수만을 더한 누적합을 기억하는 장치로 이용된다.

sum = 0
num = 0
while num < 101:
    if num % 3 == 0 or num % 7 == 0:
        sum += num
    num += 1

print("0~100의 숫자 중 3의 배수와 7의 배수들의 합:", sum)

0~100의 숫자 중 3의 배수와 7의 배수들의 합: 2208

예제 2

지정된 구구단을 화면에 출력하는 함수 times_table()을 정의하라. 단, 함수 본문에 while 반복문을 사용해야 한다.

예를 들어, times_table(3)을 호출하면 다음과 같이 3단이 출력되어야 한다.

답:

매개변수 dan을 이용하여 i가 2부터 9까지 1씩 커지는 동안 dan * i의 결과를 차례대로 출력하도록 while 반복문을 활용한다.

def times_table(dan):
    i = 2
    while i <= 9:
        print(f"{dan} * {i} = {dan * i}")
        i += 1

times_table(3)

7.1.2연습문제¶

문제 1

아래 코드의 실행 결과를 설명하라. 반복문 실행 횟수는 얼마인가?

def counter_func(num, limit) :
    i = 1
    while True :
        print(i)
        if i == limit :
            return i
        else:
            print("=" * i)
            print("*" * i)
            i += 1
        return num

counter_func(100, 5)

1
=
*

100

문제 2

임의로 생성된 숫자를 맞히는 게임을 실행하는 guessing_number_game() 함수를 정의하라. 단, 두 개의 매개변수 start와 end를 사용해야 하며, 두 매개변수의 인자는 random.randint() 함수에게 전달되어 반환되는 임의의 숫자가 포함되는 구간으로 사용되도록 한다.

7.2(부록) 이진 탐색¶

숫자 맞히기 게임에서 힌트(“너무 커요!” / “너무 작아요!”)에 근거하여 매번 탐색 범위를 절반으로 줄여 나가며 비밀 숫자를 찾아갈 수 있다. 이를 이진 탐색binary search 전략이라 한다.

이진 탐색 알고리즘

아래 코드는 이진 탐색 전략으로 숫자 맞히기 게임을 진행한다. 다만 사람이 직접 숫자를 입력하는 대신, 코드가 스스로 값을 계산해서 비밀 숫자를 찾아 간다.

import random

secret = random.randint(1, 100)
low = 1
high = 100
count = 0
guess = -1  # secret은 1~100이므로 -1로 초기화하면 반복문이 반드시 실행됨

while low <= high and guess != secret:
    guess = (low + high) // 2
    print(f"low: {low}, high: {high}", end="  →  ")
    count += 1
    print(f"시도 {count}: {guess}", end="  →  ")

    if guess == secret:
        print("맞았습니다!")
    elif guess > secret:
        print("너무 커요!")
        high = guess - 1
    else:
        print("너무 작아요!")
        low = guess + 1

print(f"{count}번 만에 찾았습니다.")

low: 1, high: 100  →  시도 1: 50  →  너무 커요!
low: 1, high: 49  →  시도 2: 25  →  너무 커요!
low: 1, high: 24  →  시도 3: 12  →  너무 커요!
low: 1, high: 11  →  시도 4: 6  →  너무 커요!
low: 1, high: 5  →  시도 5: 3  →  너무 작아요!
low: 4, high: 5  →  시도 6: 4  →  너무 작아요!
low: 5, high: 5  →  시도 7: 5  →  맞았습니다!
7번 만에 찾았습니다.

위 코드에 사용된 변수들의 역할은 다음과 같다.

secret: 맞혀야 할 비밀 숫자
low와 high: 현재 탐색 중인 범위의 하한과 상한
count: 추측 시도 횟수.
guess: 추측값. -1로 초기화해서 while 반복문이 반드시 한 번은 실행되도록 함.
low <= high and guess != secret: 반복 조건.
- 탐색 범위가 남아 있고 아직 비밀 숫자를 못 맞힌 동안 반복을 계속한다는 의미.
- 비밀 숫자를 맞히는 순간 guess == secret이 되어 반복이 자동 종료
(low + high) // 2: 매 추측 시도마다의 추측값. 현재 범위의 중간값.
추측값이 너무 큰 경우: high = guess - 1로 상한 낮추기
추측값이 너무 작은 경우: low = guess + 1로 하한 높이기

반복문이 진행될 때마다, 즉 매 추측 시도 후 비밀 숫자를 맞히지 못하면 탐색 범위가 절반으로 줄어들어 결국 비밀 숫자를 찾아내게 된다.

최대 탐색 횟수

아래 코드는 secret을 1부터 100까지 변화시키면서 이진 탐색 알고리즘으로 비밀 숫자를 찾아낼 때까지 몇 번의 추측을 시도하는지 확인한다.

while 반복문이 중첩되어 사용된다.

바깥쪽 while 반복문: secret을 1부터 100까지 차례로 바꿔가며 반복
안쪽 while 반복문: 각 secret에 대해 이진 탐색 실행
- low, high, count = 1, 100, 0: secret이 바뀔 때마다 범위와 횟수를 초기화
- max_count: 지금까지 본 최대 시도 횟수를 기억하는 변수

max_num = 100 # secret는 1부터 max_num 사이의 정수
max_count = 0
secret = 1

while secret <= max_num:
    low, high, count, guess = 1, max_num, 0, -1

    while low <= high and guess != secret:
        guess = (low + high) // 2
        count += 1
        if guess > secret:
            high = guess - 1
        elif guess < secret:
            low = guess + 1
    if count > max_count:
        max_count = count
    secret += 1

print("최대 시도 횟수:", max_count)

최대 시도 횟수: 7

실행 결과 최대 시도 횟수: 7이 출력된다. 이는 비밀 숫자가 1~100 사이의 어떤 값이라 정하더라도 이진 탐색은 반드시 7번 이하로 비밀 숫자를 찾아낸다는 의미이다.

이진 탐색은 매 시도마다 탐색 범위를 절반으로 줄인다. 따라서 최대 시도 횟수는 1부터 max_num 사이의 탐색 구간을 계속 절반 줄여서 최종 탐색 구간의 크기가 1이 될 때까지의 횟수에 1을 더한 값이다.

예를 들어, 1부터 100 사이의 값이면 탐색 구간의 크기는 다음과 같이 최대 6번 쪼개면 최종 1이 된다. 즉, 최대 7번 추측하면 반드시 비밀 숫자를 맞히게 된다.

100 -> 50 -> 25 -> 12 -> 6 -> 3 -> 1

반면에 1부터 1,000 사이의 값에 대해서는 최대 10번 추측하면 된다. 이유는 다음과 같이 9번 쪼개면 탐색 구간이 1이 되기 때문이다.

1000 -> 500 -> 250 -> 125 -> 62 -> 31 -> 15 -> 7 -> 3 -> 1

아래 예제 2에서 실제로 최대 10번이면 비밀 숫자를 찾아냄을 코드로 보여준다.

7.2.1예제¶

예제 1

아래와 같이 오름차순으로 정렬된 리스트가 주어졌다.

sorted_list = [2, 5, 8, 12, 16, 23, 38, 45, 67, 91]

이진 탐색 알고리즘을 이용하여 target = 50을 찾는 코드를 작성하라. 존재한다면 그 인덱스를, 존재하지 않는다면 "찾는 값이 없습니다."를 출력하라.

답:

target = 50은 리스트에 존재하지 않으므로 탐색 범위가 줄어들다가 low > high가 되는 순간 반복문이 break 없이 종료된다. 따라서 while ... else의 else 블록이 실행되어 "찾는 값이 없습니다."가 출력된다.

sorted_list = [2, 5, 8, 12, 16, 23, 38, 45, 67, 91]
target = 50

low = 0
high = len(sorted_list) - 1

while low <= high:
    mid = (low + high) // 2
    if sorted_list[mid] == target:
        print(f"{target}은(는) 인덱스 {mid}에 있습니다.")
        break
    elif sorted_list[mid] > target:
        high = mid - 1
    else:
        low = mid + 1
else:
    print("찾는 값이 없습니다.")

찾는 값이 없습니다.

예제 2

다음 조건을 만족시키는 max_guess_count() 함수를 정의하라.

하나의 매개변수 max_num을 사용한다.
max_guess_count(max_num)을 호출하면 secret을 1부터 max_num까지 변화시키면서 이진 탐색 알고리즘으로 비밀 숫자를 찾아낼 때까지 몇 번의 추측을 시도하는지 확인한 다음에 최대 추측 횟수를 반환한다.

답:

max_guess_count() 함수를 정의하기 위해서는 위 코드에서 max_num 변수를 매개변수로, max_count를 반환값으로 지정하면 된다.

def max_guess_count(max_num):
    max_count = 0
    secret = 1

    while secret <= max_num:
        low, high, count, guess = 1, max_num, 0, -1

        while low <= high and guess != secret:
            guess = (low + high) // 2
            count += 1
            if guess > secret:
                high = guess - 1
            elif guess < secret:
                low = guess + 1
        if count > max_count:
            max_count = count
        secret += 1

    return max_count

이진 탐색 기법으로 1부터 100까지의 숫자는 최대 7번이면 맞힐 수 있다.

max_guess_count(100)

7

이진 탐색 기법으로 1부터 1,000까지의 숫자는 최대 10번이면 맞힐 수 있다.

max_guess_count(1000)

10

7.2.2연습문제¶

문제 1

아래 코드의 실행 결과를 설명하라. 탐색 범위 [low, high]가 어떻게 변하는지 단계별로 설명하라.

sorted_list = [1, 3, 5, 7, 9, 11, 13, 15]
target = 7

low = 0
high = len(sorted_list) - 1

while low <= high:
    mid = (low + high) // 2
    if sorted_list[mid] == target:
        print(f"{target}은(는) 인덱스 {mid}에 있습니다.")
        break
    elif sorted_list[mid] > target:
        high = mid - 1
    else:
        low = mid + 1
else:
    print("찾는 값이 없습니다.")

7은(는) 인덱스 3에 있습니다.

문제 2

아래와 같이 오름차순으로 정렬된 리스트가 주어졌다.

sorted_list = [2, 5, 8, 12, 16, 23, 38, 45, 67, 91]

이진 탐색 알고리즘을 이용하여 target = 23이 리스트에 존재하는지 확인하고, 존재한다면 그 인덱스를 출력하는 코드를 작성하라. 존재하지 않는다면 "찾는 값이 없습니다."를 출력하라.

단, while 반복문을 사용해야 하며, low와 high 변수를 활용하여 탐색 범위를 절반씩 줄여 나가야 한다.

7.3리스트와 문자열 활용¶

리스트와 문자열에 대해 반복문이 필요할 때에 for 반복문보다 while 반복문이 자연스러운 경우를 살펴 본다.

7.3.1리스트와 `while` 반복문¶

아래 코드는 리스트에 포함된 정수를 차례대로 더하다가 3보다 큰 수를 만나면 바로 실행을 종료한다.

sum_list 변수: 리스트의 항목들을 누적해서 더한 값을 저장하는 장치 역할 수행
item 변수: 리스트의 항목들을 차례대로 가리키는 변수

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

sum_list = 0

for item in num_list:
    print(f"현재 항목: {item}")
    if item > 3:
        print("3보다 큰 항목임. 더 이상 더하지 않고 바로 실행 종료")
        break
    else:
        sum_list += item 

print("3보다 작거나 같은 정수들의 합:", sum_list)

현재 항목: 2
현재 항목: 1
현재 항목: 3
현재 항목: 5
3보다 큰 항목임. 더 이상 더하지 않고 바로 실행 종료
3보다 작거나 같은 정수들의 합: 6

동일한 기능의 코드를 while 반복문으로 보다 간단하게, 그것도 break 명령문 없이 구현할 수 있다.

리스트를 대상으로 while 반복문을 실행할 때는 일반적으로 인덱싱을 활용한다. 이유는 for 반복문과는 달리 while 반복문은 리스트의 항목을 직접 가리키는 기능을 제공하지 않기 때문이다.

아래 코드에서 인덱싱에 사용되는 변수의 기능은 다음과 같다.

i 변수: 인덱스 변수. 즉 0으로 출발해서 반복문이 한 번 실행될 때마다 1씩 증가.
i번 인덱스의 값(num_list[i])이 3보다 같거나 작은 동안 누적합 계산 반복

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

sum_list = 0

i = 0
while num_list[i] <= 3:
    print(f"현재 항목: {num_list[i]}")
    sum_list += num_list[i]
    i += 1 # 다음 항목으로 이동

print("3보다 작거나 같은 정수들의 합:", sum_list)

현재 항목: 2
현재 항목: 1
현재 항목: 3
3보다 작거나 같은 정수들의 합: 6

7.3.2문자열과 `while` 반복문¶

문자열에 대해서도 for 반복문보다 while 반복문이 자연스러울 수 있다. 예를 들어, 아래 코드는 문자열에서 공백 문자(' ')가 나올 때까지 문자 출력을 반복한다.

text = "hello world"

i = 0
while text[i] != ' ':
    print(text[i])
    i += 1

h
e
l
l
o

문자열에 따라 공백 문자의 위치가 달라서 반복문을 언제 종료시켜야 할지 미리 알 수 없기 때문에 while 반복문이 보다 자연스럽다. for 반복문으로 작성하려면 역시 break가 필요해진다.

text = "hello world"

for ch in text:
    if ch == ' ':
        break
    print(ch)

h
e
l
l
o

7.3.3예제¶

예제 1

문자열이 다음과 같이 주어졌다.

text = "12345abc"

주어진 문자열에서 몇 번째 문자부터 숫자가 아닌지를 확인하고 출력하는 코드를 작성하라.

힌트: while 반복문과 문자열 인덱싱 활용

답:

문자열을 앞에서부터 한 글자씩 확인하면서 숫자 문자('0'~'9')인 동안 인덱스 i를 증가시키고, 숫자가 아닌 문자를 만나는 순간 반복을 멈춰 그 위치와 문자를 출력한다.

text = "12345abc"

i = 0
while i < len(text) and '0' <= text[i] <= '9':
    i += 1

print(f"{i}번째 문자 '{text[i]}'는 더 이상 숫자가 아닙니다.")

5번째 문자 'a'는 더 이상 숫자가 아닙니다.

예제 2

리스트가 다음과 같이 주어졌다.

numbers = [5, 3, 8, 1, 9, 2]

위 항목에 숫자 9가 위치한 곳의 인덱스를 찾는 코드를 작성하라. 9가 포함되어 있지 않다면 "9는 리스트에 없음"이라고 출력해야 한다.

힌트: while 반복문과 리스트 인덱싱 활용

답:

리스트를 0번 인덱스 항목부터 순서대로 확인하면서 항목이 target과 다르면 인덱스 i를 증가시키고, 같거나 리스트 끝에 도달하면 반복을 멈춘다.

반복 종료 후 i < len(numbers)이면 해당 위치를 출력하고, 그렇지 않으면 없음을 출력한다.

numbers = [5, 3, 8, 1, 9, 2]
target = 9

i = 0
while i < len(numbers) and numbers[i] != target:
    i += 1

if i < len(numbers):
    print(target, "의 위치(인덱스):", i)
else:
    print(target, "는 리스트에 없음")

9 의 위치(인덱스): 4

7.3.4연습문제¶

문제 1

리스트가 다음과 같이 주어졌다.

numbers = [5, 3, 8, 1, 9, 2]

위 리스트에 포함된 값들 중에서 최댓값과 최댓값의 위치(인덱스)를 구하라. 단, 최댓값이 여러 번 항목으로 사용될 경우 가장 작은 인덱스로 지정한다.

힌트: while 반복문과 인덱싱 활용

문제 2

문자열이 다음과 같이 주어졌다.

text = "racecar"

위 문자열이 회문인지 판단하는 코드를 작성하라. 단, 회문은 왼쪽에서부터 읽을 때와 오른쪽에서부터 읽을 때 동일한 단어를 가리킨다.

힌트 1: while 반복문과 문자열 인덱싱을 활용하세요. 힌트 2: 인덱스 i를 왼쪽부터 출발시키고, 역방향 문자의 인덱스를 len(text) - 1 - i로 두어 비교해 보세요. (서로 다른 두 변수 left, right를 두는 투 포인터 활용도 좋은 방법입니다)

7.4continue와 break¶

for 반복문뿐만 아니라 while 반복문의 실행 도중에도 continue 명령문과 break 명령문이 실행되면 특정 경우를 건너뛰도록 하거나 while 반복문의 실행이 중단된다.

7.4.1`continue` 명령문¶

continue 명령문이 반복문 실행 도중에 실행되면 본문의 나머지 명령문을 건너뛰고 다시 반복문의 처음으로 돌아간다.

for 반복문: 현재 항목의 나머지 본문을 건너뛰고 다음 항목으로 넘어감.
while 반복문: 현재 반복의 나머지 본문을 건너뛰고 조건식을 다시 검사함.

예를 들어, 아래 코드는 1부터 9까지의 정수를 대상으로 3의 배수 여부를 판단한다.

num이 3의 배수인 경우: 3의 배수임을 출력
num이 3의 배수가 아닌 경우: continue가 실행되어 본문의 나머지를 건너뛰고 다음 num으로 넘어감

결국 3의 배수가 아닌 1, 2, 4, 5, 7, 8은 출력 없이 건너뛰어진다.

num = 1
while num < 10:
    if num % 3 == 0:
        print(num, "은(는) 3의 배수!")
        num += 1
    else:
        num += 1
        continue
        
print("1과 10 사이에서 3의 배수를 확인했음!")

3 은(는) 3의 배수!
6 은(는) 3의 배수!
9 은(는) 3의 배수!
1과 10 사이에서 3의 배수를 확인했음!

아래 코드는 위 코드와 동일하게 작동한다. 대신 for 반복문을 사용한다.

for num in range(1, 10):
    if num % 3 == 0:
        print(num, "은(는) 3의 배수!")
    else:
        continue

print("1과 10 사이에서 3의 배수를 확인했음!")

3 은(는) 3의 배수!
6 은(는) 3의 배수!
9 은(는) 3의 배수!
1과 10 사이에서 3의 배수를 확인했음!

7.4.2`break` 명령문¶

break 명령문은 for 또는 while 반복문의 실행을 즉시 중지시킨다. 아래 코드는 1부터 9까지의 정수를 대상으로 3의 배수 여부를 차례대로 판단한다.

3의 배수가 아닐 때: 3의 배수가 아님을 출력하고 다음 num으로 넘어감.
3의 배수인 경우: 3의 배수임을 출력한 후 break가 실행되어 반복문이 바로 종료됨.

따라서 num이 1, 2일 때는 3의 배수가 아님을 출력하고, 3일 때는 3의 배수임을 출력한 뒤 반복문이 종료된다. 4, 5, ... 에 대한 반복은 더 이상 실행되지 않는다.

반복문이 종료된 후에는 마지막 줄의 print()가 실행된다. break는 자신을 포함한 반복문만 종료시키며, 이후의 코드는 정상적으로 실행된다.

num = 1

while num < 10:
    if num % 3 != 0:
        print(num, "은(는) 3의 배수 아님!")
    else:
        print(num, "은(는) 3의 배수!")
        break
        
    num += 1
        
print("프로그램 종료!")

1 은(는) 3의 배수 아님!
2 은(는) 3의 배수 아님!
3 은(는) 3의 배수!
프로그램 종료!

아래 코드는 위 프로그램을 for 반복문으로 구현하였으며 실행되는 과정은 위 코드와 동일하다.

for num in range(1, 10):
    if num % 3 != 0:
        print(num, "은(는) 3의 배수 아님!")
    else:
        print(num, "은(는) 3의 배수!")
        break
        
print("프로그램 종료!")

1 은(는) 3의 배수 아님!
2 은(는) 3의 배수 아님!
3 은(는) 3의 배수!
프로그램 종료!

7.4.3`continue`와 `break` 영향 범위¶

continue와 break 명령문은 자신을 포함하면서 가장 가까운 반복문에만 영향을 준다. 따라서 while 반복문이 중첩되어 있을 때, 안쪽 반복문에서 사용된 continue나 break는 바깥쪽 반복문에 전혀 영향을 주지 않는다.

아래 코드는 단어 리스트의 각 단어를 글자별로 확인하되, 모음(a, e, i, o, u)은 continue로 건너뛴다.

안쪽 while 반복문의 continue는 안쪽 반복문의 다음 글자로 넘어갈 뿐, 바깥쪽 반복문에는 영향을 주지 않는다.
따라서 어떤 단어에 모음이 포함되어 있더라도 모든 단어가 빠짐없이 확인된다.

words = ["hello", "python", "code"]
i = 0
while i < len(words):
    word = words[i]
    print(f"[{word}] 자음만 출력: ", end="")
    j = 0
    while j < len(word):
        char = word[j]
        if char in "aeiou":
            j += 1
            continue
        print(char, end="")
        j += 1
    print()
    i += 1

[hello] 자음만 출력: hll
[python] 자음만 출력: pythn
[code] 자음만 출력: cd

반면에 아래 코드는 모음을 발견하는 순간 break로 해당 단어의 확인을 중단한다.

안쪽 while 반복문의 break는 안쪽 반복문만 중단시킬 뿐, 바깥쪽 반복문은 계속 실행된다.
따라서 한 단어에서 모음이 발견되더라도 나머지 단어는 정상적으로 확인된다.

words = ["hello", "python", "code"]

i = 0
while i < len(words):
    word = words[i]
    print(f"[{word}] 자음만 출력: ", end="")
    j = 0
    while j < len(word):
        char = word[j]
        if char in "aeiou":
            print(f" <- '{char}' 발견, 중단")
            break
        print(char, end="")
        j += 1
    print()
    i += 1

[hello] 자음만 출력: h <- 'e' 발견, 중단

[python] 자음만 출력: pyth <- 'o' 발견, 중단

[code] 자음만 출력: c <- 'o' 발견, 중단

continue와 break의 영향 범위는 while 반복문과 for 반복문이 함께 중첩으로 사용되는 경우에도 동일하다. 예를 들어 아래 코드는 바깥쪽에는 for 반복문을, 안쪽에는 while 반복문을 사용하지만 continue는 while 반복문에만 영향을 준다.

words = ["hello", "python", "code"]

for word in words:
    print(f"[{word}] 자음만 출력: ", end="")
    j = 0
    while j < len(word):
        if word[j] in "aeiou":
            j += 1
            continue
        print(word[j], end="")
        j += 1
    print()

[hello] 자음만 출력: hll
[python] 자음만 출력: pythn
[code] 자음만 출력: cd

반면에 아래 코드에서 break는 안쪽 for 반복문에만 영향을 준다.

words = ["hello", "python", "code"]

i = 0
while i < len(words):
    word = words[i]
    print(f"[{word}] 자음만 출력: ", end="")
    for char in word:
        if char in "aeiou":
            print(f" <- '{char}' 발견, 중단")
            break
        print(char, end="")
    print()
    i += 1

[hello] 자음만 출력: h <- 'e' 발견, 중단

[python] 자음만 출력: pyth <- 'o' 발견, 중단

[code] 자음만 출력: c <- 'o' 발견, 중단

7.4.4예제¶

예제 1

아래 코드의 실행 결과를 설명하라.

i = 0
while i < 4:
    j = 0
    while j < 4:
        if i == j:
            j += 1
            break
        print([i, j])
        j += 1
    i += 1

[1, 0]
[2, 0]
[2, 1]
[3, 0]
[3, 1]
[3, 2]

답:

i가 0부터 3까지 변할 때 다음을 실행한다.

각각의 i에 대해 j가 0부터 3까지 변하면서 i == j 가 참이 되는 순간까지 [i, j] 출력.

결론적으로 i > j인 경우에만 [i, j]를 출력한다.

예제 2

아래 코드의 실행 결과를 설명하라.

i = 0
while i < 4:
    j = 0
    while j < 4:
        if i == j:
            j += 1
            continue
        print([i, j])
        j += 1
    i += 1

[0, 1]
[0, 2]
[0, 3]
[1, 0]
[1, 2]
[1, 3]
[2, 0]
[2, 1]
[2, 3]
[3, 0]
[3, 1]
[3, 2]

답:

i가 0부터 3까지 변할 때 다음을 실행한다.

각각의 i에 대해 i == j가 거짓인 경우에만 리스트 [i, j] 출력.
각각의 i에 대해 j가 0부터 3까지 변하면서 i == j가 참이 되는 순간 continue 명령문이 실행됨.

결론적으로 i와 j가 다른 경우에만 [i, j]를 출력한다.

예제 3

아래 코드를 실행하면 반복문의 실행이 멈추지 않는다. 그 이유를 설명하라.

num = 0
while num < 10:
    if num % 3 == 0:
        print(num, "은(는) 3의 배수!")
    else:
        continue

    num += 1

print("1과 10 사이에서 3의 배수를 확인했음!")

답:

num = 0에서 시작하면 0 % 3 == 0이 참이므로 else 블록이 실행되지 않고 num += 1이 실행되어 num이 1이 된다.
그런데 num = 1이 되면 1 % 3 == 0이 거짓이므로 continue가 실행되어 num += 1을 건너뛰고 반복문의 처음으로 돌아간다.
이후 num은 계속 1인 채로 같은 상황이 반복되어 무한 반복에 빠진다.

7.4.5연습문제¶

문제 1

아래 두 코드의 실행 결과가 동일한 이유를 설명하라.

코드 1

for i in range(4):
    j = 0
    while j < 4:
        if i < j:
            break
        print([i, j])
        j += 1

[0, 0]
[1, 0]
[1, 1]
[2, 0]
[2, 1]
[2, 2]
[3, 0]
[3, 1]
[3, 2]
[3, 3]

코드 2

i = 0
while i in range(4):
    for j in range(4):
        if i < j:
            continue
        print([i, j])
        
    i += 1

[0, 0]
[1, 0]
[1, 1]
[2, 0]
[2, 1]
[2, 2]
[3, 0]
[3, 1]
[3, 2]
[3, 3]

문제 2

아래 코드의 실행 결과를 설명하라.

n = 3
while n < 10:
    is_even = True

    if n % 2 == 1:
        is_even = False
        print("-", n, "은(는) 홀수다.")
    
    break

    if is_even:
        print("-", n, "은(는) 짝수다.")
        
    n += 1
    
print("실행 종료!")

- 3 은(는) 홀수다.
실행 종료!

문제 3

아래 코드는 1과 100 사이에서 임의로 지정된 secret를 맞힐 때까지 코드를 실행한다.

import random

secret = random.randint(1, 100)
low = 1
high = 100
count = 0
guess = -1  # secret은 1~100이므로 -1로 초기화하면 반복문이 반드시 실행됨

while low <= high and guess != secret:
    guess = (low + high) // 2
    print(f"low: {low}, high: {high}", end="  →  ")
    count += 1
    print(f"시도 {count}: {guess}", end="  →  ")

    if guess == secret:
        print("맞았습니다!")
    elif guess > secret:
        print("너무 커요!")
        high = guess - 1
    else:
        print("너무 작아요!")
        low = guess + 1

print(f"{count}번 만에 찾았습니다.")

low: 1, high: 100  →  시도 1: 50  →  너무 작아요!
low: 51, high: 100  →  시도 2: 75  →  너무 커요!
low: 51, high: 74  →  시도 3: 62  →  너무 커요!
low: 51, high: 61  →  시도 4: 56  →  너무 커요!
low: 51, high: 55  →  시도 5: 53  →  너무 작아요!
low: 54, high: 55  →  시도 6: 54  →  맞았습니다!
6번 만에 찾았습니다.

위 코드에서 반복문의 실행은 아래 조건식에 의해 결정된다.

low <= high and guess != secret

위 조건식 대신에 low <= high를 조건식으로 사용하는 while 반복문으로 동일한 기능을 수행하는 코드를 작성하라.

힌트: break 명령문 활용

7 while 반복문

7.1숫자 맞히기 게임¶

7.1.1예제¶

7.1.2연습문제¶

7.2(부록) 이진 탐색¶

7.2.1예제¶

7.2.2연습문제¶

7.3리스트와 문자열 활용¶

7.3.1리스트와 while 반복문¶

7.3.2문자열과 while 반복문¶

7.3.3예제¶

7.3.4연습문제¶

7.4continue와 break¶

7.4.1continue 명령문¶

7.4.2break 명령문¶

7.4.3continue와 break 영향 범위¶

7.4.4예제¶

7.4.5연습문제¶

7.3.1리스트와 `while` 반복문¶

7.3.2문자열과 `while` 반복문¶

7.4.1`continue` 명령문¶

7.4.2`break` 명령문¶

7.4.3`continue`와 `break` 영향 범위¶