Chamando e criando funções#

Você deve ter notado que, para usar math.cos duas vezes, precisamos repetir o código de converter para radianos. Ficar repetindo código assim traz dois problemas:

1. se precisarmos mudar esse código temos agora um monte de lugares para mudar!
2. é muito fácil esquecer de adaptar uma parte desse código copiado e introduzir erros.

Para isso Python nos permite criar funções. Você pode pensar na função como uma parte reaproveitável de um programa. Como assim? Considere math.cos que acabamos de testar. Nós pedimos para o Python executar essa função passando um ângulo. Não sabemos (e nem precisamos saber, por enquanto) como ela faz isso, mas ela calcula o cosseno desse ângulo e devolve o resultado. Pensando no nosso programa, o que aconteceu foi que plugamos uma caixa preta na qual entram números representando ângulos e saem números representando o seu cosseno e é isso o que precisamos saber. Inclusive, chamamos math.cos duas vezes com ângulos diferentes.

Criando nossas próprias funções em Python#

Vamos começar com um exemplo de uma função que converte valores de milhas para quilômetros:

Vamos entender o que está acontecendo, começando pelos nomes:

1. O converte_milhas_para_km é o nome da nossa função em Python. Sempre que formos criar uma função em Python utilizamos a palavra def seguida do nome que queremos dar à função.
2. O distancia_mi na linha 1 é chamado de argumento da função. Neste exemplo, o argumento representa um valor em milhas que a função irá receber para aplicar o cálculo da conversão para quilômetros.
3. As linhas 2 e 3 são chamadas de corpo ou bloco da função.
4. O distancia_km na linha 3 é chamado de retorno ou resultado da função. Depois de converter a distância em milhas (distancia_mi) para uma distância em quilômetros distancia_km precisamos devolver o valor calculado. Note que para devolver o valor precisamos colocar a palavra return seguido pelo valor retornado.
5. O corpo da função é identificado com os 4 espaços no começo da linha. Esses 4 espaços são chamados de indentação.

Vamos agora definir nossa própria função? Nosso primeiro passo será definir a nossa função usando o modelo abaixo. É uma boa prática colocar as nossas funções no início do arquivo logo após as linhas contendo import.

1. Trocamos nome_da_funcao pelo nome que queremos dar a ela. No nosso caso, usaremos graus_para_radianos como nome.
2. Trocamos argumento por graus, que é a entrada da nossa função.
3. Aqui podemos colocar uma sequência de comandos Python que serão executados. A variável graus já vem preenchida quando o código da função rodar. Para facilitar neste início, vamos sempre terminar preenchendo uma variável resultado com o valor calculado pela nossa função.
4. Aqui podemos manter igual. O comando return diz que o valor a sua direita é o resultado da função e deve ser devolvido para quem chamou ela.

import math

# defina sua função aqui

# resto do código dos outros exercícios vai aqui

Você deverá estar vendo código parecido com o abaixo. Alguns pontos de atenção:

1. as linhas 4 e 5, que esão logo abaixo do def devem iniciar com 4 espaços. Todo código iniciando com 4 espaços está "dentro" da função e será executado quando graus_para_radianos for chamada
2. a definição da função (linhas 3-5) deve estar antes das linhas de print

1
2
3
4
5
6
7
8
9

import math

def graus_para_radianos(graus):
    resultado = graus * 3.14 / 180
    return resultado

# Os print abaixo estão comentados, então por enquanto eles não irão executar
# print(math.cos(30 * 3.14 / 180))
# print(math.cos(120 * 3.14 / 180))

Se você executar o código acima não vai acontecer nada. Nesse código nós estamos apenas definindo a função graus_para_radianos (por isso a palavra def). Podemos entender a linha 1 como: "Python, quando eu pedir para você executar a função graus_para_radianos, passando um valor para graus, o que você deve fazer é: multiplicar o valor armazenado na variável graus por 3.14/180 e guardar o resultado na variável resultado e depois devolver o valor armazenado na variável resultado como o resultado". Em outras palavras, é como se estivéssemos criando um novo comando do Python (assim como já temos o print ou o math.cos, por exemplo).

Vamos refletir brevemente sobre a função que acabamos de criar. Qual é o valor esperado para o resultado da chamada da função graus_para_radianos(graus)? A resposta é: depende! Depende do valor de graus. A função graus_para_radianos só pode devolver um valor se definirmos um valor para graus.

Essa ideia é a mesma que apresentamos sobre a função print, ou seja, precisamos de uma informação adicional. Uma vez que definimos uma função é como se ela se tornasse parte da linguagem Python. Assim, para esse contexto introdutório, não existe nenhuma diferença entre a função print e a função converte_milhas_para_km(graus) em termos de importância. Ambas são comandos disponíveis no Python para o programador utilizar em seu código.

print(graus_para_radianos(30))
print(graus_para_radianos(120))

rad30 = graus_para_radianos(30)
print(math.cos(rad30))
rad120 = graus_para_radianos(120)
print(math.cos(rad120))

print(graus_para_radianos(30 * 3.14 / 180))
print(graus_para_radianos(120 * 3.14 / 180))

print(math.cos(graus_para_radianos(30 * 3.14 / 180)))
print(math.cos(graus_para_radianos(120 * 3.14 / 180)))

Aqui já começamos a combinar funções:

1. primeiro computamos o resultado de graus_para_radianos(30)
2. esse valor é passado para math.cos
3. cujo resultado é passado para print para mostrar na tela.

Quanto mais complexos os programas que criarmos mais funções estaremos combinando, sejam elas criadas por nós mesmos como graus_para_radianos como funções já existentes como math.cos.

def calcula(x):
    return x * 0.017444444444444446

Em resumo, funções são muito importantes para resolver problemas que aparecem frequentemente. Ao invés de repetirmos código, criamos um novo comando do Python e usamos este comando em vários lugares.

Falando um pouco mais sobre argumentos de uma função#

Nos exemplos até o momento as funções recebem somente um argumento.

Mas podem ter casos em que a função precise receber mais de um argumento. Para resolver isso, basta colocar os argumentos separados por vírgulas.