1-3. 파이썬 기초 문법: 제어문과 함수

1. 제어문: 흐름을 조절하는 마법

프로그래밍에서 제어문은 코드의 실행 흐름을 조절하는 핵심적인 도구입니다. 마치 요리 레시피처럼, 제어문은 어떤 재료(데이터)를 언제, 어떻게, 얼마나 사용할지 결정합니다. 파이썬은 다양한 제어문을 제공하며, 이를 통해 복잡한 문제도 효율적으로 해결할 수 있습니다. 제어문은 크게 조건문과 반복문으로 나눌 수 있습니다.

1) 조건문: if, elif, else

조건문은 특정 조건이 참(True)인지 거짓(False)인지에 따라 코드 블록을 실행할지 여부를 결정합니다. if문은 가장 기본적인 형태로, 조건이 참일 경우에만 해당 코드 블록을 실행합니다. elif (else if) 문은 여러 조건을 차례대로 검사하며, 앞선 조건이 거짓일 경우에 다음 조건을 평가합니다. 마지막으로, else문은 모든 if 및 elif 조건이 거짓일 경우 실행되는 코드 블록을 정의합니다.

age = 20

if age >= 18:
    print("성인입니다.")
elif age >= 13:
    print("청소년입니다.")
else:
    print("어린이입니다.")

위 예시에서 age 변수의 값에 따라 "성인입니다.", "청소년입니다.", 또는 "어린이입니다."가 출력됩니다. if, elif, else는 조건의 우선순위에 따라 순차적으로 평가되며, 조건이 충족되면 해당 블록이 실행되고 전체 조건문을 종료합니다.

2) 반복문: for, while

반복문은 특정 코드 블록을 여러 번 반복해서 실행하는 데 사용됩니다. for문은 시퀀스(리스트, 튜플, 문자열 등)의 각 항목을 순회하거나, 정해진 횟수만큼 반복하는 데 유용합니다. while문은 주어진 조건이 참인 동안 코드 블록을 반복해서 실행합니다.

# for 문 예시
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# while 문 예시
count = 0
while count < 3:
    print(count)
    count += 1

for문은 fruits 리스트의 각 항목을 차례대로 출력하고, while문은 count 변수가 3보다 작을 때까지 0, 1, 2를 출력합니다. 반복문은 break 문을 사용하여 반복을 즉시 종료하거나, continue 문을 사용하여 현재 반복을 건너뛰고 다음 반복을 시작할 수 있습니다.

3) 제어문의 중첩

제어문은 중첩되어 사용될 수 있습니다. 즉, if문, for문, while문 안에 다른 제어문을 포함시킬 수 있습니다. 중첩된 제어문을 사용하면 더욱 복잡한 로직을 구현할 수 있지만, 코드의 가독성을 유지하기 위해 들여쓰기와 코드 구조에 주의해야 합니다.

for i in range(3):
    print(f"Outer loop: {i}")
    for j in range(2):
        print(f"  Inner loop: {j}")

위 예시는 for문 안에 또 다른 for문이 중첩된 형태입니다. 외부 루프가 3번 반복되는 동안, 내부 루프는 각 반복마다 2번 실행됩니다.

2. 함수: 코드의 재사용성과 모듈화

함수는 특정 작업을 수행하는 코드 블록을 묶어 놓은 것입니다. 함수를 사용하면 코드를 재사용하고, 프로그램의 구조를 모듈화하여 가독성과 유지 보수성을 향상시킬 수 있습니다. 파이썬에서 함수는 def 키워드를 사용하여 정의됩니다.

1) 함수 정의와 호출

함수를 정의할 때는 def 키워드, 함수 이름, 괄호 ()와 콜론 :을 사용합니다. 함수 이름 뒤의 괄호 안에는 매개변수를 정의할 수 있습니다. 함수는 return 문을 사용하여 값을 반환할 수 있으며, return 문이 없는 경우 None을 반환합니다.

