Pular para o conteúdo
CodeMDD.io | Coding Tutorials

Como retornar de uma função em Python de forma fácil?

CodeMDD.io

O retorno de uma função em Python: Uso e melhores práticas

A declaração return do Python é um componente chave das funções e métodos. Você pode usar a declaração return para fazer suas funções enviar objetos Python de volta para o código chamador. Esses objetos são conhecidos como o valor de retorno da função. Você pode usá-los para realizar mais cálculos em seus programas.

Usar a declaração return de forma eficaz é uma habilidade fundamental se você deseja codificar funções personalizadas que sejam Pythonicas e robustas.

Neste tutorial, você vai aprender:

  • Como usar a declaração return do Python em suas funções
  • Como retornar um único ou múltiplos valores em suas funções
  • Quais melhores práticas observar ao usar declarações return

Com esse conhecimento, você será capaz de escrever funções mais legíveis, mantidas e concisas em Python. Se você é completamente inexperiente em funções Python, pode conferir o guia Definindo sua própria função Python antes de mergulhar neste tutorial.

Começando com Funções Python

A maioria das linguagens de programação permite que você atribua um nome a um bloco de código que executa um cálculo específico. Esses blocos de código nomeados podem ser reutilizados rapidamente porque você pode usar seu nome para chamá-los de diferentes partes do seu código.

Programadores chamam esses blocos de código nomeados de sub-rotinas, rotinas, procedimentos ou funções, dependendo da linguagem. Python usa o termo funções.

Aqui está um exemplo simples de uma função Python que soma dois números:

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

Neste exemplo, estamos criando uma função chamada soma que recebe dois argumentos a e b. A função retorna a soma desses dois argumentos.

Para chamar a função e obter o valor de retorno, podemos fazer o seguinte:

resultado = soma(5, 3)
print(resultado)  # Output: 8

Neste caso, estamos chamando a função soma com os argumentos 5 e 3 e armazenando o valor de retorno na variável resultado. Em seguida, imprimimos esse valor na tela, que é 8.

Entendendo a declaração return do Python

A declaração return do Python é usada para indicar o valor que a função deve retornar quando é chamada. Uma função pode conter uma ou mais declarações return, mas apenas uma será executada em cada chamada da função.

Existem dois tipos de declarações return no Python: explicitas e implícitas.

Declarações return explícitas

As declarações return explícitas são usadas para retornar um valor específico da função. Você pode ter várias declarações return em uma função, mas apenas uma delas será executada em cada chamada.

Aqui está um exemplo de uma função que retorna a soma de dois números:

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

Neste exemplo, a declaração return retorna a soma de a e b. Quando a função é chamada com os argumentos 5 e 3, a soma é calculada e o valor 8 é retornado.

Declarações return implícitas

As declarações return implícitas são usadas para retornar um valor sem usar explicitamente a palavra-chave return. Em vez disso, o valor é retornado quando a função termina de executar.

Aqui está um exemplo de uma função que retorna o resultado de uma multiplicação implícita:

def multiplicacao(a, b):
    a * b  # No return statement used

Neste exemplo, a função multiplicacao calcula o produto de a e b usando o operador *. Como não há uma declaração return explícita, o resultado é retornado implicitamente quando a função termina de executar.

No entanto, observe que, neste caso, o valor de retorno não será visível fora da função. Se você tentar atribuir o resultado da função a uma variável, você receberá None. Portanto, é importante usar uma declaração return explícita sempre que você quiser retornar um valor específico da função.

resultado = multiplicacao(5, 3)
print(resultado)  # Output: None

Neste caso, o valor de resultado é None, porque a função multiplicacao não retorna explicitamente o resultado da multiplicação.

Retornando vs Imprimindo

É importante distinguir entre retornar um valor de uma função e imprimir um valor. Quando você retorna um valor de uma função, esse valor pode ser usado para realizar mais cálculos no seu programa, atribuído a uma variável ou passado como argumento para outra função.

Quando você imprime um valor, ele é simplesmente exibido na tela para que você possa ver. A impressão não permite que você use o valor para realizar cálculos adicionais ou manipulá-lo de outra forma em seu programa.

Vamos considerar um exemplo em que temos uma função que retorna a soma de dois números e também imprime o resultado:

def soma_e_imprime(a, b):
    resultado = a + b
    print(resultado)
    return resultado

