파이썬에서 return 함수 사용 방법

Python return 문: 사용법과 최적화 방법

Python return 문은 함수와 메소드에서 매우 중요한 구성 요소입니다. return 문을 사용하여 함수에서 Python 객체를 호출한 코드로 돌려보낼 수 있습니다. 이러한 객체를 함수의 반환 값(return value)이라고 합니다. 이 반환 값들은 프로그램에서 추가적인 계산을 수행하는 데 사용할 수 있습니다.

이 튜토리얼에서는 다음을 배우게 됩니다:

• 함수에서 Python return 문을 어떻게 사용하는지
• 함수에서 단일 값 또는 여러 값을 반환하는 방법
• return 문을 사용할 때 최적화 방법에 대한 권장 사항

퀴즈 풀기: 인터랙티브한 “The Python return Statement” 퀴즈로 지식을 테스트하세요. 완료 후 점수를 받아 학습 진도를 추적할 수 있습니다.

퀴즈 풀기 »

Python 함수 시작하기

대부분의 프로그래밍 언어에서는 구체적인 계산을 수행하는 코드 블록에 이름을 할당할 수 있습니다. 이러한 이름이 지정된 코드 블록을 코드의 여러 위치에서 호출할 수 있으므로 빠르게 재사용할 수 있습니다.

프로그래머들은 이러한 이름이 지정된 코드 블록을 서브루틴(subroutine), 루틴, 프로시저, 또는 함수라고 부르지만, 용어는 언어에 따라서 다를 수 있습니다. 이 튜토리얼에서는 함수로 통일하겠습니다.

Python에서 함수를 작성하려면 일정한 구문을 따르는 코드 블록을 만들면 됩니다. 다음은 함수를 작성하는 기본적인 구문입니다:

def function_name(parameters):
    # 코드 블록
    # 계산
    return value

여기에서 function_name은 함수의 이름이고, parameters는 필요한 입력 매개변수입니다. return 키워드는 함수가 호출 코드로 값을 돌려줄 때 사용됩니다.

Python 함수의 기본 작동 방식은 다음과 같습니다:

1. 함수를 호출합니다.
2. 매개변수를 사용하여 코드 블록을 실행합니다.
3. return 문을 만나면 함수는 값을 반환하고 호출한 코드로 돌아갑니다.

예를 들어보겠습니다. 다음은 add_numbers라는 이름의 함수를 사용하여 두 개의 숫자를 더하는 간단한 예입니다:

def add_numbers(a, b):
    result = a + b
    return result

# 함수 호출
sum = add_numbers(5, 3)
print(sum)  # 출력: 8

이 예제에서는 add_numbers 함수를 호출하여 5와 3을 전달하고, 함수는 이 두 숫자를 더한 값을 반환합니다. 반환된 값인 8을 sum 변수에 저장하고 출력합니다.

Python return 문 이해하기

Python에서 return 문은 함수의 실행을 중단하고 값을 반환하는 데 사용됩니다. return 문에는 선택적으로 반환할 값을 지정할 수 있으며, 값을 지정하지 않으면 None이 반환됩니다.

return 문은 함수에서 어디에서든 호출할 수 있습니다. return 문이 실행되면 해당 함수는 즉시 종료되고, return 문을 호출한 코드로 돌아갑니다.

명시적 return 문

가장 기본적인 return 문 형식은 다음과 같습니다:

return expression

return 다음에 오는 expression은 반환할 값을 나타냅니다. 예를 들어, 다음은 add_numbers 함수에서 두 숫자의 합계를 반환하는 방법을 보여줍니다:

def add_numbers(a, b):
    result = a + b
    return result

위의 예제에서 return result 문은 result 변수에 할당된 값을 반환합니다.

암시적 return 문

return 문을 사용하지 않으면 Python은 기본적으로 None을 반환합니다. 이를 암시적 return 문(implicit return statement)이라고 합니다. 예를 들어, 다음은 say_hello 함수에서 return 문 없이 None을 반환하는 방법을 보여줍니다:

def say_hello():
    print("Hello, World!")

greeting = say_hello()
print(greeting)  # 출력: None

이 예제에서 say_hello 함수는 return 문을 포함하지 않습니다. 따라서 호출 코드에서 None이 반환됩니다.

