๐ ํ์ด์ฌ ๋ฃจํ WHILE? ์์ ํฌํจ ์๋ฒฝ ์ ๋ฆฌ! ๋ฃจํ ๋ง์คํฐ๊ฐ ๋๋ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ!
ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ฝ๋๋ฅผ ํตํด ๋ฐ๋ณต๋ฌธ(Loop) ๊ฐ๋
์ ์๋ฒฝํ ์ดํดํ์ธ์! ์กฐ๊ฑด์ด ์ฐธ์ธ ๋์ ์ฝ๋๋ฅผ ์คํํ๋ while๋ฌธ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ, ํ์ฉ ์์, ๋ฌดํ ๋ฃจํ ๋ฐฉ์ง๋ฒ๊น์ง ํต์ฌ๋ง ๋ชจ์์ต๋๋ค.
ํ์ด์ฌ ์ฝ๋ฉ์ ์ฌ์ฅ, ์ ํ์ด์ฌ WHILE? ์์ ํฌํจ ํ์ต์ด ํ์์ผ๊น?
ํ๋ก๊ทธ๋๋ฐ์ ์ธ๊ณ์์ **๋ฐ๋ณต๋ฌธ(Loop)**์ ์ปดํจํฐ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฅ๋ ฅ์ด์ ํต์ฌ์
๋๋ค. ์๋ฐฑ, ์์ฒ ๋ฒ์ ๋์ผํ ์์
์ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ๊ฒ ํด์ฃผ๋ ์ด ๋ฐ๋ณต๋ฌธ ๋๋ถ์ ์ฐ๋ฆฌ๋ ๋ณต์กํ ํ๋ก๊ทธ๋จ๋ ์ฝ๊ฒ ๋ง๋ค ์ ์์ฃ . ํ์ด์ฌ์๋ for๋ฌธ๊ณผ ํจ๊ป while๋ฌธ์ด๋ผ๋ ๊ฐ๋ ฅํ ๋ฐ๋ณต๋ฌธ์ด ์กด์ฌํฉ๋๋ค.
while๋ฌธ์ ํน์ ์กฐ๊ฑด์ด ์ฐธ(True)์ธ ๋์ ์ฝ๋ ๋ธ๋ก์ ๊ณ์ํด์ ์คํํ๋ ๋ฐ๋ณต๋ฌธ์
๋๋ค. ์ฆ, ๋ช ๋ฒ์ ๋ฐ๋ณตํด์ผ ํ ์ง ํ์๋ฅผ ์ ํํ ์ ์ ์์ ๋ ๋งค์ฐ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ฉ๋๋ค. ๋ฐ์ดํฐ๊ฐ ๋ค์ด์ฌ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ฑฐ๋, ํน์ ๋ชฉํ์น์ ๋๋ฌํ ๋๊น์ง ๊ณ์ฐ์ ๋ฐ๋ณตํ๋ ๋ฑ์ ์ํฉ์์ ํ์ด์ฌ WHILE? ์์ ํฌํจ ํ์ต์ ํ์์ ์
๋๋ค. ์ด ๊ธ์์๋ while๋ฌธ์ ๊ธฐ๋ณธ ๋ฌธ๋ฒ๋ถํฐ ์ค์ํ์ ์ ์ฉํ ์ ์๋ ๋ค์ํ ์์ ๊น์ง, SEO์ ์ต์ ํ๋ ์ ๋ฌธ์ ์ธ ์ ๋ณด์ ์น๊ทผํ ์ค๋ช
์ผ๋ก ์์ธํ ์๋ ค๋๋ฆฌ๊ฒ ์ต๋๋ค. ์ง๊ธ ๋ฐ๋ก ํ์ด์ฌ WHILE? ์์ ํฌํจ์ ์ธ๊ณ๋ก ๋น ์ ธ๋ค์ด ๋ฃจํ ๋ง์คํฐ๊ฐ ๋์ด ๋ด
์๋ค! 
ํ์ด์ฌ WHILE? ์์ ํฌํจ ๊ธฐ๋ณธ ๊ตฌ์กฐ ๋ฐ ๋ฌธ๋ฒ ์ดํดํ๊ธฐ
ํ์ด์ฌ while๋ฌธ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ํต์ฌ์ ์กฐ๊ฑด์๊ณผ ๊ทธ ์กฐ๊ฑด์์ด ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋ ๋ธ๋ก์
๋๋ค.
# ํ์ด์ฌ WHILE? ์์ ํฌํจ ๊ธฐ๋ณธ ๋ฌธ๋ฒ
while ์กฐ๊ฑด์:
# ์กฐ๊ฑด์์ด ์ฐธ(True)์ผ ๋ ๋ฐ๋ณต ์คํ๋ ์ฝ๋ ๋ธ๋ก
์คํ๋ฌธ 1
์คํ๋ฌธ 2
# ๋ฃจํ๋ฅผ ์ข
๋ฃ์ํค๊ธฐ ์ํ ๋ณํ(์นด์ดํฐ ์ฆ๊ฐ ๋๋ ์กฐ๊ฑด ๋ณ๊ฒฝ)
์ฌ๊ธฐ์ ๊ฐ์ฅ ์ค์ํ ๊ฒ์ while๋ฌธ ๋ด๋ถ์ ๋ฐ๋ณต์ ๋ฉ์ถ ์ ์๋ ๋ณํ๋ฅผ ์ฃผ๋ ์ฝ๋๊ฐ ๋ฐ๋์ ํฌํจ๋์ด์ผ ํ๋ค๋ ์ ์
๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์กฐ๊ฑด์์ด ์์ํ ์ฐธ์ด ๋์ด **๋ฌดํ ๋ฃจํ(Infinite Loop)**์ ๋น ์ง๊ฒ ๋ฉ๋๋ค.
๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์นด์ดํธ ์์ ๋ฅผ ํตํด ํ์ด์ฌ WHILE? ์์ ํฌํจ์ ์๋ ์๋ฆฌ๋ฅผ ๋ช ํํ ์ดํดํด ๋ด ์๋ค.
# ์์ 1: 1๋ถํฐ 5๊น์ง ์ซ์ ์ถ๋ ฅํ๊ธฐ
count = 1 # ์ด๊ธฐํ (์์์ )
while count <= 5: # ์กฐ๊ฑด์: count๊ฐ 5 ์ดํ์ธ ๋์
print(count)
count = count + 1 # ๋ณํ: count๋ฅผ 1์ฉ ์ฆ๊ฐ์์ผ ์ธ์ ๊ฐ 5๋ฅผ ์ด๊ณผํ๊ฒ ๋ง๋ฆ
# ์ถ๋ ฅ ๊ฒฐ๊ณผ: 1, 2, 3, 4, 5
์ด ์์ ์์ count = count + 1 (๋๋ count += 1) ๋ถ๋ถ์ด ์๋ค๋ฉด, count๋ ๊ณ์ 1์ด๊ณ ์กฐ๊ฑด(1 <= 5)์ ์์ํ ์ฐธ์ด ๋์ด ์ฝ๋๊ฐ ๋ฉ์ถ์ง ์์ ๊ฒ์
๋๋ค. **๋ณํ(Update)**๋ while๋ฌธ์ ์๋ช
๊ณผ ๊ฐ์ต๋๋ค.
๋ฃจํ ์ ์ด์ ํ์ ์์: BREAK์ CONTINUE (ํ์ด์ฌ WHILE? ์์ ํฌํจ)
ํจ์จ์ ์ธ ํ์ด์ฌ while๋ฌธ ์ฌ์ฉ์ ์ํด์๋ ๋ ๊ฐ์ง ํต์ฌ ๋ฃจํ ์ ์ด๋ฌธ์ธ **break**์ **continue**๋ฅผ ๋ฐ๋์ ์์์ผ ํฉ๋๋ค. ์ด๋ค์ ๋ฃจํ์ ํ๋ฆ์ ์ํ๋ ๋๋ก ์กฐ์ํ ์ ์๊ฒ ํด์ค๋๋ค.
break: ํ์ฌ ์คํ ์ค์ธ ๋ฃจํ๋ฅผ ์ฆ์ ์ข ๋ฃํ๊ณ , ๋ฃจํ ๋ค์ ์ฝ๋๋ก ๋์ด๊ฐ๋๋ค. ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ์ ๋ ๋ฃจํ๋ฅผ ๋น ์ ธ๋๊ฐ์ผ ํ ๋ ์ ์ฉํฉ๋๋ค.continue: ํ์ฌ ์คํ ์ค์ธ ๋ฃจํ์ ๋๋จธ์ง ์ฝ๋๋ฅผ ๊ฑด๋๋ฐ๊ณ , ์ฆ์ **๋ค์ ๋ฐ๋ณต(์กฐ๊ฑด์ ๊ฒ์ฌ)**์ผ๋ก ๋์ด๊ฐ๋๋ค.
๋ ์ ์ด๋ฌธ์ ํ์ฉํ ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ฝ๋๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
# ์์ 2: 7์ด ๋๋ฉด ๋ฃจํ๋ฅผ ๋ฉ์ถ๊ณ , ํ์๋ง ์ถ๋ ฅํ๊ธฐ
number = 0
while True: # ๋ฌดํ ๋ฃจํ ์ค์ (break๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํจ)
number += 1
if number % 2 == 0: # ์ง์์ด๋ฉด
continue # ์๋ print๋ฅผ ๊ฑด๋๋ฐ๊ณ ๋ค์ ๋ฐ๋ณต์ผ๋ก ์ด๋
if number == 7: # ์ซ์๊ฐ 7์ด๋ฉด
break # ๋ฃจํ๋ฅผ ์ฆ์ ์ข
๋ฃ
print(number)
# ์ถ๋ ฅ ๊ฒฐ๊ณผ: 1, 3, 5 (7์ break ๋๋ฌธ์ ์ถ๋ ฅ๋์ง ์์)
์ด์ฒ๋ผ while True๋ก ๋ฌดํ ๋ฃจํ๋ฅผ ์ค์ ํ ๋ค, ๋ด๋ถ์ if๋ฌธ๊ณผ **break**๋ฅผ ๋ฃ์ด ํน์ ์กฐ๊ฑด์์๋ง ๋ฃจํ๋ฅผ ์ข
๋ฃ์ํค๋ ๋ฐฉ์์ ์ฌ์ฉ์ ์
๋ ฅ ์ฒ๋ฆฌ ๋ฑ์์ ๋งค์ฐ ํํ๊ฒ ์ฌ์ฉ๋๋ ํ์ด์ฌ WHILE? ์์ ํฌํจ ํจํด์
๋๋ค.
์ค์ ํ์ฉ! ์ฌ์ฉ์ ์
๋ ฅ ์ฒ๋ฆฌ์ ์ ํจ์ฑ ๊ฒ์ฌ (ํ์ด์ฌ WHILE? ์์ ํฌํจ)
while๋ฌธ์ด ๊ฐ์ฅ ๋น์ ๋ฐํ๋ ์๊ฐ์ ์ฌ์ฉ์๋ก๋ถํฐ ์ฌ๋ฐ๋ฅธ ์
๋ ฅ์ ๋ฐ์ ๋๊น์ง ๋ฐ๋ณตํด์ผ ํ ๋์
๋๋ค. ํ์๊ฐ ์ ํด์ ธ ์์ง ์๊ณ , ์ฌ์ฉ์์ ์
๋ ฅ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๋ฐ๋ณต ์ฌ๋ถ๊ฐ ๊ฒฐ์ ๋๊ธฐ ๋๋ฌธ์
๋๋ค.
์๋ฅผ ๋ค์ด, ์ฌ์ฉ์์๊ฒ "Y"๋ "N" ์ค ํ๋๋ง ์ ๋ ฅ๋ฐ์์ผ ํ๋ ์ํฉ์ ๊ฐ์ ํด ๋ด ์๋ค.
# ์์ 3: ์ฌ๋ฐ๋ฅธ ์
๋ ฅ์ด ๋ค์ด์ฌ ๋๊น์ง ๋ฐ๋ณต
while True:
user_input = input("๊ฒ์์ ๋ค์ ์์ํ์๊ฒ ์ต๋๊น? (Y/N): ")
if user_input.upper() in ('Y', 'N'):
print(f"[{user_input.upper()}] ๋ฅผ ์ ํํ์
จ์ต๋๋ค.")
break # ์ฌ๋ฐ๋ฅธ ์
๋ ฅ์ด ๋ค์ด์ค๋ฉด ๋ฃจํ ์ข
๋ฃ
else:
print("์๋ชป๋ ์
๋ ฅ์
๋๋ค. Y ๋๋ N ์ค ํ๋๋ฅผ ์
๋ ฅํด์ฃผ์ธ์.")
print("ํ๋ก๊ทธ๋จ ์ข
๋ฃ.")
์ด ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ฝ๋๋ฅผ ํตํด, ์ฐ๋ฆฌ๋ ์ฌ์ฉ์๊ฐ ์ค์๋ก ์๋ชป๋ ๊ฐ์ ์
๋ ฅํ๋๋ผ๋ ํ๋ก๊ทธ๋จ์ด ๋ฉ์ถ์ง ์๊ณ ์ง์์ ์ผ๋ก ํผ๋๋ฐฑ์ ์ ๊ณตํ๋ฉฐ ์ฌ๋ฐ๋ฅธ ์
๋ ฅ์ ์ ๋ํ ์ ์์ต๋๋ค. ์ด๋ ์ฌ์ฉ์ ์นํ์ ์ธ ํ๋ก๊ทธ๋จ์ ๋ง๋๋ ๋ฐ ์์ด while๋ฌธ์ ๊ฐ๋ ฅํจ์ ๋ณด์ฌ์ค๋๋ค. while๋ฌธ์ ์ด์ฒ๋ผ ์ ํจ์ฑ ๊ฒ์ฌ๋ ๋ก๊ทธ์ธ์ด ์ฑ๊ณตํ ๋๊น์ง ๋ฐ๋ณตํ๋ ๋ฑ์ ์ํฉ์์ ํต์ฌ์ ์ธ ์ญํ ์ ์ํํฉ๋๋ค.
๋ฌดํ ๋ฃจํ์ ์ํ์ฑ๊ณผ ํ์ด์ฌ WHILE? ์์ ํฌํจ ์์ ์ฅ์น
์์ ์ ์ ์ธ๊ธํ๋ฏ์ด, while๋ฌธ์ ์ฌ์ฉํ ๋ ๊ฐ์ฅ ์ฃผ์ํด์ผ ํ ๊ฒ์ **๋ฌดํ ๋ฃจํ(Infinite Loop)**์
๋๋ค. ์กฐ๊ฑด์์ด ์์ํ ์ฐธ์ธ ์ํ๋ก ๋จ์ ํ๋ก๊ทธ๋จ์ด ๋ฉ์ถ์ง ์๊ณ CPU ์์์ ๋ญ๋นํ๊ฒ ๋ฉ๋๋ค.
๋ฌดํ ๋ฃจํ๊ฐ ๋ฐ์ํ๋ ํํ ๊ฒฝ์ฐ:
์กฐ๊ฑด ๋ณํ ์ฝ๋ ๋๋ฝ: ๋ฃจํ ๋ณ์(์นด์ดํฐ)๋ฅผ ์ฆ๊ฐ์ํค๊ฑฐ๋ ์กฐ๊ฑด์์ ๋ณ๊ฒฝํ๋ ์ฝ๋๋ฅผ ๋น ๋จ๋ฆฐ ๊ฒฝ์ฐ.
์กฐ๊ฑด ๋ณํ ๋ฐฉํฅ ์ค๋ฅ: ๋ฃจํ ๋ณ์๋ฅผ ์ฆ๊ฐ์์ผ์ผ ํ๋๋ฐ ์ค์๋ก ๊ฐ์์ํค๋ ๋ฑ, ์กฐ๊ฑด์์ด ์ฐธ์ธ ๋ฐฉํฅ์ผ๋ก๋ง ๋ณํ๊ฐ ์ผ์ด๋๋ ๊ฒฝ์ฐ.
# ๊ฒฝ๊ณ ! ๋ฌดํ ๋ฃจํ ์์
# count = 1
# while count <= 10:
# print(count)
# # count += 1 ์ฝ๋๊ฐ ๋๋ฝ๋๋ฉด ๋ฌดํ ๋ฐ๋ณต!
ํ์ด์ฌ WHILE? ์์ ํฌํจ ํ์ต ์ ๋ฌดํ ๋ฃจํ ๋ฐฉ์ง๋ฅผ ์ํ ์์ ์ฅ์น๋ฅผ ๋ง๋ จํ๋ ์ต๊ด์ด ์ค์ํฉ๋๋ค.
์นด์ดํฐ ์ ํ: ๋ฃจํ ๋ณ์์ ์ํ์ ์ ๋๊ณ ๋ฐ๋์ ๋ฃจํ ๋ด์์ ๋ณํ๋ฅผ ์ฃผ์ด ๊ทธ ์ํ์ ์ ๋๋ฌํ๊ฒ ๋ง๋ญ๋๋ค.
ํ์ ์์ ์ค์ : ๋ณต์กํ ์กฐ๊ฑด ๊ฒ์ฌ ๋ฃจํ์์๋ ์ต๋ ๋ฐ๋ณต ํ์(์: 1000๋ฒ)๋ฅผ ์ค์ ํ๊ณ , ๊ทธ ํ์๋ฅผ ๋์ผ๋ฉด ๊ฐ์ ๋ก **
break**๋ฅผ ์คํํ๊ฒ ํ์ฌ ํ๋ก๊ทธ๋จ์ด ๋ฉ์ถ๋ ๊ฒ์ ๋ฐฉ์งํฉ๋๋ค.
์์ ํ๊ณ ํจ์จ์ ์ธ ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ํด์๋ ๋ฃจํ๊ฐ ์ธ์ , ์ด๋ป๊ฒ ์ข ๋ฃ๋ ์ง ๋ช ํํ๊ฒ ์ค๊ณํ๋ ๊ฒ์ด ํต์ฌ์ ๋๋ค.
๊ฒฐ๋ก : ํ์ด์ฌ WHILE? ์์ ํฌํจ ๋ง์คํฐ, ๋ค์ ๋จ๊ณ๋ก!
์ง๊ธ๊น์ง ํ์ด์ฌ WHILE? ์์ ํฌํจ์ ๊ธฐ๋ณธ ๋ฌธ๋ฒ, break/continue ์ ์ด๋ฌธ ํ์ฉ๋ฒ, ๊ทธ๋ฆฌ๊ณ ์ค์ฉ์ ์ธ ์ฌ์ฉ์ ์
๋ ฅ ์ฒ๋ฆฌ ๋ฐ ๋ฌดํ ๋ฃจํ ๋ฐฉ์ง๋ฒ๊น์ง ์ฌ๋ ์๊ฒ ๋ค๋ฃจ์์ต๋๋ค. ํ์ด์ฌ while๋ฌธ์ ํ์๋ฅผ ์ ์ ์๋ ๋ฐ๋ณต ์์
์์ ๊ทธ ์ง๊ฐ๋ฅผ ๋ฐํํ๋ฉฐ, ์ฌ๋ฌ๋ถ์ ์ฝ๋๋ฅผ ๋์ฑ ์ ์ฐํ๊ณ ๊ฐ๋ ฅํ๊ฒ ๋ง๋ค์ด ์ค ๊ฒ์
๋๋ค.
ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ฝ๋๋ฅผ ์ง์ ์์ผ๋ก ํ์ดํํ๊ณ ์คํํด ๋ณด๋ ๊ณผ์ ์ด์ผ๋ง๋ก ์ด ๊ฐ๋
์ ์์ ํ ์๊ธฐ ๊ฒ์ผ๋ก ๋ง๋๋ ๊ฐ์ฅ ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์
๋๋ค. ์ด์ ์ฌ๋ฌ๋ถ์ while๋ฌธ์ ๋๋ ค์ํ์ง ์๊ณ ๋ค์ํ ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์ ์ ์ ์ฉํ ์ ์๋ ์ค๋น๊ฐ ๋์์ต๋๋ค! 
CTA: ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ธ์ ํ์ด์ฌ for๋ฌธ๊ณผ์ ์ฐจ์ด์ ์ด๋, ์ค์ฒฉ ๋ฃจํ์ ๋ํด ๋ ๊ถ๊ธํ์ง ์์ผ์ ๊ฐ์? ๋๊ธ๋ก ์ง๋ฌธ์ ๋จ๊ฒจ์ฃผ์๊ฑฐ๋, 'ํ์ด์ฌ for๋ฌธ ์์ ์ ๋ณต' ์ฝํ
์ธ ๋ฅผ ๊ฒ์ํด ๋ณด์ธ์!
FAQ (์์ฃผ ๋ฌป๋ ์ง๋ฌธ)
Q1: while๋ฌธ๊ณผ for๋ฌธ์ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ ๋ฌด์์ธ๊ฐ์?
A: ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ ๋ฐ๋ณต ํ์์ ๋ช
ํ์ฑ์
๋๋ค. for๋ฌธ์ ๋ฐ๋ณต ํ์๊ฐ ์ ํด์ ธ ์๊ฑฐ๋ (์: ๋ฆฌ์คํธ์ ํญ๋ชฉ ์๋งํผ) ํน์ ๋ฒ์(Range)๋ฅผ ์ํํ ๋ ์ฌ์ฉํฉ๋๋ค. ๋ฐ๋ฉด while๋ฌธ์ ๋ฐ๋ณต ํ์๋ฅผ ์ ์ ์๊ณ ํน์ ์กฐ๊ฑด์ด ์ฐธ์ธ ๋์ ๋ฌด๊ธฐํ์ผ๋ก ๋ฐ๋ณตํด์ผ ํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
Q2: ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ else ๊ตฌ๋ฌธ์ ์ด๋ป๊ฒ ์ฌ์ฉ๋๋์?
A: ํ์ด์ฌ์ while๋ฌธ์ ํน์ดํ๊ฒ๋ else ๊ตฌ๋ฌธ์ ๊ฐ์ง ์ ์์ต๋๋ค. while ๋ฃจํ๊ฐ ์กฐ๊ฑด์์ด ๊ฑฐ์ง์ด ๋์ด ์ ์์ ์ผ๋ก ์ข
๋ฃ๋ ๋ else ๋ธ๋ก์ด ์คํ๋ฉ๋๋ค. ๋ง์ฝ ๋ฃจํ๊ฐ break ๋ฌธ์ ์ํด ๊ฐ์ ๋ก ์ข
๋ฃ๋๋ฉด else ๋ธ๋ก์ ์คํ๋์ง ์์ต๋๋ค.
Q3: ๋ฌดํ ๋ฃจํ์ ๋น ์ก์ ๋ ๊ฐ์ ๋ก ์ข ๋ฃํ๋ ๋ฐฉ๋ฒ์ด ์๋์?
A: ๋ค, ์์ต๋๋ค. ํ๋ก๊ทธ๋จ์ด ๋ฌดํ ๋ฃจํ์ ๋น ์ ธ ๋ฉ์ถ์ง ์์ ๊ฒฝ์ฐ, ์ฝ๋๋ฅผ ์คํํ๊ณ ์๋ ์ฝ์์ด๋ ํฐ๋ฏธ๋ ์ฐฝ์์ Ctrl + C ํค๋ฅผ ๋๋ฅด๋ฉด KeyboardInterrupt ์ค๋ฅ๋ฅผ ๋ฐ์์ํค๋ฉด์ ํ๋ก๊ทธ๋จ์ ๊ฐ์ ๋ก ์ข
๋ฃ์ํฌ ์ ์์ต๋๋ค.
Q4: ํ์ด์ฌ WHILE? ์์ ํฌํจ ์ ์ฝ๋๋ฅผ ๋ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ๋ ํ์ด ์๋์?
A: ๋ฃจํ ๋ณ์๋ฅผ ๋ณ๊ฒฝํ ๋ count = count + 1 ๋์ **count += 1**๊ณผ ๊ฐ์ ๋ณตํฉ ํ ๋น ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋๋ฅผ ๋ ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋
์ฑ ์๊ฒ ๋ง๋ค ์ ์์ต๋๋ค. ๋ํ, ๊ธด ์กฐ๊ฑด์์ ์ฌ์ฉํ๊ธฐ๋ณด๋ค ํจ์๋ ๋ณ์๋ฅผ ํ์ฉํ์ฌ ์กฐ๊ฑด์ ์์ฒด๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ์ ์งํ๋ ๊ฒ์ด ์ข์ต๋๋ค.

๋๊ธ
๋๊ธ ์ฐ๊ธฐ