Funções

No nosso aprendizado Python até aqui, já usamos diversas funções: print, range, input. Imagine se todas as vezes que quiséssemos mostrar alguma coisa na tela, nosso código precisasse de reescrever (reimplementar) a função print. Felizmente, basta sabermos que print existe e como usá-la; não precisamos repetir código (e evitamos todos os problemas que isso acarreta).

Ao contrário do caso de print, todo o código que escrevemos até aqui precisaria ser repetido se quiséssemos utilizá-lo novamente. Usando nosso código anterior, se quisermos calcular dois números da sequência de Fibonacci e multiplicá-los, precisamos de repetir o código duas vezes, colocando os números em variáveis diferentes, e então multiplicá-las. Para facilitar o processo e não repetir código, bastaria definir uma função nthfibo (de n-ésimo Fibonacci) e chamá-la duas vezes:

def nthfibo(n):
    # calcula o n-ésimo número da sequência de Fibonacci
    pass # pass é uma keyword que não faz nada; é só um placeholder
         # para o código que ainda vamos escrever

nthfibo(4) * nthfibo(5)

O exemplo acima já nos dá uma ideia da sintaxe usada para definir funções. A keyword def inicia a definição; em seguida vem o nome da função (a nomenclatura deve seguir as mesmas regras de nomes de variáveis), e em seguida os nomes de seus valores de entrada (opcionais, também chamados de argumentos ou parâmetros) entre parênteses e separados por vírgulas, e então dois pontos (:). Na linha seguinte vem um bloco de código indentado, que é o corpo da função. Esse corpo é executado quando chamamos a função.

No exemplo nthfibo, o nome da função é (obviamente) nthfibo, a função possui somente um argumento n que devemos fornecer ao chamar a função. Para chamar uma função escrevemos seu nome seguido de parênteses, com seus argumentos entre os parênteses e separados por vírgula. Note que no exemplo as chamadas de nthfibo(4) e nthfibo(5) estão fora do corpo da função.

Você provavelmente teve problemas respondendo o exercício anterior. Em Python (e em quase todas as outras linguagens de programação), é preciso especificar o resultado da função usando a keyword return. Compare o resultado de chamar as duas funções abaixo:

def nothing():
    pass
def two():
    return 2
print(nothing())
print(two())

Quando uma função não possui a keyword return especificando seu resultado/saída, ela não retorna nada. Em Python, nada é representado por None. Poderíamos escrever a função nothing mais explicitamente:

def nothing():
    # equivalente à definição anterior
    return None

None não parece muito útil, mas na verdade tem seus usos. Por exemplo, você provalmente já tentou logar em algum site em que você não se lembrava do seu nome de usuário ou o email que usou; ao entrar os seus dados e receber a mensagem de que aquele usuário/email não estava castrado no sistema, algum código no servidor do site provavelmente retornou None (ou null, como costuma se chamar em outras linguagens).

Importante: uma função só retorna uma vez. Após retornar, ela não faz mais nada. Você pode até escrever código depois de um return, mas ele não será executado (tente!).

Até aqui nós temos escrito programas pequenos, mas programas reais podem ser muito longos (SQLite — uma base de dados que provavelmente está presente no seu computador e no seu celular — tem por volta de 238 mil linhas de código; o programa que implementa a linguagem Python está se aproximando de um milhão de linhas de código). Em programas desta escala, até mesmo não repetir nomes de variáveis passa a ser um problema. Felizmente, esse é um não-problema, dado que a maioria das variáveis tem um escopo definido.

Por exemplo, ao definir nthfibo, escolhemos n como o nome de seu único argumento. Ao invocarmos nthfibo(10), a variável n assume o valor 10 dentro do corpo da função nthfibo, mas seu valor fora dela (se houver) continua o mesmo. Veja:

n = 42
print(n)
nthfibo(10)
print(n)

A lógica é a seguinte: apesar de já existir uma variável n ‘fora’ de nthfibo, a definição de nthfibo redeclara uma variável n com escopo local; para todos efeitos, esta é uma nova variável, que nada interfere com a outra variável declarada no escopo de fora de nthfibo.

Apesar de não ser possível (normalmente) modificar variáveis de um escopo exterior de uma função, a função pode acessar estas variáveis (desde que seus nomes não conflitem com nomes internos, como é o caso do exemplo anterior entre n e nthfibo). Veja:

pi = 3.14159

def sphere_area(r):
    return 4 * pi * r**2

def sphere_volume(r):
    return 4/3 * pi * r**3

Se precisarmos de modificar uma variável de um escopo externo com um valor calculado por uma função, basta retornar o valor e fazer o assignment.

def increment(n):
    return n + 1

n = 5
increment(n)
print(n)
n = increment(n)
print(n)

Note que nada impede que funções sejam argumentos de outras funções. Podemos definir uma função map_sum:

def map_sum(f, n):
    total = 0
    for i in range(1, n + 1):
        total = total + f(i)
    return total

def add_one(n):
    return n + 1

map_sum(add_one, 10)

Uma função pode retornar mais de um valor, basta separar os valores a serem retornados por vírgulas:

def nthfibo_rec(n):
    if n == 1:
        return 0, 0
    elif n == 2:
        return 1, 0
    elif n > 2:
        prev, prevprev = nthfibo_rec(n - 1)
        return prev + prevprev, prev

Teste esta versão de nthfibo_rec(n) com \(n = 35\) e \(n = 10000\). (Ignore o fato de que ela retorna tanto o n-ésimo e o n-1-ésimo números da sequência.)

Como vimos com range, uma função Python pode ter argumentos opcionais. Isto é útil quando (assim como no caso de range!) há um valor ‘padrão’ para um argumento, que mesmo assim por vezes queremos alterar. Por exemplo, ao definir uma função que calcula o logaritmo de um número, podemos ter dois argumentos: o primeiro (obrigatório) seria o número do qual queremos o logaritmo, e o segundo (opcional) seria a base do logaritmo (cujo valor padrão pode ser a base natural \(e\) se quisermos agradar matemáticos, ou \(2\) se quisermos agradar programadores).

def logaritmo(n, b=2):
    pass

logaritmo(8) # 3
logaritmo(8, 8) # 1