Python return функция: Возврат значений из функции. Оператор return. Урок 13 курса «Python. Введение в программирование»

Возврат значений из функции. Оператор return. Урок 13 курса «Python. Введение в программирование»

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

Если интерпретатор Питона, выполняя тело функции, встречает return, то он «забирает» значение, указанное после этой команды, и «уходит» из функции.

def cylinder():
    r = float(input())
    h = float(input())
    # площадь боковой поверхности цилиндра:
    side = 2 * 3.14 * r * h
    # площадь одного основания цилиндра:
    circle = 3.14 * r**2
    # полная площадь цилиндра:
    full = side + 2 * circle
    return full
 
 
square = cylinder()
print(square)

Пример выполнения:

3
7
188.4

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

Не сама переменная, а ее значение, в данном случае – какое-либо число, полученное в результате вычисления площади цилиндра.

В основной ветке программы это значение присваивается глобальной переменной square. То есть выражение square = cylinder() выполняется так:

1. Вызывается функция cylinder().

2. Из нее возвращается значение.

3. Это значение присваивается переменной square.

Не обязательно присваивать результат переменной, его можно сразу вывести на экран:

...
print(cylinder())

Здесь число, полученное из cylinder(), непосредственно передается функции print(). Если мы в программе просто напишем cylinder(), не присвоив полученные данные переменной или не передав их куда-либо дальше, то эти данные будут потеряны. Но синтаксической ошибки не будет.

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

def cylinder():
    try:
        r = float(input())
        h = float(input())
    except ValueError:
        return
    side = 2 * 3.14 * r * h
    circle = 3.14 * r**2
    full = side + 2 * circle
    return full
print(cylinder())

Если попытаться вместо цифр ввести буквы, то сработает return, вложенный в except. Он завершит выполнение функции, так что все нижеследующие вычисления, в том числе return full, будут опущены. Пример выполнения:

r
None

Но постойте! Что это за слово None, которое нам вернул «пустой»

return? Это ничего, такой объект – «ничто». Он принадлежит классу NoneType. До этого мы знали четыре типа данных, они же четыре класса: int, float, str, bool. Пришло время пятого.

Когда после return ничего не указывается, то по умолчанию считается, что там стоит объект None. При желании мы можете явно писать return None.

Более того. Ранее мы рассматривали функции, которые вроде бы не возвращали никакого значения, потому что в них не было оператора return. На самом деле возвращали, просто мы не обращали на него внимание, не присваивали никакой переменной и не выводили на экран. В Python всякая функция что-либо возвращает. Если в ней нет оператора

return, то она возвращает None. То же самое, как если в ней имеется «пустой» return.

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

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

def cylinder():
    r = float(input())
    h = float(input())
    side = 2 * 3.  14 * r * h
    circle = 3.14 * r ** 2
    full = side + 2 * circle
    return side, full
 
 
s_cyl, f_cyl = cylinder()
print("Площадь боковой поверхности %.2f" % s_cyl)
print("Полная площадь %.2f" % f_cyl)

Из функции cylinder() возвращаются два значения. Первое из них присваивается переменной s_cyl, второе – f_cyl. Возможность такого группового присвоения – особенность Python, обычно не характерная для других языков:

>>> a, b, c = 10, 15, 19
>>> a
10
>>> b
15
>>> c
19

Фокус здесь в том, что перечисление значений через запятую (например, 10, 15, 19) создает объект типа

tuple. На русский переводится как «кортеж». Это разновидность структур данных, которые будут изучены позже.

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

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

Распаковка не является обязательной. Будет работать и так:

…
print(cylinder())

Пример выполнения:

4
3
(75.36, 175.84)

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

Практическая работа

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

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

Примеры решения и дополнительные уроки в pdf-версии курса

Оператор return и возвращение результата из функции

Последнее обновление: 16. 01.2022

Возвращение результата

Функция может возвращать результат. Для этого в функции используется оператор return, после которого указывается возвращаемое значение:

def имя_функции ([параметры]):
    инструкции
    return возвращаемое_значение

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

def get_message():
    return "Hello METANIT.COM"

Здесь после оператора return идет строка "Hello METANIT.COM"

— это значение и будет возвращать функция get_message().

Затем это результат функции можно присвоить переменной или использовать как обычное значение:

