Каково простое базовое объяснение того, что такое оператор return, как его использовать в Python?

И в чем разница между ним и printзаявлением?

В print()функции записи, то есть, «печатает», строка в консоли. returnУтверждение вызывает вашу функцию выхода и рука значение для вызывающего. Смысл функций в целом - принимать входные данные и что-то возвращать. Оператор returnиспользуется, когда функция готова вернуть значение вызывающей стороне.

Например, вот функция, использующая print()и return:

def foo():
    print("hello from inside of foo")
    return 1

Теперь вы можете запустить код, вызывающий foo, например:

if __name__ == '__main__':
    print("going to call foo")
    x = foo()
    print("called foo")
    print("foo returned " + str(x))

Если вы запустите это как сценарий (например, .pyфайл), а не в интерпретаторе Python, вы получите следующий результат:

going to call foo
hello from inside foo
called foo   
foo returned 1

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

Вот еще один пример интерпретатора, демонстрирующий это:

>>> def foo():
...     print("hello from within foo")
...     return 1
...
>>> foo()
hello from within foo
1
>>> def bar():
...   return 10 * foo()
...
>>> bar()
hello from within foo
10

Вы можете видеть, что когда foo()вызывается из bar(), 1 не записывается в консоль. Вместо этого он используется для вычисления возвращаемого значения bar().

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

Я думаю, что словарь - ваш лучший справочник здесь

Возврат и печать

Короче говоря:

return возвращает что-то или отвечает вызывающему функцию, в то время как print производит текст

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

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

Вот определение функции из Википедии

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

Подумайте об этом на секунду. Что это значит, когда вы говорите, что функция имеет значение?

Это означает, что вы действительно можете заменить значение функции нормальным значением! (Предполагая, что два значения относятся к одному типу значений)

Зачем вам это нужно, спросите вы?

А как насчет других функций, которые могут принимать значения того же типа в качестве входных ?

def square(n):
    return n * n

def add_one(n):
    return n + 1

print square(12)

# square(12) is the same as writing 144

print add_one(square(12))
print add_one(144)
#These both have the same output

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

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

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

Просто помните, что когда вы используете return, вы в основном говорите: «Вызов этой функции аналогичен записи возвращаемого значения».

Python фактически вставит для вас возвращаемое значение, если вы откажетесь вводить собственное, оно называется «None», и это особый тип, который просто ничего не означает, или null.

В python мы начинаем определение функции с «def» и обычно, но не обязательно, заканчиваем функцию с «return».

Функция переменной x обозначается как f (x). Что делает эта функция? Предположим, эта функция прибавляет 2 к x. Итак, f (x) = x + 2

Теперь код этой функции будет:

def A_function (x):
    return x + 2

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

print A_function (2)
>>> 4

Мы могли бы просто написать код немного иначе, например:

def A_function (x):
    y = x + 2
    return y
print A_function (2)

Это также даст «4».

Теперь мы даже можем использовать этот код:

def A_function (x):
    x = x + 2
    return x
print A_function (2)

Это также даст 4. Видите, что «x» рядом с return на самом деле означает (x + 2), а не x из «A_function (x)».

Думаю, из этого простого примера вы поймете значение команды возврата.

return означает «вывести это значение из этой функции».

print означает "отправить это значение (обычно) на стандартный вывод"

В Python REPL возврат функции будет выводиться на экран по умолчанию (это не совсем то же самое, что print).

Это пример печати:

>>> n = "foo\nbar" #just assigning a variable. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>

Это пример возврата:

>>> def getN():
...    return "foo\nbar"
...
>>> getN() #When this isn't assigned to something, it is just output
'foo\nbar'
>>> n = getN() # assigning a variable to the return value. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>

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

В строке № 4:

def ret(n):
    if n > 9:
         temp = "two digits"
         return temp     #Line 4        
    else:
         temp = "one digit"
         return temp     #Line 8
    print("return statement")
ret(10)

После выполнения условного оператора ret()функция завершается из-за return temp(строка 4). Таким образом print("return statement"), не выполняется.

Выход:

two digits   

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

Возврат значений
В строках 4 и 8 оператор return используется для возврата значения временной переменной после выполнения условия.

Чтобы выявить разницу между печатью и возвратом :

def ret(n):
    if n > 9:
        print("two digits")
        return "two digits"           
    else :
        print("one digit")
        return "one digit"        
ret(25)

Выход:

two digits
'two digits'

Просто добавьте к отличному ответу @Nathan Hughes:

returnЗаявление может быть использовано в качестве своего рода потока управления. Поместив один (или несколько) returnоператоров в середину функции, мы можем сказать: «Прекратите выполнение этой функции. Мы либо получили то, что хотели, либо что-то пошло не так!»

Вот пример:

>>> def make_3_characters_long(some_string):
...     if len(some_string) == 3:
...         return False
...     if str(some_string) != some_string:
...         return "Not a string!"
...     if len(some_string) < 3:
...         return ''.join(some_string,'x')[:,3]
...     return some_string[:,3]
... 
>>> threechars = make_3_characters_long('xyz')    
>>> if threechars:
...     print threechars
... else:
...     print "threechars is already 3 characters long!"
... 
threechars is already 3 characters long!

Дополнительные советы по этому способу использования см . В разделе « Стиль кода» Руководства по Python return.

Разницу между «возвратом» и «печатью» можно также найти в следующем примере:

ВОЗВРАЩЕНИЕ:

def bigger(a, b):
    if a > b:
        return a
    elif a <b:
        return b
    else:
        return a

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

РАСПЕЧАТАТЬ:

def bigger(a, b):
    if a > b:
        print a
    elif a <b:
        print b
    else:
        print a

ПРИМЕЧАНИЕ. Во многих тестовых случаях это не сработает.

ОШИБКА:

----  

FAILURE: Test case input: 3, 8.

            Expected result: 8  

FAILURE: Test case input: 4, 3.

            Expected result: 4  

FAILURE: Test case input: 3, 3.

            Expected result: 3  

You passed 0 out of 3 test cases

Думаю, здесь может быть полезен действительно простой ответ:

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

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

(Полностью признаю, что более подробные ответы более точны.)

Вот мое понимание. (надеюсь, это кому-то поможет и это правильно).

def count_number_of(x):
    count = 0
    for item in x:
        if item == "what_you_look_for":
        count = count + 1
    return count

Итак, этот простой фрагмент кода подсчитывает количество вхождений чего-либо. Размещение доходности является значительным. Он сообщает вашей программе, где вам нужно значение. Поэтому, когда вы печатаете, вы отправляете вывод на экран. Когда вы вернетесь, вы скажете, чтобы ценность куда-то ушла. В этом случае вы можете видеть, что count = 0 имеет отступ с return - мы хотим, чтобы значение (count + 1) заменяло 0. Если вы попытаетесь следовать логике кода, когда вы делаете отступ для команды return, на выходе всегда будет 1 , потому что мы никогда не скажем, что начальный счет изменится. Надеюсь, я правильно понял. Да, и return всегда находится внутри функции.

returnявляется частью определения функции, а printвыводит текст на стандартный вывод (обычно в консоль).

Функция - это процедура, принимающая параметры и возвращающая значение. returnдля последнего, в то время как с первым покончено def.

Пример:

def timestwo(x):
    return x*2

Лучшее в returnфункции - это то, что вы можете возвращать значение из функции, но вы можете делать то же самое, printтак в чем разница? По сути, это returnне просто возврат, он дает вывод в объектной форме, чтобы мы могли сохранить это возвращаемое значение из функции в любую переменную, но мы не можем этого сделать, printпотому что это то же самое, что и stdout/coutв C Programming.

Следуйте приведенному ниже коду для лучшего понимания

КОД

def add(a, b):
    print "ADDING %d + %d" % (a, b)
    return a + b

def subtract(a, b):
    print "SUBTRACTING %d - %d" % (a, b)
    return a - b

def multiply(a, b):
    print "MULTIPLYING %d * %d" % (a, b)
    return a * b

def divide(a, b):
    print "DIVIDING %d / %d" % (a, b)
    return a / b


print "Let's do some math with just functions!"

age = add(30, 5)
height = subtract(78, 4)
weight = multiply(90, 2)
iq = divide(100, 2)

print "Age: %d, Height: %d, Weight: %d, IQ: %d" % (age, height, weight, iq)


# A puzzle for the extra credit, type it in anyway.
print "Here is a puzzle."

what = add(age, subtract(height, multiply(weight, divide(iq, 2))))

print "That becomes: ", what, "Can you do it by hand?"

Теперь мы выполняем собственные математические функции для add, subtract, multiply,и divide. Важно отметить последнюю строку, в которой мы говорим return a + b(in add). Это делает следующее:

1. Наша функция вызывается с двумя аргументами: aи b.
2. Мы распечатываем, что делает наша функция, в данном случае «ДОБАВЛЕНИЕ».
3. Затем мы говорим Python сделать что-то вроде обратного: мы возвращаем добавление a + b. Вы можете сказать это так: «Я добавляю, aа bзатем возвращаю их».
4. Python складывает два числа. Затем, когда функция завершится, любая строка, которая ее запускает, сможет присвоить этот a + bрезультат переменной.

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

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

Следующий код показывает, как использовать returnи printправильно:

def fact(x):
    if x < 2:
        return 1
    return x * fact(x - 1)

print(fact(5))

Это объяснение верно для всех языков программирования, а не только для Python .