Пропустить до содержимого
CodeMDD.io | Coding Tutorials

Возврат функции в Python: Как использовать?

[

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

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

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

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

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

Пройдите викторину: Проверьте свои знания с интерактивной викториной “Команда return в Python”. По ее завершении вы получите оценку, чтобы следить за своим прогрессом в учении:

Пройти викторину »

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

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

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

Давайте рассмотрим простой пример функции Python:

def multiply_by_two(x):
    return x * 2

В этом примере мы определяем функцию multiply_by_two, которая принимает один параметр x и возвращает его удвоенное значение. Когда мы вызываем эту функцию и передаем ей значение 5, она вернет результат 10.

result = multiply_by_two(5)
print(result)  # Output: 10

В этом случае, функция multiply_by_two выполняется и возвращает значение 10, которое сохраняется в переменной result и выводится на экран.

Понимание команды return в Python

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

Явные выражения return

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

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

def sum_numbers(a, b):
    return a + b

Когда мы вызываем эту функцию и передаем ей числа 3 и 4, она вернет их сумму, равную 7.

result = sum_numbers(3, 4)
print(result)  # Output: 7

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

Неявные выражения return

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

Рассмотрим следующий пример функции, которая принимает номер месяца и возвращает соответствующее ему название:

def get_month_name(month):
    if month == 1:
        return 'January'
    elif month == 2:
        return 'February'
    elif month == 3:
        return 'March'
    # etc.


result = get_month_name(2)
print(result)  # Output: "February"

В этом примере функция get_month_name проверяет значение переменной month и возвращает соответствующее название месяца с помощью команды return. Если значение month равно 2, функция вернет строку “February”.

Если вызвать функцию get_month_name с другим значением, например 4, она все равно вернет значение None, поскольку нет явного выражения return для этого значения.

result = get_month_name(4)
print(result)  # Output: None

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

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

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

Давайте рассмотрим пример, чтобы проиллюстрировать эту разницу. У нас есть функция square, которая принимает число и выводит его квадратный корень:

def square(x):
    print(x * x)


result = square(5)
print(result)  # Output: None

Здесь функция square выводит результат умножения числа на само себя (квадрат) с помощью команды print. Однако она не возвращает значение, а просто выводит его на экран. Если мы попытаемся сохранить этот вывод в переменную result и вывести его на экран, мы получим значение None, так как функция square не возвращает никакого значения.

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

def square(x):
    return x * x


result = square(5)
print(result)  # Output: 25

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

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

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

Рассмотрим следующий пример функции get_circle_info, которая принимает радиус окружности и возвращает ее площадь и длину окружности:

import math


def get_circle_info(radius):
    area = math.pi * radius * radius
    circumference = 2 * math.pi * radius
    return area, circumference


circle_area, circle_circumference = get_circle_info(5)
print(circle_area)        # Output: 78.53981633974483
print(circle_circumference)  # Output: 31.41592653589793

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

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

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

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

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

def hello_world():
    print("Hello, World!")
    return None

В этом примере функция hello_world просто выводит фразу “Hello, World!” на экран с помощью команды print. Затем она возвращает значение None, чтобы явно указать, что ничего не возвращает.

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

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

def multiply_by_two(x):
    return x * 2


result = multiply_by_two(5)
print(result)  # Output: 10

В этом примере функция multiply_by_two возвращает удвоенное значение своего аргумента x. Мы сохраняем это значение в переменной result и выводим его на экран. Таким образом, можно ясно видеть, что функция вернула значение 10, и мы используем его в дальнейших вычислениях или выводе.

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

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

# Плохо
def calculate_sum(a, b):
    return a * 2 + b - (a + b)


# Хорошо
def calculate_sum(a, b):
    multiplied = a * 2
    summed = a + b
    result = multiplied + b - summed
    return result

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

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

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

# Плохо
result = 0


def add_to_result(x):
    global result
    result += x


# Хорошо
def add(x, y):
    return x + y

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

Использование return с условиями

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

def is_positive(x):
    if x > 0:
        return True
    return False

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

Оптимизация циклов

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

def find_positive(numbers):
    for number in numbers:
        if number > 0:
            return number
    return None

В этом примере функция find_positive проверяет элементы списка numbers и возвращает первое положительное число. Если в списке нет положительных чисел, функция возвращает значение None. Использование команды return внутри цикла позволяет остановить его выполнение, как только выполнено условие, что позволяет сэкономить вычислительные ресурсы.

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

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

def calculate_discount(total_amount):
    if total_amount >= 100:
        return 0.1 * total_amount
    elif total_amount >= 50:
        return 0.05 * total_amount
    else:
        return total_amount
        print("This line will never be executed")

В этом примере функция calculate_discount вычисляет скидку для общей суммы покупки. Если общая сумма больше или равна 100, функция возвращает 10% от этой суммы. Если общая сумма больше или равна 50, функция возвращает 5% от нее. В противном случае, функция просто возвращает исходную сумму. Отладочная инструкция print, которая находится после команды return, никогда не будет выполнена, так как функция завершает свое выполнение при использовании команды return.

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

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

def get_user_info():
    name = "John"
    age = 30
    country = "USA"
    return {
        "name": name,
        "age": age,
        "country": country
    }

В этом примере функция get_user_info определяет именованные объекты name, age и country. Затем она создает словарь, который содержит эти объекты, и возвращает его с помощью команды return. Можно использовать этот словарь в вызывающей программе для доступа к значениям по именам.

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

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

def outer_function(message):
    def inner_function():
        print(message)
    return inner_function


my_function = outer_function("Hello, World!")
my_function()  # Output: "Hello, World!"

В этом примере функция outer_function принимает сообщение в качестве аргумента и возвращает внутреннюю функцию inner_function. Когда мы вызываем outer_function и сохраняем возвращаемую функцию в переменную my_function, мы создаем замыкание. При вызове my_function мы видим, что она запоминает сообщение, переданное в outer_function, и выводит его на экран.

Принятие и возвращение функций: декораторы

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

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

def decorator_function(original_function):
    def wrapper_function():
        print("Before the function is called")
        original_function()
        print("After the function is called")
    return wrapper_function


@decorator_function
def target_function():
    print("The target function is called")


target_function()

В этом примере мы определяем декоратор decorator_function, который принимает другую функцию в качестве аргумента и создает внутреннюю функцию wrapper_function. Внутренняя функция выполняет какие-то действия перед и после вызова исходной функции original_function. Затем мы применяем декоратор к функции target_function с помощью символа @, чтобы изменить ее поведение.

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

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

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height


def create_rectangle(width, height):
    return Rectangle(width, height)


new_rectangle = create_rectangle(10, 5)
print(new_rectangle.width)   # Output: 10
print(new_rectangle.height)  # Output: 5

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

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

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

def divide(x, y):
    try:
        result = x / y
        return result
    finally:
        print("The division is done")


divided_result = divide(10, 2)
print(divided_result)  # Output: 5.0

В этом примере функция divide делит число x на число y с помощью оператора /. Результат деления сохраняется в переменной result и возвращается с помощью команды return. Блок finally включает инструкцию print, чтобы сообщить о завершении деления.

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

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

def countdown(n):
    while n > 0:
        yield n
        n -= 1
    return "Countdown is finished"


for number in countdown(5):
    print(number)


# Output:
# 5
# 4
# 3
# 2
# 1


countdown_generator = countdown(3)
for number in countdown_generator:
    print(number)


try:
    print(next(countdown_generator))
except StopIteration as e:
    print(e)


# Output:
# 3
# 2
# 1
# Countdown is finished

В этом примере генераторная функция countdown принимает значение n и возвращает числа от n до 1 с помощью команды yield. Когда n становится равным 0, функция использует команду return, чтобы завершить итерацию и вернуть строку “Countdown is finished”. В цикле for мы можем использовать генератор для печати чисел от 5 до 1. Когда итерация генератора заканчивается, возникает исключение StopIteration, в котором есть информация о причине завершения итерации.

Заключение

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