Veja o primeiro programa ao lado: o mesmo cálculo de média aparece três vezes. Se a regra mudar (por exemplo, a segunda prova passar a valer o dobro), teremos de corrigir três lugares e torcer para não esquecer nenhum.

Uma função é um bloco de código com nome. Escrevemos o bloco uma vez e o chamamos pelo nome sempre que precisarmos.

• Reaproveitamento: escreve uma vez, usa muitas.
• Organização: cada função resolve um pedaço do problema.
• Correção: um erro corrigido na função fica corrigido em todos os usos.

Desde a primeira aula usamos funções prontas do Python. Toda chamada tem a mesma forma: nome(argumentos). A função recebe valores, faz um trabalho e, quase sempre, devolve um resultado.

Quando o Python encontra um def, ele apenas guarda a função com aquele nome. O corpo só roda quando a função é chamada, e roda de novo a cada chamada.

Na chamada, a execução salta para dentro da função, executa o corpo e depois volta para a linha seguinte de quem chamou.

Por isso a função precisa ser definida antes da primeira chamada. A forma mais comum de organizar: todas as definições no topo do arquivo, o programa principal embaixo.

Na chamada, cada argumento é entregue ao parâmetro na mesma posição: o 1º argumento vai para o 1º parâmetro, e assim por diante. É como se o Python fizesse base = 3 e altura = 4 antes de começar o corpo.

O argumento pode ser qualquer expressão: um número, uma variável, uma conta ou até o resultado de outra função.

Crie uma função moldura(texto) que mostre o texto dentro de uma moldura de asteriscos, com um espaço de cada lado. A moldura deve se ajustar ao tamanho do texto.

moldura("Python")

**********
* Python *
**********

Depois, chame a função para três palavras diferentes.

return valor encerra a função e entrega o valor para quem chamou. A chamada passa a “valer” esse resultado, como len("abc") vale 3.

Com o valor em mãos, quem chamou decide o que fazer: guardar em uma variável, usar em uma conta, comparar em um if ou passar para outra função.

Assim que um return é executado, a função termina na hora, mesmo que existam mais linhas depois dele ou que esteja no meio de um laço.

Isso permite escrever vários return, um para cada caso. Depois que um caso foi resolvido, não é preciso else: se a execução chegou à linha seguinte, é porque o return anterior não aconteceu.

Quando a função devolve um bool, a chamada vai direto no if ou no while, e o código fica parecido com uma frase: if eh_par(n):.

Uma comparação já é True ou False. Por isso return n % 2 == 0 substitui um if inteiro.

Um return só pode entregar um valor, mas esse valor pode ser uma tupla. Basta separar os resultados por vírgula: return a, b.

Quem chamou recebe a tupla e pode desempacotá-la em várias variáveis, como vimos na aula de coleções.

1. Crie calcular_imc(peso, altura), que devolve peso ÷ altura².
2. Crie classificar_imc(imc), que devolve o texto da classificação.
3. No programa principal, leia peso e altura, chame as duas funções e mostre o resultado com uma casa decimal.

Variáveis criadas dentro de uma função, inclusive os parâmetros, são locais: nascem quando a função é chamada e desaparecem quando ela termina.

Fora da função, esses nomes não existem. A única forma de um resultado sair da função é pelo return.

Duas funções podem usar o mesmo nome de variável sem conflito: cada uma tem o seu próprio espaço de nomes, chamado escopo.

Uma função até consegue ler uma variável global, mas depender disso deixa o código difícil de entender: o resultado muda conforme coisas que estão fora da função.

E se a função atribuir a esse nome em qualquer ponto do corpo, o Python passa a considerá-lo local na função inteira. Usar antes de atribuir gera UnboundLocalError.

Lembra de “dois nomes, uma lista”? Passar uma lista para uma função funciona do mesmo jeito: o parâmetro vira outro nome para a mesma lista.

Por isso, se a função alterar a lista (append, lista[i] = ..., remove), a alteração aparece para quem chamou.

Com números, strings e tuplas isso não acontece: como são imutáveis, a função não tem como modificá-los.

Um parâmetro pode ter um valor padrão, usado quando a chamada não envia aquele argumento: def saudar(nome, saudacao="Olá"):.

Você já usou isso sem perceber: round(x) arredonda para inteiro porque o número de casas tem padrão; print tem sep=" " e end="\n" como padrões.

Na chamada, podemos dizer a qual parâmetro cada valor se destina: nome=valor. Assim a ordem deixa de importar e a chamada fica autoexplicativa.

É muito útil quando a função tem vários parâmetros com padrão e queremos mudar só um deles, por exemplo só o simbolo de linha.

Você também já viu isso: print(..., end="") e lista.sort(reverse=True).

Crie a função formatar_preco(valor, moeda="R$", casas=2), que devolve um texto com a moeda, um espaço e o valor com a quantidade de casas pedida.

Dica: dentro das chaves de uma f-string, a quantidade de casas pode vir de uma variável: f"{valor:.{casas}f}".

Uma função pode chamar outras funções. Assim, um problema grande é quebrado em partes pequenas, cada uma fácil de escrever e de testar sozinha.

Durante a execução, o Python guarda uma pilha de chamadas: cada chamada em andamento fica empilhada sobre quem a chamou e, ao terminar, sai da pilha e devolve o resultado para quem está logo abaixo.

Um programa com funções costuma seguir este formato:

1. Definições no topo, cada uma com um nome que diga o que ela faz (um verbo ajuda: calcular_, ler_, mostrar_).
2. Um programa principal curto no final, que lê os dados, chama as funções e mostra os resultados.

A primeira linha do corpo pode ser um texto entre aspas triplas, a docstring, que documenta o que a função recebe e devolve.

Funções também evitam repetição de input: ler_opcao só devolve uma opção depois que ela for válida.

Um módulo é um arquivo com funções prontas. O Python traz vários; para usar, basta importar.

O programa ao lado funciona, mas repete o mesmo trecho para cada aluno. Refatore: reescreva-o com funções, sem mudar o que ele mostra.

1. media(n1, n2, n3) devolve a média.
2. situacao(m) devolve "aprovado" ou "reprovado".
3. mostrar(nome, n1, n2, n3) usa as duas anteriores e mostra a linha do aluno.

Depois, acrescente um quarto aluno: com funções, deve bastar uma linha.