Python 제어 흐름 정리: Boolean과 비교 연산자부터 조건문, 반복문까지

Alchemist·2026년 9월 29일
booleandictionaryelifforifpython반복문비교연산자조건문

KT AIVLE

목록 보기
28/130

들어가며

프로그램은 기본적으로 작성된 코드를 위에서 아래로 순서대로 실행한다. 하지만 실제 프로그램에서는 조건에 따라 특정 코드를 실행하거나 건너뛰고, 여러 데이터를 대상으로 같은 작업을 반복해서 실행하는 흐름이 필요하다.

Python에서는 이런 실행 흐름을 제어하기 위해 Boolean, 비교 연산자, 조건문, 반복문을 사용할 수 있다.

이 글에서는 다음 흐름을 중심으로 Python의 제어 구조를 정리한다.

  • 참과 거짓을 표현하는 Boolean
  • 두 값을 비교하는 비교 연산자
  • 조건에 따라 실행을 나누는 if, else, elif
  • 조건문을 중첩하는 방법
  • 리스트를 순회하는 for
  • 다차원 리스트의 반복 처리
  • 딕셔너리와 반복문을 함께 사용하는 방법

제어문이 필요한 이유

코드가 단순히 위에서 아래로만 실행된다면 항상 같은 작업만 수행하게 된다.

하지만 프로그램은 상황에 따라 다른 동작을 해야 할 때가 많다.

예를 들어 사용자가 입력한 아이디가 올바를 때만 환영 메시지를 보여 주거나, 여러 사람의 정보를 하나씩 꺼내 같은 형식으로 출력해야 할 수 있다.

이처럼 프로그램의 실행 흐름을 바꾸는 대표적인 방법이 조건문과 반복문이다.

조건문은 조건에 따라 실행할 코드를 선택하고, 반복문은 여러 데이터를 대상으로 같은 작업을 반복한다.

이 두 기능을 이해하려면 먼저 조건을 표현하는 Boolean과 비교 연산자를 알아야 한다.

Boolean: 참과 거짓을 표현하는 데이터 타입

Boolean은 참과 거짓을 표현하는 데이터 타입이다.

Python에서는 다음 두 값을 사용한다.

print(True)
print(False)

결과:

True
False

Boolean이 가질 수 있는 값은 True와 False 두 가지다.

숫자나 문자열처럼 어떤 데이터를 직접 표현하기도 하지만, 제어문에서는 특히 어떤 조건이 맞는지 틀리는지를 판단하는 결과값으로 사용된다.

예를 들어 다음과 같은 질문을 코드로 표현할 수 있다.

입력한 아이디가 저장된 아이디와 같은가?

이 질문의 결과는 결국 둘 중 하나다.

True
False

이 결과를 조건문과 연결하면 프로그램이 상황에 따라 다른 코드를 실행할 수 있다.

비교 연산자

비교 연산자는 두 값을 비교하고 결과를 True 또는 False로 반환한다.

같은 값인지 비교하기

print('1 == 1', 1 == 1)
print('1 == 2', 1 == 2)

결과:

1 == 1 True
1 == 2 False

==는 양쪽 값이 같은지 비교한다.

대입에 사용하는 =와 비교에 사용하는 ==는 역할이 다르기 때문에 구분해야 한다.

a = 1

위 코드는 a에 1을 저장하는 대입이다.

반면 다음 코드는 두 값을 비교한다.

1 == 1

결과는 True다.

크기 비교하기

print('1 < 2', 1 < 2)
print('1 > 2', 1 > 2)
print('1 >= 1', 1 >= 1)
print('2 >= 1', 2 >= 1)

결과:

1 < 2 True
1 > 2 False
1 >= 1 True
2 >= 1 True

각 연산자는 다음 의미를 가진다.

연산자의미
==같다
<왼쪽 값이 더 작다
>왼쪽 값이 더 크다
>=왼쪽 값이 오른쪽 값보다 크거나 같다
!=서로 다르다

서로 다른 값인지 비교하기

print('1 != 1', 1 != 1)
print('2 != 1', 2 != 1)

결과:

1 != 1 False
2 != 1 True

!=는 두 값이 서로 다른지 확인한다.