반환 vs 출력

”반환(return)“의 개념을 이해하기 전에 “출력(print)“과의 차이점을 이해해야 합니다.

Python에서는 print() 함수를 사용하여 결과를 콘솔에 출력합니다. print() 함수는 결괏값을 출력하고 콘솔에 표시하기 위한 목적으로 사용되지만, 실제로 값을 반환하지는 않습니다.

반면에 return 문은 함수에서 값을 반환하는 데 사용되며, 호출한 코드로 해당 값이 전달됩니다.

다음은 print() 함수와 return 문의 차이를 보여주는 예입니다:

def print_hello():
    print("Hello, World!")

def return_hello():
    return "Hello, World!"

greeting = print_hello()
print(greeting)  # 출력: None

greeting = return_hello()
print(greeting)  # 출력: Hello, World!

print_hello 함수는 print() 문을 사용하여 “Hello, World!”를 콘솔에 출력하지만, 호출한 코드에서는 None을 반환합니다.

반면에 return_hello 함수에서는 return 문을 사용하여 “Hello, World!”를 반환하므로, 호출한 코드에서는 “Hello, World!”가 출력됩니다.

여러 값을 반환하기

Python에서는 여러 값을 동시에 반환할 수 있습니다. 여러 값을 반환할 때는 return 문 다음에 쉼표로 구분된 값을 나열하면 됩니다. 반환된 여러 값은 호출된 코드에서 튜플로 받을 수 있습니다.

예를 들어, 다음은 get_name_info라는 이름의 함수에서 이름과 나이를 반환하는 예입니다:

def get_name_info():
    name = input("이름을 입력하세요: ")
    age = int(input("나이를 입력하세요: "))
    return name, age

# 함수 호출
name, age = get_name_info()
print("이름:", name)
print("나이:", age)

이 예제에서는 get_name_info 함수를 호출하여 사용자로부터 이름과 나이를 입력받습니다. 이후 return 문을 사용하여 이름과 나이를 반환합니다. 호출한 코드에서는 반환된 값을 name과 age 변수에 할당하고 출력합니다.

Python return 문 사용 시 최적화

return 문을 사용할 때 다음과 같은 최적화 방법을 고려할 수 있습니다.

명시적으로 None 반환하기

Python에서 함수에서 아무 값도 반환하지 않을 때 기본적으로 None을 반환합니다. 하지만 가독성을 위해 None 반환을 명시적으로 코딩하는 것이 좋습니다.

예를 들어, 다음은 greet 함수에서 이름을 입력받고 인사말을 출력하는 예입니다:

def greet():
    name = input("이름을 입력하세요: ")
    print("안녕하세요,", name, "님!")

# 함수 호출
result = greet()
print(result)  # 출력: None

위의 예제에서 greet 함수는 print() 문을 사용하여 인사말을 출력하지만, 반환 값이 없습니다. 함수 호출 코드에서 None이 반환됩니다.

이 경우, return 문을 사용하여 None을 명시적으로 반환하는 것이 좋습니다. 아래는 greet 함수를 최적화한 예입니다:

def greet():
    name = input("이름을 입력하세요: ")
    print("안녕하세요,", name, "님!")
    return None

# 함수 호출
result = greet()
print(result)  # 출력: None

변경된 예제에서 return None 문이 추가되었습니다. 이제 greet 함수는 None을 명시적으로 반환합니다. 반환 값이 없음을 더 명확하게 알 수 있습니다.

반환 값 기억하기

함수가 반환하는 값을 사용해야 하는 경우, 해당 값을 변수에 할당하여 기억하는 것이 좋습니다. 이렇게 하면 나중에 값을 사용할 때 편리합니다.

예를 들어, 다음은 divide 함수에서 두 숫자를 나눈 결과를 반환한 후에 출력하는 예입니다:

def divide(a, b):
    result = a https://codemdd.io/ b
    return result

# 함수 호출
divide(10, 2)
print(result)  # 오류: result is not defined

변수 result는 divide 함수 내에서만 유효한지라, 함수에서 반환한 후에는 호출한 코드에서 사용할 수 없습니다. 이러한 오류를 방지하기 위해 반환 값을 변수에 할당해야 합니다. 아래는 변경된 예제입니다:

def divide(a, b):
    result = a https://codemdd.io/ b
    return result

# 함수 호출
quotient = divide(10, 2)
print(quotient)  # 출력: 5.0

변경된 예제에서 divide 함수의 반환 값을 quotient 변수에 할당하여 기억합니다. 이후 호출한 코드에서 quotient 변수를 사용하여 결과를 출력합니다.

복잡한 표현식 피하기

return 문 내에서 복잡한 표현식을 사용하는 것은 코드를 이해하기 어렵게 만들 수 있습니다. 따라서 반환 값이 계산되는 부분을 여러 개의 단계로 나누거나 변수에 할당하는 것이 좋습니다.

예를 들어, 다음은 calculate_average 함수에서 입력된 점수 리스트의 평균을 계산하여 반환하는 예입니다:

def calculate_average(scores):
    total = sum(scores)
    average = total https://codemdd.io/ len(scores)
    return average

# 함수 호출
avg = calculate_average([90, 85, 92, 78])
print(avg)  # 출력: 86.25

변경된 예제에서 return 문 내에서 평균을 계산하는 부분을 여러 개의 단계로 나누었습니다. 이렇게 하면 코드가 더욱 읽기 쉽고 이해하기 쉬워집니다.

반환 값 vs 전역 변수 수정

return 문을 사용하여 값을 반환하는 대신 전역 변수를 수정하는 것은 피해야 합니다. 전역 변수를 수정하는 것은 코드를 이해하기 어렵게 만들 수 있으며, 코드의 의도를 명확하게 전달하기 어렵게 할 수 있습니다.

따라서 함수에서 값을 반환할 때는 반환 값을 사용하고, 전역 변수를 수정하는 것은 지양해야 합니다.

예를 들어, 다음은 add_to_total 함수에서 두 숫자를 합하여 전역 변수 total을 수정하는 예입니다:

total = 0

def add_to_total(a, b):
    global total
    total = a + b

# 함수 호출
add_to_total(5, 3)
print(total)  # 출력: 8

변경된 예제에서는 add_to_total 함수가 전역 변수 total을 수정합니다. 이렇게 하면 함수가 의도하지 않은 다른 영향을 줄 수 있습니다. 따라서 함수에서 값을 반환하여 호출한 코드에서 해당 값을 사용하는 것이 좋습니다.

조건문과 함께 return 사용하기

return 문은 조건문과 함께 사용하여 함수를 중단하고 값이나 오류를 반환할 수 있습니다.

예를 들어, 다음은 divide 함수에서 두 숫자를 나누기 전에 0으로 나누는지 확인하는 예입니다:

def divide(a, b):
    if b == 0:
        return "나누는 수는 0이 될 수 없습니다."

    result = a https://codemdd.io/ b
    return result

# 함수 호출
quotient = divide(10, 0)
print(quotient)  # 출력: "나누는 수는 0이 될 수 없습니다."

이 예제에서 divide 함수는 if 문을 사용하여 b가 0인지 확인합니다. 0으로 나누는 경우, 함수는 오류 메시지를 반환하고 즉시 종료됩니다.

조건문과 함께 return 문을 사용함으로써 함수에서 요구 사항을 만족하지 않는 경우 호출 코드에 적절한 오류 메시지를 반환할 수 있습니다.

True 또는 False 반환하기

Python에서는 True 또는 False 값을 반환하여 조건을 생성하거나 확인할 수 있습니다.

예를 들어, 다음은 is_even 함수에서 주어진 숫자가 짝수인지 여부를 반환하는 예입니다:

def is_even(number):
    if number % 2 == 0:
        return True

    return False

# 함수 호출
result = is_even(6)
print(result)  # 출력: True

이 예제에서 is_even 함수는 주어진 숫자가 짝수인지 확인하고, 해당 조건에 따라 True 또는 False 값을 반환합니다.

조건에 따라 True 또는 False 값을 반환하는 것은 프로그램에서 조건을 검사하는 데 유용합니다.

루프에서 빠져 나오기

return 문을 사용하여 루프를 조기에 종료하거나 중지할 수 있습니다. 이를 루프 탈출(loop breaking)이라고 합니다.

