Organizando o código com funções

Entenda como funções deixam o código mais limpo, legível e fácil de manter.

Você já aprendeu a criar funções, usar parâmetros e retornar valores. Agora chegou o momento de entender por que e como usar funções para deixar seu código mais organizado, legível e fácil de manter.

Pense assim: escrever um programa sem funções é como arrumar um guarda-roupa jogando tudo em uma gaveta só — funciona, mas na hora de encontrar algo você vai sofrer. Funções são como as divisórias e prateleiras: cada coisa em seu lugar, fácil de localizar e de rearrumar.

Por que organizar o código?

Quando um programa cresce, ele pode facilmente se tornar uma bagunça difícil de entender. Veja este exemplo sem funções:

# Programa sem funções — tudo misturado
nome = input("Digite seu nome: ")
idade = int(input("Digite sua idade: "))
salario = float(input("Digite seu salário: "))

# Calcular desconto INSS (simplificado)
if salario <= 1320:
   desconto = salario * 0.075
elif salario <= 2571.29:
   desconto = salario * 0.09
else:
   desconto = salario * 0.12

salario_liquido = salario - desconto

# Verificar se é maior de idade
if idade >= 18:
   status = "maior de idade"
else:
   status = "menor de idade"

# Exibir resultado
print(f"\nOlá, {nome}!")
print(f"Você é {status}.")
print(f"Salário bruto: R$ {salario:.2f}")
print(f"Desconto INSS: R$ {desconto:.2f}")
print(f"Salário líquido: R$ {salario_liquido:.2f}")

O código funciona, mas está tudo no mesmo lugar. Imagine um programa com 300 linhas: você teria que analisar todo o código para entender o que cada parte faz, até encontrar a parte que deseja corrigir ou modificar.

Agora veja o mesmo programa com funções:

def coletar_dados():
   nome = input("Digite seu nome: ")
   idade = int(input("Digite sua idade: "))
   salario = float(input("Digite seu salário: "))
   return nome, idade, salario

def calcular_desconto_inss(salario):
   if salario <= 1320:
       return salario * 0.075
   elif salario <= 2571.29:
       return salario * 0.09
   else:
       return salario * 0.12

def verificar_maioridade(idade):
   if idade >= 18:
       return "maior de idade"
   return "menor de idade"

def exibir_resultado(nome, status, salario, desconto):
   salario_liquido = salario - desconto
   print(f"\nOlá, {nome}!")
   print(f"Você é {status}.")
   print(f"Salário bruto: R$ {salario:.2f}")
   print(f"Desconto INSS: R$ {desconto:.2f}")
   print(f"Salário líquido: R$ {salario_liquido:.2f}")

# Programa principal — claro e direto
nome, idade, salario = coletar_dados()
desconto = calcular_desconto_inss(salario)
status = verificar_maioridade(idade)
exibir_resultado(nome, status, salario, desconto)

Agora cada função faz uma coisa só e o programa principal lê quase como uma frase: "colete dados, calcule o desconto, verifique a maioridade, exiba o resultado".

Outra vantagem de criar funções é que se você precisar verificar algum trecho do código, por exemplo, verificar se a função calcular_desconto_inss() está correta, basta chamá-la com valores conhecidos, sem precisar executar o programa inteiro.

Princípio do "Faça uma coisa só"

Uma boa função deve ter uma responsabilidade única e bem definida. Se você precisar usar a palavra "e" para descrever o que ela faz, provavelmente ela está fazendo coisa demais.

Evite isso:

def calcular_e_exibir_desconto(salario):
   if salario <= 1320:
       desconto = salario * 0.075
   else:
       desconto = salario * 0.12
   print(f"Desconto: R$ {desconto:.2f}")  # calcula E exibe — duas responsabilidades!

Prefira isso:

def calcular_desconto(salario):
   if salario <= 1320:
       return salario * 0.075
   return salario * 0.12

def exibir_desconto(desconto):
   print(f"Desconto: R$ {desconto:.2f}")

Separando as responsabilidades, você pode reutilizar calcular_desconto() em qualquer parte do programa sem obrigá-la a imprimir algo na tela.

Evitando repetição de código

Um dos maiores benefícios das funções é eliminar código repetido. Se você escreveu o mesmo trecho duas vezes, é sinal de que ele pode virar uma função.

Código repetido — difícil de manter:

# Saudação para o usuário 1
print("=" * 30)
print("Bem-vindo ao sistema!")
print("=" * 30)

# Saudação para o usuário 2
print("=" * 30)
print("Bem-vindo ao sistema!")
print("=" * 30)

Se você quiser mudar a mensagem, precisa alterar em dois lugares. Com 10 lugares, vira um pesadelo.

Com função — fácil de manter:

def exibir_cabecalho():
   print("=" * 30)
   print("Bem-vindo ao sistema!")
   print("=" * 30)

exibir_cabecalho()
# ... outras partes do código ...
exibir_cabecalho()

Agora, para mudar a mensagem, você altera apenas a função — e todos os lugares que a usam serão atualizados automaticamente.