Neste exemplo, a função soma_e_imprime calcula a soma de a e b e atribui o resultado à variável resultado. Em seguida, ela imprime o resultado na tela usando a função print(). Por fim, a função retorna o valor de resultado.

Agora, vamos considerar como usar essa função em nosso programa:

x = 5
y = 3


resultado = soma_e_imprime(x, y)
print(resultado)  # Output: 8

Neste exemplo, estamos chamando a função soma_e_imprime com os argumentos x e y e atribuindo o valor de retorno à variável resultado. Em seguida, imprimimos o valor de resultado na tela, que é 8.

Observe que a função não retornou diretamente o valor impresso na tela. O valor retornado foi a soma dos dois números, que foi atribuída à variável resultado.

Portanto, é importante entender a diferença entre retornar um valor e imprimir um valor, pois isso pode afetar a maneira como você usa o resultado em seu programa.

Retornando Múltiplos Valores

Em Python, você pode retornar não apenas um único valor de uma função, mas também vários valores em um único retorno. Isso é conhecido como retorno de múltiplos valores.

Para retornar múltiplos valores de uma função, você pode usar uma estrutura de dados, como uma lista, tupla ou dicionário, para agrupar os valores e retorná-los juntos.

Aqui está um exemplo de uma função que retorna o quociente e o resto de uma divisão:

def divisao(a, b):
    quociente = a https://codemdd.io/ b
    resto = a % b
    return quociente, resto

Neste exemplo, a função divisao calcula o quociente da divisão de a por b usando o operador https://codemdd.io/ e o resto da divisão usando o operador %. Em seguida, ela retorna os valores de quociente e resto em um único retorno.

Para receber os valores retornados da função, você pode usar a atribuição múltipla para desempacotar os valores em variáveis separadas:

resultado_quociente, resultado_resto = divisao(9, 4)
print(resultado_quociente)  # Output: 2
print(resultado_resto)  # Output: 1

Neste caso, estamos chamando a função divisao com os argumentos 9 e 4 e atribuindo os valores de retorno às variáveis resultado_quociente e resultado_resto. Em seguida, imprimimos esses valores na tela.

Observe que os valores retornados da função são empacotados em uma tupla e desempacotados na atribuição múltipla. Isso nos permite acessar cada valor individualmente usando as variáveis correspondentes.

Retornar múltiplos valores de uma função pode ser útil em várias situações, quando você deseja retornar mais de uma informação derivada de um cálculo.

Usando a declaração return do Python: Melhores práticas

Ao usar a declaração return em suas funções Python, existem algumas melhores práticas que você pode seguir para tornar seu código mais legível, organizado e eficiente.

Aqui estão algumas das melhores práticas ao usar a declaração return:

Retornando None de forma explícita

None é um valor especial do Python que representa a ausência de valor. Ao usar a declaração return, é uma boa prática retornar None explicitamente quando uma função não tem um valor de retorno significativo.

Aqui está um exemplo de uma função que gera uma saudação personalizada com base em um nome:

def saudacao(nome):
    if nome:
        return f"Olá, {nome}!"
    else:
        return None

Neste exemplo, a função saudacao verifica se o nome é fornecido como argumento. Se um nome for fornecido, a função retorna uma saudação personalizada. Caso contrário, ela retorna None explicitamente para indicar que não há um valor de retorno significativo.

Retornar None explicitamente em vez de não usar a declaração return ajuda a evitar confusões e torna a intenção da função mais clara.

Lembrando do valor de retorno

Quando você chama uma função e obtém o valor de retorno, é importante armazenar esse valor em uma variável se você quiser usá-lo posteriormente em seu programa. Se você não armazenar o valor de retorno, ele será perdido.

Aqui está um exemplo de uma função que retorna a soma de dois números:

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

Neste exemplo, a função soma retorna a soma de a e b. Se chamarmos a função sem armazenar o valor de retorno, o resultado será perdido:

soma(5, 3)  # Output: 8

Neste caso, a função é chamada com os argumentos 5 e 3, e o resultado 8 é retornado. No entanto, como não armazenamos o valor de retorno em uma variável, não podemos usá-lo novamente em nosso programa.

Portanto, é importante lembrar de atribuir o valor de retorno a uma variável se você pretende usá-lo posteriormente.

Evitando expressões complexas

Ao usar a declaração return, é uma boa prática evitar o uso de expressões complexas para calcular o valor de retorno. Em vez disso, você pode armazenar o resultado em uma variável e retornar essa variável.