예를 들어, 다음은 find_number 함수에서 주어진 숫자를 찾고, 찾으면 True를 반환하고 루프에서 탈출하는 예입니다:

def find_number(numbers, target):
    for number in numbers:
        if number == target:
            return True

    return False

# 함수 호출
numbers = [1, 2, 3, 4, 5]
result = find_number(numbers, 3)
print(result)  # 출력: True

이 예제에서 find_number 함수는 for 루프를 사용하여 주어진 숫자 리스트의 각 항목을 확인합니다. 리스트에서 주어진 숫자를 찾으면 True를 반환하고 함수는 종료됩니다.

루프 탈출은 주어진 조건을 만족하는 결과를 최대한 빠르게 찾는 데 유용합니다.

죽은 코드 식별하기

함수에서 return 문 이후에 실행되는 코드는 실행되지 않으므로 죽은 코드(dead code)라고 합니다. 죽은 코드는 제거해야 하는 불필요한 코드이며, 코드의 가독성을 향상시키고 실행 시간을 단축시킵니다.

예를 들어, 다음은 is_positive 함수에서 주어진 숫자가 양수인지 확인하는 예입니다:

def is_positive(number):
    if number > 0:
        return True

    print("이 메시지는 절대 출력되지 않습니다.")
    return False

# 함수 호출
result = is_positive(5)
print(result)  # 출력: True

이 예제에서는 if 문을 사용하여 숫자가 양수인지 확인합니다. 숫자가 양수인 경우, True를 반환하고 함수가 종료됩니다.

print() 문 다음의 return 문 이후에 있는 코드는 실행되지 않습니다. return 문 이후에 있는 죽은 코드는 제거될 수 있습니다.

여러 개의 이름 있는 객체 반환하기

Python에서는 객체의 이름을 지정하여 여러 개의 객체를 동시에 반환할 수 있습니다. 이름 있는 객체는 딕셔너리 형태로 반환되며, 호출된 코드에서는 해당 객체에 이름을 사용하여 값을 가져올 수 있습니다.

예를 들어, 다음은 get_person_info 함수에서 이름과 나이를 반환하는 예입니다:

def get_person_info():
    name = "John"
    age = 30
    return {
        "name": name,
        "age": age
    }

# 함수 호출
info = get_person_info()
print("이름:", info["name"])
print("나이:", info["age"])

이 예제에서 get_person_info 함수는 이름과 나이를 딕셔너리 객체로 반환합니다. 호출한 코드에서는 info 변수를 사용하여 이름과 나이를 가져옵니다.

클로저로 함수 반환하기

Python에서는 함수를 다른 함수 내에서 정의하여 반환할 수 있습니다. 이를 클로저(closure)라고 합니다. 클로저를 사용하여 함수를 반환하면 중첩된 함수의 변수에 계속 접근할 수 있습니다.

예를 들어, 다음은 calculate_average 함수에서 점수 리스트의 평균값을 계산하고 반환하는 내부 함수인 average 함수를 반환하는 예입니다:

def calculate_average(scores):
    def average():
        total = sum(scores)
        return total https://codemdd.io/ len(scores)

    return average

# 클로저 함수 생성
ave = calculate_average([90, 85, 92, 78])

# 함수 호출
result = ave()
print(result)  # 출력: 86.25

이 예제에서 calculate_average 함수는 average 함수를 정의하고 반환합니다. 클로저 함수인 average 함수를 호출하여 점수의 평균값을 계산하고 출력합니다.

클로저를 사용하면 함수 내에 있는 변수를 외부에서도 계속 접근할 수 있으므로 코드를 더욱 유연하고 재사용 가능하게 할 수 있습니다.

데코레이터로 함수 받고 반환하기

Python에서 함수를 받아들이고 함수를 반환하는 함수를 작성한 다음 이를 데코레이터(decorator)라고 합니다. 데코레이터는 코드 기능을 변경하거나 수정하는 데 유용합니다.

예를 들어, 다음은 decorator 함수로 데코레이터를 작성하는 예입니다:

def decorator(func):
    def wrapper():
        print("데코레이터 시작")
        func()
        print("데코레이터 종료")

    return wrapper

# 데코레이터 적용
@decorator
def greet():
    print("안녕하세요!")

