Qual é a explicação básica simples do que é a instrução return, como usá-la em Python?

E qual é a diferença entre isso e a printdeclaração?

A print()função escreve, ou seja, "imprime", uma string no console. A returninstrução faz com que sua função saia e devolva um valor ao chamador. O objetivo das funções em geral é receber entradas e retornar algo. A returninstrução é usada quando uma função está pronta para retornar um valor a seu chamador.

Por exemplo, aqui está uma função que utiliza print()e return:

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

Agora você pode executar o código que chama foo, assim:

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

Se você executar isso como um script (por exemplo, um .pyarquivo) em vez de no interpretador Python, você obterá a seguinte saída:

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

Espero que isso torne isso mais claro. O interpretador grava valores de retorno no console para que eu possa ver por que alguém está confuso.

Aqui está outro exemplo do intérprete que demonstra que:

>>> 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

Você pode ver que, quando foo()é chamado de bar(), 1 não é gravado no console. Em vez disso, é usado para calcular o valor retornado bar().

print()é uma função que causa um efeito colateral (ela escreve uma string no console), mas a execução continua com a próxima instrução. returnfaz com que a função pare de ser executada e devolva um valor a quem a chamou.

Acho que o dicionário é a sua melhor referência aqui

Devolver e imprimir

Em resumo:

return devolve algo ou responde ao chamador da função enquanto print produz texto

Pense na instrução de impressão como causando um efeito colateral , ela faz sua função escrever algum texto para o usuário, mas não pode ser usado por outra função.

Tentarei explicar isso melhor com alguns exemplos e algumas definições da Wikipedia.

Aqui está a definição de uma função da Wikipedia

Uma função, em matemática, associa uma quantidade, o argumento da função, também conhecida como a entrada, com outra quantidade, o valor da função, também conhecida como a saída.

Pense nisso por um segundo. O que significa quando você diz que a função tem um valor?

O que isso significa é que você pode substituir o valor de uma função por um valor normal! (Supondo que os dois valores sejam o mesmo tipo de valor)

Por que você quer que você pergunte?

E quanto a outras funções que podem aceitar o mesmo tipo de valor como entrada ?

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

Existe um termo matemático sofisticado para funções que dependem apenas de suas entradas para produzir suas saídas: Transparência referencial. Novamente, uma definição da Wikipedia.

Transparência referencial e opacidade referencial são propriedades de partes de programas de computador. Diz-se que uma expressão é referencialmente transparente se puder ser substituída pelo seu valor sem alterar o comportamento de um programa

Pode ser um pouco difícil entender o que isso significa se você for novo em programação, mas acho que você vai entender depois de alguma experimentação. Em geral, porém, você pode fazer coisas como imprimir em uma função e também pode ter uma instrução de retorno no final.

Apenas lembre-se de que quando você usa return, está basicamente dizendo "Uma chamada para esta função é o mesmo que escrever o valor que é retornado"

O Python irá, na verdade, inserir um valor de retorno para você se você recusar colocar o seu próprio, é chamado de "Nenhum" e é um tipo especial que simplesmente não significa nada ou nulo.

Em python, começamos a definir uma função com "def" e geralmente, mas não necessariamente, terminamos a função com "return".

Uma função da variável x é denotada como f (x). O que essa função faz? Suponha que esta função some 2 a x. Então, f (x) = x + 2

Agora, o código desta função será:

def A_function (x):
    return x + 2

Depois de definir a função, você pode usá-la para qualquer variável e obter o resultado. Tal como:

print A_function (2)
>>> 4

Poderíamos apenas escrever o código de maneira um pouco diferente, como:

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

Isso também resultaria em "4".

Agora, podemos até usar este código:

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

Isso também resultaria em 4. Veja, que o "x" ao lado de return na verdade significa (x + 2), não x de "função A (x)".

Eu acho que a partir deste exemplo simples, você entenderia o significado do comando de retorno.

Essa resposta abrange alguns dos casos que não foram discutidos acima.
A instrução de retorno permite que você termine a execução de uma função antes de chegar ao fim. Isso faz com que o fluxo de execução retorne imediatamente ao chamador.

Na linha número 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)

Depois que a instrução condicional é executada, a ret()função é encerrada devido a return temp(linha 4). Portanto, o print("return statement")não é executado.

Resultado:

two digits   

Este código que aparece após as instruções condicionais, ou o lugar que o fluxo de controle não pode alcançar, é o código morto .