Aqui está um exemplo de uma função que retorna o resultado de uma expressão complexa:

def calcular():
    return 2 + 3 * 4 - 1 https://codemdd.io/ 2

Neste exemplo, a função calcular retorna o resultado de uma expressão com operações matemáticas. Embora o valor de retorno seja calculado corretamente, a expressão é complexa e pode ser difícil de entender.

Uma abordagem mais clara seria armazenar o resultado em uma variável e retornar essa variável:

def calcular():
    resultado = 2 + 3 * 4 - 1 https://codemdd.io/ 2
    return resultado

Desta forma, o valor de retorno é calculado da mesma maneira, mas a expressão é mais clara e mais fácil de entender.

Evitar expressões complexas em declarações return torna o código mais legível e facilita a manutenção posterior.

Retornando valores vs modificando globais

Ao escrever funções, é uma boa prática retornar valores calculados em vez de modificar variáveis globais diretamente.

Modificar variáveis globais pode tornar o código mais difícil de entender e depurar. Retornar valores de uma função permite que você isole o cálculo específico da função em um contexto local e evite efeitos colaterais indesejados.

Aqui está um exemplo de uma função que retorna a soma de dois números:

resultado = 0  # Global variable


def soma(a, b):
    global resultado
    resultado = a + b

Neste exemplo, a função soma recebe dois argumentos a e b e calcula a soma desses dois números. Em seguida, ela atribui o valor da soma à variável global resultado. O uso da palavra-chave global permite que a função acesse a variável global.

Embora essa abordagem funcione, ela pode levar a resultados inesperados se várias funções modificarem a mesma variável global em diferentes partes do código.

Em vez disso, é uma prática melhor retornar o valor calculado e armazená-lo em uma variável em outro lugar do programa:

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


resultado = soma(5, 3)

Dessa forma, a função soma retorna a soma dos dois números e o valor de retorno é atribuído à variável resultado em outro lugar do programa.

Essa abordagem torna o código mais modular e evita possíveis conflitos de variáveis globais.

Usando return com condicionais

Você pode usar a declaração return em conjunto com condicionais para retornar diferentes valores com base em uma condição.

Aqui está um exemplo de uma função que retorna uma mensagem com base na idade de uma pessoa:

def mensagem_idade(idade):
    if idade < 18:
        return "Você é menor de idade."
    else:
        return "Você é maior de idade."

Neste exemplo, a função mensagem_idade verifica se a idade fornecida é menor que 18 e retorna uma mensagem apropriada com base nessa condição. Se a idade for menor que 18, a mensagem “Você é menor de idade” será retornada. Caso contrário, a mensagem “Você é maior de idade” será retornada.

O uso de condicionais com a declaração return permite que você retorne diferentes valores com base em diferentes circunstâncias.

Retornando True or False

Você também pode usar a declaração return para retornar valores booleanos True ou False com base em uma condição.

Aqui está um exemplo de uma função que verifica se um número é par:

def is_par(numero):
    if numero % 2 == 0:
        return True
    else:
        return False

Neste exemplo, a função is_par verifica se o número fornecido é divisível por 2 com o operador %. Se o número for divisível por 2, a função retorna True. Caso contrário, ela retorna False.

Usar a declaração return com valores booleanos True ou False é uma maneira conveniente de retornar resultados de uma função que representam um estado lógico.

Loops de curto-circuito

Em algumas situações, você pode usar a declaração return para interromper um loop de maneira antecipada, quando uma determinada condição for atendida.

Aqui está um exemplo de uma função que verifica se uma lista contém um determinado valor:

def contem_valor(lista, valor):
    for item in lista:
        if item == valor:
            return True
    return False

Neste exemplo, a função contem_valor percorre cada item da lista usando um loop for. Se um item for igual ao valor fornecido, a função retorna True imediatamente, interrompendo o loop. Se nenhum item for igual ao valor fornecido, a função retorna False depois que o loop for concluído.

O uso da declaração return permite que você interrompa um loop de maneira antecipada no momento em que a condição desejada for atendida.

Reconhecendo código morto

Ao escrever funções, é importante reconhecer o código morto - código que nunca será executado porque ocorre depois de uma declaração return.

Aqui está um exemplo de uma função com código morto:

def exemplo():
    return 42
    print("Este código nunca será executado.")

Neste exemplo, o código depois da declaração return nunca será executado porque a função retorna imediatamente quando a declaração return é alcançada.

