2. 나의 첫 번째 Python 프로그램

1장에서 Python을 설치하고, 대화형 셸(REPL)을 사용하는 법과 간단한 스크립트 파일을 실행하는 방법을 배웠습니다. 또한 오류와 트레이스백을 처음으로 살펴보았습니다. 이제 첫 번째 실제 Python 프로그램을 작성해 볼 시간입니다. 화면에 정보를 표시하고, 사용자로부터 입력을 받아, 의미 있는 결과를 만들어 내는 프로그램을 작성할 것입니다.

이 장에서는 거의 모든 Python 프로그램에서 사용하게 될 기본 구성 요소들을 소개합니다. 출력을 표시하는 print() 함수(function), 코드를 문서화하는 주석(comment), 데이터를 저장하는 변수(variable), 사용자로부터 정보를 받는 input() 함수(function)를 다룹니다. 이 장을 마치면 고전적인 입력-처리-출력(input-process-output) 패턴을 따르는, 간단하지만 완전한 대화형 프로그램을 만들 수 있게 됩니다.

2.1) print() 함수로 텍스트 출력하기

print() 함수는 Python에서 가장 중요한 도구 중 하나입니다. 이 함수는 텍스트(및 기타 정보)를 화면에 표시하여 프로그램이 사용자와 소통할 수 있게 해 줍니다. 1장에서 이미 print()를 간단히 살펴보았지만, 이제는 좀 더 깊이 있게 살펴보겠습니다.

2.1.1) 기본 출력

가장 단순한 형태에서, print()는 따옴표로 둘러싸인 텍스트를 출력합니다. 이것이 어떻게 동작하는지 스크립트 파일을 만들어 확인해 보겠습니다:

python

# hello.py
print("Hello, World!")

이 스크립트를 실행하면 Python은 다음을 표시합니다:

Hello, World!

따옴표 안의 텍스트인 "Hello, World!"를 문자열(string)이라고 부릅니다. 문자열은 문자(알파벳, 숫자, 기호, 공백)의 시퀀스로, Python이 텍스트로 취급하는 값입니다. 문자열은 5장에서 훨씬 더 자세히 다룰 예정이지만, 지금은 Python에서 텍스트를 표현하는 방법이라고 생각하시면 됩니다.

따옴표 안에 원하는 어떤 텍스트든 넣어서 출력할 수 있습니다:

python

# greetings.py
print("Welcome to Python programming!")
print("This is your first real program.")
print("Python makes programming fun and accessible.")

출력:

Welcome to Python programming!
This is your first real program.
Python makes programming fun and accessible.

각각의 print() 문은 별도의 줄에 출력을 생성합니다. Python은 각 print() 호출 뒤에 자동으로 줄바꿈(newline)을 추가하여 커서를 다음 줄로 이동시킵니다.

2.1.2) 여러 항목 출력하기

print() 함수는 쉼표로 구분하여 여러 항목을 한 번에 표시할 수 있습니다:

python

# multiple_items.py
print("Python", "is", "awesome!")
print("I", "am", "learning", "to", "code")

출력:

Python is awesome!
I am learning to code

항목을 쉼표로 구분하면, print()가 항목 사이에 자동으로 공백을 삽입합니다. 덕분에 공백을 직접 추가하지 않고도 여러 조각의 텍스트를 쉽게 결합할 수 있습니다.

서로 다른 종류의 데이터도 섞어서 사용할 수 있습니다. 예를 들어, 텍스트와 숫자를 함께 출력할 수 있습니다:

python

# mixed_output.py
print("The answer is", 42)
print("Python version", 3.12, "is powerful")

출력:

The answer is 42
Python version 3.12 is powerful

Python은 숫자를 출력할 때 자동으로 텍스트로 변환하므로, 지금은 기술적인 세부사항을 걱정할 필요가 없습니다. 서로 다른 데이터 타입(data type)에 대해서는 3장에서 더 자세히 배웁니다.

2.1.3) 작은따옴표 vs 큰따옴표

Python은 문자열(string)에 작은따옴표(')와 큰따옴표(")를 모두 사용할 수 있습니다. 단순한 텍스트의 경우 둘은 완전히 동일하게 동작합니다:

python

# quotes.py
print("This uses double quotes")
print('This uses single quotes')
print("Both work exactly the same way")

출력:

This uses double quotes
This uses single quotes
Both work exactly the same way

하지만 텍스트 안에 아포스트로피나 큰따옴표가 포함되면 따옴표 선택이 중요해집니다. 텍스트에 아포스트로피(작은따옴표와 동일한 문자)가 포함되어 있다면, 이를 감싸는 문자열에는 큰따옴표를 사용하는 것이 좋습니다:

python

# apostrophes.py
print("It's a beautiful day!")
print("Python's syntax is clean")

출력:

It's a beautiful day!
Python's syntax is clean

여기서 작은따옴표를 사용하면 Python이 혼란스러워집니다:

python

# This causes an error:
print('It's a beautiful day!')  # Error! Python sees three separate quotes

이 오류는 "It's"에 있는 아포스트로피를 문자열의 끝으로 인식하여, "s a beautiful day!" 부분이 잘못된 코드로 남기 때문입니다.

마찬가지로, 텍스트에 큰따옴표가 들어 있다면 문자열을 작은따옴표로 감싸는 것이 좋습니다:

python

# quotations.py
print('She said, "Hello!"')
print('The book is called "Python Basics"')

출력:

She said, "Hello!"
The book is called "Python Basics"

실용적인 가이드라인: 작은따옴표와 큰따옴표 중 한 가지 스타일을 선택해서 코드 전반에 걸쳐 일관되게 사용하십시오. 대부분의 Python 프로그래머는 일반 문자열에는 큰따옴표를 선호하지만, 어느 쪽이든 괜찮습니다. 평소 사용하는 따옴표 문자가 문자열 안에 포함될 때만 다른 스타일로 전환하면 됩니다.

2.1.4) 빈 줄 출력하기

출력을 더 읽기 쉽게 만들기 위해 빈 줄을 추가하고 싶을 때가 있습니다. 이때는 인자를 주지 않고 print()를 호출하면 됩니다:

python

# spacing.py
print("First section of output")
print("More information here")
print()  # Empty line
print("Second section of output")
print("This is separated from the first section")

출력:

First section of output
More information here
 
Second section of output
This is separated from the first section

인자 없이 호출한 print()가 빈 줄을 만들어 주어, 서로 다른 구역을 시각적으로 구분해 출력을 더 읽기 쉽게 만들어 줍니다.

2.1.5) 문자열 속 특수 문자

