제어문 - 반복문

1. 반복문

• 동일한 작업을 여러 번 실행하기 위해 사용되는 제어 구조
• 주로 for 문과 while 문 사용
• 각각의 반복문은 다른 상황에 적합한 방식으로 사용

2. while 문

• 특정 조건이 참인 동안 반복적으로 코드 블록을 실행하는 제어 구조
• 주어진 조건이 참인 동안 반복적으로 코드를 실행하며, 조건이 거짓이 되면 반복을 멈춘다.

while 조건:
    # 조건이 참인 동안 실행될 코드

• 조건은 평가 결과가 참(True) 또는 거짓(False)이 될 수 있는 표현식
• 조건이 참일 때 코드 블록이 실행되며, 코드 블록이 실행된 후에 다시 조건을 검사한다. 조건이 여전히 참이라면 코드 블록을 다시 실행하고, 이 과정을 조건이 거짓이 될 때까지 반복한다.

# 무한루프
while True:
    print('안녕하세요')

안녕하세요 무한 반복...

i = 1

while i <= 5:
    print('Hello Python')
    i += 1

Hello Python
Hello Python
Hello Python
Hello Python
Hello Python

i = 1
sum = 0

while i<=10:
  sum += i # sum = sum + i
  i += 1

print(f'1부터 10까지의 합: {sum}')

1부터 10까지의 합: 55

i = 1
sum = 0

while i<=100:
  if i% 2 == 0:
     sum += i # sum = sum + i
  i += 1

print(f'1부터 100까지의 짝수의 합: {sum}')

1부터 100까지의 짝수의 합: 2550

# 원하는 구구단을 입력받아 해당 단의 구구단을 출력
dan = int(input('원하는 단을 입력하세요: '))
print(f'{dan} 단')

i = 1
while i <= 9:
    print(f'{dan} * {i} = {dan * i}')
    i += 1

원하는 단을 입력하세요: 6
6 단
6 * 1 = 6
6 * 2 = 12
6 * 3 = 18
6 * 4 = 24
6 * 5 = 30
6 * 6 = 36
6 * 7 = 42
6 * 8 = 48
6 * 9 = 54

3. for 문

• 시퀀스(리스트, 튜플, 문자열 등)의 각 항목에 대해 반복 작업을 수행하는 반복문
• 주로 "지정된 범위 내에서 반복"할 때 사용
• 반복할 요소들이 미리 정해져 있는 경우에 유용

# 요소: 반복할 시퀀스의 각 항목이 for 문의 실행 도중에 할당되는 변수
for 요소 in 시퀀스:
    # 요소에 대한 작업 수행

for s in "Hello":
    print(s)

H
e
l
l
o

list1 = [10, 20, 30, 40]

for li in list1:
    print(li)

10
20
30
40

4. range() 함수

• 순차적인 정수의 시퀀스를 생성하는 데 사용되는 내장 함수
• 주로 for 문과 함께 사용되며, 일정한 범위 내에서 반복 작업을 수행할 때 유용하게 활용된다.
• range() 함수의 결과로 생성되는 순차적인 정수 시퀀스는 실제로 메모리에 저장되지 않고 필요할 때마다 생성되므로, 큰 범위의 반복문에도 효율적으로 사용할 수 있다.

range([start], stop, [step])

num = range(0, 10, 1)
print(num)

for i in num:
    print(i, end=' ')

range(0, 10)
0 1 2 3 4 5 6 7 8 9 

for i in range(0, 10, 1):
    print(i, end=' ')

print()
for i in range(0, 10): # step을 생략하면 기본값이 1
    print(i, end=' ')

print()
for i in range(10): # start를 생략하면 기본값이 0
    print(i, end=' ')

print()
for i in range(1, 11, 2):
    print(i, end=' ')

0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
1 3 5 7 9 

# for 문을 이용하여 1부터 100까지의 짝수의 총합 구하기
sum = 0
for i in range(0, 101, 2):
    sum += i

print(f'1부터 100까지 짝수의 총합: {sum}')

1부터 100까지 짝수의 총합: 2550

5. enumerate() 함수