Reconhecer e remover código morto é importante para manter seu código limpo e fácil de entender.

Retornando múltiplos objetos nomeados

Além de retornar múltiplos valores de uma função, você também pode retornar múltiplos objetos nomeados usando uma estrutura de dados, como um dicionário.

Aqui está um exemplo de uma função que retorna os nomes e idades de duas pessoas:

def pessoas():
    return {
        "pessoa1": {
            "nome": "João",
            "idade": 25,
        },
        "pessoa2": {
            "nome": "Maria",
            "idade": 30,
        }
    }

Neste exemplo, a função pessoas retorna um dicionário com dois objetos nomeados pessoa1 e pessoa2. Cada objeto contém um nome e uma idade.

Para acessar os valores retornados da função, você pode usar a notação de acesso de dicionário:

dados_pessoa1 = pessoas()["pessoa1"]
print(dados_pessoa1["nome"])  # Output: João
print(dados_pessoa1["idade"])  # Output: 25

Neste caso, estamos acessando os valores retornados da função pessoas usando a notação de acesso de dicionário. Primeiro, obtemos os dados da pessoa1 e depois imprimimos o nome e a idade dessa pessoa.

Usar essa abordagem permite que você retorne múltiplos objetos nomeados de uma função e acesse os valores individualmente.

Retornando Funções: Encerramentos

Em Python, você pode retornar não apenas valores simples de uma função, mas também outras funções. Isso é conhecido como retorno de funções.

Quando uma função retorna outra função, a função retornada é chamada de encerramento. Um encerramento consiste em uma função interna e as variáveis locais que ela referência.

Aqui está um exemplo de uma função que retorna um encerramento que calcula a raiz quadrada de um número:

def criar_calculadora_raiz_quadrada():
    def calcular_raiz_quadrada(numero):
        return numero ** 0.5
    return calcular_raiz_quadrada

Neste exemplo, a função criar_calculadora_raiz_quadrada retorna uma função interna chamada calcular_raiz_quadrada. Essa função interna calcula a raiz quadrada do número fornecido usando o operador **.

Para usar o encerramento retornado, você pode atribuí-lo a uma variável e chamá-lo como uma função:

raiz_quadrada = criar_calculadora_raiz_quadrada()
resultado = raiz_quadrada(9)
print(resultado)  # Output: 3.0

Neste caso, estamos chamando a função criar_calculadora_raiz_quadrada e atribuindo o encerramento retornado à variável raiz_quadrada. Em seguida, chamamos o encerramento como uma função, passando o número 9 como argumento. O resultado da raiz quadrada é 3.0, que é impresso na tela.

O uso de encerramentos permite que você retorne funções completas, incluindo código e variáveis relacionadas, permitindo um alto grau de flexibilidade e reuso de código.

Tomando e Retornando Funções: Decoradores

Outra maneira interessante de usar a declaração return é tomando uma função como argumento e retornando outra função. Isso é conhecido como decorador.

Os decoradores permitem modificar o comportamento de uma função sem alterar seu código original. Eles envolvem a função original em outra função, adicionando funcionalidade extra antes, depois ou ao redor da função original.

Aqui está um exemplo de um decorador que mede o tempo de execução de uma função:

import time


def medir_tempo(funcao):
    def funcao_decorada(*args, **kwargs):
        start = time.time()
        resultado = funcao(*args, **kwargs)
        end = time.time()
        tempo = end - start
        print(f"A função {funcao.__name__} foi executada em {tempo} segundos.")
        return resultado
    return funcao_decorada

Neste exemplo, a função medir_tempo recebe uma função como argumento e retorna outra função chamada funcao_decorada. Essa função decorada mede o tempo de execução da função original e imprime o resultado na tela.

Para aplicar o decorador a uma função, você pode usar a sintaxe @ antes da definição da função:

@medir_tempo
def soma(a, b):
    return a + b

Neste caso, estamos aplicando o decorador medir_tempo à função soma. Isso significa que, quando chamarmos a função soma, o decorador será aplicado automaticamente, medindo o tempo de execução e imprimindo o resultado na tela.

Os decoradores são uma ferramenta poderosa em Python que permite estender e modificar o comportamento das funções de forma flexível e modular.

Retornando Objetos Definidos pelo Usuário: O Padrão de Fábrica

Além de retornar valores simples ou funções, você também pode retornar objetos definidos pelo usuário de uma função. Isso é conhecido como retorno de objetos definidos pelo usuário.