def greet(name):
    """
    이 함수는 이름을 받아 인사말을 반환합니다.
    """
    return f"Hello, {name}!"

greeting = greet("World")  # 함수 호출
print(greeting)

위 예시에서 greet 함수는 name이라는 매개변수를 받아서 "Hello, {name}!" 문자열을 반환합니다. 함수를 호출할 때는 함수 이름과 괄호 안에 필요한 인자를 전달합니다.

2) 함수 인자

함수는 다양한 방식으로 인자를 받을 수 있습니다.

• 위치 인자: 함수 정의에 지정된 순서대로 인자를 전달합니다.
• 키워드 인자: 인자 이름(키워드)과 함께 값을 전달합니다. 순서에 상관없이 인자를 지정할 수 있습니다.
• 기본값 인자: 함수 정의 시 인자에 기본값을 지정하여, 함수 호출 시 해당 인자를 생략할 수 있도록 합니다.
• 가변 인자 (*args, **kwargs): 함수가 임의의 개수의 인자를 받을 수 있도록 합니다. *args는 위치 인자를 튜플로 받고, **kwargs는 키워드 인자를 딕셔너리로 받습니다.

# 위치 인자
def add(x, y):
    return x + y

result = add(3, 5)

# 키워드 인자
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

message = greet(name="Alice", greeting="Hi")  # 키워드 인자 사용
message = greet(greeting="Hey", name="Bob") # 순서 상관 없음

# 기본값 인자
def power(base, exponent=2): # exponent의 기본값은 2
    return base ** exponent

print(power(2))          # 2의 2승 (exponent=2)
print(power(2, 3))       # 2의 3승

# 가변 인자
def print_args(*args, **kwargs):
    print("args:", args)      # (1, 2, 3)
    print("kwargs:", kwargs)  # {'name': 'Alice', 'age': 30}

print_args(1, 2, 3, name="Alice", age=30)

위 예시들은 각 인자 유형의 사용법을 보여줍니다. 함수 인자를 적절하게 활용하면 함수의 유연성과 재사용성을 크게 향상시킬 수 있습니다. *args와 **kwargs는 함수가 다양한 입력을 처리해야 할 때 특히 유용합니다.

3) 함수와 스코프 (Scope)

스코프는 변수의 유효 범위를 의미합니다. 파이썬에서 변수는 local, enclosing function locals, global, built-in (LEGB) 순서로 스코프를 가집니다.

• Local: 함수 내에서 정의된 변수는 해당 함수 내에서만 유효합니다.
• Enclosing function locals: 중첩된 함수에서, 외부 함수에서 정의된 변수는 내부 함수에서 접근할 수 있습니다.
• Global: 모듈(파일) 수준에서 정의된 변수는 해당 모듈 전체에서 접근할 수 있습니다.
• Built-in: 파이썬 내장 함수와 변수들은 모든 스코프에서 접근할 수 있습니다.

global_variable = 10  # Global scope

def outer_function():
    enclosing_variable = 20  # Enclosing function locals scope

    def inner_function():
        local_variable = 30  # Local scope
        print(local_variable)         # 30
        print(enclosing_variable)     # 20
        print(global_variable)        # 10
    inner_function()

outer_function()

변수를 사용할 때는 해당 변수가 정의된 스코프를 고려해야 합니다. 만약 함수 내에서 전역 변수를 수정하려면 global 키워드를 사용해야 합니다.

global_var = 0

def increment():
    global global_var  # global_var를 전역 변수로 선언
    global_var += 1

increment()
print(global_var)  # 출력: 1

3. 제어문과 함수의 활용

제어문과 함수는 함께 사용되어 복잡한 문제를 해결하는 강력한 도구를 형성합니다. 예를 들어, 특정 조건에 따라 다른 함수를 호출하거나, 반복문을 사용하여 함수를 여러 번 실행할 수 있습니다.

1) 제어문과 함수 조합 예시