가끔은 출력에 직접 입력하기 어렵거나 Python에서 특별한 의미를 가지는 문자를 포함해야 할 때가 있습니다. 예를 들어, 문자열 중간에 줄바꿈을 넣고 싶을 때는 어떻게 해야 할까요? 정렬을 위해 탭을 넣고 싶을 때는 어떻게 해야 할까요? Python은 이러한 문자를 표현하기 위해 백슬래시(\)로 시작하는 특별한 두 문자 조합인 이스케이프 시퀀스(escape sequence)를 제공합니다.

이러한 이스케이프 시퀀스는 여러 줄로 된 메시지를 만들거나, 데이터 열을 정렬하거나, Windows에서 파일 경로를 다루는 등 특정 방식으로 출력을 형식화해야 할 때 특히 유용합니다. 더 많은 프로그램을 작성하게 되면 \n을 자주 사용하게 될 것입니다.

가장 흔한 이스케이프 시퀀스는 줄바꿈(라인 브레이크)을 나타내는 \n입니다:

python

# newlines.py
print("First line\nSecond line\nThird line")

출력:

First line
Second line
Third line

\n은 문자열 내에서 해당 위치에서 새 줄로 이동하라는 의미입니다. 하나의 print() 문으로 여러 줄의 출력을 만들고 싶을 때 유용합니다.

또 다른 유용한 이스케이프 시퀀스는 탭(수평 간격)을 나타내는 \t입니다:

python

# tabs.py
print("Name:\tJohn")
print("Age:\t25")
print("City:\tNew York")

출력:

Name:	John
Age:	25
City:	New York

\t는 일정한 간격을 만들어 값들을 열 형태로 정렬하는 데 도움이 됩니다.

만약 출력에 실제 백슬래시를 포함해야 한다면 \\를 사용합니다:

python

# backslash.py
print("The file path is C:\\Users\\Documents")

출력:

The file path is C:\Users\Documents

이스케이프 시퀀스와 문자열 처리에 대해서는 5장에서 훨씬 더 깊이 있게 다룰 예정입니다. 지금은 \n은 새 줄을 만들고 \t는 탭을 만든다는 것만 알면 됩니다.

2.2) 코드를 설명하기 위한 주석 사용하기

프로그램이 복잡해질수록, 코드가 무엇을 하는지 설명하는 것이 중요해집니다. 이는 코드를 읽게 될 다른 사람뿐 아니라 미래의 자신을 위해서도 필요합니다. Python은 이런 목적을 위해 주석(comment)을 제공합니다. 주석은 코드 안에 있는 메모로, 프로그램을 실행할 때 Python이 완전히 무시합니다.

2.2.1) 한 줄 주석

Python에서 한 줄 안에서 # 기호 뒤에 오는 모든 텍스트는 주석입니다. Python은 그 줄에서 #부터 줄 끝까지의 모든 내용을 무시합니다:

python

# comment_example.py
# This is a comment. Python ignores this line completely.
print("This line runs")  # This comment explains the print statement
# print("This line does NOT run because it's commented out")
print("This line also runs")

출력:

This line runs
This line also runs

두 번째 print() 문은 전체 줄이 주석 처리되었기 때문에 실행되지 않았습니다. 이는 코드를 삭제하지 않고도 일시적으로 비활성화하고 싶을 때 유용합니다.

주석은 단독으로 한 줄을 차지할 수도 있고, 코드 줄 끝에 붙을 수도 있습니다. 두 스타일 모두 흔하게 사용됩니다:

python

# display_info.py
# Display a welcome message to the user
print("Welcome to the program!")
 
print("Processing data...")  # Inform the user of progress

2.2.2) 좋은 주석을 언제, 어떻게 쓸까

주석은 코드가 무엇을 하는지보다 왜 그렇게 하는지를 설명해야 합니다. 다음은 좋지 않은 주석의 예입니다:

python

# Bad comment - just repeats what the code obviously does
print("Hello")  # Print "Hello"

이 주석은 코드를 읽는 사람이 이미 알 수 있는 내용을 그대로 반복할 뿐이므로 아무런 가치를 더하지 못합니다.

더 나은 접근은 다음과 같습니다:

python

# Good comment - explains the purpose or context
# Greet the user before requesting their information
print("Hello")

이 주석은 "Hello"를 출력하는 이유를 설명합니다. 이는 사용자와의 더 큰 상호작용의 일부라는 점을 알려 줍니다.

도움이 되는 주석을 위한 가이드라인:

목적을 설명하기: 이 코드는 왜 존재합니까? 어떤 문제를 해결합니까?
복잡한 로직을 명확히 하기: 바로 이해되지 않는 부분이 있다면 설명을 덧붙입니다.
중요한 결정 기록하기: 왜 다른 방법이 아닌 이 접근 방식을 선택했는지 설명합니다.
주의할 점 표시하기: 혼란스럽거나 예상 밖일 수 있는 부분을 지적합니다.
항상 최신 상태 유지하기: 코드를 변경했다면 주석도 함께 업데이트합니다.

효과적인 주석을 보여 주는 예시는 다음과 같습니다:

