Fundamentos de Funções

Até agora, seu código foi executando linha por linha. Mas e se você precisar reutilizar a mesma funcionalidade? Copiar e colar toda vez? Funções resolvem esse problema — empacote um bloco de código, dê um nome a ele, e chame-o sempre que precisar. Este é o primeiro passo de "escrever código" para "organizar código."

1. O que é uma Função

Uma função é um bloco de código nomeado que você pode chamar a qualquer momento.

# Define uma função
def say_hello():
    print("Olá!")
    print("Bem-vindo ao Python!")

# Chama a função
say_hello()
say_hello()      # Pode chamar várias vezes

Saída:

Olá!
Bem-vindo ao Python!
Olá!
Bem-vindo ao Python!

2. Parâmetros: Passando Dados para Funções

Funções podem aceitar parâmetros para torná-las mais flexíveis:

def greet(name):
    """Cumprimenta uma pessoa pelo nome"""
    print(f"Olá, {name}! Bem-vindo ao Python.")

greet("João Silva")     # Olá, João Silva! Bem-vindo ao Python.
greet("Maria Souza")    # Olá, Maria Souza! Bem-vindo ao Python.

Múltiplos Parâmetros

def introduce(name, age, city):
    print(f"Meu nome é {name}, tenho {age} anos, sou de {city}.")

introduce("João Silva", 25, "São Paulo")
introduce("Maria Souza", 30, "Rio de Janeiro")

Ordem dos Parâmetros: Argumentos Posicionais

Ao chamar uma função, os argumentos são correspondidos por posição:

def create_user(name, age, is_admin):
    print(f"Criando usuário: {name}, Idade: {age}, Admin: {is_admin}")

create_user("João Silva", 25, False)    # Correspondido por ordem
create_user(False, "João Silva", 25)    # Ordem errada — incompatível!

Exemplo: Funções de Calculadora (Dificuldade ⭐)

def add(a, b):
    print(f"{a} + {b} = {a + b}")

def multiply(a, b):
    print(f"{a} * {b} = {a * b}")

add(5, 3)          # 5 + 3 = 8
multiply(5, 3)     # 5 * 3 = 15

3. Valores de Retorno

Funções podem usar return para enviar um resultado de volta ao chamador:

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

result = add(5, 3)
print(result)               # 8

# Valores de retorno podem ser usados diretamente em expressões
total = add(10, 20) + add(30, 40)
print(total)                # 100

Múltiplos Valores de Retorno

Python pode retornar vários valores de uma vez (essencialmente retornando uma tupla):

def get_min_max(numbers):
    return min(numbers), max(numbers)

result = get_min_max([3, 1, 4, 1, 5])
print(result)               # (1, 5)

# Desempacota diretamente o resultado
low, high = get_min_max([3, 1, 4, 1, 5])
print(f"Min: {low}, Max: {high}")

Como return Funciona

return imediatamente encerra a execução da função; código após ele não será executado:

def check_age(age):
    if age < 0:
        return "Idade não pode ser negativa!"    # Retorno antecipado
    if age < 18:
        return "Menor de idade"
    return "Adulto"

print(check_age(-5))     # Idade não pode ser negativa!
print(check_age(15))     # Menor de idade
print(check_age(25))     # Adulto

Exemplo: Ferramenta de Conversão de Temperatura (Dificuldade ⭐⭐)

def celsius_to_fahrenheit(c):
    """Converte Celsius para Fahrenheit"""
    return c * 9 / 5 + 32

def fahrenheit_to_celsius(f):
    """Converte Fahrenheit para Celsius"""
    return (f - 32) * 5 / 9

# Teste
print(f"0°C = {celsius_to_fahrenheit(0):.1f}°F")      # 32.0°F
print(f"100°C = {celsius_to_fahrenheit(100):.1f}°F")   # 212.0°F
print(f"32°F = {fahrenheit_to_celsius(32):.1f}°C")     # 0.0°C
print(f"212°F = {fahrenheit_to_celsius(212):.1f}°C")   # 100.0°C

