Возврат значений из функции. Оператор 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
 
sCyl, fCyl = cylinder()
print("Площадь боковой поверхности %.2f" % sCyl)
print("Полная площадь %.2f" % fCyl)

Из функции cylinder() возвращаются два значения. Первое из них присваивается переменной sCyl, второе – fCyl. Возможность такого группового присвоения – особенность 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-версии и android-приложении курса


Оператор 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

Чтобы получить значение из функции на любом языке программирования, мы используем оператор 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: пошаговое руководство

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

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

Найдите подходящий учебный лагерь

  • Career Karma подберет для вас лучшие технологические учебные курсы
  • Доступ к эксклюзивным стипендиям и подготовительным курсам

Выберите интересующий вас вопрос
Разработка программного обеспеченияДизайнОбработка данныхАналитика данныхПродажиUX-дизайнКибербезопасностьЦифровой маркетингИмя

Фамилия

Электронная почта

Номер телефона

Продолжая, вы соглашаетесь с нашими Условиями обслуживания и Политикой конфиденциальности, а также соглашаетесь получать предложения и возможности от Career Karma по телефону, тексту сообщение и электронная почта.

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

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

Обновление функций Python

Python включает ряд встроенных функций, таких как print() , str() и len() , которые выполняют определенные задачи.

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

Вот синтаксис объявления функции в Python:

 def example_function():
  yourcodehere

Python Return

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

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

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

Вот синтаксис ключевого слова return:

 def example_function():
return "Example"

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

Оператор return возвращает значение остальной части программы, но его также можно использовать отдельно. Если после оператора return не определено выражение, Нет Возвращается . Вот пример этого в действии:

 def example_function():
возвращаться
example_function()

Наш код возвращает: Нет .

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

Возврат Python: пример

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

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

 сэндвич = "Ветчина и сыр"
def calculate_price (продукт):
if product == "Ветчина и сыр":
возврат 2.50
elif product == "Тунец и огурец":
возврат 2,25
elif product == "Яичный майонез":
возврат 2,25
elif product == "Куриный клуб":
возврат 2,75
еще:
возврат 2.50
calculate_price(бутерброд)

Давайте запустим нашу программу и посмотрим, что произойдет:

В первой строке кода мы объявляем название бутерброда, цену которого хотим узнать. В этом случае наша переменная Python сэндвич хранит значение Ham and Cheese .

Затем мы объявляем функцию с именем calculate_price() , которая принимает один параметр: название бутерброда, который клиент хотел бы купить. Мы использовали операторы Python if, чтобы сверить название продукта с нашим списком бутербродов. Когда название продукта найдено, наша программа возвращает цену, которую она определила.

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

  • «Ветчина и сыр»: 2,50
  • «Куриный клуб»: 2,75
  • Еще один бутерброд: 2,50

В последней строке мы вызываем наш метод calculate_price() и передайте переменную сэндвича в качестве аргумента. Когда вызывается наш метод calculate_price() , наша программа выполняет этот метод и возвращает цену сэндвича, которую мы указали.

В этом случае сэндвич, который заказал наш клиент, равен Ветчина и сыр , поэтому наша программа возвращает 2,50.

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

Возврат в Python: еще один пример

Давайте рассмотрим еще один пример оператора return , чтобы проиллюстрировать, как он работает. Скажем, мы создаем программу, которая вычисляет сдачу, которую причитается покупателю. Мы могли бы выполнить эту задачу, используя следующий код:

 цена = 2,50
def calculate_change (сумма_дано):
сумма возврата_данная - цена
calculate_change(4.00)

Наш код возвращает:

Мы объявили функцию с именем calculate_change , которая вычитает цену бутерброда из суммы, указанной покупателем. В этом случае цена бутерброда составляет 2,50 доллара, а пользователь дал официантке 4 доллара. Итак, наша программа возвращает 1,50 доллара.

«Карма карьеры вошла в мою жизнь, когда я больше всего в ней нуждалась, и быстро помогла мне попасть на буткемп. Через два месяца после выпуска я нашла работу своей мечты, которая соответствовала моим ценностям и целям в жизни!»

Венера, инженер-программист Rockbot

Заключение

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

No related posts.