python

# temperature_converter.py
# This program converts temperatures from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
# Display program title
print("Temperature Converter")
print("Fahrenheit to Celsius")
print()
 
# We'll learn how to get user input in section 2.4
# For now, we'll use a fixed temperature value
fahrenheit = 75  # Temperature in Fahrenheit to convert
 
# Perform the conversion using the standard formula
# Subtract 32 first (order matters due to the formula)
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print("Temperature:", fahrenheit, "°F =", celsius, "°C")

출력:

Temperature Converter
Fahrenheit to Celsius
 
Temperature: 75 °F = 23.88888888888889 °C

주석이 프로그램의 목적, 사용 중인 공식, 계산의 논리를 설명하고 있다는 점에 주목하십시오. 특히 처음 이 코드를 접하는 사람에게 코드 이해를 훨씬 쉽게 만들어 줍니다.

2.2.3) 여러 줄 주석과 도크스트링

더 긴 설명이 필요하다면, 여러 개의 한 줄 주석을 사용할 수 있습니다:

python

# multi_line_comments.py
# This program demonstrates a longer explanation
# that spans multiple lines. Each line starts
# with a # symbol.
print("Program starts here")

Python에는 일부 다른 언어처럼 특별한 여러 줄 주석 문법이 없습니다. 하지만 삼중 따옴표 문자열(triple-quoted string)을 사용하는 대체 방법이 있습니다. 함수에 대한 문서 문자열인 도크스트링(docstring)은 19장에서 자세히 배우겠지만, 여기서는 간단히 예시만 보겠습니다:

python

# docstring_preview.py
"""
This is a multi-line string that can serve as a comment.
It's not technically a comment—it's a string that Python
creates but doesn't use. However, it's often used for
longer explanations at the beginning of files.
"""
print("Program starts here")

지금은 주석에는 #를 사용하는 데 집중하십시오. 삼중 따옴표 문자열과 그 올바른 사용법은 이후 장에서 다루겠습니다.

2.2.4) 테스트를 위해 코드 주석 처리하기

주석은 테스트를 하는 동안 코드를 일시적으로 비활성화하는 데에도 유용합니다:

python

# testing.py
print("This always runs")
# print("This is disabled for testing")
print("This also always runs")

이 기법을 "코드를 주석 처리(commenting out)"한다고 부릅니다. 특정 줄이 없는 상태에서 프로그램이 어떻게 동작하는지 확인하고 싶지만, 그 줄을 영구적으로 삭제하고 싶지는 않을 때 유용합니다.

2.3) 변수와 대입 소개 (미리 보기)

프로그램은 데이터를 저장하고 조작할 수 있을 때 훨씬 더 유용해집니다. 변수(variable)는 값을 담는 이름 붙은 컨테이너입니다. 변수를 정보 보관용 라벨이 붙은 상자처럼 생각하시면 됩니다. 정보를 상자에 저장해 두었다가 나중에 다시 꺼내 사용할 수 있습니다.

중요한 메모: 이 절은 이 장의 예제들을 이해하는 데 도움이 되도록 변수에 대한 미리 보기를 제공합니다. 변수의 이름 규칙, 데이터 타입(data type), Python이 내부적으로 변수를 어떻게 다루는지 등은 3장에서 깊이 있게 다룰 예정입니다. 지금은 기본 개념과 사용법에만 초점을 맞추겠습니다.

2.3.1) 대입으로 변수 만들기

변수는 대입 연산자(assignment operator) =를 사용해 만듭니다. 기본 패턴은 다음과 같습니다:

variable_name = value

변수 이름은 왼쪽에, 값은 오른쪽에 두고, =가 둘을 연결합니다:

python

# variables_basic.py
message = "Hello, Python!"
print(message)

출력:

Hello, Python!

이때 일어나는 일을 단계별로 살펴보면:

Python이 message라는 이름의 변수를 만듭니다.
Python이 문자열 "Hello, Python!"을 그 변수에 저장합니다.
print() 함수에서 message를 사용하면, Python이 저장된 값을 꺼내와서 화면에 표시합니다.

변수는 여러 종류의 데이터를 저장할 수 있습니다. 다음은 몇 가지 예입니다:

python

# variable_types.py
greeting = "Welcome!"  # A string (text)
age = 25  # A number (integer)
price = 19.99  # A number with a decimal point (float)
is_student = True  # A boolean (True or False)
 
print(greeting)
print(age)
print(price)
print(is_student)

출력:

Welcome!
25
19.99
True

이러한 서로 다른 데이터 타입(문자열, 정수, 실수, 불리언)에 대해서는 3장에서 배웁니다. 지금은 변수에 다양한 종류의 정보를 저장할 수 있다는 점만 이해하시면 됩니다.

2.3.2) 변수가 왜 유용한가

변수는 코드를 더 유연하고 유지 보수하기 쉽게 만들어 줍니다. 다음 두 가지 접근을 비교해 보겠습니다.

변수 없이:

python

# no_variables.py
print("Welcome, John!")
print("John, your account balance is $1000")
print("Thank you for banking with us, John!")

변수 사용:

python

# with_variables.py
name = "John"
balance = 1000
 
print("Welcome,", name + "!")
print(name, "your account balance is $", balance)
print("Thank you for banking with us,", name + "!")

두 프로그램 모두 비슷한 출력을 만들어 내지만, 변수를 사용한 버전은 중요한 장점이 있습니다:

수정이 쉬움: 이름을 바꾸려면 세 줄을 고치는 대신 name = "John" 한 줄만 바꾸면 됩니다.
오류 감소: 한 곳에서 이름 철자를 잘못 쓰는 실수를 줄일 수 있습니다.
더 유연함: 나중에 name의 값을 코드에 직접 쓰는 대신 사용자 입력으로부터 받도록 쉽게 바꿀 수 있습니다.