def get_message():
    return "Hello METANIT.COM"


message = get_message()  # получаем результат функции get_message в переменную message
print(message)          # Hello METANIT.COM

# можно напрямую передать результат функции get_message
print(get_message())    # Hello METANIT. COM

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

def double(number):
    return 2 * number

Здесь функция double будет возвращать результат выражения 2 * number:

def double(number):
    return 2 * number

result1 = double(4)     # result1 = 8
result2 = double(5)     # result2 = 10
print(f"result1 = {result1}")   # result1 = 8
print(f"result2 = {result2}")   # result2 = 10

Или другой пример — получение суммы чисел:

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


result = sum(4, 6)                  # result = 0
print(f"sum(4, 6) = {result}")      # sum(4, 6) = 10
print(f"sum(3, 5) = {sum(3, 5)}")   # sum(3, 5) = 8

Выход из функции

Оператор return не только возвращает значение, но и производит выход из функции. Поэтому он должен определяться после остальных инструкций. Например:

def get_message():
    return "Hello METANIT.COM"
    print("End of the function")

print(get_message())

С точки зрения синтаксиса данная функция корректна, однако ее инструкция print("End of the function") не имеет смысла — она никогда не выполнится, так как до ее выполнения оператор return возвратит значение и произведет выход из функции.

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

def print_person(name, age):
    if age > 120 or age < 1:
        print("Invalid age")
        return
    print(f"Name: {name}  Age: {age}")


print_person("Tom", 22)
print_person("Bob", -102)

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

Однако если возраст корректен, то выводим информацию о пользователе на консоль. Консольный вывод:

Name: Tom  Age: 22
Invalid age

НазадСодержаниеВперед

Как работает return() в Python? | Flexiple Tutorials

Нанимаете? Flexiple поможет вам создать команду вашей мечты из разработчиков и дизайнеров.

Hire Talent

Чтобы получить значение функции на любом языке программирования, мы используем оператор return(). Аналогично, в Python оператор return() используется для выхода из функции и возврата значения из функции. В этом руководстве мы узнаем о различных способах использования операторов return() в Python.

Содержание

1. Введение в оператор return()
2. Возврат нескольких значений в Python
3. Аргумент в функции return()
4. Функция, возвращающая другую функцию
5. Заключительные мысли

return() в Python

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

• Операторы после оператора return() не выполняются.
Оператор return()
• нельзя использовать вне функции.
• Если инструкция return() не содержит выражения, возвращается значение NONE.

Синтаксис return() в Python:

        определение имя_функции():
        заявления....
        вернуть [выражение]
     

Использование оператора return() для возврата нескольких значений в Python

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

Ввод:

        def statFun(a, b):
        разница = а-б
        процент_diff = (разница/год)*100
        разница возврата, процент_diff;
        разница, процент_diff = statFun()
        печать (разница)
        печать (percent_diff)
     

Здесь функция statFun() возвращает значения, и с помощью кортежа мы возвращаем оба значения.

Вывод:

        8
        20
     

return() в Python с аргументом

В Python аргументы могут использоваться с оператором return. Начнем с того, что аргументы — это параметр, заданный пользователем, и, как мы знаем, аргумент — это значение (я) в качестве входных данных, которые пользователь дает функции.

Ввод:

        определение divNum(a, b):
            если б != 0
                возврат а/б;
        еще:
            вернуть 0;
        распечатать (дивномер (4, 2))
        распечатать (дивномер (2, 0))
     

Здесь функция divNum() принимает два аргумента, и если второй аргумент не равен нулю, она делит их, в противном случае возвращает 0.

Вывод:

        2
        0
     

Функция, возвращающая другую функцию в Python

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

Ввод:

        функция защиты_1(а):
            определение функции_2 (б):
                возврат а-б
            вернуть func_2
        х = функция_1 (100)
        print ("Значение a-b равно", x(50))
        определение other_func(a):
            вернуть * 10
        Функция определения():
            вернуть other_func
        у = функция ()
        print ("\nЗначение a*b равно" y(10))
     

Вывод:

        Значение a-b равно 50
        Значение a*b равно 100.
     

Заключительные мысли

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

Другие руководства

Как добавлять строки в Python?Как проверить, содержит ли список Python элементы?Как инициализировать списки в Python?

