Как вернуться из функции Python?

[

Использование оператора return в Python: использование и лучшие практики

Оператор return в Python является ключевым компонентом функций и методов. С его помощью вы можете возвращать объекты Python обратно в вызывающий код. Эти объекты называются возвращаемым значением функции. Вы можете использовать их для проведения дальнейших вычислений в своих программах.

Эффективное использование оператора return является основным навыком, если вы хотите написать пользовательские функции, которые являются питоническими и надежными.

В этом учебнике вы узнаете:

• Как использовать оператор return в ваших функциях
• Как возвращать одно или несколько значений из функций
• Какие лучшие практики следует соблюдать при использовании оператора return

Начало работы с функциями Python

Большинство языков программирования позволяют вам назначать имя для блока кода, который выполняет определенные вычисления. Эти названные блоки кода могут быть легко повторно использованы, поскольку вы можете использовать их имя для вызова из разных мест кода.

Программисты называют эти названные блоки кода подпрограммами, рутинами, процедурами или функциями, в зависимости от языка программирования. Функции в Python, например, позволяют вам объединить некоторый код вместе, чтобы выполнить определенную задачу или вычисление.

Вот пример определения простой функции в Python:

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

В этом примере мы определяем функцию multiply, которая принимает два аргумента x и y. Она умножает эти два числа вместе и возвращает результат. Мы можем вызвать эту функцию, передав ей два числа, и она вернет произведение этих чисел:

product = multiply(2, 3)
print(product) # Output: 6

Это простой пример, но функции могут быть гораздо сложнее и выполнять более сложные вычисления. Когда вызывается функция, она выполняет код внутри себя и возвращает значение с помощью оператора return.

Понимание оператора return в Python

Оператор return используется внутри функций для возврата значения или выхода из функции. Когда Python достигает оператора return, он завершает выполнение функции и возвращает значение, указанное после return.

Явные операторы return

В Python вы можете использовать оператор return для явного возврата значения из функции. При использовании явного оператора return вы указываете конкретное значение, которое будет возвращено из функции.

def square(x):
    return x * x

result = square(5)
print(result) # Вывод: 25

В этом примере мы определяем функцию square, которая принимает один аргумент x и возвращает квадрат этого числа. Мы вызываем функцию square со значением 5, и она возвращает 25.

Note: После оператора return может следовать любое выражение или значение, которое может быть вычислено.

Неявные операторы return

В Python функция может иметь неявный оператор return, когда вы не указываете конкретное значение внутри оператора return. Вместо этого функция может просто завершить свое выполнение и вернуться к вызывающему коду без возврата значения.

def print_message(message):
    print(message)
    return

print_message("Hello, World!")

В этом примере мы определяем функцию print_message, которая принимает один аргумент message и выводит его на экран. Если нам не нужно возвращать какое-либо значение из функции print_message, мы можем просто завершить ее выполнение без явного оператора return.

Note: Если внутри функции отсутствует явный оператор return, она возвращает специальное значение None по умолчанию.

Возвращение значений против печати

Одна из ошибок, которые могут быть сделаны при использовании оператора return, заключается в неправильном понимании разницы между возвращением значения и его печатью. Иногда люди путают или не учитывают эту разницу и получают неправильные результаты.

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

result = add(2, 3)
print(result) # Вывод: None

В этом примере мы определяем функцию add, которая принимает два аргумента x и y и выполняет сложение этих чисел. Внутри функции мы используем оператор print для вывода суммы на экран. Однако, мы не возвращаем это значение из функции.

При вызове функции add и присваивании результата переменной result, мы получаем значение None. Использование оператора print в функции не возвращает значение, а только печатает его на экран.

Если вам нужно получить результат сложения, вы должны использовать оператор return вместо print:

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

result = add(2, 3)
print(result) # Вывод: 5

В этом примере мы используем оператор return для возврата суммы x + y из функции add. Теперь, при вызове функции и присваивании результата переменной result, мы получаем правильное значение 5.

Note: Если функция не содержит явного оператора return, она возвращает None по умолчанию.

Возвращение нескольких значений

Оператор return также позволяет возвращать несколько значений из функции. В Python вы можете упаковать несколько значений внутри оператора return с помощью скобок или используя запятую, чтобы разделить значения.

def divide(x, y):
    quotient = x // y
    remainder = x % y
    return quotient, remainder

result = divide(10, 3)
print(result) # Вывод: (3, 1)

В этом примере мы определяем функцию divide, которая принимает два аргумента x и y. Она выполняет деление x на y и возвращает частное и остаток от деления. Мы вызываем функцию divide со значениями 10 и 3, и она возвращает кортеж (3, 1), который содержит частное и остаток от деления.

Вы можете разделить этот кортеж на отдельные переменные:

quotient, remainder = divide(10, 3)
print(quotient) # Вывод: 3
print(remainder) # Вывод: 1

Теперь мы присваиваем частное и остаток от деления отдельным переменным quotient и remainder с помощью механизма распаковки кортежей.

Note: Когда вы возвращаете несколько значений из функции, они фактически упаковываются в кортеж. Вы можете распаковать этот кортеж в отдельные переменные, как показано в примере выше.

Использование оператора return в Python: лучшие практики

При использовании оператора return в ваших функциях существуют некоторые лучшие практики, которые помогут сделать ваш код более понятным и улучшить его производительность.

Явное возвращение значения None

Когда функция ничего не возвращает, хорошей практикой является явное указание возврата значения None. Это делает ваш код более понятным и позволяет другим программистам понять, что ваша функция не предназначена для возврата результата.

Вот пример функции, которая печатает приветствие на экран и не возвращает значения:

def print_greeting(name):
    print(f"Hello, {name}!")

result = print_greeting("John")
print(result) # Вывод: None

В этом примере мы явно не указываем оператор return, поэтому функция возвращает значение None.

Однако, в хорошем коде такой случай стоит укажить явно:

def print_greeting(name):
    print(f"Hello, {name}!")
    return None

result = print_greeting("John")
print(result) # Вывод: None

Этот пример делает явным указание, что функция print_greeting не возвращает значение.

Запоминание возвращаемого значения

Когда функция возвращает значение, хорошей практикой является помещение этого значения в переменную. Это помогает вам запомнить возвращаемое значение и использовать его в вашей программе.

def sum(x, y):
    result = x + y
    return result

total = sum(5, 10)
print(total) # Вывод: 15

В этом примере мы помещаем возвращаемое значение из функции sum в переменную total. Это позволяет нам сохранить результат и использовать его для дальнейших вычислений или операций.

Избегание сложных выражений

При использовании оператора return старайтесь избегать сложных выражений или операций. Вместо этого разбивайте код на более простые шаги и сохраняйте промежуточные результаты в переменных.

def calculate_average(numbers):
    total = sum(numbers)
    average = total / len(numbers)
    return average

В этом примере мы вычисляем среднее значение списка чисел. Мы рассчитываем общую сумму чисел с помощью функции sum, затем делим эту сумму на количество чисел в списке. Возвращаемое значение - это среднее значение.

Этот подход делает код более читабельным и позволяет легко проверять и отлаживать каждую часть кода.

Возвращение значений против изменения глобальных переменных

Оператор return используется для возврата значения из функции, но он также позволяет избежать изменения глобальных переменных внутри функции.

Когда вы изменяете глобальные переменные внутри функции, это может привести к непредсказуемому поведению вашей программы. Вместо этого, при использовании оператора return, вы возвращаете значения из функции и сохраняете их в локальных переменных в вызывающем коде.

x = 10

def increment():
    global x
    x = x + 1

increment()
print(x) # Вывод: 11

В этом примере мы определяем функцию increment, которая увеличивает значение глобальной переменной x на 1. Мы используем ключевое слово global, чтобы указать, что мы хотим изменить глобальную переменную x. После вызова функции increment мы печатаем значение x и получаем 11.

Однако, лучшей практикой является возвращение значений из функции и сохранение их в переменных:

x = 10

def increment(x):
    return x + 1

x = increment(x)
print(x) # Вывод: 11

В этом примере мы определяем функцию increment, которая принимает аргумент x и возвращает его увеличенное значение на 1. Мы вызываем функцию increment с глобальной переменной x и присваиваем результат обратно в x. После этого мы печатаем значение x и получаем 11.

Использование оператора return с условными операторами

Оператор return может использоваться с условными операторами, чтобы рано выйти из функции, если выполняется определенное условие. Это может быть полезно, когда не нужно выполнить остаток функции, если выполняется определенное условие.

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

result = is_positive(5)
print(result) # Вывод: True

В этом примере мы определяем функцию is_positive, которая принимает один аргумент number и проверяет, является ли он положительным. Если число положительное, мы возвращаем значение True, в противном случае возвращаем False.

Оператор return позволяет нам выйти из функции и возвратить значение прямо изнутри условного оператора, когда условие выполняется.

Возвращение True или False

В Python оператор return может возвращать логические значения True или False. Это может быть полезно, когда вы хотите вернуть результат проверки определенного условия.

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

result = is_even(4)
print(result) # Вывод: True

В этом примере мы определяем функцию is_even, которая принимает один аргумент number и проверяет, является ли он четным. Если число четное, мы возвращаем значение True, в противном случае возвращаем False.

Note: Вместо использования условных операторов для возвращения логического значения, вы также можете вернуть логическое значение напрямую с помощью оператора return:

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

result = is_even(4)
print(result) # Вывод: True

Этот код эквивалентен предыдущему примеру, но мы возвращаем логическое значение number % 2 == 0 напрямую, без использования условного оператора.

Краткое выполнение циклов

Оператор return позволяет сокращать выполнение циклов, когда вы достигаете нужного результата и не хотите продолжать выполнение цикла.

def find_prime_numbers(numbers):
    prime_numbers = []
    for number in numbers:
        if is_prime(number):
            prime_numbers.append(number)
        else:
            return prime_numbers
    return prime_numbers

numbers = [2, 3, 4, 5, 6, 7, 8, 9, 10]
result = find_prime_numbers(numbers)
print(result) # Вывод: [2, 3]

В этом примере мы определяем функцию find_prime_numbers, которая принимает список чисел и возвращает список простых чисел из этого списка. Мы проходимся по каждому числу в списке, вызываем функцию is_prime для проверки, является ли число простым. Если число простое, мы добавляем его в список prime_numbers. Если число не является простым, мы рано покидаем цикл с помощью оператора return, чтобы сохранить только простые числа, найденные до этого момента.

После цикла мы возвращаем список prime_numbers.

Распознавание мертвого кода

Иногда в функции может быть написан код, который никогда не выполнится из-за условий или логики. В таких случаях использование оператора return позволяет распознать этот мертвый код и избежать его выполнения.

def is_positive(number):
    if number > 0:
        return True
    else:
        print("Number is not positive")
        return False
    print("This line will never be executed")

result = is_positive(-5)
print(result) # Вывод: False

В этом примере мы определяем функцию is_positive, которая принимает один аргумент number и проверяет, является ли он положительным. Если число положительное, мы сразу же возвращаем True. В противном случае мы печатаем сообщение “Number is not positive”, а затем возвращаем False.

Строка print("This line will never be executed") на самом деле никогда не будет выполнена, так как на этом этапе функция уже завершила свое выполнение с помощью оператора return.

Всякий раз, когда вы пишете код, запускайте его и тестируйте его, и во время отладки одним из инструментов, которые у вас будут, является вывод на консоль или печать сообщений. Если вы знаете, что код никогда не будет выполнен, вы можете определить его как мертвый код, и это может быть признаком ошибки или ненужной логики. Распознавание и избегание мертвого кода помогает сделать ваш код более чистым и эффективным.

Возвращение нескольких именованных объектов

Оператор return также позволяет вернуть несколько именованных объектов из функции, используя разные переменные для каждого объекта.

def get_student_scores():
    name = "John"
    math_score = 90
    english_score = 85
    return name, math_score, english_score

name, math_score, english_score = get_student_scores()
print(name) # Вывод: John
print(math_score) # Вывод: 90
print(english_score) # Вывод: 85

В этом примере мы определяем функцию get_student_scores, которая возвращает несколько именованных значений: имя студента, оценку по математике и оценку по английскому языку. Затем мы вызываем функцию get_student_scores и распаковываем возвращаемые значения в отдельные переменные name, math_score и english_score, чтобы мы могли использовать их в нашем коде.

Возврат функций: Замыкания

В Python функции могут возвращать другие функции, что называется замыканиями. Замыкание - это функция, которая запоминает значения внешних переменных, даже если эти переменные уже не существуют.

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

multiply_by_2 = multiplier(2)
print(multiply_by_2(5)) # Вывод: 10

multiply_by_3 = multiplier(3)
print(multiply_by_3(5)) # Вывод: 15

В этом примере мы определяем функцию multiplier, которая принимает один аргумент x и возвращает другую функцию multiply. Функция multiply принимает один аргумент y и возвращает произведение x и y.

Мы вызываем функцию multiplier с аргументами 2 и 3 и сохраняем полученные функции multiply_by_2 и multiply_by_3. Затем мы вызываем эти функции с аргументом 5 и получаем результаты 10 и 15 соответственно.

Замыкания позволяют нам создавать и использовать функции, которые могут запоминать значения внешних переменных, даже если эти переменные уже не существуют. Их можно использовать для создания функций высшего порядка, функций оберток и других полезных конструкций.

Прием и возврат функций: Декораторы

В Python функции могут принимать и возвращать другие функции. Это позволяет использовать функции как аргументы других функций и возвращать их в качестве результата.

Один из распространенных способов использования этой возможности - создание декораторов. Декоратор - это функция, которая принимает одну функцию и возвращает другую функцию. Декораторы используются для изменения или расширения функциональности других функций без необходимости изменения их исходного кода.

def uppercase_decorator(func):
    def wrapper():
        result = func()
        return result.upper()
    return wrapper

@uppercase_decorator
def say_hello():
    return "Hello, World!"

print(say_hello()) # Вывод: HELLO, WORLD!

В этом примере мы определяем декоратор uppercase_decorator, который принимает одну функцию func и возвращает другую функцию wrapper. Функция wrapper вызывает исходную функцию func и изменяет результат путем преобразования его в верхний регистр.

Затем мы используем декоратор uppercase_decorator перед определением функции say_hello. Это означает, что функция say_hello будет обернута внутри декоратора uppercase_decorator и ее результат будет преобразован в верхний регистр.

При вызове функции say_hello мы получаем результат HELLO, WORLD!, так как декоратор изменяет его прямо перед возвратом.

Декораторы предоставляют гибкость и переиспользование кода при работе с функциями в Python. Они являются мощным инструментом программиста и используются для разных задач, таких как логирование, аутентификация, кэширование и многое другое.

Возвращение пользовательских объектов: Паттерн Фабрика

Оператор return также позволяет возвращать пользовательские объекты из функции. Это полезно, когда вы хотите создать и вернуть объект определенного типа или класса.

class Dog:
    def __init__(self, name):
        self.name = name

def create_dog(name):
    return Dog(name)

dog = create_dog("Buddy")
print(dog.name) # Вывод: Buddy

В этом примере мы определяем класс Dog, который имеет одно свойство name. Затем мы определяем функцию create_dog, которая принимает аргумент name и возвращает объект типа Dog со значением name.

Мы вызываем функцию create_dog с аргументом “Buddy” и сохраняем возвращаемый объект в переменную dog. Затем мы печатаем свойство name объекта dog и получаем “Buddy”.

Использование оператора return для возврата пользовательских объектов позволяет вам создавать объекты, настраивать их и возвращать их из функций по мере необходимости.

Использование оператора return в блоках try … finally

Оператор return также может использоваться в блоках try ... finally для возврата значения из функции, даже если происходит исключение или блок finally выполняется.

def divide(x, y):
    try:
        result = x / y
        return result
    finally:
        print("Executing finally block")

result = divide(10, 2)
print(result) # Вывод: 5.0

В этом примере мы определяем функцию divide, которая делит число x на число y. Мы используем блок try для попытки выполнения операции деления и сохранения результата в переменной result. В блоке finally мы печатаем сообщение “Executing finally block”.

После выполнения операции деления, значение 5.0 возвращается из функции с помощью оператора return и сохраняется в переменной result. Затем печатается результат 5.0.

Если происходит исключение во время операции деления, блок finally всегда выполняется, даже если нет соответствующего блока except.

def divide(x, y):
    try:
        result = x / y
        return result
    finally:
        print("Executing finally block")

result = divide(10, 0)
print(result) # Вывод: Error: division by zero

В этом примере мы вызываем функцию divide с аргументами 10 и 0, что вызывает исключение деления на ноль. Однако, блок finally все равно выполняется и печатает сообщение “Executing finally block”, даже если операция деления приводит к ошибке. Значение None возвращается, так как функция не содержит явного оператора return.

Использование оператора return в генераторных функциях

Оператор return может использоваться в генераторных функциях для возврата значения и завершения итерации. Генераторная функция - это функция, которая возвращает итератор и позволяет создавать последовательности значений по требованию.

def countdown(n):
    while n > 0:
        yield n
        n -= 1
    return

for i in countdown(5):
    print(i) # Вывод: 5, 4, 3, 2, 1

# Получение возврата из генератора
generator = countdown(3)
print(next(generator)) # Вывод: 3
print(next(generator)) # Вывод: 2
print(next(generator)) # Вывод: 1
print(next(generator)) # Вызывает StopIteration исключение

В этом примере мы определяем генераторную функцию countdown, которая принимает начальное значение n и возвращает итератор, который генерирует значения от n до 1.

Мы используем ключевое слово yield для возврата значений из генератора и оператор return для завершения итерации. Когда оператор return вызывается, генератор итерации заканчивается и вызывает исключение StopIteration.

Мы можем использовать генераторный объект countdown(5) в цикле for для печати значений от 5 до 1. Мы также можем использовать функцию next(generator), чтобы получить каждое значение из генератора по требованию.

Заключение

Оператор return является ключевым компонентом функций в Python и позволяет возвращать значения обратно в вызывающий код. Вы можете использовать оператор return для возврата одного или нескольких значений, а также для возврата функций, пользовательских объектов и других результатов.

Когда вы пишете функции на Python, помните о лучших практиках при использовании оператора return:

• Явно возвращайте None, когда функция не возвращает значение.
• Запоминайте возвращаемые значения, чтобы использовать их в коде.
• Избегайте сложных выражений и операций в операторе return.
• Используйте возврат значений вместо изменения глобальных переменных.
• Используйте оператор return с условными операторами для раннего выхода из функции.
• Возвращайте логические значения True или False.
• При кратком выполнении циклов используйте оператор return.
• Избегайте мертвого кода и распознавайте его.
• Возвращайте несколько именованных объектов.
• Используйте оператор return для возврата функций и создания замыканий.
• Реализуйте декораторы, используя оператор return.
• Возвращайте пользовательские объекты и создавайте паттерны фабрики.
• Используйте оператор return в блоках try ... finally для возврата значений и завершения итерации.
• Используйте оператор return в генераторных функциях для возврата значений и завершения итерации.

С учетом этих лучших практик вы сможете писать более чистый, понятный и производительный код в Python, используя оператор return.