• 파이썬에서 반복문을 사용할 때 인덱스와 값을 함께 가져오기 위해 사용되는 내장 함수
• 주로 for 문과 함께 사용되며, 반복문 내에서 순서를 추적하면서 값과 해당 값의 인덱스를 함께 사용할 때 유용하다.
• enumerate() 함수는 (인덱스, 값)의 튜플을 반환하는 이터레이터(iterator)를 생성한다.

enumerate(iterable, [start=0])

for e in enumerate('hello'): # start 기본값은 0
    print(e)

(0, 'h')
(1, 'e')
(2, 'l')
(3, 'l')
(4, 'o')

for e in enumerate('hello', 2):
    print(e)

(2, 'h')
(3, 'e')
(4, 'l')
(5, 'l')
(6, 'o')

list1 = [10, 20, 30, 40]

for e in enumerate(list1):
    print(e)

(0, 10)
(1, 20)
(2, 30)
(3, 40)

list1 = [10, 20, 30, 40]

for i,v in enumerate(list1):
    print(f'인덱스:{i}, 값:{v}')

인덱스:0, 값:10
인덱스:1, 값:20
인덱스:2, 값:30
인덱스:3, 값:40

6. zip 함수

• 파이썬에서 여러 개의 반복 가능한(iterable) 객체를 병렬적으로 묶어주는 내장 함수
• 각 객체로부터 순서대로 하나의 요소씩 가져와 튜플로 묶어주는 이터레이터를 반환한다.
• 주로 여러 개의 리스트나 튜플을 병렬적으로 처리하고자 할 때 사용된다.

zip(iterable1, iterable2, ...)

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for i in range(0, 3):
    print(li1[i], li2[i])

10 apple
20 banana
30 orange

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for i in range(len(li1)):
    print((li1[i], li2[i]))

(10, 'apple')
(20, 'banana')
(30, 'orange')

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for l1, l2 in zip(li1, li2):
    print(l1, l2)

10 apple
20 banana
30 orange

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for li in zip(li1, li2):
    print(li)

(10, 'apple')
(20, 'banana')
(30, 'orange')

li1 = [10, 20, 30, 40, 50]
li2 = ['apple', 'banana', 'orange']

for l1, l2 in zip(li1, li2):
    print(l1, l2)

10 apple
20 banana
30 orange

7. 중첩 반복문

• 하나의 반복문 안에 다른 반복문이 포함된 구조
• 외부 반복문의 각 반복마다 내부 반복문이 모두 실행되는 방식으로 작동
• 다차원의 데이터를 처리하거나 복잡한 작업을 수행할 수 있다.

for 외부_변수 in 외부_시퀀스:
    for 내부_변수 in 내부_시퀀스:
        # 내부 반복문 코드
    # 외부 반복문 코드

for i in range(1, 4):
    print(f'😎 i: {i}')
    for j in range(1, 4):
        print(f'   😍 j: {j}')

😎 i: 1
   😍 j: 1
   😍 j: 2
   😍 j: 3
😎 i: 2
   😍 j: 1
   😍 j: 2
   😍 j: 3
😎 i: 3
   😍 j: 1
   😍 j: 2
   😍 j: 3

for i in range(5):
    for j in range(5):
        print('🎃', end=' ')
    print()

🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃

for i in range(5):
    for j in range(i, 5): # range(0, 5), range(0, 1)
        print('🎃', end=' ')
    print()

🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃
🎃 🎃 🎃
🎃 🎃
🎃

→ i는 0~4까지 반복이 된다.
i=0) j in range(0, 5) 이므로 j는 0~4까지 호박을 출력한다. 호박 5개
i=1) j in range(1, 5) 이므로 j는 1~4까지 호박을 출력한다. 호박 4개
i=2) j in range(2, 5) 이므로 j는 2~4까지 호박을 출력한다. 호박 3개
i=3) j in range(3, 5) 이므로 j는 3~4까지 호박을 출력한다. 호박 2개
i=4) j in range(4, 5) 이므로 j는 4~4까지 호박을 출력한다. 호박 1개

for i in range(5):
    for j in range(0, i+1):
        print('🎃', end=' ')
    print()

