Python return

Até aqui, as funções da Ana mostravam coisas na tela com print. Mas muitas vezes você não quer ver o resultado: quer usá-lo. Somar o total de duas notas, guardar o preço com desconto numa variável, comparar a média com 7. Para isso, a função precisa devolver o resultado para quem a chamou. É o trabalho do return (em inglês, "devolver", "retornar").

A ideia: falar a resposta × entregar a resposta

A Ana pede ao sobrinho: "faz a conta de quanto deu o pão e o leite". Ele pode responder de dois jeitos:

• Falar em voz alta: "Deu treze e cinquenta!". A Ana ouve, mas a resposta sumiu no ar. Se ela quiser somar o valor com a conta do gás, vai ter de pedir de novo.
• Escrever num papel e entregar na mão dela: agora a Ana tem o número. Pode guardá-lo, somá-lo com outro, comparar, anotar no caderno.

O print é falar em voz alta: mostra na tela, para uma pessoa ler, e acabou. O return é entregar o papel: o valor volta para o programa, no lugar onde a função foi chamada, e o programa faz com ele o que quiser.

1. A primeira função com return

def dobro(numero):
    return numero * 2


resultado = dobro(5)
print(resultado)

$ python3 dobro.py
10

return

"Devolva". A palavra-chave que termina a função e manda um valor de volta.

numero * 2

O valor devolvido. O Python faz a conta primeiro e devolve o resultado.

resultado = dobro(5)

A chamada dobro(5) vira o valor devolvido, 10. É como se a linha fosse resultado = 10.

print(resultado)

Quem mostra na tela é o programa principal, aqui fora, porque ele quis.

A frase mais importante desta aula: a chamada de uma função vira o valor que ela devolve. Por isso dá para usar a chamada em qualquer lugar onde caberia um valor:

def dobro(numero):
    return numero * 2


print(dobro(5) + 1)
print(dobro(dobro(3)))
print(f"O dobro de 7 é {dobro(7)}.")
if dobro(4) > 6:
    print("Passou de 6")

$ python3 usar_valor.py
11
12
O dobro de 7 é 14.
Passou de 6

• dobro(5) + 1: a chamada vira 10, e 10 + 1 dá 11.
• dobro(dobro(3)): primeiro a de dentro, dobro(3), vira 6; depois dobro(6) vira 12.
• Numa f-string e num if, a chamada também vira o valor: 14, e 8 > 6.

2. print × return: a confusão número 1

As duas funções abaixo parecem fazer a mesma coisa. Não fazem:

def soma_com_print(a, b):
    print(a + b)


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


x = soma_com_print(2, 3)
y = soma_com_return(2, 3)
print("x vale", x)
print("y vale", y)

$ python3 print_x_return.py
5                                                  « o print de dentro da soma_com_print
x vale None
y vale 5

1. x = soma_com_print(2, 3): a função mostrou 5 na tela, mas não devolveu nada. Então x recebeu None, o "nada" do Python (aula O Valor None).
2. y = soma_com_return(2, 3): a função não mostrou nada, mas devolveu 5. y guardou o 5.

Por que o modo interativo confunde

No modo interativo (>>>, aula O Modo Interativo), as duas funções parecem iguais:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def soma_com_print(a, b):
...     print(a + b)
...
>>> def soma_com_return(a, b):
...     return a + b
...
>>> soma_com_print(2, 3)
5
>>> soma_com_return(2, 3)
5                                                  « quem mostrou foi o >>>, não a função
>>> x = soma_com_print(2, 3)
5
>>> x                                              « x é None: o >>> não mostra nada
>>> print(x)
None
>>> exit()

O >>> mostra sozinho o valor de cada coisa que você digita, então o 5 devolvido pelo return aparece na tela. Já num arquivo .py, ninguém mostra nada por você:

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


soma_com_return(2, 3)

$ python3 so_chamar.py
$                                                  « nenhuma saída: o 5 foi devolvido e jogado fora

A função calculou 5 e devolveu, mas ninguém guardou nem mostrou o valor. Ele foi descartado. Num programa, use o valor devolvido: guarde numa variável, ou passe para o print.

def area(largura, altura):
    print(largura * altura)


total = area(3, 4) + area(2, 5)
print(f"Área total: {total} m²")

def area(largura, altura):
    return largura * altura


total = area(3, 4) + area(2, 5)
print(f"Área total: {total} m²")

3. Sem return, a função devolve None

Toda função devolve alguma coisa. Quando o corpo acaba sem passar por um return, o Python devolve None sozinho. As funções das aulas anteriores, que só tinham print, devolviam None o tempo todo, e ninguém percebia:

def saudar(nome):
    print(f"Bom dia, {nome}!")


resposta = saudar("Ana")
print(resposta)
print(type(resposta))

$ python3 none.py
Bom dia, Ana!
None
<class 'NoneType'>

Isso é normal e está certo para funções cujo trabalho é fazer algo (mostrar uma mensagem, gravar um arquivo), e não calcular algo. O problema é quando você esperava um valor e esqueceu o return; veja em Quando dá errado.

4. O return encerra a função

Quando o Python executa um return, a função acaba naquele momento. O que vier depois, dentro dela, não roda:

def dobro(numero):
    return numero * 2
    print("Esta linha nunca aparece")


print(dobro(5))

$ python3 depois_return.py
10

Vários return com if

Isso é útil com o if: cada caminho devolve uma resposta diferente.

def situacao(nota):
    if nota >= 7:
        return "Aprovada"
    return "Recuperação"


print(situacao(8.5))
print(situacao(6))

