Definir funções com parâmetros e retorno

Uma função reúne uma operação sob um nome para que ela possa ser chamada novamente. A definição começa com def, seguida do nome, parênteses e dois-pontos. O corpo fica indentado.

Ao executar a instrução def, o Python disponibiliza o nome mostrar_boas_vindas para as linhas seguintes. Porém, isso ainda não executa o print que está no corpo.

Execute este código no Python 3. Nenhuma mensagem será exibida, pois ainda não há uma chamada.

Depois da definição, escreva o nome da função seguido de parênteses para chamá-la. Cada chamada entra no corpo e executa suas instruções uma vez.

A mensagem aparece duas vezes: uma para cada chamada.

O fluxo passa pela definição sem entrar no corpo. Somente ao chegar a uma chamada ele segue para o bloco indentado e depois continua no script.

Na definição, os nomes entre parênteses são parâmetros. Na chamada, os valores ou expressões entre parênteses são argumentos.

Em chamadas posicionais simples, o primeiro argumento corresponde ao primeiro parâmetro, o segundo argumento ao segundo parâmetro, e assim por diante.

Ao executar a chamada, "Bia" corresponde a nome e "Recife" corresponde a cidade.

O corpo da função não precisa mudar para trabalhar com outros dados. Cada chamada fornece novos argumentos aos mesmos parâmetros.

Um argumento também pode ser uma expressão: ela é calculada, e seu resultado ocupa a posição correspondente.

As três chamadas executam o mesmo corpo com dados diferentes.

Dentro da função, return avalia uma expressão e entrega o valor obtido ao ponto em que a função foi chamada. Assim, a chamada passa a representar esse valor no restante do código.

Os argumentos 6 e 4 chegam à função. A expressão resulta em 24, que é devolvido e armazenado em area.

O fluxo tem duas direções: os argumentos entram na função e o resultado retorna ao ponto da chamada.

Uma chamada com resultado pode aparecer onde um valor seria aceito. Você pode armazená-la em uma variável ou usá-la diretamente em outro cálculo.

Cada chamada de dobrar(9) vale 18. Na segunda expressão, esse valor participa da soma.

print apresenta informação na tela. Já return entrega um valor ao ponto do programa que fez a chamada.

Uma função que apenas imprime pode produzir uma saída visível e, ainda assim, não entregar esse valor para a atribuição.

Ao executar o script, observe separadamente a saída de dentro da função e o valor armazenado em resultado.

Quando a função usa return, a chamada passa a valer o resultado devolvido. O código que fez a chamada pode armazená-lo e depois exibi-lo com print.

Agora resultado recebe o número 12. O print que apresenta esse número está fora da função.

Se a execução chega ao fim da função sem encontrar return, a chamada retorna implicitamente None. Escrever return sem uma expressão também encerra a chamada retornando None.

As duas chamadas produzem None, embora somente a primeira função apresente uma mensagem.

Quando um caminho executa return, a chamada termina imediatamente. Nenhuma instrução posterior do corpo é executada nessa chamada. O valor retornado ocupa o lugar da chamada, e o programa continua no código chamador.

Com pontos igual a 12, a condição é verdadeira. A função devolve a mensagem imediatamente, sem executar o print que vem depois do bloco condicional.

O losango representa a condição. Ao alcançar um ponto de retorno, o fluxo sai da função e volta diretamente ao local da chamada.

Um return colocado depois de uma condição atende ao caminho que não retornou antes. Assim, os caminhos relevantes podem terminar com resultados previstos. Se algum caminho chegar ao fim do corpo sem executar return com valor, o resultado será None.

Para valores positivos ou negativos, a chamada termina dentro de uma condição. Se nenhuma condição for verdadeira, a execução chega ao retorno final.

Em uma busca, return pode ficar dentro do for. Quando um valor atende à condição, ele é devolvido imediatamente: o laço para e a chamada inteira termina. Por isso, apenas o primeiro valor adequado é retornado.

A função examina os valores na ordem da lista.

O return None deve ficar depois do laço. Esse ponto só é alcançado quando nenhum item provocou o retorno anterior. Se a lista estiver vazia, o corpo do for nem será executado e a função também chegará diretamente a return None.

Nos dois casos, a busca termina sem encontrar um valor acima do limite.

Dentro de um laço, return encerra a função e entrega um resultado ao código chamador. Já break interrompe apenas o laço; a execução pode continuar nas instruções seguintes da mesma função.

Esta versão guarda o valor, interrompe o laço e só depois retorna.

Compare até onde cada instrução conduz o fluxo de execução.

Uma função pode agrupar dois resultados em uma tupla. Para isso, escreva os valores separados por vírgula depois de return.

Embora existam dois elementos, a chamada devolve um único objeto: a tupla que contém ambos.

A função calcula horas completas e minutos restantes.

Você pode armazenar a tupla completa em uma variável ou desempacotar seus elementos diretamente.

No desempacotamento, a ordem deve corresponder ao return: o primeiro resultado vai para o primeiro nome, e o segundo vai para o segundo nome.

Compare o armazenamento da tupla completa com o desempacotamento direto.

No seu editor, crie uma função chamada calcular_progresso com dois parâmetros: pontos e meta.

Considere que pontos sempre será um número inteiro não negativo e que meta sempre será um número inteiro positivo. Não é necessário validar as entradas.

A função deve devolver, nesta ordem:

1. a quantidade de pontos que ainda faltam;
2. uma mensagem de situação.

Se os pontos forem iguais ou superiores à meta, devolva 0 e "Meta atingida". Caso contrário, devolva a diferença entre a meta e os pontos, junto de "Continue avançando".

Os dois argumentos entram na função. Depois da comparação, um único objeto — uma tupla com dois elementos — volta ao ponto da chamada e é distribuído para duas variáveis.

Crie um arquivo Python, escreva a função e acrescente as três conferências abaixo. Use return dentro da função. Faça o desempacotamento e o print fora dela.

Execute o arquivo com Python 3 e compare exatamente os números e as mensagens exibidos.

Acrescente estas chamadas abaixo da sua definição. Elas verificam um valor abaixo, outro exatamente no limite e outro acima da meta.

Compare esta solução com a sua. Cada caminho devolve uma tupla na mesma ordem, permitindo o mesmo desempacotamento após qualquer chamada.