비교 연산자의 중요한 특징은 어떤 비교를 하더라도 최종 결과가 Boolean이라는 점이다.

이 결과를 if와 연결하면 조건에 따라 실행 흐름을 바꿀 수 있다.

if: 조건이 참일 때만 실행하기

가장 기본적인 조건문은 if다.

형식은 다음과 같다.

if 조건:
    실행할 코드

if 뒤의 조건이 True라면 들여쓰기된 코드가 실행된다.

반대로 조건이 False라면 해당 코드 블록을 건너뛴다.

True인 경우

print(0)

if True:
    print(1)

print(2)

결과:

0
1
2

조건이 True이므로 print(1)이 실행된다.

False인 경우

print(0)

if False:
    print(1)

print(2)

결과:

0
2

이번에는 조건이 False이므로 들여쓰기된 print(1)은 실행되지 않는다.

if가 영향을 주는 범위는 들여쓰기된 코드 블록이다.

Python 조건문과 들여쓰기

Python에서는 들여쓰기가 단순히 코드를 보기 좋게 만드는 용도가 아니다.

어떤 코드가 조건문에 포함되는지를 결정하는 문법의 일부다.

if True:
    print(1)

print(2)

print(1)은 if에 포함되지만 print(2)는 포함되지 않는다.

따라서 print(2)는 조건과 관계없이 실행된다.

들여쓰기 방식을 섞어 사용하면 코드 구조를 이해하기 어렵거나 오류가 발생할 수 있으므로 한 가지 방식을 일관되게 사용하는 것이 중요하다.

사용자 입력과 비교 연산자를 조건문에 연결하기

조건문은 True나 False를 직접 적는 것보다, 비교 연산자의 결과를 조건으로 사용할 때 실제 프로그램에서 더 유용해진다.

예를 들어 사용자가 입력한 아이디가 저장된 아이디와 같은 경우에만 메시지를 출력할 수 있다.

input_id = input('id : ')
user_id = 'python'

if input_id == user_id:
    print('Welcome')

사용자가 다음과 같이 입력했다고 하자.

id : python

input_id == user_id의 결과는 다음과 같다.

True

따라서 조건문 내부의 코드가 실행된다.

Welcome

다른 값을 입력하면 비교 결과가 False가 되고 Welcome은 출력되지 않는다.

여기까지의 흐름을 연결하면 다음과 같다.

사용자 입력
→ 값 비교
→ True 또는 False
→ if가 실행 여부 결정

Boolean과 비교 연산자가 조건문과 직접 연결되는 이유다.

else: 조건이 거짓일 때 실행할 코드 만들기

기본 if만 사용하면 조건이 False일 때 아무 작업도 하지 않는다.

조건이 맞지 않을 때도 다른 동작을 실행하려면 else를 사용할 수 있다.

if 조건:
    조건이 True일 때 실행
else:
    조건이 False일 때 실행

기본 동작 확인하기

print(0)

if True:
    print(1)
else:
    print(2)

print(3)

결과:

0
1
3

조건이 True이므로 if 블록이 실행되고 else 블록은 실행되지 않는다.

반대로 다음 코드를 보자.

print(0)

if False:
    print(1)
else:
    print(2)

print(3)

결과:

0
2
3

조건이 False이므로 if 대신 else가 실행된다.

즉, if와 else를 함께 사용하면 둘 중 하나의 코드 블록만 실행되는 구조를 만들 수 있다.

아이디 확인 프로그램에 else 추가하기

input_id = input('id : ')
user_id = 'python'

if input_id == user_id:
    print('Welcome')
else:
    print('Who?')

올바른 아이디를 입력하면:

Welcome

다른 아이디를 입력하면:

Who?

이제 프로그램이 두 가지 상황에 모두 반응한다.

elif: 여러 조건 중 하나 선택하기

확인해야 할 조건이 두 개보다 많다면 elif를 사용할 수 있다.

기본 구조는 다음과 같다.

if 첫 번째_조건:
    첫 번째_코드
elif 두 번째_조건:
    두 번째_코드
else:
    나머지_코드

조건은 위에서부터 순서대로 확인한다.

첫 번째 조건이 참인 경우

print(0)

if True:
    print(1)