Retornar objetos definidos pelo usuário permite que você crie instâncias de classes personalizadas e as retorne para uso posterior. Isso é útil quando você deseja criar um objeto complexo com um conjunto específico de propriedades e comportamentos.

Aqui está um exemplo de uma função que retorna uma instância de uma classe Pessoa personalizada:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade


def criar_pessoa(nome, idade):
    return Pessoa(nome, idade)

Neste exemplo, a função criar_pessoa recebe um nome e uma idade como argumentos e retorna uma nova instância da classe Pessoa com essas propriedades.

Para usar o objeto retornado da função, você pode atribuí-lo a uma variável e acessar suas propriedades:

pessoa = criar_pessoa("João", 25)
print(pessoa.nome)  # Output: João
print(pessoa.idade)  # Output: 25

Neste caso, estamos chamando a função criar_pessoa com os argumentos "João" e 25 e atribuindo o objeto retornado à variável pessoa. Em seguida, imprimimos as propriedades nome e idade do objeto.

Retornar objetos definidos pelo usuário permite que você crie instâncias personalizadas de classes e as retorne para uso posterior em seu programa.

Usando return em blocos try ... finally

Em Python, você pode usar a declaração return dentro de um bloco try ... finally para garantir que um determinado código seja executado antes de retornar da função.

A estrutura try ... finally permite que você especifique um bloco de código que será executado independentemente de ocorrer uma exceção ou não. Isso é útil quando você precisa liberar recursos, fechar arquivos ou realizar outras tarefas de limpeza antes de retornar da função.

Aqui está um exemplo de uma função que lê o conteúdo de um arquivo e retorna os dados:

def ler_arquivo_cidades(nome_arquivo):
    try:
        arquivo = open(nome_arquivo, "r")
        dados = arquivo.read()
        return dados
    finally:
        if arquivo:
            arquivo.close()

Neste exemplo, a função ler_arquivo_cidades tenta abrir o arquivo com o nome fornecido e ler os dados. Se não houver erros, os dados serão retornados imediatamente. Caso contrário, o bloco finally será executado para garantir que o arquivo seja fechado corretamente, mesmo ocorrendo uma exceção.

Usar a declaração return em um bloco try ... finally garante que o código de limpeza seja executado corretamente, mesmo se ocorrer uma exceção.

Usando return em Funções Geradoras

Em Python, você pode usar a declaração return em funções geradoras para interromper a geração de valores e retornar da função.

Uma função geradora é uma função que contém a palavra-chave yield em seu corpo. A declaração yield é usada para retornar um valor temporariamente e pausar a execução da função, permitindo que ela seja retomada posteriormente a partir do ponto em que foi interrompida.

Há casos em que você pode querer interromper a geração de valores antes de atingir o fim da função. Nesses casos, você pode usar a declaração return para encerrar a função prematuramente.

Aqui está um exemplo de uma função geradora que gera os números de Fibonacci:

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
        if a > 100:
            return

Neste exemplo, a função fibonacci usa um loop infinito para gerar os números de Fibonacci. A declaração yield é usada para retornar temporariamente cada número gerado. Quando o número a ultrapassa 100, a função é encerrada precocemente usando a declaração return.

Para iterar sobre os números de Fibonacci gerados, você pode usar um loop for:

for numero in fibonacci():
    print(numero)

Neste caso, estamos iterando sobre os números gerados pela função fibonacci e imprimindo-os na tela até que a função seja encerrada prematuramente.

Usar a declaração return em funções geradoras permite controlar o fluxo de geração de valores e encerrar a função quando necessário.

Conclusão

A declaração return do Python é uma ferramenta poderosa para enviar valores de volta de uma função para o código chamador. Você pode usar a declaração return para retornar valores simples, múltiplos valores, funções ou até mesmo objetos personalizados definidos pelo usuário.

Ao usar a declaração return em suas funções, é importante seguir as melhores práticas para tornar seu código mais legível, organizado e eficiente. Algumas das melhores práticas incluem retornar None explicitamente, lembrar de atribuir o valor de retorno a uma variável, evitar expressões complexas, retornar valores em vez de modificar variáveis globais, usar a declaração return com condicionais e loops de curto-circuito, reconhecer código morto e retornar múltiplos objetos nomeados.

Com essas melhores práticas em mente, você estará preparado para usar a declaração return de forma eficaz em suas funções Python e escrever um código mais robusto e Pythonico.