파이썬 기초 - 조건문과 반복문

파이썬 조건문과 반복문

조건문 (Conditional Statements)

if 문

조건에 따라 다른 코드를 실행하고 싶을 때 사용한다.

# 기본 if문
age = 20

if age >= 18:
    print("성인이다")

if-else 문

조건이 참일 때와 거짓일 때 각각 다른 코드를 실행한다.

# 기본 if-else문
age = 16

if age >= 18:
    print("성인이다")
else:
    print("미성년자다")

if-elif-else 문

여러 조건을 순차적으로 검사하여 해당하는 코드를 실행한다.

# 기본 if-elif-else문
age = 16

if age < 13:
    print("어린이다")
elif age < 18:
    print("청소년이다")
else:
    print("성인이다")

중첩 if 문

if 문 안에 다른 if 문을 사용할 수 있다.

# 중첩 if문
age = 20
has_id = True

if age >= 18:
    if has_id:
        print("술을 구매할 수 있다")
    else:
        print("신분증을 제시해야 한다")
else:
    print("미성년자는 술을 구매할 수 없다")

논리 연산자와 조건문

여러 조건을 함께 검사할 수 있다.

# and: 모든 조건이 참이어야 참
age = 20
income = 3000000

if age >= 19 and income >= 2000000:
    print("신용카드 발급이 가능하다")
else:
    print("신용카드 발급 조건을 충족하지 못한다")

# or: 하나 이상의 조건이 참이면 참
has_cash = False
has_card = True

if has_cash or has_card:
    print("결제 가능하다")
else:
    print("결제 수단이 없다")

# not: 조건의 결과를 반대로
is_raining = True

if not is_raining:
    print("외출하기 좋은 날씨다")
else:
    print("우산을 가져가야 한다")

조건부 표현식 (삼항 연산자)

간단한 if-else를 한 줄로 표현할 수 있다.

# 기본 삼항 연산자
age = 20
status = "성인" if age >= 18 else "미성년자"
print(status)  # "성인"

# 삼항 연산자를 사용하지 않으면:
if age >= 18:
    status = "성인"
else:
    status = "미성년자"

# 삼항 연산자 활용 예시
score = 85
result = "합격" if score >= 60 else "불합격"
print(result)  # "합격"

# 연속된 삼항 연산자 (가독성이 떨어지므로 주의)
age = 16
category = "어린이" if age < 13 else ("청소년" if age < 18 else "성인")
print(category)  # "청소년"

반복문 (Loops)

for 문

시퀀스(리스트, 튜플, 문자열 등)의 각 요소에 대해 코드를 반복 실행한다.

# 리스트의 각 항목에 대해 반복
fruits = ["apple", "banana", "orange"]

for fruit in fruits:
    print(f"과일: {fruit}")

# 문자열의 각 문자에 대해 반복
message = "Hello"

for char in message:
    print(char)


# 숫자 범위에 대해 반복 (range 함수 사용)
for num in range(5):  # 0부터 4까지
    print(f"숫자: {num}")


# range(시작, 끝) - 시작부터 (끝-1)까지
for num in range(2, 6):  # 2부터 5까지
    print(f"숫자: {num}")

# range(시작, 끝, 증가폭) - 시작부터 (끝-1)까지 증가폭만큼 증가
for num in range(1, 10, 2):  # 1부터 9까지 2씩 증가
    print(f"숫자: {num}")

인덱스와 함께 반복하기 (enumerate)

반복문을 사용할 때, 현재 요소와 함께 해당 요소의 인덱스(위치)도 필요한 경우가 많다. enumerate() 함수는 이런 상황에서 매우 유용하다.

enumerate()는 반복 가능한 객체(리스트, 튜플, 문자열 등)를 입력으로 받아, 각 요소의 인덱스와 값을 튜플 형태로 반환한다.

# enumerate 기본 사용법
fruits = ["apple", "banana", "orange"]

# enumerate() 함수는 (인덱스, 값) 형태의 튜플을 반환한다
for item in enumerate(fruits):
    print(item)

# 일반적으로는 튜플 언패킹을 사용하여 인덱스와 값을 따로 받는다
for index, fruit in enumerate(fruits):
    print(f"위치 {index}에 있는 과일: {fruit}")


# 시작 인덱스 지정 (기본값은 0)
for index, fruit in enumerate(fruits, 1):  # 1부터 시작
    print(f"{index}번째 과일: {fruit}")

enumerate 없이 구현한다면?

enumerate를 사용하지 않고 인덱스와 값을 함께 얻으려면 다음과 같이 해야 한다:

fruits = ["apple", "banana", "orange"]
for i in range(len(fruits)):
    print(f"위치 {i}에 있는 과일: {fruits[i]}")

 