Лучшие статьи

Как нанять разработчика для стартапа Шпаргалка по строковым методам JavaScriptCSS Шпаргалка по свойствам позиций

Понравился этот блог?

Работайте с топовыми

стартапами и компаниями. Получайте оплату вовремя. Подать заявку

Попробуйте высококачественный разработчик

в течение 7 дней. Платите, только если удовлетворены. View Talent

Copyright @2023 Flexiple Inc

Заявление о возврате Python — AskPython

Автор Панкадж Кумар / 11 мая 2023 г.

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

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

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

Понимание оператора возврата Python в функциях

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

Синтаксис оператора возврата Python

Синтаксис прост, он состоит из ключевого слова return, за которым следует выражение.

Синтаксис:

возвращаемое выражение
 

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

Пример оператора возврата Python

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

определить добавить (х, у):
    всего = х + у
    общая сумма возврата
 

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

определить добавить (х, у):
    вернуть х + у
 

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

результат = добавить (5, 3)
печать (результат)
 

Вывод:

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

Каждая функция в Python что-то возвращает

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

>>> определение foo():
...     проходить
...
>>>
>>> напечатать (foo())
Никто
>>>
 

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

Оператор возврата Python без какого-либо значения

Если оператор возврата не имеет значения, функция возвращает Нет .

>>> определение return_none():
...     возвращаться
...
>>> печать (return_none())
Никто
>>>
 

Итак, либо вы использовали оператор возврата без значения, либо оператор возврата отсутствует, и функция возвращает None.

Функции Python могут иметь несколько операторов возврата

Функция может иметь несколько возвратов, тот, который удовлетворяет условию, будет выполнен первым, и функция завершит работу.

Пример:

определение type_of_int (i):
    если я % 2 == 0:
        вернуть «даже»
    еще:
        вернуть «нечетный»
результат = type_of_int(7)
печать (результат)
 

Выходные данные:

Функции Python возвращают несколько типов значений

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

Пример:

Давайте рассмотрим пример, в котором функция возвращает число значений, имеющих несколько типов.

защита get_demo_data (object_type):
    если 'str' == object_type:
        вернуть «тест»
    elif 'кортеж' == object_type:
        возврат (1, 2, 3)
    Элиф 'список' == object_type:
        вернуть [1, 2, 3]
    elif 'dict' == object_type:
        вернуть {"1": 1, "2": 2, "3": 3}
    еще:
        возврат Нет
print(get_demo_data('str'))   # Вывод: 'test'
print(get_demo_data('tuple')) # Вывод: (1, 2, 3)
print(get_demo_data('list'))  # Вывод: [1, 2, 3]
print(get_demo_data('dict'))  # Вывод: {"1": 1, "2": 2, "3": 3}
print(get_demo_data('set'))   # Вывод: нет
 

Вывод:

тест
(1, 2, 3)
[1, 2, 3]
{'1': 1, '2': 2, '3': 3}
Никто
 

Возврат нескольких значений из функции в одном операторе return

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

Пример:

защита return_multiple_values():
    вернуть 1, 2, 3
 
 
печать (return_multiple_values ​​())
печать (тип (return_multiple_values ​​()))
 

Вывод:

(1, 2, 3)
<класс 'кортеж'>
 

Оператор возврата Python с блоком finally

Когда оператор return выполняется внутри блока try-except, сначала выполняется код блока finally перед возвратом значения вызывающей стороне.

Пример:

привет ():
    пытаться:
        вернуть 'привет, попробуй'
    окончательно:
        print('наконец заблокировать')
 
 
определение hello_new():
    пытаться:
        поднять TypeError
    кроме TypeError как te:
        вернуть «привет, кроме»
    окончательно:
        print('наконец заблокировать')
 
 
распечатать(привет())
печать (hello_new ())
 

Вывод:

наконец заблокировать
привет попробуй
наконец заблокировать
привет кроме
 

Если в блоке finally есть инструкция return, то предыдущая инструкция return игнорируется и возвращается значение из блока finally.

привет ():
    пытаться:
        вернуть 'привет, попробуй'
    окончательно:
        print('наконец заблокировать')
        вернуть «привет от наконец»
 
 
распечатать(привет())
 

Выход :

наконец заблокировать
привет от наконец
 

Сводка

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

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