2.3.3) 변수 다시 대입하기

변수는 프로그램 실행 중에 값이 바뀔 수 있습니다. 이를 재대입(reassignment)이라고 합니다:

python

# reassignment.py
score = 0
print("Initial score:", score)
 
score = 10
print("After first update:", score)
 
score = 25
print("After second update:", score)

출력:

Initial score: 0
After first update: 10
After second update: 25

변수에 새 값을 대입할 때마다 Python은 이전 값을 새 값으로 교체합니다. 이전 값은 버려집니다.

또한 변수의 현재 값을 사용해서 새 값을 계산할 수도 있습니다:

python

# updating_values.py
count = 5
print("Starting count:", count)
 
count = count + 1  # Add 1 to count
print("After adding 1:", count)
 
count = count + 10  # Add 10 to count
print("After adding 10:", count)

출력:

Starting count: 5
After adding 1: 6
After adding 10: 16

count = count + 1 같은 패턴은 프로그래밍에서 매우 흔합니다. 이는 "count의 현재 값을 가져와서 1을 더한 후, 그 결과를 다시 count에 저장하라"는 의미입니다. 4장에서 이 패턴의 축약형(count += 1)을 배우겠습니다.

2.3.4) 변수 이름 규칙 미리 보기

Python의 변수 이름은 특정 규칙을 따라야 합니다:

문자, 숫자, 밑줄(_)을 포함할 수 있습니다.
숫자로 시작할 수 없고, 문자 또는 밑줄로 시작해야 합니다.
공백이나 @, $, % 같은 특수 문자를 포함할 수 없습니다.
Python 키워드(예: print, if, for 등 예약어)는 사용할 수 없습니다.

다음은 유효한 변수 이름의 예입니다:

python

# valid_names.py
user_name = "Alice"
age2 = 30
_private_value = 42
totalPrice = 99.99

그리고 유효하지 않은 이름들:

python

# These cause errors:
# 2age = 30  # Cannot start with a number
# user-name = "Alice"  # Cannot contain hyphens
# total price = 99.99  # Cannot contain spaces
# print = "Hello"  # Cannot use Python keywords

모범 사례: 변수가 무엇을 나타내는지 설명해 주는 의미 있는 이름을 사용하십시오. a보다는 user_age가, tp보다는 total_price가 더 좋습니다. 이름 규칙과 관례는 3장에서 자세히 다루겠습니다.

2.3.5) 변수가 프로그램을 동적으로 만든다

변수의 진정한 힘은 프로그램을 더 동적으로 만들 때 드러납니다:

python

# dynamic_greeting.py
name = "Alice"
age = 28
city = "Seattle"
 
print("Personal Information")
print("====================")
print("Name:", name)
print("Age:", age)
print("City:", city)
print()
print("Summary:", name, "is", age, "years old and lives in", city)

출력:

Personal Information
====================
Name: Alice
Age: 28
City: Seattle
 
Summary: Alice is 28 years old and lives in Seattle

프로그램 맨 위에 있는 name, age, city의 값만 변경하면, print() 문을 수정하지 않고도 전체 출력을 손쉽게 바꿀 수 있습니다. 이렇게 데이터와 로직을 분리하는 것은 좋은 프로그래밍의 핵심 원칙입니다.

앞으로 미리 보기: 3장에서는 변수에 대해 데이터 타입, 형 변환, 이름 규칙, Python이 변수를 내부에서 어떻게 관리하는지 등을 포함해 포괄적으로 살펴보겠습니다. 지금까지 배운 내용만으로도 간단한 프로그램에서 변수를 활용하기에 충분합니다.

2.4) input()으로 키보드 입력 읽기

지금까지 작성한 프로그램에서는 모든 데이터가 코드 안에 직접 적혀 있었습니다(하드코딩). 하지만 실제 프로그램은 종종 사용자와 상호작용하면서 사용자가 제공하는 정보를 입력으로 받습니다. Python의 input() 함수는 이를 가능하게 합니다.

2.4.1) 기본 입력

input() 함수는 프롬프트(prompt)라고 불리는 메시지를 화면에 표시하고, 사용자가 무언가를 입력한 뒤 Enter를 누를 때까지 기다립니다. 기본 패턴은 다음과 같습니다:

python

# basic_input.py
name = input("What is your name? ")
print("Hello,", name + "!")

이 프로그램을 실행하면 다음과 같은 일이 일어납니다:

What is your name? Alice
Hello, Alice!

이 과정을 단계별로 나누어 보면:

Python이 input("What is your name? ")를 실행합니다.
Python이 프롬프트 What is your name? 를 표시합니다.
프로그램이 일시 중지되고, 사용자가 입력할 때까지 기다립니다.
사용자가 Alice를 입력하고 Enter를 누릅니다.
Python이 "Alice"라는 텍스트를 name 변수에 저장합니다.
프로그램이 계속 실행되어 인사 메시지를 출력합니다.

input()에 전달하는 텍스트가 바로 사용자가 입력하기 전에 보게 될 프롬프트입니다. 프롬프트 끝에는 항상 공백을 하나 넣는 것이 좋습니다(물음표 뒤의 공백에 주목). 이렇게 하면 프롬프트와 사용자의 입력이 시각적으로 구분되어 읽기 쉬워집니다.

2.4.2) input()은 항상 문자열을 반환한다

여기서 매우 중요한 점이 있습니다. input()은 사용자가 숫자를 입력하더라도 항상 문자열(string)을 반환합니다:

python

# input_as_string.py
age = input("How old are you? ")
print("You entered:", age)
print("The type is:", type(age))

이 프로그램을 실행하고 25를 입력하면:

How old are you? 25
You entered: 25
The type is: <class 'str'>

사용자가 25를 입력했지만, Python은 이를 숫자 25가 아니라 문자열 "25"로 저장합니다. type() 함수는 age가 정수가 아니라 문자열(str)임을 확인시켜 줍니다.