# 함수 호출
greet()

이 예제에서 decorator 함수는 다른 함수를 인수로 받고 해당 함수를 수정한 후 수정된 함수를 반환합니다.

greet 함수 위에 @decorator라는 데코레이터를 작성하여 greet 함수에 적용합니다. greet 함수를 호출하면 decorator 함수가 호출되고, 수정된 greet 함수가 실행됩니다.

데코레이터를 사용하면 함수의 동작을 쉽게 수정하거나 코드에 추가 기능을 더할 수 있습니다.

팩토리 패턴으로 사용자 정의 객체 반환하기

Python에서는 팩토리 패턴을 사용하여 사용자 정의 객체를 반환할 수 있습니다. 팩토리 패턴은 객체를 생성하는 별도의 팩토리 함수를 사용하는 디자인 패턴입니다.

예를 들어, 다음은 create_person 함수에서 사용자 정의 Person 객체를 반환하는 예입니다:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def create_person(name, age):
    return Person(name, age)

# 함수 호출
person = create_person("John", 30)
print(person.name)  # 출력: John
print(person.age)  # 출력: 30

이 예제에서 create_person 함수는 주어진 이름과 나이를 사용하여 Person 객체를 생성하고 반환합니다. 생성된 Person 객체는 호출한 코드에서 사용할 수 있습니다.

팩토리 패턴은 코드를 구조화하고 관련 객체를 생성하는 데 유용합니다.

try...finally 블록에서 return 사용하기

try...finally 블록을 사용하면 코드에서 예외(오류)를 처리하는 동안에도 정리 코드를 실행할 수 있습니다. 이러한 블록에서도 return 문을 사용할 수 있습니다.

예를 들어, 다음은 divide 함수에서 try...finally 블록을 사용하여 두 숫자를 나눈 후에도 항상 리소스를 정리하는 예입니다:

def divide(a, b):
    try:
        result = a https://codemdd.io/ b
        return result
    finally:
        print("리소스 정리 중...")

# 함수 호출
quotient = divide(10, 5)
print(quotient)  # 출력: 2.0

이 예제에서 divide 함수는 두 숫자를 나눈 결과를 반환합니다. try 블록에서 예외가 발생하지 않으면 return 문이 실행되고, 해당 결과가 반환됩니다.

finally 블록은 항상 실행되므로, return 문 이후에 있는 정리 코드가 실행됩니다. 이러한 방식으로 함수가 종료되기 전에 정리 작업을 수행할 수 있습니다.

제너레이터 함수에서 return 사용하기

Python에서는 제너레이터(generator) 함수에서도 return 문을 사용할 수 있습니다. 제너레이터 함수는 yield 문을 사용하여 값이 반환될 때까지 실행을 일시 중지하고, 호출 코드로 값들을 전달하는 함수입니다.

제너레이터 함수에서 return 문을 사용하면 제너레이터 함수의 실행을 완전히 중단하고 반환 값을 호출한 코드로 전달할 수 있습니다.

def generate_numbers():
    yield 1
    yield 2
    return

# 제너레이터 생성
numbers = generate_numbers()

# 제너레이터 사용
for number in numbers:
    print(number)

이 예제에서 generate_numbers 함수는 yield 문을 사용하여 값을 반환합니다. return 문은 yield 문 이후에 있는데, return 문이 실행되면 제너레이터 함수의 실행이 완전히 중단됩니다.

함수의 실행을 중단하는 것은 제너레이터를 사용하여 조건에 따라 값을 생성하거나, 데이터를 처리하는데 유용한 기능입니다.

결론

Python의 return 문은 함수의 실행을 중지하고 값을 반환하는 데 사용됩니다. return 문을 사용하는 것은 함수의 기능을 활용하는 핵심 요소입니다.

이 튜토리얼에서는 Python return 문을 사용하는 방법과 주의사항에 대해 배웠습니다. 여러 값을 반환하는 방법, 최적화 방법, 클로저와 데코레이터의 활용 방법 등 다양한 내용을 다루었습니다.

이를 활용하여 보다 유지보수 가능하고 가독성 있은 코드를 작성할 수 있습니다. Python의 함수 기능을 최대한 활용하여 프로그램을 개발하는 데 도움이 될 것입니다.