4. Docstrings

O comentário na primeira linha após a definição da função, escrito com """, é o docstring — explica o que a função faz:

def calculate_bmi(weight, height):
    """
    Calcula o Índice de Massa Corporal (IMC)

    Parâmetros:
        weight (float): Peso corporal em kg
        height (float): Altura corporal em m

    Retorna:
        float: Valor do IMC
    """
    return weight / (height ** 2)

# Visualiza o docstring
print(calculate_bmi.__doc__)
help(calculate_bmi)

5. Pilha de Chamada de Função

Quando uma função chama outra, Python mantém uma "pilha de chamada" na memória:

def a():
    print("Entrando em a")
    b()
    print("Saindo de a")

def b():
    print("Entrando em b")
    c()
    print("Saindo de b")

def c():
    print("Entrando em c")
    print("Saindo de c")

a()

Saída:

Entrando em a
Entrando em b
Entrando em c
Saindo de c
Saindo de b
Saindo de a

Como uma pilha de pratos — o último colocado é o primeiro retirado. Esta estrutura "último a entrar, primeiro a sair" é chamada de pilha. Chamadas de função profundamente aninhadas podem causar "estouro de pilha" (ex.: recursão sem condição de término).

Casos de Uso Comuns

• Reutilização de código: Extraia lógica repetida em funções, defina uma vez e chame de múltiplos lugares.
• Programação modular: Cada função faz uma coisa (responsabilidade única), facilitando teste e manutenção.
• Encapsulamento de lógica de cálculo: Encapsule fórmulas matemáticas, transformações de dados, validações de formato, etc., em funções.
• Controle de fluxo: Use funções com múltiplos valores de retorno para lidar com múltiplos cenários (erros, valores vazios, resultados normais).

❓ Perguntas Frequentes

P: Qual a diferença entre return e print()? R: return envia o resultado de volta ao chamador; print() apenas exibe saída no console. Uma função precisa de return para passar um valor para fora. Com print(), você só pode vê-lo — não pode usá-lo. P: Uma função pode ter múltiplas declarações return? R: Sim. Uma função pode ter múltiplas declarações return, mas apenas a primeira encontrada será executada — ela imediatamente encerra a função. Isso é comum em lógica condicional: diferentes condições retornam valores diferentes. P: Uma função precisa ter parâmetros? R: Não. Funções sem parâmetros são perfeitamente válidas. Por exemplo, def get_current_time(): não precisa de parâmetros e retorna diretamente a hora atual (usando o módulo datetime). O número de parâmetros depende se a função precisa de dados externos.

📖 Resumo

• Funções são definidas com def, empacotando código em blocos nomeados reutilizáveis
• Parâmetros tornam as funções flexíveis; são correspondidos por posição
• return envia um resultado e encerra a função; múltiplos valores de retorno são essencialmente uma tupla
• Funções sem return retornam None
• Docstrings usam """ para descrever funções; visualizados com help()
• A pilha de chamada de função é uma estrutura último-a-entrar-primeiro-a-sair; aninhamento profundo pode causar estouro de pilha

📝 Atividades

1. Iniciante (Dificuldade ⭐): Escreva uma função is_even(n) que recebe um inteiro e retorna True se for par, False caso contrário. Use o operador %.

2. Intermediário (Dificuldade ⭐⭐): Escreva uma função grade(score) que recebe uma nota (0-100) e retorna a letra correspondente: 90+ retorna "A", 80-89 retorna "B", 70-79 retorna "C", 60-69 retorna "D", abaixo de 60 retorna "F". Use if-elif para implementar.

3. Avançado (Dificuldade ⭐⭐⭐): Escreva três funções add(), subtract(), multiply(). Depois escreva uma quarta função calculate(a, b, operator) que recebe dois números e uma string de operador ("+", "-", "*"), chama a função correspondente e retorna o resultado. Se o operador não for suportado, retorne None.