이 점은 계산을 수행할 때 중요합니다. 문자열과는 직접적으로 수학 연산을 할 수 없습니다:

python

# This causes an error:
age = input("How old are you? ")
next_year_age = age + 1  # Error! Can't add a number to a string

Python은 문자열 "25"에 숫자 1을 더하는 방법을 알지 못하기 때문에 이 코드는 오류를 발생시킵니다.

2.4.3) 입력 값을 숫자로 변환하기

입력 값을 숫자로 사용하려면, int()(정수용) 또는 float()(실수용)를 사용해 명시적으로 변환해야 합니다:

python

# input_conversion.py
age_string = input("How old are you? ")
age = int(age_string)  # Convert string to integer
 
next_year = age + 1
print("Next year, you will be", next_year, "years old")

이 프로그램을 실행하고 25를 입력하면:

How old are you? 25
Next year, you will be 26 years old

입력과 변환을 한 줄로 합칠 수도 있습니다:

python

# input_conversion_compact.py
age = int(input("How old are you? "))
next_year = age + 1
print("Next year, you will be", next_year, "years old")

이 버전이 더 간결하며, 실제 코드에서 가장 흔히 보게 될 스타일입니다. 안쪽에서부터 바깥쪽으로 작동합니다:

input("How old are you? ")가 사용자의 입력을 문자열로 받습니다.
int(...)가 그 문자열을 정수로 변환합니다.
그 정수가 age 변수에 저장됩니다.

실수(소수점이 있는 숫자)를 다룰 때는 float()를 사용할 수 있습니다:

python

# float_input.py
price = float(input("Enter the price: $"))
tax_rate = 0.08
tax = price * tax_rate
total = price + tax
 
print("Price: $", price)
print("Tax: $", tax)
print("Total: $", total)

이 프로그램을 실행하고 19.99를 입력하면:

Enter the price: $19.99
Price: $ 19.99
Tax: $ 1.5992
Total: $ 21.5892

중요: 사용자가 숫자로 변환할 수 없는 텍스트를 입력하면 Python은 오류를 발생시킵니다. 예를 들어, int(input("Enter a number: "))를 사용했는데 사용자가 "hello"를 입력하면, Python은 "hello"를 정수로 변환할 수 없기 때문에 오류 메시지를 보여줍니다. 이런 상황을 우아하게 처리하는 방법은 27장에서 예외 처리(exception handling)를 공부할 때 배우겠습니다.

2.4.4) 여러 개의 입력 받기

프로그램은 종종 사용자로부터 여러 개의 정보를 받아야 합니다. 이때는 input()을 여러 번 호출하면 됩니다:

python

# multiple_inputs.py
print("Please enter your information:")
print()
 
first_name = input("First name: ")
last_name = input("Last name: ")
age = int(input("Age: "))
city = input("City: ")
 
print()
print("Summary")
print("=======")
print("Name:", first_name, last_name)
print("Age:", age)
print("Location:", city)

실행 예:

Please enter your information:
 
First name: John
Last name: Smith
Age: 30
City: Boston
 
Summary
=======
Name: John Smith
Age: 30
Location: Boston

프로그램이 각 정보를 개별적으로 요청하고 있다는 점에 주목하십시오. 이렇게 하면 사용자가 무엇을 어떤 순서로 입력해야 하는지 분명히 알 수 있습니다.

2.4.5) 알기 쉬운 프롬프트 만들기

좋은 프롬프트는 프로그램 사용성을 크게 높여 줍니다. 다음 가이드라인을 참고하십시오.

원하는 것이 무엇인지 구체적으로 적기:

python

# Good prompts
name = input("Enter your full name: ")
temperature = float(input("Enter temperature in Fahrenheit: "))
quantity = int(input("How many items do you want to purchase? "))

기대하는 형식이나 단위를 포함하기:

python

# format_prompts.py
date = input("Enter date (MM/DD/YYYY): ")
phone = input("Enter phone number (XXX-XXX-XXXX): ")
price = float(input("Enter price in dollars (without $): "))

명확하고 친근한 문장 사용하기:

python

# friendly_prompts.py
print("Welcome to the Temperature Converter!")
print()
temp = float(input("Please enter a temperature in Fahrenheit: "))

명확한 프롬프트는 사용자 혼란을 줄이고 프로그램을 더 전문적으로 보이게 합니다.

2.5) 간단한 입력-처리-출력 프로그램

대부분의 프로그램은 입력-처리-출력(Input-Process-Output, IPO)이라고 불리는 공통 패턴을 따릅니다:

입력(Input): 사용자나 다른 소스로부터 데이터를 받습니다.
처리(Process): 받은 데이터를 계산하거나 변환합니다.
출력(Output): 결과를 표시합니다.

이 패턴은 매우 기본적이어서 프로그래밍을 계속해 나가는 동안 수없이 많은 프로그램에서 사용하게 됩니다. 이제 몇 가지 완성된 예제를 통해 이 패턴을 살펴보겠습니다.

2.5.1) 예시: 온도 변환기

화씨(Fahrenheit)를 섭씨(Celsius)로 변환하는 완전한 프로그램을 만들어 보겠습니다:

python

# temperature_converter.py
# This program converts a temperature from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
print("Temperature Converter")
print("Fahrenheit to Celsius")
print("=" * 30)  # Print a line of equal signs
print()
 
# INPUT: Get temperature from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# PROCESS: Convert using the formula
celsius = (fahrenheit - 32) * 5 / 9
 
# OUTPUT: Display the result
print()
print("Result:", fahrenheit, "°F =", celsius, "°C")

실행 예:

Temperature Converter
Fahrenheit to Celsius
==============================
 
Enter temperature in Fahrenheit: 75
 
Result: 75.0 °F = 23.88888888888889 °C