🎃
🎃 🎃
🎃 🎃 🎃
🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃

→ i는 0~4까지 반복이 된다.
i=0) j in range(0, 1) 이므로 j는 0~0까지 호박을 출력한다. 호박 1개
i=1) j in range(0, 2) 이므로 j는 0~1까지 호박을 출력한다. 호박 2개
i=2) j in range(0, 3) 이므로 j는 0~2까지 호박을 출력한다. 호박 3개
i=3) j in range(0, 4) 이므로 j는 0~3까지 호박을 출력한다. 호박 4개
i=4) j in range(0, 5) 이므로 j는 0~4까지 호박을 출력한다. 호박 5개

아래와 같은 코드로 작성해도 같은 결과들이 출력이 된다.

for i in range(5):
  for j in range(5-i):
      print('🎃', end = ' ')
  print()

🎃 🎃 🎃 🎃 🎃 
🎃 🎃 🎃 🎃 
🎃 🎃 🎃 
🎃 🎃 
🎃 

→ i는 0~4까지 반복이 된다.
i=0) j in range(5-0) 이므로 j는 호박 5개 출력
i=1) j in range(5-1) 이므로 j는 호박 4개 출력
i=2) j in range(5-2) 이므로 j는 호박 3개 출력
i=3) j in range(5-3) 이므로 j는 호박 2개 출력
i=4) j in range(5-4) 이므로 j는 호박 1개 출력

for i in range(5):
  for j in range(i+1):
      print('🎃', end = ' ')
  print()

🎃 
🎃 🎃 
🎃 🎃 🎃 
🎃 🎃 🎃 🎃 
🎃 🎃 🎃 🎃 🎃 

→ i는 0~4까지 반복이 된다.
i=0) j in range(0+1) 이므로 j는 호박 1개 출력
i=1) j in range(1+1) 이므로 j는 호박 2개 출력
i=2) j in range(2+1) 이므로 j는 호박 3개 출력
i=3) j in range(3+1) 이므로 j는 호박 4개 출력
i=4) j in range(4+1) 이므로 j는 호박 5개 출력

# 2단부터 9단까지 구구단을 출력하는 프로그램을 작성

# for 문
for i in range(2, 10):
  print(f'{i}단')
  for j in range(1, 10):
      print(f'{i}*{j} = {i*j}')
  print()

→ i는 2~9까지 반복
i=2) j는 1~9까지 반복하며 구구단 출력
... 반복
... 반복
i=9) j는 1~9까지 반복하며 구구단 출력

# while 문
i = 2
j = 1

while i <= 9:
  print(f'{i}단')
  for j in range(1,10):
    print(f'{i} * {j} = {i * j}')
  i += 1
  print()

→ 초기값 i=2, j=1
i가 9보다 작거나 같을 때까지
j=1~9까지 반복하며 i와 곱하여 구구단 출력
i에 1증가하여
i=2~9까지 즉, 2단~9단까지의 구구단 출력

---

✔ 다시 정리해보기!

시퀀스 : 리스트 튜플, 문자열 등

🔹 range() 함수

파이썬에서 순차적인 정수의 시퀀스를 생성하는데 사용되는 내장 함수.
메모리 저장X 필요할 때마다 생성됨.

range([start], stop, [step])

• start (선택 사항): 시작 값. 기본값 0.
• stop: 끝 값. stop 값 직전까지의 정수 포함.
• step (선택 사항): 스텝 수. 기본값 1.

🔹 enumerate() 함수

파이썬에서 반복문을 사용할 때 인덱스와 값을 함께 가져오기 위해 사용되는 내장 함수.
(인덱스, 값)의 튜플을 반환하는 이터레이터(iterator)를 생성한다.

enumerate(iterable, [start=0])

• Iterable(반복 가능 객체)
• Iterator(이터레이터): 이터러블 객체에서 iter() 함수를 호출해 얻을 수 있으며, next() 함수를 사용해 요소를 하나씩 순차적으로 접근한다.

🔹 zip() 함수

파이썬에서 여러 개의 반복 가능한(iterable) 객체를 병렬적으로 묶어주는 내장 함수.

zip(iterable1, iterable2, ...)