enumerate의 실용적 활용

# 리스트의 특정 요소 위치 찾기
fruits = ["apple", "banana", "orange", "apple", "kiwi"]
apple_indices = []

for index, fruit in enumerate(fruits):
    if fruit == "apple":
        apple_indices.append(index)

print(f"사과의 위치들: {apple_indices}")  # 사과의 위치들: [0, 3]

# 텍스트에서 특정 문자의 위치 모두 찾기
text = "Hello, World!"
positions = {char: [] for char in set(text)}  # 각 문자별 빈 리스트 생성

for index, char in enumerate(text):
    positions[char].append(index)

print(positions)

# 여러 리스트를 동시에 순회하면서 인덱스 활용하기
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]

for i, (name, score) in enumerate(zip(names, scores), 1):
    print(f"학생 {i}: {name}, 점수: {score}")

while 문

조건이 참인 동안 코드를 반복 실행한다.

# 기본 while 문
count = 1

while count <= 5:
    print(f"현재 카운트: {count}")
    count += 1  # count = count + 1과 같다

# 사용자 입력에 따른 반복
answer = ""
while answer != "quit":
    answer = input("계속하려면 아무 키나 누르고, 종료하려면 'quit'를 입력하세요: ")
    if answer != "quit":
        print(f"입력한 값: {answer}")

# 무한 루프와 break
while True:
    response = input("종료하려면 'exit'를 입력하세요: ")
    if response == 'exit':
        print("프로그램을 종료합니다.")
        break  # 반복문 종료
    print(f"입력한 값: {response}")

break와 continue

반복문의 흐름을 제어한다.

# break: 반복문 즉시 종료
for num in range(1, 11):
    if num == 5:
        print("5를 발견하여 반복문을 종료합니다.")
        break
    print(f"현재 숫자: {num}")


# continue: 현재 반복을 건너뛰고 다음 반복으로 진행
for num in range(1, 6):
    if num == 3:
        print("3은 건너뜁니다.")
        continue
    print(f"현재 숫자: {num}")


# 실용적인 예: 짝수만 출력하기
for num in range(1, 11):
    if num % 2 != 0:  # 홀수면 건너뛰기
        continue
    print(f"짝수: {num}")

else 절과 반복문

반복문이 정상적으로 종료되었을 때 실행할 코드를 지정한다.

# for문과 else
for num in range(1, 6):
    print(f"숫자: {num}")
else:
    print("반복이 정상적으로 완료됐다")

# break로 종료되면 else 블록은 실행되지 않음
for num in range(1, 6):
    if num == 3:
        print("3을 발견했으므로 반복문을 중단한다")
        break
    print(f"숫자: {num}")
else:
    print("이 문장은 출력되지 않는다")

# while문과 else
count = 1
while count <= 3:
    print(f"카운트: {count}")
    count += 1
else:
    print("카운팅이 완료됐다")


# 반복문의 else를 활용한 검색 예제
numbers = [1, 3, 5, 7, 9]
search_for = 4

for num in numbers:
    if num == search_for:
        print(f"{search_for}를 찾았다!")
        break
else:
    print(f"{search_for}는 리스트에 없다")

중첩 반복문

반복문 안에 다른 반복문을 사용할 수 있다.

# 기본 중첩 반복문
for i in range(1, 4):  # 바깥쪽 반복문
    print(f"바깥쪽 반복: {i}")
    for j in range(1, 3):  # 안쪽 반복문
        print(f"  안쪽 반복: {j}")


# 구구단 출력
for i in range(2, 4):  # 2단부터 3단까지
    print(f"{i}단:")
    for j in range(1, 10):
        print(f"  {i} x {j} = {i*j}")
    print()  # 줄바꿈

# 별표로 삼각형 만들기
rows = 5
for i in range(1, rows + 1):
    print('*' * i)


# 중첩 반복문과 break/continue 사용
for i in range(1, 4):
    print(f"i = {i}:")
    for j in range(1, 4):
        if i == 2 and j == 2:
            print("건너뜁니다")
            continue
        print(f" j = {j}")

List Comprehension

반복문을 이용해 리스트를 간결하게 생성한다.

# 기본 리스트 내포 (1~10까지의 제곱 값 리스트 만들기)
squares = [x**2 for x in range(1, 11)]
print(f"제곱 값 리스트: {squares}")
# 제곱 값 리스트: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 일반 반복문으로 작성하면:
squares_traditional = []
for x in range(1, 11):
    squares_traditional.append(x**2)
# 결과는 동일하지만 코드가 더 길어진다