elif True:
    print(2)
else:
    print(3)

print(4)

결과:

0
1
4

첫 번째 if가 이미 True이므로 해당 블록이 실행되고, 뒤의 elif와 else는 실행되지 않는다.

첫 번째 조건은 거짓이고 두 번째 조건이 참인 경우

print(0)

if False:
    print(1)
elif True:
    print(2)
else:
    print(3)

print(4)

결과:

0
2
4

첫 번째 조건이 False이기 때문에 다음 elif를 확인한다.

elif가 True이므로 print(2)가 실행된다.

모든 조건이 거짓인 경우

print(0)

if False:
    print(1)
elif False:
    print(2)
else:
    print(3)

print(4)

결과:

0
3
4

앞의 조건이 모두 False이므로 마지막 else가 실행된다.

여러 아이디 처리하기

input_id = input('id : ')

id1 = 'python'
id2 = 'developer'

if input_id == id1:
    print('Welcome')
elif input_id == id2:
    print('Welcome')
else:
    print('Who?')

이 구조에서는 두 개의 서로 다른 아이디를 각각 확인할 수 있다.

핵심은 if, elif, else 중 조건에 맞는 하나의 경로만 선택되어 실행된다는 점이다.

조건문 중첩하기

하나의 조건을 통과한 뒤 추가 조건을 검사해야 할 수도 있다.

예를 들어 아이디가 맞는지를 먼저 확인하고, 아이디가 맞을 때만 비밀번호를 확인하는 구조를 만들 수 있다.

input_id = input('id:')
user_id = 'python'

input_password = input('password:')
password = '111111'

if input_id == user_id:
    if input_password == password:
        print('Welcome')
    else:
        print('Wrong password')
else:
    print('Wrong id')

실행 흐름을 나누면 다음과 같다.

아이디가 틀리면:

Wrong id

아이디는 맞지만 비밀번호가 틀리면:

Wrong password

아이디와 비밀번호가 모두 맞으면:

Welcome

중첩 조건문에서는 들여쓰기 단계가 한 단계 더 깊어진다.

if 첫_번째_조건:
    if 두_번째_조건:
        실행할_코드

바깥쪽 조건이 먼저 True가 되어야 안쪽 조건을 검사할 수 있다.

반복문이 필요한 이유

여러 데이터에 같은 작업을 수행해야 할 때 같은 코드를 계속 복사해서 작성하는 것은 비효율적이다.

예를 들어 여러 이름에 각각 인사해야 한다고 생각해 보자.

데이터를 리스트에 저장하고 for를 사용하면 리스트의 값을 하나씩 꺼내 같은 작업을 반복할 수 있다.

for: 리스트의 값을 하나씩 처리하기

다음과 같은 이름 목록이 있다고 하자.

names = ['kim', 'lee', 'park', 'choi']

for를 사용하면 각 이름을 하나씩 꺼낼 수 있다.

names = ['kim', 'lee', 'park', 'choi']

for name in names:
    print('Hello, ' + name + ' . Bye, ' + name + '.')

결과:

Hello, kim . Bye, kim.
Hello, lee . Bye, lee.
Hello, park . Bye, park.
Hello, choi . Bye, choi.

for name in names:의 동작을 순서대로 보면 다음과 같다.

  1. names에서 첫 번째 값을 꺼낸다.
  2. 꺼낸 값을 name에 저장한다.
  3. 들여쓰기된 코드를 실행한다.
  4. 다음 값을 name에 저장한다.
  5. 리스트의 모든 값을 처리할 때까지 같은 작업을 반복한다.

따라서 name은 반복할 때마다 다른 값을 가진다.

반복문에서도 조건문과 마찬가지로 들여쓰기된 코드 블록이 반복 대상이 된다.

다차원 리스트 다루기

한 사람에 대한 정보가 이름 하나뿐 아니라 주소와 관심 분야까지 포함한다면 하나의 리스트 안에 여러 리스트를 넣어 표현할 수 있다.

persons = [
    ['kim', 'Seoul', 'Web'],
    ['lee', 'Seoul', 'IOT'],
    ['park', 'Tongyeong', 'ML'],
]

각 내부 리스트는 한 사람의 정보를 표현한다.

