Funções são estruturas fundamentais na programação, permitindo a reutilização de código e a modularização de lógicas complexas. Vamos explorar a sintaxe e os conceitos essenciais de funções em Python.

Cenários de Uso de Funções

Considere um cenário onde percisamos processar dados de vendas repetidamente. Sem funções, o código pode se tornar redundante:

vendas = [100, 200, 300, 400]
total = 0
for valor in vendas:
    total += valor
media = total / len(vendas)
print(f"Total: {total}, Média: {media}")

# Repetição semelhante para outro conjunto de dados
outras_vendas = [50, 150, 250]
total2 = 0
for valor in outras_vendas:
    total2 += valor
media2 = total2 / len(outras_vendas)
print(f"Total: {total2}, Média: {media2}")

Para eliminar essa duplicidade, encapsulamos a lógica em uma função:

def calcular_estatisticas(dados):
    soma = 0
    for elemento in dados:
        soma += elemento
    media_calculada = soma / len(dados) if len(dados) > 0 else 0
    return soma, media_calculada

vendas_1 = [100, 200, 300, 400]
total_1, media_1 = calcular_estatisticas(vendas_1)
print(f"Total: {total_1}, Média: {media_1}")

vendas_2 = [50, 150, 250]
total_2, media_2 = calcular_estatisticas(vendas_2)
print(f"Total: {total_2}, Média: {media_2}")

Ao definir a função calcular_estatisticas, reutilizamos o código simplesmente chamando-a com diferentes argumentos.

Estrutura Sintática Básica

A definição de uma função segue o padrão:

def nome_da_funcao():
    corpo_da_funcao

nome_da_funcao()  # Chamada

A palavra-chave def inicia a definição, seguida pelo nome e parênteses. O corpo é indentado e executado apenas quando a função é chamada.

Estruturas Avançadas

Funções podem incluir parâmetros e valores de retorno.

Função Vazia: Usada como maracdor durante o desenvolvimento.

def funcao_vazia():
    pass

Função com Parâmetros: Aceita entradas para processamento.

def saudacao(nome):
    print(f"Olá, {nome}!")

saudacao("Maria")

Função com Retorno: Devolve um valor ao chamador.

def quadrado(numero):
    resultado = numero ** 2
    return resultado

valor = quadrado(5)
print(valor)  # Saída: 25

Valores de Retorno

O valor de retorno é a saída produzida por uma função. Métodos embutidos, como pop em listas, exemplificam isso:

lista_exemplo = [10, 20, 30]
item_removido = lista_exemplo.pop()
print(item_removido)  # 30
nova_lista = lista_exemplo
print(nova_lista)  # [10, 20]

A palavra-chave return define o valor de retorno. Se omitido, a função retorna None.

def verificar_par(numero):
    if numero % 2 == 0:
        return True
    return False

resultado = verificar_par(4)
print(resultado)  # True

def imprimir_mensagem():
    print("Processando...")
    # Sem return explícito, retorna None

saida = imprimir_mensagem()
print(saida)  # None

Múltiplos valores são retornados como uma tupla:

def min_max(dados):
    menor = min(dados)
    maior = max(dados)
    return menor, maior

valores = [3, 1, 4, 1, 5]
min_val, max_val = min_max(valores)
print(min_val, max_val)  # 1 5

Parâmetros de Funções (Foco Principal)

Funções podem ser sem parâmetros ou com parâmetros, permitindo a passagem de dados.

Parâmetros Formais vs. Argumentos Reais

Parâmetros formais são variáveis declaradas na definição. Argumentos reais são os valores passados na chamada.

def calcular_desconto(preco, taxa):
    desconto = preco * (taxa / 100)
    return preco - desconto

preco_final = calcular_desconto(100, 10)
print(preco_final)  # 90.0

Aqui, preco e taxa são parâmetros formais; 100 e 10 são argumentos reais.

Argumentos Posicionais

Passados na ordem definida:

def concatenar(texto1, texto2):
    return texto1 + " " + texto2

resultado = concatenar("Bom", "dia")
print(resultado)  # Bom dia

Argumentos por Palavra-chave

Permitem especificar quais parâmetros recebem quais valores:

def exibir_info(nome, idade):
    print(f"{nome} tem {idade} anos")

exibir_info(idade=25, nome="Carlos")

Ao misturar argumentos posicionais e por palavra-chave, os posicionais devem vir primeiro:

def funcao_mista(a, b, c):
    print(a, b, c)

funcao_mista(1, c=3, b=2)  # Saída: 1 2 3

Parâmetros Padrão

Definem valores default, usados quando não fornecidos:

def gerar_relatorio(dados, formato="texto"):
    if formato == "texto":
        print("Relatório em texto:", dados)
    else:
        print("Relatório em outro formato:", dados)

gerar_relatorio([1, 2, 3])  # Usa formato padrão "texto"
gerar_relatorio([4, 5, 6], formato="gráfico")

Parâmetros padrão devem seguir os não-padrão na definição.

Parâmetros Variáveis (*args e **kwargs)

*args coleta argumentos posicionais adicionais em uma tupla:

def soma_variavel(*numeros):
    total = 0
    for num in numeros:
        total += num
    return total

print(soma_variavel(1, 2, 3))  # 6
print(soma_variavel(10, 20))   # 30

**kwargs coleta argumentos por palavra-chave adicionais em um dicionário:

def mostrar_configuracoes(**opcoes):
    for chave, valor in opcoes.items():
        print(f"{chave}: {valor}")

mostrar_configuracoes(tema="claro", fonte="Arial")

Esses parâmetros podem ser combinados com outros:

def funcao_complexa(a, b=10, *args, **kwargs):
    print(a, b)
    print("args:", args)
    print("kwargs:", kwargs)

funcao_complexa(1, 2, 3, 4, chave="valor")
# Saída:
# 1 2
# args: (3, 4)
# kwargs: {'chave': 'valor'}

Na chamada, * desempcaota iteráveis e ** desempacota dicionários:

def processar(a, b, c):
    print(a, b, c)

lista = [10, 20, 30]
processar(*lista)  # 10 20 30

dicionario = {'a': 1, 'b': 2, 'c': 3}
processar(**dicionario)  # 1 2 3

Ordem dos Parâmetros na Definição

A ordem recomendada é: parâmetros normais, parâmetros padrão, *args, **kwargs.

def exemplo_final(x, y=5, *args, **kwargs):
    print(f"x={x}, y={y}")
    print("args:", args)
    print("kwargs:", kwargs)

exemplo_final(1, 2, 3, 4, nome="teste")
# Saída:
# x=1, y=2
# args: (3, 4)
# kwargs: {'nome': 'teste'}

Exercício Prático

Crie funções para gerenciar uma lista de tarefas. Implemente adicionar_tarefa e listar_tarefas.

tarefas = []

def adicionar_tarefa(descricao, prioridade="média"):
    nova_tarefa = {"descricao": descricao, "prioridade": prioridade, "concluida": False}
    tarefas.append(nova_tarefa)
    print(f"Tarefa adicionada: {descricao}")

def listar_tarefas():
    if not tarefas:
        print("Nenhuma tarefa cadastrada.")
    else:
        for i, tarefa in enumerate(tarefas, 1):
            status = "Concluída" if tarefa["concluida"] else "Pendente"
            print(f"{i}. {tarefa['descricao']} - Prioridade: {tarefa['prioridade']} - {status}")

# Uso
adicionar_tarefa("Estudar Python")
adicionar_tarefa("Fazer exercícios", prioridade="alta")
listar_tarefas()