Funções: definição, parâmetros e escopo

Funções são o principal mecanismo de organização de código em Python. Elas permitem nomear um bloco de instruções, reutilizá-lo quantas vezes for necessário e dividir problemas complexos em partes menores e gerenciáveis. Um programa bem estruturado é essencialmente uma coleção de funções bem definidas.

Definindo uma Função

A palavra-chave def inicia a definição de uma função:

def saudar():
    print("Olá! Bem-vindo ao Python.")

# Chamando a função
saudar()  # Olá! Bem-vindo ao Python.
saudar()  # pode ser chamada quantas vezes quiser

A função só é executada quando chamada — a definição apenas a registra na memória.

Parâmetros e Argumentos

Funções se tornam mais úteis quando aceitam dados externos:

def saudar(nome):
    print(f"Olá, {nome}! Bem-vindo ao Python.")

saudar("Ricardo")  # Olá, Ricardo! Bem-vindo ao Python.
saudar("Ana")      # Olá, Ana! Bem-vindo ao Python.

Parâmetro é o nome na definição da função (nome). Argumento é o valor passado na chamada ("Ricardo").

Funções podem ter múltiplos parâmetros:

def apresentar(nome, idade, cidade):
    print(f"{nome}, {idade} anos, mora em {cidade}.")

apresentar("Carlos", 28, "São Paulo")

Parâmetros com Valor Padrão

É possível definir valores padrão para parâmetros — tornando-os opcionais na chamada:

def conectar(host, porta=5432, ssl=True):
    print(f"Conectando em {host}:{porta} (SSL: {ssl})")

conectar("db.servidor.com")                  # usa porta 5432 e ssl True
conectar("db.servidor.com", 3306)            # porta diferente
conectar("db.servidor.com", 3306, False)     # sem SSL

Parâmetros com valor padrão devem sempre vir depois dos parâmetros obrigatórios.

Argumentos Nomeados (Keyword Arguments)

Ao chamar uma função, você pode nomear os argumentos — tornando a ordem irrelevante e o código mais legível:

def criar_usuario(nome, email, admin=False):
    print(f"Usuário: {nome} | E-mail: {email} | Admin: {admin}")

criar_usuario(email="ana@exemplo.com", nome="Ana", admin=True)

Retornando Valores

Funções podem devolver resultados com return:

def calcular_imc(peso, altura):
    imc = peso / altura ** 2
    return imc

resultado = calcular_imc(70, 1.75)
print(f"IMC: {resultado:.2f}")  # IMC: 22.86

Quando return é executado, a função encerra imediatamente. É possível retornar múltiplos valores — Python os empacota automaticamente em uma tupla:

def minmax(numeros):
    return min(numeros), max(numeros)

menor, maior = minmax([4, 1, 9, 3, 7])
print(menor, maior)  # 1 9

Uma função sem return explícito retorna None implicitamente.

Escopo de Variáveis

Escopo define onde uma variável é visível e acessível. Python segue a regra LEGB:

Local — dentro da função atual
Enclosing — em funções externas que envolvem a atual
Global — no nível do módulo
Built-in — nomes nativos do Python (print, len, etc.)

x = 10  # variável global

def mostrar():
    x = 20  # variável local — não afeta a global
    print(x)

mostrar()  # 20
print(x)   # 10

Para modificar uma variável global dentro de uma função, use global — mas use com cautela, pois dificulta a leitura e o teste do código:

contador = 0

def incrementar():
    global contador
    contador += 1

incrementar()
incrementar()
print(contador)  # 2

Funções como Objetos

Em Python, funções são objetos de primeira classe — podem ser atribuídas a variáveis, passadas como argumentos e retornadas por outras funções:

def dobrar(x):
    return x * 2

def triplicar(x):
    return x * 3

def aplicar(func, valor):
    return func(valor)

print(aplicar(dobrar, 5))     # 10
print(aplicar(triplicar, 5))  # 15

Funções Lambda

Para funções simples de uma linha, Python oferece as lambdas — funções anônimas:

quadrado = lambda x: x ** 2
print(quadrado(4))  # 16

# Muito usadas com funções como sorted(), map(), filter()
nomes = ["Carlos", "Ana", "Bruno", "Diana"]
ordenados = sorted(nomes, key=lambda nome: len(nome))
print(ordenados)  # ['Ana', 'Bruno', 'Carlos', 'Diana']

Lambdas são restritas a uma única expressão. Para lógica mais complexa, defina uma função normal com def.

Docstrings

Boas funções documentam seu propósito com uma docstring — uma string logo após o def:

def calcular_juros(principal, taxa, periodo):
    """
    Calcula o juros simples sobre um valor.

    Args:
        principal: Valor inicial aplicado.
        taxa: Taxa de juros por período (em decimal, ex: 0.05 para 5%).
        periodo: Número de períodos.

    Returns:
        O valor total acumulado após os juros.
    """
    return principal * (1 + taxa * periodo)

help(calcular_juros)  # exibe a docstring formatada

Exemplo Completo: Calculadora

def somar(a, b):
    """Retorna a soma de dois números."""
    return a + b

def subtrair(a, b):
    """Retorna a subtração de dois números."""
    return a - b

def multiplicar(a, b):
    """Retorna o produto de dois números."""
    return a * b

def dividir(a, b):
    """Retorna a divisão de dois números. Lança erro se b for zero."""
    if b == 0:
        raise ValueError("Divisão por zero não é permitida.")
    return a / b

def calcular(a, operacao, b):
    operacoes = {
        "+": somar,
        "-": subtrair,
        "*": multiplicar,
        "/": dividir,
    }
    if operacao not in operacoes:
        raise ValueError(f"Operação '{operacao}' não suportada.")
    return operacoes[operacao](a, b)

print(calcular(10, "+", 5))   # 15
print(calcular(10, "/", 4))   # 2.5
print(calcular(3,  "*", 7))   # 21

Resumo

def define uma função; ela só executa quando chamada
Parâmetros podem ser obrigatórios ou ter valores padrão
Argumentos nomeados melhoram a legibilidade nas chamadas
return devolve valores; múltiplos retornos são empacotados em tupla
Escopo segue a regra LEGB: Local, Enclosing, Global, Built-in
Funções são objetos — podem ser passadas como argumentos
Lambdas servem para funções simples de uma linha
Docstrings documentam o propósito e o uso da função

Referências e Leituras Complementares

Funções — documentação oficial — https://docs.python.org/3/tutorial/controlflow.html#defining-functions
Escopo e namespaces — https://docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces
Expressões lambda — https://docs.python.org/3/reference/expressions.html#lambda
Convenções de docstring (PEP 257) — https://peps.python.org/pep-0257/
MATTHES, Eric. Python Crash Course. 3. ed. No Starch Press, 2023. Cap. 8.
LUTZ, Mark. Learning Python. 5. ed. O'Reilly Media, 2013. Cap. 16–17.
RAMALHO, Luciano. Fluent Python. 2. ed. O'Reilly Media, 2022. Cap. 7.

Funções: definição, parâmetros e escopo Já leu