인덱스로 특정 값 가져오기

print(persons[0][0])

결과:

kim

persons[0]은 첫 번째 사람의 리스트다.

['kim', 'Seoul', 'Web']

여기서 다시 [0]을 사용하면 첫 번째 값인 이름을 가져온다.

반복문으로 한 사람씩 처리하기

for person in persons:
    print(person[0] + ',' + person[1] + ',' + person[2])

결과:

kim,Seoul,Web
lee,Seoul,IOT
park,Tongyeong,ML

person에는 반복할 때마다 내부 리스트 하나가 들어간다.

따라서 다음과 같이 각 위치의 값을 사용할 수 있다.

person[0]
person[1]
person[2]

리스트의 값을 여러 변수에 나누어 저장하기

리스트의 각 값을 인덱스로 하나씩 가져올 수도 있다.

person = ['kim', 'Seoul', 'Web']

name = person[0]
address = person[1]
interest = person[2]

print(name, address, interest)

결과:

kim Seoul Web

하지만 같은 구조의 데이터라면 한 번에 여러 변수로 나눠 받을 수도 있다.

name, address, interest = ['kim', 'Seoul', 'Web']

print(name, address, interest)

결과:

kim Seoul Web

이 방식을 반복문과 결합하면 다차원 리스트의 각 값을 바로 변수로 받아 사용할 수 있다.

persons = [
    ['kim', 'Seoul', 'Web'],
    ['lee', 'Seoul', 'IOT'],
    ['park', 'Tongyeong', 'ML'],
]

for name, address, interest in persons:
    print(name + ',' + address + ',' + interest)

결과:

kim,Seoul,Web
lee,Seoul,IOT
park,Tongyeong,ML

이렇게 하면 person[0], person[1], person[2]처럼 위치를 직접 기억하지 않고 각 값에 의미 있는 변수 이름을 붙여 사용할 수 있다.

딕셔너리로 데이터에 이름 붙이기

리스트는 값의 위치로 데이터를 구분한다.

['kim', 'Seoul', 'Web']

이 구조에서는 첫 번째 값이 이름인지, 두 번째 값이 주소인지 데이터만 보고 바로 알기 어렵다.

딕셔너리를 사용하면 각 값에 키를 붙일 수 있다.

person = {
    'name': 'kim',
    'address': 'Seoul',
    'interest': 'Web'
}

이제 위치가 아니라 키를 이용해 값을 가져온다.

print(person['name'])

결과:

kim

for로 딕셔너리 순회하기

딕셔너리를 for로 반복하면 키를 하나씩 가져올 수 있다.

person = {
    'name': 'kim',
    'address': 'Seoul',
    'interest': 'Web'
}

for key in person:
    print(key, person[key])

결과:

name kim
address Seoul
interest Web

반복 과정에서 key에는 다음 값들이 차례대로 들어간다.

name
address
interest

그리고 실제 값은 다음처럼 가져온다.

person[key]

즉, 딕셔너리를 반복하면서 키와 그 키에 연결된 값을 함께 처리할 수 있다.

여러 딕셔너리를 리스트로 관리하기

한 사람의 정보를 딕셔너리로 표현했다면 여러 사람의 정보는 딕셔너리 여러 개를 리스트에 넣어 관리할 수 있다.

persons = [
    {
        'name': 'kim',
        'address': 'Seoul',
        'interest': 'Web'
    },
    {
        'name': 'lee',
        'address': 'Seoul',
        'interest': 'IOT'
    },
    {
        'name': 'park',
        'address': 'Tongyeong',
        'interest': 'ML'
    }
]

여기에는 두 종류의 반복이 필요하다.

첫 번째 반복은 사람을 하나씩 꺼낸다.

for person in persons:

두 번째 반복은 한 사람의 딕셔너리에서 키를 하나씩 꺼낸다.

for key in person:

두 반복을 중첩하면 다음과 같이 작성할 수 있다.

persons = [
    {'name': 'kim', 'address': 'Seoul', 'interest': 'Web'},
    {'name': 'lee', 'address': 'Seoul', 'interest': 'IOT'},
    {'name': 'park', 'address': 'Tongyeong', 'interest': 'ML'}
]