$ python3 situacao.py
Aprovada
Recuperação

Com nota 8.5, a condição é verdadeira: o primeiro return devolve "Aprovada" e a função acaba ali, sem chegar ao segundo. Com nota 6, a condição é falsa, o Python pula o bloco do if e encontra o segundo return. Repare que nem foi preciso um else: se chegou à última linha, é porque o if não devolveu nada antes.

return sozinho: "pode parar"

Um return sem valor também encerra a função, e devolve None. Serve para sair mais cedo:

def avisar_estoque(quantidade):
    if quantidade > 0:
        return
    print("Atenção: acabou o estoque!")


avisar_estoque(5)
avisar_estoque(0)
print(avisar_estoque(5))

$ python3 return_vazio.py
Atenção: acabou o estoque!
None

Com 5 unidades, a função sai no return e não avisa nada. Com 0, ela segue até o aviso. E o print da última linha mostra o que o return sozinho devolveu: None.

5. Devolvendo vários valores

Às vezes a função calcula mais de uma coisa. Escreva os valores separados por vírgula depois do return:

def resumo(notas):
    total = sum(notas)
    media = total / len(notas)
    return total, media


soma, media = resumo([8, 9, 7, 10])
print(f"Soma: {soma}")
print(f"Média: {media}")
print(resumo([8, 9, 7, 10]))

$ python3 varios.py
Soma: 34
Média: 8.5
(34, 8.5)

sum(notas) e len(notas)

A soma dos itens da lista e a quantidade de itens (aula Funções Embutidas).

return total, media

Devolve os dois valores juntos, num pacote só.

soma, media = resumo(…)

Abre o pacote: o primeiro valor vai para soma, o segundo para media, como na aula Atribuição Múltipla.

(34, 8.5)

Sem abrir o pacote, você vê o que ele é: uma tupla, uma sequência entre parênteses (aula Tuplas). Na verdade, o return sempre devolve um valor só; com a vírgula, esse valor é uma tupla com dois itens.

Formas diferentes de entregar o resultado

A mesma conta, a média de duas notas, pode ser entregue de três jeitos:

# 1. A função mostra
def media_mostrar(a, b):
    print((a + b) / 2)


# 2. A função devolve, e quem chamou mostra
def media(a, b):
    return (a + b) / 2


# 3. A função devolve um texto pronto
def media_texto(a, b):
    return f"Média: {(a + b) / 2}"


media_mostrar(8, 9)
print(media(8, 9))
print(media_texto(8, 9))

$ python3 formas.py
8.5
8.5
Média: 8.5

Quando dá errado

def soma_com_print(a, b):
    print(a + b)


total = soma_com_print(2, 3) + 1
print(total)

$ python3 print_conta.py
5
Traceback (most recent call last):
  File "/home/ana/print_conta.py", line 5, in <module>
    total = soma_com_print(2, 3) + 1
            ~~~~~~~~~~~~~~~~~~~~~^~~
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

def media(nota1, nota2):
    resultado = (nota1 + nota2) / 2


m = media(8, 9)
print(f"Média: {m}")

$ python3 esqueceu.py
Média: None

def somar(numeros):
    total = 0
    for n in numeros:
        total = total + n
        return total


print(somar([5, 10, 20]))

$ python3 return_no_for.py
5

preco = 10
return preco * 2

$ python3 fora_funcao.py
  File "/home/ana/fora_funcao.py", line 2
    return preco * 2
    ^^^^^^^^^^^^^^^^
SyntaxError: 'return' outside function

def resumo(notas):
    total = sum(notas)
    media = total / len(notas)
    return total, media


soma, media, maior = resumo([8, 9, 7, 10])

$ python3 desempacotar.py
Traceback (most recent call last):
  File "/home/ana/desempacotar.py", line 7, in <module>
    soma, media, maior = resumo([8, 9, 7, 10])
    ^^^^^^^^^^^^^^^^^^
ValueError: not enough values to unpack (expected 3, got 2)

Referência rápida

Exercícios

Missão final: o desconto da padaria

def com_desconto(preco, porcentagem):
    pass  # troque o pass pela conta, com return


bolo = com_desconto(40, 10)
torta = com_desconto(60, 25)
print(f"Bolo: R$ {bolo:.2f}")
print(f"Torta: R$ {torta:.2f}")
print(f"Os dois: R$ {bolo + torta:.2f}")

def com_desconto(preco, porcentagem):
    return preco - preco * porcentagem / 100


bolo = com_desconto(40, 10)
torta = com_desconto(60, 25)
print(f"Bolo: R$ {bolo:.2f}")
print(f"Torta: R$ {torta:.2f}")
print(f"Os dois: R$ {bolo + torta:.2f}")

Rode o código inicial antes de mexer: com o pass, a função devolve None, e o Python reclama TypeError: unsupported format string passed to NoneType.__format__ ("formatação não suportada para NoneType"): o :.2f não sabe mostrar None com 2 casas. De novo o NoneType denunciando um return que falta.

Resumo

• return valor encerra a função e devolve o valor; a chamada vira esse valor e pode ser guardada, somada, comparada.
• print mostra para a pessoa; return entrega para o programa. Função que calcula, devolve.
• O >>> mostra sozinho o valor devolvido; num arquivo, ninguém mostra: use print(f()) ou guarde numa variável.
• Sem return, a função devolve None. NoneType num erro quase sempre é um return esquecido.
• Depois do return, nada mais roda na função. Vários return com if dão uma resposta por caminho.
• return a, b devolve vários valores (uma tupla), que você abre com x, y = f().