이 프로그램이 어떻게 IPO 패턴을 명확히 따르는지 살펴보십시오:

입력(Input): 화씨 온도를 입력받습니다.
처리(Process): 변환 공식을 적용합니다.
출력(Output): 섭씨 결과를 표시합니다.

코드에 있는 주석이 이 세 부분을 명시적으로 구분해 주어, 프로그램 구조를 이해하기 쉽게 만들어 줍니다.

2.5.2) 예시: 직사각형 넓이 계산기

이번에는 직사각형의 넓이를 계산하는 또 다른 IPO 예제를 보겠습니다:

python

# rectangle_area.py
# Calculate the area of a rectangle
# Formula: Area = length × width
 
print("Rectangle Area Calculator")
print("=" * 30)
print()
 
# INPUT: Get dimensions from user
length = float(input("Enter the length: "))
width = float(input("Enter the width: "))
 
# PROCESS: Calculate area
area = length * width
 
# OUTPUT: Display the result
print()
print("A rectangle with length", length, "and width", width)
print("has an area of", area, "square units")

실행 예:

Rectangle Area Calculator
==============================
 
Enter the length: 5.5
Enter the width: 3.2
 
A rectangle with length 5.5 and width 3.2
has an area of 17.6 square units

2.5.3) 예시: 쇼핑 총액 계산기

이번 예제는 세금을 포함한 쇼핑 총액을 계산합니다:

python

# shopping_total.py
# Calculate total cost including tax
 
print("Shopping Total Calculator")
print("=" * 30)
print()
 
# INPUT: Get price and tax rate
price = float(input("Enter item price: $"))
tax_rate = float(input("Enter tax rate (as decimal, e.g., 0.08 for 8%): "))
 
# PROCESS: Calculate tax and total
tax_amount = price * tax_rate
total = price + tax_amount
 
# OUTPUT: Display itemized breakdown
# Note: Comma in print() adds a space after $
print()
print("Purchase Summary")
print("-" * 30)
print("Item price:    $", price)
print("Tax rate:      ", tax_rate * 100, "%")
print("Tax amount:    $", tax_amount)
print("-" * 30)
print("Total:         $", total)

실행 예:

Shopping Total Calculator
==============================
 
Enter item price: $49.99
Enter tax rate (as decimal, e.g., 0.08 for 8%): 0.08
 
Purchase Summary
------------------------------
Item price:    $ 49.99
Tax rate:       8.0 %
Tax amount:    $ 3.9992
------------------------------
Total:         $ 53.9892

2.6) 간단한 오류 메시지 읽기로 기본 디버깅하기

숙련된 프로그래머도 항상 실수를 합니다. 오류 메시지를 읽고 이해하는 법을 배우는 것은 수많은 좌절의 시간을 줄여 줄 필수적인 기술입니다. Python의 오류 메시지는 실제로 꽤 도움이 됩니다. 무엇이 잘못되었는지와 문제가 어디에서 발생했는지를 알려 주기 때문입니다.

"오류 메시지(error message)"와 "트레이스백(traceback)"은 관련 있지만 약간 다른 용어입니다. 트레이스백(traceback)은 오류가 발생했을 때 Python이 보여 주는 전체 보고서로, 오류 유형, 설명, 그리고 오류에 이르기까지의 코드 경로를 포함합니다. 오류 메시지(error message)는 그중 마지막 줄로, 무엇이 잘못되었는지 설명하는 부분입니다. 일상적인 대화에서는 프로그래머들이 종종 전체 트레이스백을 "오류 메시지"라고 부르기도 합니다.

2.6.1) 오류 메시지 이해하기

Python이 오류를 만나면, 무엇이 잘못되었는지에 대한 자세한 보고서인 트레이스백(traceback)을 출력합니다. 간단한 예를 살펴보겠습니다:

python

