1. 반복문
반복문은 동일한 작업을 여러 번 실행하기 위해 사용되는 제어 구조입니다.
주로 for 문과 while 문이 사용되며, 각각의 반복문은 다른 상황에 적합한 방식으로 사용됩니다.
(1) while 문
while 문은 특정 조건이 참인 동안 반복적으로 코드 블록을 실행하는 제어 구조입니다. while 문은 주어진 조건이 참인 동안 반복적으로 코드를 실행하며, 조건이 거짓이 되면 반복을 멈춥니다.
while 조건:
# 조건이 참인 동안 실행될 코드
조건은 평가 결과가 참(True) 또는 거짓(False)이 될 수 있는 표현식입니다. 조건이 참일 때 코드 블록이 실행되며, 코드 블록이 실행된 후에 다시 조건을 검사합니다. 조건이 여전히 참이라면 코드 블록을 다시 실행하고, 이 과정을 조건이 거짓이 될 때까지 반복합니다.
* 기본예시
i = 1
while i <= 5:
print('Hello Python')
i += 1
| Hello Python Hello Python Hello Python Hello Python Hello Python |
while 문을 사용할 때 주의해야 할 몇 가지 사항이 있습니다.
- 무한 루프: 만약 while 문의 조건이 항상 참이라면 코드가 무한 루프에 빠질 수 있습니다. 프로그램이 의도대로 종료되지 않는 상황을 방지하기 위해 조건을 제대로 설정해야 합니다.
- 조건 변경: while 문 내에서 조건을 변경해야 루프가 종료되는 경우도 있습니다. 그렇지 않으면 무한 루프에 빠질 수 있습니다.
- 끝 조건: 반복이 더 이상 필요하지 않을 때 while 문을 종료하는 조건을 명확하게 설정해야 합니다.
적절한 초기화: 반복 변수나 조건을 사용하기 전에 적절하게 초기화해야 합니다
* while 반복문을 for 반복문처럼 사용하기
i = 1
while i < 10 :
print("{}번째 반복입니다.".format(i))
i += 1
| 1번째 반복입니다. 2번째 반복입니다. 3번째 반복입니다. 4번째 반복입니다. 5번째 반복입니다. 6번째 반복입니다. 7번째 반복입니다. 8번째 반복입니다. 9번째 반복입니다. |
* # 1부터 n까지의 총합
# 1부터 10까지의 총합
i = 1
sum = 0
while i <= 10:
sum += i
i += 1
print('1부터 10까지의 합: {sum}')
| 1부터 10까지의 합: 55 |
# 1부터 10까지의 총합
i = 1
sum = 0
while i <= 10:
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
| 원하는 단을 입력하세요: 5 5 단 5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45 |
(2) for 문
for 문은 시퀀스(리스트, 튜플, 문자열 등)의 각 항목에 대해 반복 작업을 수행하는 반복문입니다. for 문은 주로 "지정된 범위 내에서 반복"할 때 사용됩니다. 이것은 반복할 요소들이 미리 정해져 있는 경우에 유용합니다.
for 요소 in 시퀀스:
# 요소에 대한 작업 수행
- 요소: 반복할 시퀀스의 각 항목이 for 문의 실행 도중에 할당되는 변수입니다.
- 시퀀스: 반복할 데이터의 컬렉션(리스트, 튜플, 문자열 등)을 지정합니다.
- 작업: 각 요소에 대해 수행할 작업을 표현합니다.
list1 = [10, 20, 30, 40]
for li in list1:
print(li)
| 10 20 30 40 |
- 시퀀스 유형: for 문은 시퀀스 자료형에 대해 사용됩니다. 이외의 다른 자료형(숫자, 불린 등)에는 사용할 수 없습니다.
- 반복 변수: for 문 내에서 반복 변수를 초기화할 필요가 없습니다. 반복문이 실행될 때마다 시퀀스의 요소가 변수에 할당됩니다.
- 변경 불가능한 시퀀스: for 문은 변경 불가능한(immutable) 시퀀스(예: 문자열, 튜플)와 함께 사용할 수 있습니다.
- 범위와 조건: for 문은 시퀀스의 각 항목을 순차적으로 반복합니다. 조건에 따라 특정 요소를 건너뛸 수는 있지만, 일반적으로 순차적인 반복 작업에 사용됩니다.
2. 내장함수
(1) range ( )
range() 함수는 파이썬에서 순차적인 정수의 시퀀스를 생성하는 데 사용되는 내장 함수입니다. 주로 for 문과 함께 사용되며, 일정한 범위 내에서 반복 작업을 수행할 때 유용하게 활용됩니다. range() 함수의 결과로 생성되는 순차적인 정수 시퀀스는 실제로 메모리에 저장되지 않고 필요할 때마다 생성되므로, 큰 범위의 반복문에도 효율적으로 사용할 수 있습니다.
range ( [ start ] , stop , [ step ] ) range() 함수의 반환값은 range 객체로, 이 객체는 실제 정수 시퀀스를 저장하지 않고 범위 정보만 가지고 있습니다.
- start (선택 사항): 순차적인 범위의 시작 값을 지정합니다. 기본값은 0입니다.
stop: 순차적인 범위의 끝 값을 지정합니다. 생성된 시퀀스는 stop 값 직전까지의 정수를 포함합니다.
step (선택 사항): 순차적인 값을 증가시키는 간격을 지정합니다. 기본값은 1입니다.
따라서 필요한 정수 시퀀스는 실제 사용 시에 생성됩니다.
for i in range(0, 11, 1):
print(i, end=' ')
| 0 1 2 3 4 5 6 7 8 9 10 |
ㄴrange(0, 10)에서 10은 포함되지 않아요!
ㄴ 0~10까지 하려면 range(0,11) 으로 입력!
num = range(0, 10, 1)
print(num)
for i in num:
print(i, end=' ')
| range(0, 11) 0 1 2 3 4 5 6 7 8 9 10 |
ㄴ 변수에 넣어서 출력하면 "범위와 요소"들이 출력됩니다.
for i in range(0, 11): # step 생략 (기본값 1)
print(i, end=' ')
| 0 1 2 3 4 5 6 7 8 9 10 |
for i in range(11): # start 생략 (기본값 0)
print(i, end=' ')
| 0 1 2 3 4 5 6 7 8 9 10 |
for i in range(1, 11, 2): # step 2 입력시 짝수/홀수만 출력
print(i, end=' ')
| 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 |
(2) enumerate ( )
enumerate() 함수는 파이썬에서 반복문을 사용할 때 인덱스와 값을 함께 가져오기 위해 사용되는 내장 함수입니다. 주로 for 문과 함께 사용되며, 반복문 내에서 순서를 추적하면서 값과 해당 값의 인덱스를 함께 사용할 때 유용합니다. enumerate() 함수는 (인덱스, 값)의 튜플을 반환하는 이터레이터(iterator)를 생성합니다.
enumerate ( iterable , start = 0 )
- iterable: 반복 가능한 객체(리스트, 튜플, 문자열 등)를 지정합니다.
- start (선택 사항): 인덱스의 시작 값을 지정합니다. 기본값은 0입니다.
- enumerate() 함수는 (인덱스, 값) 형태의 튜플을 생성하여 이터레이터를 반환합니다.
이를 for 문과 함께 사용하여 인덱스와 값을 동시에 가져와 처리할 수 있습니다.
li1 = [10, 20, 30, 40, 50]
for e in enumerate(li1):
print(e) #e
---------------------------------------------------------------------------
for e in enumerate(li1, 0): #start 생략가능 (기본값0)
print(e)
| (0, 10) (1, 20) (2, 30) (3, 40) (4, 50) |
li1 = [10, 20, 30, 40, 50]
for i, v in enumerate(li1):
print(f'index:{i} , value:{v}')
| index:0 , value:10 index:1 , value:20 index:2 , value:30 index:3 , value:40 index:4 , value:50 |
(3) zip ( )
zip() 함수는 파이썬에서 여러 개의 반복 가능한(iterable) 객체를 병렬적으로 묶어주는 내장 함수입니다. 각 객체로부터 순서대로 하나의 요소씩 가져와 튜플로 묶어주는 이터레이터를 반환합니다. 주로 여러 개의 리스트나 튜플을 병렬적으로 처리하고자 할 때 사용됩니다.
zip ( iterable1 , iterable2 , ... ) 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 |
ㄴ 범위를 숫자를 사용한 for문은 잘 사용하지 않습니다.
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 |
ㄴ 범위를 함수로 표현한다면 확장성이 좋습니다.
문제는 두개의 list 의 요소의 갯수가 다르면 에러가 납니다.
이 부분을 보완 하기 위해 zip( ) 을 사용합니다.
li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']
for li in zip(li1, li2):
print(li)
| (10, 'apple') (20, 'banana') (30, 'orange') |
ㄴ 다른 list에서의 요소들을 짝으로 묶고 튜플로 반환합니다.
li1 = [10, 20, 30, 40]
li2 = ['apple', 'banana', 'orange']
for li in zip(li1, li2):
print(li)
| (10, 'apple') (20, 'banana') (30, 'orange') |
ㄴ 요소들의 짝이 맞지 않더라도 오류가 뜨지 않습니다.
ㄴ 적은(짧은) list에 맞워서 묶고 튜플로 반환합니다.
or n, A, a in zip('12345', 'ABCDE', 'abcde'):
print((n, A, a))
1 A a 2 B b 3 C c 4 D d 5 E e |
(4) 중첩 반복문
파이썬에서 중첩된 반복문은 하나의 반복문 안에 다른 반복문이 포함된 구조를 의미합니다. 중첩 반복문은 외부 반복문의 각 반복마다 내부 반복문이 모두 실행되는 방식으로 작동합니다. 이를 통해 다차원의 데이터를 처리하거나 복잡한 작업을 수행할 수 있습니다.
for 외부_변수 in 외부_시퀀스:
for 내부_변수 in 내부_시퀀스:
# 내부 반복문 코드
# 외부 반복문 코드
- 외부_변수: 외부 반복문의 현재 요소를 나타내는 변수입니다.
- 외부_시퀀스: 외부 반복문에서 순회할 반복 가능한 객체(리스트, 튜플 등)입니다.
- 내부_변수: 내부 반복문의 현재 요소를 나타내는 변수입니다.
- 내부_시퀀스: 내부 반복문에서 순회할 반복 가능한 객체입니다.
for i in range(1, 4):
print(f'😎 i: {i}')
for j in range(1, 4):
print(f' 😍 i: {j}')
| 😎 i: 1 😍 i: 1 😍 i: 2 😍 i: 3 😎 i: 2 😍 i: 1 😍 i: 2 😍 i: 3 😎 i: 3 😍 i: 1 😍 i: 2 😍 i: 3 |
예시문제_1
* 🎃를 이용하여 아래와 같은 도형을 만들어보자.
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
🎃 🎃 🎃 🎃 🎃
for i in range(5):
for j in range(5):
print('🎃', end=' ')
print()
| 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 🎃 |
for i in range(5):
for j in range(5):
print('🎃', end=' ')
print()
-------------------------------------------------------------------------------------------------------------------------------------------------------
for i in range(5): # 0, 1, 2, 3, 4
for j in range(i, 5): # 0, 1, 2, 3, 4
print('🎃', end=' ')
print()
| 🎃🎃🎃🎃🎃 🎃🎃🎃🎃 🎃🎃🎃 🎃🎃 🎃 |
for i in range(1,6,1):
print('🎃'*i, end=' ')
print( )
for i in range(5,0,-1): # 0, 1, 2, 3, 4
for j in range(i, 5): # 0, 1, 2, 3, 4
print('🎃', end=' ')
print()
| 🎃 🎃🎃 🎃🎃🎃 🎃🎃🎃🎃 🎃🎃🎃🎃🎃 |
예시문제_2
* 2단부터 9단까지 구구단을 출력하는 프로그램을 작성
#.for문
for i in range(2, 10): # 2, 3, 4, 5, 6, 7, 8, 9
print(f'{i}단')
for j in range(1, 10):
print(f'{i} * {j} = {i*j}')
print()
----------------------------------------------------------------------------------------------------------------------------
#.while문
i = 2
j = 1
while i <= 9:
print(f'{i}단')
while j <= 9:
print(f'{i} * {j} = {i*j}')
j += 1
j = 1 #j를 초기화시켜줘야 합니다.
i += 1
print()
| 2단 2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18 3단 3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27 4단 4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 4 * 5 = 20 4 * 6 = 24 4 * 7 = 28 4 * 8 = 32 4 * 9 = 36 5단 5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45 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 7단 7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 7 * 8 = 56 7 * 9 = 63 8단 8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 8 * 9 = 72 9단 9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 |
'Python > 개념' 카테고리의 다른 글
| Day 5-2. 사용자 정의 함수 (0) | 2024.03.15 |
|---|---|
| Day 5-1. 컬렉션과 반복문 (0) | 2024.03.15 |
| Day 4-4. 제어문 - 조건문 (0) | 2024.03.14 |
| Day 4-3. 파이썬 연산자 (0) | 2024.03.14 |
| Day 4-2. 컬렉션 타입 - 딕셔너리 (1) | 2024.03.14 |