# 조건부 리스트 내포 (1~10 중 짝수의 제곱 값만 리스트로 만들기)
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(f"짝수 제곱 리스트: {even_squares}")
# 짝수 제곱 리스트: [4, 16, 36, 64, 100]

# if-else가 있는 리스트 내포 (1~10의 숫자에 대해 짝수면 제곱, 홀수면 세제곱)
mixed_powers = [x**2 if x % 2 == 0 else x**3 for x in range(1, 6)]
print(f"조건부 제곱 리스트: {mixed_powers}")
# 조건부 제곱 리스트: [1, 4, 27, 16, 125]

# 중첩 반복문을 이용한 리스트 내포 (구구단의 모든 결과 값)
multiplication_table = [i*j for i in range(2, 5) for j in range(1, 5)]
print(f"구구단 결과: {multiplication_table}")
# 구구단 결과: [2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]

# 중첩 반복문을 일반적인 방식으로 작성하면:
traditional_table = []
for i in range(2, 5):
    for j in range(1, 5):
        traditional_table.append(i*j)
# 결과는 동일

# 중첩된 리스트 내포 (2차원 행렬 생성)
matrix = [[i*j for j in range(1, 4)] for i in range(1, 4)]
print(f"2차원 행렬: {matrix}")
# 2차원 행렬: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

# 문자열 처리 리스트 내포
words = ["apple", "banana", "cherry", "date"]
capitalized = [word.upper() for word in words]
print(f"대문자로 변환: {capitalized}")
# 대문자로 변환: ['APPLE', 'BANANA', 'CHERRY', 'DATE']

word_lengths = [len(word) for word in words]
print(f"단어 길이: {word_lengths}")
# 단어 길이: [5, 6, 6, 4]

Dictionary Comprehension

반복문을 이용해 딕셔너리를 간결하게 생성한다.

# 기본 딕셔너리 내포 (1~5의 제곱값을 키-값 쌍으로 저장)
squared = {x: x**2 for x in range(1, 6)}
print(f"제곱값 딕셔너리: {squared}")
# 제곱값 딕셔너리: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 일반 반복문으로 표현하면:
squared_traditional = {}
for x in range(1, 6):
    squared_traditional[x] = x**2

# 조건부 딕셔너리 내포 (짝수만 포함)
even_squared = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(f"짝수 제곱 딕셔너리: {even_squared}")
# 짝수 제곱 딕셔너리: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# 기존 딕셔너리 변환 (20% 할인된 가격)
prices = {"apple": 1000, "banana": 2000, "orange": 1500}
discount_prices = {fruit: price * 0.8 for fruit, price in prices.items()}
print(f"할인 가격: {discount_prices}")
# 할인 가격: {'apple': 800.0, 'banana': 1600.0, 'orange': 1200.0}

# 키와 값을 바꾸기
swapped = {value: key for key, value in {"a": 1, "b": 2, "c": 3}.items()}
print(f"키-값 교환: {swapped}")
# 키-값 교환: {1: 'a', 2: 'b', 3: 'c'}

# 조건부 값 변환 (짝수 가격은 20% 할인, 홀수 가격은 10% 할인)
prices = {"item1": 1000, "item2": 2000, "item3": 3000, "item4": 4000}
variable_discount = {item: (price * 0.8 if price % 2000 == 0 else price * 0.9) 
                     for item, price in prices.items()}
print(f"다양한 할인 가격: {variable_discount}")
# 다양한 할인 가격: {'item1': 900.0, 'item2': 1600.0, 'item3': 2700.0, 'item4': 3200.0}

실용적인 예제

예제 1: 구구단 출력 프로그램

요구사항

 

1. 다음 조건을 만족하는 구구단 출력 프로그램을 작성한다.
   • 사용자로부터 시작 단과 끝 단을 입력받는다.
   • 입력받은 시작 단부터 끝 단까지의 구구단을 출력한다.
   • 각 단은 1부터 9까지 곱한 결과를 보여준다.
2. 프로그램은 다음 기능을 수행해야 한다:
   • 시작 단과 끝 단 입력받기
   • 유효성 검사 (1~9 사이의 값이며, 시작 단이 끝 단보다 작거나 같아야 함)
   • 조건을 충족하면 해당 범위의 구구단 출력
   • 조건을 충족하지 않으면 오류 메시지 출력

 

# 사용자 입력 받기
print("구구단 출력 프로그램")
start = int(input("시작 단 입력: "))
end = int(input("끝 단 입력: "))

# 유효성 검사
if start < 1 or end > 9 or start > end:
    print("1~9 사이의 값을 입력하고, 시작 단은 끝 단보다 작거나 같아야 합니다.")