print('==== persons ====')

for person in persons:
    for key in person:
        print(key, ':', person[key])

    print('-----------------')

결과:

==== persons ====
name : kim
address : Seoul
interest : Web
-----------------
name : lee
address : Seoul
interest : IOT
-----------------
name : park
address : Tongyeong
interest : ML
-----------------

바깥쪽 for는 사람 단위로 반복하고, 안쪽 for는 그 사람의 각 속성을 반복한다.

이 구조를 이해하면 리스트와 딕셔너리가 결합된 데이터를 반복문으로 처리하는 흐름을 이해할 수 있다.

조건문과 반복문의 공통점

조건문과 반복문은 목적은 다르지만 공통적으로 코드의 실행 흐름을 제어한다.

조건문은 어떤 코드를 실행할지 결정한다.

if 조건:
    실행
else:
    다른_실행

반복문은 같은 코드 블록을 여러 데이터에 대해 실행한다.

for 값 in 데이터:
    반복_실행

둘 모두 : 뒤에 코드 블록이 이어지고, Python에서는 들여쓰기로 그 범위를 표현한다.

따라서 제어문을 읽을 때는 키워드뿐 아니라 들여쓰기 구조까지 함께 확인하는 것이 중요하다.

전체 흐름 연결하기

제어 흐름의 핵심 개념은 서로 따로 존재하지 않는다.

먼저 비교 연산을 수행하면:

input_id == user_id

그 결과로 Boolean이 만들어진다.

True
False

이 Boolean을 if가 받아 실행할 코드를 결정한다.

if input_id == user_id:
    print('Welcome')

조건이 두 갈래라면 else를 사용할 수 있다.

if input_id == user_id:
    print('Welcome')
else:
    print('Who?')

여러 조건을 순서대로 검사해야 한다면 elif를 추가한다.

if input_id == id1:
    print('Welcome')
elif input_id == id2:
    print('Welcome')
else:
    print('Who?')

한 조건 안에서 다시 다른 조건을 검사해야 한다면 조건문을 중첩한다.

if input_id == user_id:
    if input_password == password:
        print('Welcome')

반대로 여러 데이터를 하나씩 처리해야 한다면 for를 사용한다.

for name in names:
    print(name)

데이터가 리스트 안의 리스트이거나 리스트 안의 딕셔너리처럼 복잡해져도 같은 원리로 반복할 수 있다.

즉, Boolean과 비교 연산자가 판단을 만들고, 조건문이 실행 경로를 선택하며, 반복문이 여러 데이터를 반복 처리한다.

정리

Python의 제어 흐름은 프로그램이 항상 같은 순서로만 동작하지 않고 상황과 데이터에 따라 다른 작업을 수행하도록 만든다.

Boolean은 True와 False를 표현하고, 비교 연산자는 두 값을 비교해 Boolean 결과를 만든다.

if는 조건이 참일 때 특정 코드 블록을 실행하고, else는 조건이 거짓일 때 실행할 코드를 지정한다. elif를 사용하면 여러 조건을 순서대로 검사할 수 있으며, 조건문 안에 다시 조건문을 작성하면 단계적인 판단 구조를 만들 수 있다.

for는 리스트의 값을 하나씩 꺼내 같은 작업을 반복한다. 다차원 리스트에서는 내부 리스트를 순회하거나 값을 여러 변수로 나누어 받을 수 있고, 딕셔너리는 키를 이용해 데이터의 의미를 명확하게 표현할 수 있다.

리스트 안에 여러 딕셔너리를 저장한 뒤 반복문을 중첩하면 여러 대상과 각 대상의 속성을 차례대로 처리할 수 있다.

이 흐름을 연결해서 이해하면 비교 결과를 이용해 실행 경로를 선택하고, 구조화된 데이터를 반복 처리하는 Python의 기본 제어 구조를 이해할 수 있다.

profile
Alchemist
html_programming_language
이전 포스트

Python 입문 정리: 실행 환경부터 데이터 타입, 변수, 디버깅, PyPI 활용까지

다음 포스트

Python 기초부터 객체지향까지: 자료형, 제어문, 함수, 예외 처리, 모듈, 클래스 정리

0개의 댓글