Nomear bem,
refatorar melhor

O mapa da Unidade 4

Três semanas construindo as estruturas de dados que sustentam programas reais. Hoje fechamos a unidade — e abrimos a porta para a programação modular.

Ao final, você será capaz de.

Recap do Dia 1

• Função → bloco de código nomeado que executa uma tarefa e pode ser chamado quantas vezes quisermos
• Assinatura → o "cartão de identidade" da função: def nome(parâmetros)
• Parâmetros → as entradas que a função recebe; argumentos são os valores passados na chamada
• Retorno → return devolve um valor a quem chamou; uma função com retorno gera um resultado
• Função × procedimento → função devolve valor (cálculos); procedimento só executa ações (exibir, salvar) — sem return útil

O nome é documentação viva

Um bom nome de função explica a intenção do código antes mesmo de você ler o corpo dela. Compare: qual destes dois trechos você entende sem precisar abrir a função?

# Nomes ruins — o que isso faz?
def cm(n1, n2):
    return (n1 + n2) / 2

def proc(l):
    for x in l:
        print(x)

# Na hora de usar... mistério:
r = cm(8, 6)
proc(turma)

# Nomes semânticos — lê-se como frase
def calcular_media(nota1, nota2):
    return (nota1 + nota2) / 2

def exibir_alunos(lista_alunos):
    for aluno in lista_alunos:
        print(aluno)

# Na hora de usar... transparente:
media = calcular_media(8, 6)
exibir_alunos(turma)

Quatro convenções de nomeação

O nome importa; o estilo de escrever o nome também. Cada linguagem adota convenções. Em Python, a recomendação oficial (PEP 8) é clara:

Qual a convenção recomendada?

Em Python, qual das convenções de nomeação é a mais recomendada para escrever os nomes de funções e variáveis?

Biblioteca de utilidades & __main__

Uma biblioteca é só um conjunto de funções úteis que outros arquivos podem importar e reutilizar. Mas há um problema: se o arquivo tem testes no fim, eles rodam ao importar. A solução é o bloco if __name__ == "__main__".

# utilidades.py — a biblioteca
def calcular_soma(vetor):
    return sum(vetor)

def calcular_media(vetor):
    if len(vetor) == 0:
        return 0
    return sum(vetor) / len(vetor)

# Teste só roda se executar ESTE arquivo
if __name__ == "__main__":
    dados = [10, 20, 30]
    print("Soma:", calcular_soma(dados))
    print("Média:", calcular_media(dados))

# app.py — reutiliza, sem disparar testes
from utilidades import calcular_media

print(calcular_media([7, 8, 9]))
# imprime só 8.0 — nada do bloco de teste

Para que serve o __main__?

Qual a principal vantagem de colocar o código de teste de um módulo dentro do bloco if __name__ == "__main__"?

Vetor: antes × depois

O mesmo programa — ler um vetor, exibi-lo e calcular soma, média e maior valor — escrito de duas formas. À esquerda, tudo no nível principal. À direita, dividido em funções com responsabilidade única.

# ANTES — tudo junto, no nível principal
vetor = []
n = int(input("Quantos números? "))
for _ in range(n):
    vetor.append(float(input("Valor: ")))

print("Vetor:", vetor)

soma = 0
for v in vetor:
    soma += v
print("Soma:", soma)

media = soma / len(vetor)   # quebra se vazio!
print("Média:", media)

maior = vetor[0]
for v in vetor:
    if v > maior:
        maior = v
print("Maior:", maior)

# DEPOIS — biblioteca de funções
def ler_vetor():
    vetor = []
    n = int(input("Quantos números? "))
    for _ in range(n):
        vetor.append(float(input("Valor: ")))
    return vetor

def exibir_vetor(vetor):        # sem retorno
    print("Vetor:", vetor)

def calcular_soma(vetor):       # com retorno
    return sum(vetor)

def calcular_media(vetor):      # trata vazio
    if len(vetor) == 0:
        return 0
    return calcular_soma(vetor) / len(vetor)

def encontrar_maior(vetor):
    if len(vetor) == 0:
        return None
    return max(vetor)

if __name__ == "__main__":
    dados = ler_vetor()
    exibir_vetor(dados)
    print("Soma:", calcular_soma(dados))
    print("Média:", calcular_media(dados))
    print("Maior:", encontrar_maior(dados))

A biblioteca de utilidades

Refatore um código "tudo junto" que opera sobre um vetor, separando-o em funções pequenas com responsabilidade única. Durante a aula.

Refatorar renomeando funções

Pegue um programa que já funciona e melhore seus nomes: renomeie as funções com nomes claros em snake_case, ajuste variáveis e reorganize para maior clareza.

Para ir além

Dois vídeos curtos que aprofundam os temas de hoje — nomeação e subrotinas.