Funções e
modularização

Ao final, você será capaz de.

Função é uma receita

Imagine um confeiteiro com a receita do melhor bolo de chocolate: misturar os secos, depois os molhados, bater, assar. Toda vez que alguém encomenda um bolo, ele não reinventa o processo — pega a receita e executa.

Em programação é igual. Uma função é um bloco de código organizado e reutilizável que executa uma tarefa específica. Em vez de escrever o mesmo código várias vezes, nós o "empacotamos" e damos um nome a ele.

def fazer_bolo():
    print("Misture os ingredientes")
    print("Coloque no forno")
    print("Bolo pronto!")

fazer_bolo()   # chamando a função

Anatomia de uma função

def saudacao():
    print("Olá, seja bem-vindo!")


saudacao()
print("Linha do programa principal.")
saudacao()

O programa desvia e volta

Quando uma função é chamada, o programa interrompe o fluxo principal, executa a função e depois continua exatamente de onde parou.

Olá, seja bem-vindo!
Linha do programa principal.
Olá, seja bem-vindo!

A mesma função, dados diferentes

Uma calculadora não é recriada para cada equação — muda-se apenas os valores. Parâmetros são as variáveis declaradas na definição da função: as "portas de entrada" por onde valores externos passam.

def saudacao_ana():
    print("Olá, Ana!")

def saudacao_carlos():
    print("Olá, Carlos!")

def saudacao_bia():
    print("Olá, Bia!")

def saudacao(nome):
    print("Olá,", nome + "!")

saudacao("Ana")
saudacao("Carlos")
saudacao("Bia")

Parâmetro x argumento

Muita gente usa como sinônimo, mas há uma diferença que aparece em prova e em entrevista:

def saudacao(nome):      # 'nome' é o PARÂMETRO
    print("Olá,", nome)

saudacao("Maria")        # 'Maria' é o ARGUMENTO

Devolver é diferente de imprimir

Muitas funções não apenas executam uma ação: elas calculam um resultado e o enviam de volta para quem chamou. Isso é o return (Retorne, no pseudocódigo). Ao executá-lo, a função encerra e devolve o valor.

def dobro(n):
    print(n * 2)

x = dobro(5)      # imprime 10
print(x)          # None  ← nada voltou

def dobro(n):
    return n * 2

x = dobro(5)      # x recebe 10
print(x + 3)      # 13  ← dá para continuar

Onde a variável vive

Escopo é a região do código onde uma variável existe e pode ser acessada. Variáveis criadas dentro de uma função são locais: só existem enquanto a função está executando e são destruídas quando ela termina.

def calcular_total(preco, qtd):
    subtotal = preco * qtd      # variável LOCAL
    return subtotal

print(calcular_total(10, 3))    # 30
print(subtotal)                 # NameError: name 'subtotal' is not defined

Global: use com cuidado

Variáveis globais são criadas no programa principal, fora de qualquer função. Podem ser acessadas por diferentes partes do programa — e é justamente aí que mora o problema.

taxa = 0.1

def total(valor):
    return valor + valor * taxa

# quem lê a função não sabe
# de onde 'taxa' veio

def total(valor, taxa):
    return valor + valor * taxa

print(total(100, 0.1))   # 110.0
# a função é autossuficiente
# e testável isoladamente

O que acontece aqui?

O que acontece quando tentamos acessar uma variável local fora da função onde ela foi declarada?

Achar o padrão repetido

Uma loja aplica 15% de desconto em três produtos. Repare no que se repete — e no que muda.

preco1 = 100
final1 = preco1 - preco1 * 0.15
print("Produto 1:", final1)

preco2 = 250
final2 = preco2 - preco2 * 0.15
print("Produto 2:", final2)

preco3 = 80
final3 = preco3 - preco3 * 0.15
print("Produto 3:", final3)

def aplicar_desconto(preco, taxa):
    return preco - preco * taxa

print("Produto 1:", aplicar_desconto(100, 0.15))
print("Produto 2:", aplicar_desconto(250, 0.15))
print("Produto 3:", aplicar_desconto(80, 0.15))

Quantas alterações?

Se a regra da loja mudar e incluir uma taxa extra para todos os produtos, quantas alterações seriam necessárias no código modularizado?

Como escrever uma função decente

Calculadora modular

Criem uma calculadora que usa função com parâmetros e retorno. O fluxo do programa é: receber dados → processar com a função → retornar resultado → exibir.

Calculadora funcionando

def calcular(n1, n2, op):
    if op == "+":
        return n1 + n2
    elif op == "-":
        return n1 - n2
    elif op == "*":
        return n1 * n2
    elif op == "/":
        if n2 != 0:
            return n1 / n2
        else:
            print("Erro: divisão por zero!")
            return 0
    else:
        print("Operador inválido!")
        return 0

print("--- Calculadora modular ---")
num1 = float(input("Primeiro número: "))
operador = input("Operador (+ - * /): ")
num2 = float(input("Segundo número: "))

resultado = calcular(num1, num2, operador)
print("Resultado:", resultado)

--- Calculadora modular ---
Primeiro número: 12
Operador (+ - * /): /
Segundo número: 4
Resultado: 3.0

Ler o código do colega

O Code Review é prática indispensável no mercado: outra pessoa lê seu código antes dele entrar no sistema. Eleva a qualidade e espalha conhecimento pelo time.

Funções em seis linhas

• def nome(param): — define; o corpo vem indentado abaixo
• nome(argumento) — chama; sem os parênteses, nada executa
• return valor — devolve e encerra a função na hora
• Sem return, a função devolve None
• Variável criada dentro da função é local — some quando a função acaba
• Repetiu o mesmo trecho duas vezes? Provavelmente é uma função esperando para nascer