else:
    # 구구단 출력 (시작단부터 끝단까지)
    for i in range(start, end + 1):
        print(f"===== {i}단 =====")
        for j in range(1, 10):
            print(f"{i} x {j} = {i * j}")
        print()  # 단 사이 공백 줄 추가

 

예제 2: 학생 성적 처리 예제 (컴프리헨션 활용)

요구사항

 

1. 다음 조건을 만족하는 학생 성적 처리 프로그램을 작성한다.
   • 최소 4명 이상의 학생 정보가 담긴 기본 데이터를 사용한다.
   • 각 학생마다 이름, 국어, 수학, 영어 점수가 포함되어야 한다.
   • 모든 데이터 처리는 가능한 리스트 컴프리헨션과 딕셔너리 컴프리헨션을 활용한다.
2. 프로그램은 다음 기능을 수행해야 한다:
   • 모든 학생의 평균 점수를 계산하고 출력한다. (소수점 첫째 자리까지 반올림)
   • 각 학생 정보에 평균 점수를 추가한다.
   • 학생 이름과 평균 점수를 연결한 딕셔너리를 생성한다.
   • 수학 점수가 90점 이상인 학생들의 이름을 추출한다.
   • 각 과목별 최고 득점자를 찾는다.
   • 각 과목별 학생의 등급(A, B, C 등)을 매긴다.
   • 각 과목별 평균 점수를 계산한다.
   • 모든 과목에서 80점 이상 받은 학생을 찾는다.
3. 출력 형식은 다음을 포함해야 한다:
   • 모든 학생의 평균 점수 리스트
   • 이름-평균 연결 딕셔너리
   • 수학 고득점자 명단
   • 과목별 최고 득점자 정보
   • 학생별 과목 등급 정보
   • 과목별 평균 점수
   • 전 과목 고득점자 명단

 

# 기본 학생 데이터
students = [
    {"name": "Kim", "korean": 85, "math": 90, "english": 78},
    {"name": "Lee", "korean": 92, "math": 95, "english": 88},
    {"name": "Park", "korean": 78, "math": 85, "english": 92},
    {"name": "Choi", "korean": 88, "math": 92, "english": 96}
]

# 1. 리스트 컴프리헨션을 사용하여 각 학생의 평균 점수 계산
averages = [round((s["korean"] + s["math"] + s["english"]) / 3, 1) for s in students]
print(f"모든 학생의 평균 점수: {averages}")

# 2. 리스트 컴프리헨션으로 학생 정보에 평균 점수 추가
students_with_avg = [{**s, "average": round((s["korean"] + s["math"] + s["english"]) / 3, 1)} for s in students]

# 3. 딕셔너리 컴프리헨션으로 이름:평균 형태의 딕셔너리 생성
name_to_avg = {s["name"]: round((s["korean"] + s["math"] + s["english"]) / 3, 1) for s in students}
print(f"이름-평균 딕셔너리: {name_to_avg}")

# 4. 리스트 컴프리헨션으로 수학 90점 이상인 학생 이름 추출
math_high_scorers = [s["name"] for s in students if s["math"] >= 90]
print(f"수학 90점 이상 학생: {math_high_scorers}")

# 5. 딕셔너리 컴프리헨션으로 각 과목별 최고 득점자 찾기
top_scorers = {
    "korean": max([s["name"] for s in students], key=lambda name: next(st["korean"] for st in students if st["name"] == name)),
    "math": max([s["name"] for s in students], key=lambda name: next(st["math"] for st in students if st["name"] == name)),
    "english": max([s["name"] for s in students], key=lambda name: next(st["english"] for st in students if st["name"] == name))
}
print(f"과목별 최고 득점자: {top_scorers}")

# 6. 컴프리헨션과 조건부 표현식을 결합
grade_points = {s["name"]: [
    "A" if s["korean"] >= 90 else "B" if s["korean"] >= 80 else "C",
    "A" if s["math"] >= 90 else "B" if s["math"] >= 80 else "C",
    "A" if s["english"] >= 90 else "B" if s["english"] >= 80 else "C"
] for s in students}
print(f"학생별 등급: {grade_points}")

# 7. 중첩 리스트 컴프리헨션으로 과목별 평균 계산
subject_avgs = {
    "korean": round(sum([s["korean"] for s in students]) / len(students), 1),
    "math": round(sum([s["math"] for s in students]) / len(students), 1),
    "english": round(sum([s["english"] for s in students]) / len(students), 1)
}
print(f"과목별 평균: {subject_avgs}")

# 8. 모든 과목에서 80점 이상 받은 학생 필터링
excellent_students = [s["name"] for s in students if all(s[subject] >= 80 for subject in ["korean", "math", "english"])]
print(f"모든 과목 80점 이상 학생: {excellent_students}")