Retornando valores
Nas linhas 4 e 8, a instrução return está sendo usada para retornar o valor de uma variável temporária após a condição ter sido executada.

Para destacar a diferença entre imprimir e devolver :

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

Resultado:

two digits
'two digits'

return significa, "emitir este valor a partir desta função".

print significa "enviar este valor para (geralmente) stdout"

No REPL do Python, um retorno de função será exibido na tela por padrão (não é exatamente o mesmo que imprimir).

Este é um exemplo de impressão:

>>> 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
>>>

Este é um exemplo de retorno:

>>> 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
>>>

Só para acrescentar à excelente resposta de @Nathan Hughes:

A returninstrução pode ser usada como uma espécie de fluxo de controle. Ao colocar uma (ou mais) returninstruções no meio de uma função, podemos dizer: "pare de executar esta função. Ou conseguimos o que queríamos ou algo deu errado!"

Aqui está um exemplo:

>>> 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!

Consulte a seção Estilo de código do Guia Python para obter mais conselhos sobre essa forma de uso return.

A diferença entre "return" e "print" também pode ser encontrada no seguinte exemplo:

RETORNA:

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

O código acima fornecerá resultados corretos para todas as entradas.

IMPRESSÃO:

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

NOTA: Isso falhará em muitos casos de teste.

ERRO:

----  

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

Aqui está o meu entendimento. (espero que ajude alguém e esteja correto).

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

Portanto, este código simples conta o número de ocorrências de algo. A colocação de retorno é significativa. Ele informa ao programa onde você precisa do valor. Portanto, ao imprimir, você envia a saída para a tela. Ao retornar você informa o valor para ir a algum lugar. Neste caso, você pode ver que contagem = 0 é indentado com retorno - queremos que o valor (contagem + 1) substitua 0. Se você tentar seguir a lógica do código quando indentar mais o comando de retorno, a saída será sempre 1 , porque nunca diríamos para a contagem inicial mudar. Espero ter acertado. Ah, e o retorno está sempre dentro de uma função.

return faz parte de uma definição de função, enquanto print envia texto para a saída padrão (geralmente o console).

Uma função é um procedimento que aceita parâmetros e retorna um valor. returné para o último, enquanto o primeiro é feito def.

Exemplo:

def timestwo(x):
    return x*2

Acho que uma resposta realmente simples pode ser útil aqui:

returntorna o valor (uma variável, geralmente) disponível para uso pelo chamador (por exemplo, para ser armazenado por uma função que a função usando returnestá dentro). Sem return, seu valor ou variável não estaria disponível para o chamador armazenar / reutilizar.

print imprime na tela, mas não disponibiliza o valor ou a variável para uso do chamador.

(Admitindo totalmente que as respostas mais completas são mais precisas.)

A melhor coisa sobre a returnfunção é que você pode retornar um valor da função, mas você pode fazer o mesmo com, printentão qual é a diferença? Basicamente, returnnão é apenas retornar que dá saída na forma de objeto para que possamos salvar o valor de retorno da função para qualquer variável, mas não podemos fazer com printporque é o mesmo que stdout/coutem C Programming.

Siga o código abaixo para melhor compreensão

CÓDIGO

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?"

Agora estamos fazendo nossas próprias funções matemáticas para add, subtract, multiply,e divide. O importante a notar é a última linha onde dizemos return a + b(in add). O que isso faz é o seguinte:

1. Nossa função é chamada com dois argumentos: ae b.
2. Imprimimos o que nossa função está fazendo, neste caso "ADICIONANDO".
3. Em seguida, dizemos ao Python para fazer algo meio para trás: retornamos a adição de a + b. Você pode dizer isso como, "Eu adiciono ae bdepois os devolvo."
4. Python adiciona os dois números. Então, quando a função terminar, qualquer linha que a execute poderá atribuir esse a + bresultado a uma variável.

returndeve ser usado para funções / métodos recursivos ou você deseja usar o valor retornado para aplicativos posteriores em seu algoritmo.

print deve ser usado quando você deseja exibir uma saída significativa e desejada para o usuário e não quer sobrecarregar a tela com resultados intermediários nos quais o usuário não está interessado, embora sejam úteis para depurar seu código.

O código a seguir mostra como usar returne printcorretamente:

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

print(fact(5))

Esta explicação é verdadeira para todas as linguagens de programação, não apenas para python .