# error_example.py
print("Starting the program")
print("This line works fine"
print("This line might not be reached")

이 코드를 실행하려고 하면 Python은 다음과 같은 메시지를 출력합니다:

  File "error_example.py", line 2
    print("This line works fine"
                                ^
SyntaxError: '(' was never closed

이 오류 메시지가 말해 주는 내용을 나누어 보면:

파일 이름: error_example.py - 오류가 발생한 파일입니다.
줄 번호: line 2 - Python이 문제를 감지한 줄입니다.
코드 조각: 문제의 줄을 보여 주며, ^로 Python이 문제를 인식한 지점을 가리킵니다.
오류 유형: SyntaxError - 어떤 종류의 오류인지 나타냅니다.
설명: '(' was never closed - 사람이 읽을 수 있는 형태의 설명입니다.

이 오류는 2번째 줄에서 닫는 괄호를 빼먹었기 때문에 발생합니다. Python은 다음 줄까지를 같은 print() 문의 일부로 읽으려다 혼란스러워진 것입니다.

2.6.2) 초보자가 자주 만나는 공통 오류 유형

이제 초보자에게 가장 흔한 오류 유형과 그 해결 방법을 살펴보겠습니다.

SyntaxError: Invalid Syntax

가장 흔한 오류입니다. Python이 코드의 문법을 이해하지 못했다는 의미입니다.

콜론 누락:

python

# missing_colon.py
name = input("What is your name? ")
if name == "Alice"  # Missing colon
    print("Hello, Alice!")

오류:

  File "missing_colon.py", line 2
    if name == "Alice"
                     ^
SyntaxError: expected ':'

주의: if 문에 대해서는 아직 배우지 않았습니다. 8장에서 다룰 예정입니다. 여기서는 오류가 어떤 모습인지 보여 주기 위한 예시일 뿐입니다.

따옴표 불일치:

python

# mismatched_quotes.py
message = "Hello, world!'
print(message)

오류:

  File "mismatched_quotes.py", line 1
    message = "Hello, world!'
              ^
SyntaxError: unterminated string literal (detected at line 1)

문자열이 큰따옴표(")로 시작했는데 작은따옴표(')로 끝나기 때문에 발생한 오류입니다. Python은 문자열의 양 끝에 같은 종류의 따옴표가 오기를 기대합니다.

NameError: Name Not Defined

존재하지 않는 변수를 사용하려고 할 때 발생하는 오류입니다:

python

# name_error.py
print("Starting calculation")
result = total + 10  # 'total' was never created
print(result)

오류:

Traceback (most recent call last):
  File "name_error.py", line 2, in <module>
    result = total + 10
             ^^^^^
NameError: name 'total' is not defined

total 변수를 생성한 적이 없기 때문에, Python은 total이 무엇인지 알지 못한다고 알려 줍니다. 해결책은 사용하기 전에 total을 정의하는 것입니다:

python

# name_error_fixed.py
print("Starting calculation")
total = 0  # Define the variable first
result = total + 10
print(result)

NameError의 일반적인 원인:

변수 이름 오타 (total 대신 totla 등)
값을 대입하기 전에 변수를 사용하는 경우
변수를 아예 만들지 않은 경우

TypeError: Unsupported Operand Type(s)

서로 호환되지 않는 타입끼리 연산하려고 할 때 발생합니다:

python

# type_error.py
age = input("How old are you? ")
next_year = age + 1  # Can't add a number to a string
print("Next year:", next_year)

오류:

Traceback (most recent call last):
  File "type_error.py", line 2, in <module>
    next_year = age + 1
                ~~~~^~~
TypeError: can only concatenate str (not "int") to str

Python은 age가 문자열(입력은 항상 문자열이기 때문)임을 알려 주며, 문자열에 숫자를 더할 수 없다고 말하고 있습니다. 해결책은 입력을 정수로 변환하는 것입니다:

python

# type_error_fixed.py
age = int(input("How old are you? "))  # Convert to integer
next_year = age + 1
print("Next year:", next_year)

ValueError: Invalid Literal

문자열을 숫자로 변환하려고 하는데, 그 문자열이 유효한 숫자를 나타내지 않을 때 발생합니다:

python

# value_error.py
age = int(input("How old are you? "))
print("You are", age, "years old")

사용자가 숫자 대신 텍스트를 입력한 경우:

How old are you? twenty
Traceback (most recent call last):
  File "value_error.py", line 1, in <module>
    age = int(input("How old are you? "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'twenty'

Python은 문자열 "twenty"를 정수로 변환할 수 없다고 알려 줍니다. 사용자는 20과 같은 숫자를 입력해야 합니다.

중요: 현재 단계에서 사용자가 잘못된 입력을 하면 프로그램이 오류와 함께 종료되는 것은 자연스러운 일입니다. 27장에서 예외 처리(exception handling)를 배울 때, 이런 상황을 우아하게 처리하고, 프로그램이 오류에서 회복해 다시 입력을 요청하도록 만드는 방법을 배우게 됩니다.

2.6.3) 트레이스백을 꼼꼼히 읽기

오류가 발생하면 Python은 코드 어디에서 오류가 났는지 거슬러 올라가는 트레이스백(traceback)을 보여 줍니다. 단순한 프로그램에서는 트레이스백이 짧습니다:

python

# simple_traceback.py
print("Starting program")
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello,", name)
print("Next year you'll be", age + 1)

사용자가 나이에 잘못된 값을 입력하면:

Starting program
Enter your name: Alice
Enter your age: abc
Traceback (most recent call last):
  File "simple_traceback.py", line 3, in <module>
    age = int(input("Enter your age: "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'abc'

트레이스백은 다음 내용을 보여 줍니다:

오류가 발생한 파일 이름과 줄 번호
문제를 일으킨 실제 코드 줄
오류 유형과 설명

읽는 요령: 트레이스백의 맨 아래부터 위로 올라가며 읽으십시오. 마지막 줄이 무엇이 잘못되었는지 말해 줍니다. 그 위에 있는 줄들은 코드에서 어느 부분에서 문제가 발생했는지 보여 줍니다.

2.6.4) 흔한 디버깅 전략

오류를 만났을 때는 다음 단계를 따라 보십시오.

1. 오류 메시지를 꼼꼼히 읽기

당황하지 마십시오. 오류 메시지는 여러분을 돕기 위해 존재합니다. 전체 메시지를 읽고, 무엇을 말하고 있는지 이해하려고 노력하십시오.

2. 줄 번호 확인하기

오류 메시지는 Python이 문제가 있다고 생각하는 줄 번호를 알려 줍니다. 다만 실제 실수는 바로 앞 줄에 있을 수도 있습니다. 예를 들어, 2번째 줄에서 닫는 괄호를 빼먹었는데, Python이 3번째 줄에서야 이를 감지할 수도 있습니다.

3. 흔한 실수 점검하기

따옴표 누락 또는 불일치
닫는 괄호나 대괄호 누락
콜론 누락(if, for, while 등은 나중에 배움)
변수 이름 오타
입력을 숫자로 변환하는 것을 잊은 경우

4. print()로 값 검사하기

무엇이 잘못되고 있는지 확실하지 않을 때는, print() 문을 추가해 변수에 어떤 값이 들어 있는지 확인해 보십시오:

python

# debugging_with_print.py
price = input("Enter price: ")
print("DEBUG: price =", price, "type =", type(price))  # Debugging line
 
tax = price * 0.08  # This will cause an error
print("Tax:", tax)

디버그 출력 덕분에 price가 숫자가 아니라 문자열이라는 사실을 알 수 있고, 문제의 원인을 파악하는 데 도움이 됩니다.

5. 코드를 주석 처리해 문제를 분리하기

여러 줄의 코드 중 어느 줄이 문제를 일으키는지 확실하지 않을 때는, 오류가 사라질 때까지 일부 줄을 주석 처리하십시오:

python

# isolating_error.py
name = input("Enter name: ")
# age = int(input("Enter age: "))  # Commented out for testing
# city = input("Enter city: ")  # Commented out for testing
print("Name:", name)

오류가 사라지면, 문제는 주석 처리한 줄들 중 어딘가에 있다는 것을 알 수 있습니다.

6. 단순한 버전부터 시작하기

프로그램이 제대로 동작하지 않을 때는, 가장 기본적인 형태로 단순화해 보십시오:

python

# simplified_version.py
# Start with just the basic structure
print("Program starting")
# Add one feature at a time and test

단순한 버전이 제대로 작동하면, 기능을 하나씩 추가하면서 매번 테스트합니다.

2.6.5) 오류를 예방하는 방법

디버깅이 중요하긴 하지만, 처음부터 오류를 예방하는 것이 더 좋습니다.

코드를 점진적으로 작성하기

전체 프로그램을 한 번에 다 작성한 뒤 처음으로 실행하지 마십시오. 몇 줄씩 작성하고, 프로그램을 실행해 그 줄들이 제대로 동작하는지 확인한 뒤, 다음 코드를 추가하십시오. 이렇게 하면 오류가 발생했을 때, 방금 추가한 코드에 문제가 있다는 것을 쉽게 알 수 있습니다.

python

# incremental_development.py
# Step 1: Get input and test
name = input("Enter name: ")
print("DEBUG: Got name:", name)
 
# Step 2: Add more input and test
# age = int(input("Enter age: "))
# print("DEBUG: Got age:", age)
 
# Step 3: Add processing and test
# ... and so on

의미 있는 변수 이름 사용하기

명확한 변수 이름은 실수를 줄이는 데 도움이 됩니다:

python

# Clear variable names make errors less likely
user_age = int(input("Enter your age: "))
next_year_age = user_age + 1

논리를 설명하는 주석 추가하기

주석은 코드가 무엇을 해야 하는지 이해하는 데 도움을 줍니다. 이를 통해 코드가 실제로는 무엇을 하고 있는지 비교해 보고 오류를 더 쉽게 발견할 수 있습니다:

python

# temperature_with_comments.py
# Get temperature in Fahrenheit from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# Convert to Celsius using the standard formula: C = (F - 32) × 5/9
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print(fahrenheit, "°F =", celsius, "°C")

다양한 입력으로 테스트하기

프로그램을 한 번만 테스트하지 마십시오. 여러 가지 입력, 특히 경계 상황을 포함해 테스트해 보십시오:

일반적인 값: 25, 100
0: 0
음수: -10
소수: 3.14
매우 큰 수: 1000000

이렇게 하면 사용자가 프로그램을 사용할 때 문제가 되기 전에, 스스로 미리 문제를 발견할 수 있습니다.

2.6.6) 언제 도움을 요청해야 하는가

때로는 스스로 해결할 수 없는 오류를 만나게 됩니다. 도움을 요청하기 전에 다음을 해 보십시오:

오류 메시지를 꼼꼼히 읽기 - 메시지가 무엇을 말하는지 이해했는지 확인합니다.
오류를 검색하기 - 오류 메시지를(변수 이름 등 구체적인 부분을 제외하고) 복사해 인터넷에서 검색합니다. 많은 오류는 이미 다른 사람들이 겪고 해결한 적이 있습니다.
코드를 꼼꼼히 확인하기 - 오타, 빠진 문장 부호, 흔한 실수 등을 찾아 봅니다.
최소 예제 만들기 - 여전히 해결되지 않으면, 오류를 재현할 수 있는 가장 작은 코드 버전으로 줄여 봅니다.

도움을 요청할 때는 다음 정보를 제공하십시오:

전체 오류 메시지
오류를 발생시키는 코드
기대했던 동작
실제로 일어난 일
이미 시도해 본 해결 방법들

기억하십시오: 오류는 프로그래밍의 정상적인 일부입니다. 초보자부터 전문가까지 모든 프로그래머는 매일 오류를 만납니다. 차이가 있다면, 경험 많은 프로그래머는 오류 메시지를 효율적으로 읽고, 흔한 해결책을 알고 있다는 점뿐입니다. 연습을 통해 여러분도 이러한 능력을 갖추게 됩니다.

이제 print()로 출력하기, 주석으로 코드 문서화하기, 변수에 데이터 저장하기, input()으로 사용자 입력 받기, 입력-처리-출력 패턴 따르기, 간단한 오류를 디버깅하는 등 Python 프로그래밍의 기본 구성 요소들을 배웠습니다.

이 개념들은 앞으로 배우게 될 Python의 모든 것의 기초를 이룹니다. 다음 장에서는 변수와 기본 데이터 타입을 더 깊이 있게 살펴보며, Python이 서로 다른 종류의 정보를 어떻게 저장하고 조작하는지 보다 완전하게 이해하게 될 것입니다.

이 장의 핵심 정리:

print()를 사용해 텍스트와 기타 정보를 사용자에게 표시합니다.
#로 시작하는 주석을 사용해 코드를 설명하고 자신의 생각을 기록합니다.
대입 연산자(=)로 변수에 데이터를 저장합니다.
input()으로 사용자 입력을 받고, 필요할 때 숫자로 변환합니다.
입력-처리-출력 패턴에 따라 프로그램을 구조화합니다.
오류 메시지를 꼼꼼히 읽으십시오. 오류를 고칠 수 있도록 도와주기 위한 것입니다.
코드를 점진적으로 작성하고 자주 테스트하여 오류를 초기에 발견합니다.

이러한 능력을 통해 이제 간단하지만 완전한 대화형 프로그램을 작성할 수 있습니다. 앞으로 학습을 계속해 나가면서 이 기본기를 바탕으로 점점 더 정교한 애플리케이션을 만들 수 있게 될 것입니다.