Em programação, temos o conceito DRY (Don't Repeat Yourself) que nos incentiva a não escrever código repetido. As funções ajudam exatamente com isso.

Nomeando funções de forma clara

Um código bem organizado também se comunica pelo nome das funções. Um bom nome de função deve deixar claro o que ela faz sem precisar ler o código interno.

Nome confuso Nome claro
def f(x): def calcular_imposto(salario):
def proc(dados): def processar_pagamento(dados):
def verifica(n): def verificar_maioridade(idade):
def faz_tudo(): def gerar_relatorio_mensal():

Dica: Use verbos nos nomes das funções — calcular, verificar, exibir, salvar, processar. Isso deixa imediatamente claro que a função faz algo.

Estruturando um programa com funções

Um programa bem estruturado com funções costuma seguir um padrão: as funções são definidas no topo e o código principal fica no final, de forma limpa e legível.

# ======================
# FUNÇÕES
# ======================

def saudacao(nome):
   return f"Olá, {nome}! Bem-vindo ao sistema de biblioteca."

def registrar_livro(titulo, autor):
   return {"titulo": titulo, "autor": autor}

def exibir_livro(livro):
   print(f"📖 {livro['titulo']} — {livro['autor']}")

def listar_biblioteca(biblioteca):
   if not biblioteca:
       print("Nenhum livro cadastrado.")
       return
   print("\n=== Biblioteca ===")
   for livro in biblioteca:
       exibir_livro(livro)

# ======================
# PROGRAMA PRINCIPAL
# ======================

nome_usuario = input("Qual é o seu nome? ")
print(saudacao(nome_usuario))

biblioteca = []
biblioteca.append(registrar_livro("O Pequeno Príncipe", "Antoine de Saint-Exupéry"))
biblioteca.append(registrar_livro("Dom Casmurro", "Machado de Assis"))
biblioteca.append(registrar_livro("1984", "George Orwell"))

listar_biblioteca(biblioteca)

Saída:

Qual é o seu nome? Ana
Olá, Ana! Bem-vindo ao sistema de biblioteca.

=== Biblioteca ===
📖 O Pequeno Príncipe — Antoine de Saint-Exupéry
📖 Dom Casmurro — Machado de Assis
📖 1984 — George Orwell

Veja como o programa principal ficou pequeno e legível: qualquer pessoa consegue entender o que o programa faz lendo apenas as últimas linhas.

Exemplo prático: calculadora organizada

Vamos ver um exemplo completo de como as funções tornam um programa real mais fácil de entender e expandir:

def somar(a, b):
   return a + b

def subtrair(a, b):
   return a - b

def multiplicar(a, b):
   return a * b

def dividir(a, b):
   if b == 0:
       return None  # Não é possível dividir por zero
   return a / b

def exibir_menu():
   print("\n=== Calculadora ===")
   print("1 - Somar")
   print("2 - Subtrair")
   print("3 - Multiplicar")
   print("4 - Dividir")
   print("0 - Sair")

def obter_numeros():
   a = float(input("Digite o primeiro número: "))
   b = float(input("Digite o segundo número: "))
   return a, b

def executar_operacao(opcao, a, b):
   if opcao == "1":
       return somar(a, b)
   elif opcao == "2":
       return subtrair(a, b)
   elif opcao == "3":
       return multiplicar(a, b)
   elif opcao == "4":
       return dividir(a, b)
   else:
       return None

# Programa principal
opcao = ""
while True:  
   exibir_menu()
   opcao = input("Escolha uma opção: ")

   if opcao == "0":
       print("Até logo!")
       break

   a, b = obter_numeros()
   resultado = executar_operacao(opcao, a, b)

   if resultado is None:
       print("Operação inválida ou divisão por zero!")
   else:
       print(f"Resultado: {resultado}")

Cada função tem seu papel bem definido. Se quiser adicionar uma operação de potência, basta criar a função potencia(a, b) e incluí-la em executar_operacao() — sem mexer em nada mais.

Perceba que aqui nós deixamos a condição de parada do while como True. Então como o programa sai do loop? Ele vai sair do loop através do break que acionamos caso o usuário digite a opção "0"! O código acima também poderia ser reescrito da seguinte forma, sem o break:

# Funções...

# Programa principal
opcao = ""
while opcao != "0":
   exibir_menu()
   opcao = input("Escolha uma opção: ")
   if opcao != "0":
       a, b = obter_numeros()
       resultado = executar_operacao(opcao, a, b)
       if resultado is None:
           print("Operação inválida ou divisão por zero!")
       else:
           print(f"Resultado: {resultado}")
   else:
       print("Até logo!")

O que aprendemos nesta lição

Nesta lição, você aprendeu que:

  • Funções tornam o código mais legível, organizado e fácil de manter, como prateleiras que guardam cada coisa em seu lugar.
  • Uma boa função deve ter uma responsabilidade única — se precisar de "e" para descrever o que ela faz, provavelmente está fazendo coisa demais.
  • Funções eliminam repetição de código: ao mudar a função, todos os lugares que a usam são atualizados de uma vez.
  • Nomear funções com verbos e nomes descritivos torna o código muito mais fácil de entender sem precisar ler o interior de cada função.
  • Um programa bem estruturado define as funções no início e deixa o código principal curto e legível no final.