다음은 if/else 조건문과 함수를 조합하여 사용한 예시입니다.

def check_even_odd(number):
    """
    주어진 숫자가 짝수인지 홀수인지 판별합니다.
    """
    if number % 2 == 0:
        return "짝수"
    else:
        return "홀수"

num = 10
result = check_even_odd(num)
print(f"{num}은(는) {result}입니다.")

위 예시에서 check_even_odd 함수는 if/else 문을 사용하여 숫자가 짝수인지 홀수인지 판단하고, 그 결과를 반환합니다.

def calculate_sum(numbers):
    """
    숫자 리스트의 합을 계산합니다.
    """
    total = 0
    for number in numbers:
        total += number
    return total

numbers = [1, 2, 3, 4, 5]
sum_result = calculate_sum(numbers)
print(f"합계: {sum_result}")

이 예시는 for 루프와 함수를 함께 사용하여 숫자 리스트의 합을 계산합니다.

2) 재귀 함수

재귀 함수는 함수가 자기 자신을 호출하는 함수입니다. 재귀 함수는 문제를 더 작은 하위 문제로 나누어 해결하는 데 유용합니다. 재귀 함수를 사용할 때는 종료 조건을 명확하게 정의해야 합니다. 종료 조건이 없으면 무한 루프에 빠질 수 있습니다.

def factorial(n):
    """
    팩토리얼을 계산하는 재귀 함수입니다.
    """
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

result = factorial(5)
print(f"5! = {result}")  # 출력: 5! = 120

위 예시는 팩토리얼을 계산하는 재귀 함수입니다. factorial 함수는 n이 0일 경우 1을 반환하고, 그렇지 않은 경우 n * factorial(n-1)을 반환하여 자기 자신을 호출합니다.

4. 실전 예제: 간단한 계산기

제어문과 함수를 활용하여 간단한 계산기를 만들어 보겠습니다.

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    if y == 0:
        return "0으로 나눌 수 없습니다."
    return x / y

def calculator():
    print("계산기를 시작합니다.")
    while True:
        try:
            num1 = float(input("첫 번째 숫자를 입력하세요: "))
            operator = input("연산자를 입력하세요 (+, -, *, /): ")
            num2 = float(input("두 번째 숫자를 입력하세요: "))
        except ValueError:
            print("잘못된 입력입니다. 숫자를 입력하세요.")
            continue

        if operator == "+":
            result = add(num1, num2)
        elif operator == "-":
            result = subtract(num1, num2)
        elif operator == "*":
            result = multiply(num1, num2)
        elif operator == "/":
            result = divide(num1, num2)
        else:
            print("잘못된 연산자입니다.")
            continue

        print("결과:", result)

        another_calculation = input("계속 계산하시겠습니까? (y/n): ")
        if another_calculation.lower() != "y":
            break

calculator()

이 계산기 프로그램은 add, subtract, multiply, divide 함수를 정의하여 기본적인 사칙 연산을 수행합니다. calculator 함수는 사용자 입력을 받아 연산을 수행하고 결과를 출력하며, 사용자가 'n'을 입력할 때까지 반복됩니다. try-except 블록을 사용하여 잘못된 입력에 대한 예외 처리를 하고, if/elif/else 문을 사용하여 연산자를 선택합니다.

5. 결론

제어문과 함수는 파이썬 프로그래밍의 핵심 요소입니다. 제어문을 통해 프로그램의 실행 흐름을 효과적으로 제어하고, 함수를 통해 코드를 모듈화하고 재사용성을 높일 수 있습니다. 이 두 가지 개념을 이해하고 적절히 활용하면, 보다 효율적이고 유지 보수가 용이한 파이썬 코드를 작성할 수 있습니다. 숙련된 개발자는 제어문과 함수의 조합을 통해 복잡한 문제를 해결하고, 코드를 더욱 깔끔하고 효율적으로 만들 수 있습니다.