Programação imperativa descreve o programa como sequência de comandos.
Ela foca em “como fazer” passo a passo.
Primeiramente, o código modifica estado através de variáveis.
Por exemplo, loops for e while controlam o fluxo.
Além disso, condicionais if-else tomam decisões.
A voz passiva é usada aqui: “as instruções são executadas em ordem”.
Quando utilizar programação imperativa? Em scripts simples e algoritmos.
Também em código onde performance e controle são críticos.
A programação procedural é uma extensão com funções.
Ela organiza o código em blocos reutilizáveis e modulares.
Vamos explorar ambos os paradigmas com exemplos.
Três subtítulos guiarão você pelo estilo imperativo.
Ao final, você entenderá as bases de toda programação.
Imperativo puro: sequência, decisão e repetição
Programação imperativa usa três estruturas fundamentais.
Sequência executa comandos um após o outro.
Decisão (if) escolhe caminhos diferentes.
Repetição (for, while) executa blocos múltiplas vezes.
Quando usar imperativo puro? Em algoritmos simples e diretos.
Também em código de inicialização e configuração.
A voz passiva é aplicada: “as variáveis são atualizadas diretamente”.
Exemplo de programação imperativa:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
# Exemplo imperativo: cálculo de fatorial print("=== Programação Imperativa ===") n = 5 fatorial = 1 i = 1 # Sequência com repetição while i <= n: fatorial = fatorial * i # Modifica estado i = i + 1 print(f"Fatorial de {n} é {fatorial}") # Exemplo: soma de números pares até um limite limite = 10 soma_pares = 0 for numero in range(1, limite + 1): if numero % 2 == 0: # Decisão soma_pares = soma_pares + numero # Modifica estado print(f"Soma dos pares até {limite}: {soma_pares}") # Exemplo: busca linear em lista lista = [3, 7, 2, 9, 5, 1, 8] alvo = 9 encontrado = False posicao = -1 for i in range(len(lista)): if lista[i] == alvo: encontrado = True posicao = i break if encontrado: print(f"Elemento {alvo} encontrado na posição {posicao}") else: print(f"Elemento {alvo} não encontrado") # Exemplo: contagem de vogais texto = "Python é incrível" vogais = "aeiouAEIOU" contagem = 0 for letra in texto: if letra in vogais: contagem += 1 print(f"Vogais em '{texto}': {contagem}") |
Imperativo puro é simples e de fácil entendimento. Ele reflete diretamente como o computador executa.
Procedural: organizando código com funções
Programação procedural adiciona funções ao imperativo. Ela evita repetição e melhora a legibilidade. Quando usar procedural? Em projetos de médio porte. Também quando a lógica pode ser dividida em etapas. A voz passiva é aplicada: “os dados são passados entre funções”. Exemplo de programação procedural:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
# Programação procedural com funções def calcular_media(numeros): """Calcula média de uma lista de números.""" if not numeros: return 0 soma = 0 for n in numeros: soma += n return soma / len(numeros) def filtrar_maiores_que(lista, limite): """Retorna apenas números maiores que o limite.""" resultado = [] for item in lista: if item > limite: resultado.append(item) return resultado def dobrar_valores(lista): """Dobra cada valor da lista.""" resultado = [] for item in lista: resultado.append(item * 2) return resultado def main(): """Função principal que orquestra as operações.""" dados = [1, 5, 3, 8, 2, 9, 4, 7] print(f"Dados originais: {dados}") # Passo 1: Filtrar maiores que 3 filtrados = filtrar_maiores_que(dados, 3) print(f"Maiores que 3: {filtrados}") # Passo 2: Dobrar os valores dobrados = dobrar_valores(filtrados) print(f"Dobrados: {dobrados}") # Passo 3: Calcular média media = calcular_media(dobrados) print(f"Média dos dobrados: {media:.2f}") return media # Execução principal print("=== Programação Procedural ===") resultado = main() print(f"Resultado final: {resultado:.2f}") # Outro exemplo: sistema de notas def ler_notas(): """Lê notas até que o usuário digite -1.""" notas = [] while True: nota = float(input("Digite uma nota (-1 para sair): ")) if nota == -1: break if 0 <= nota <= 10: notas.append(nota) else: print("Nota inválida! Use valores entre 0 e 10.") return notas def calcular_estatisticas(notas): """Calcula média, maior e menor nota.""" if not notas: return (0, 0, 0) media = sum(notas) / len(notas) maior = max(notas) menor = min(notas) return (media, maior, menor) def exibir_resultados(estatisticas): """Exibe as estatísticas formatadas.""" media, maior, menor = estatisticas print(f"\n--- Resultados ---") print(f"Média: {media:.2f}") print(f"Maior nota: {maior}") print(f"Menor nota: {menor}") print(f"Total de notas: {len(notas)}") # Simulação sem input automático para demonstração print("\n=== Sistema de Notas (Simulado) ===") notas = [7.5, 8.0, 6.5, 9.0, 5.5] print(f"Notas simuladas: {notas}") estatisticas = calcular_estatisticas(notas) exibir_resultados(estatisticas) |
Funções tornam o código modular e reutilizável. Cada função tem uma responsabilidade única e clara.
Quando usar imperativo vs outros paradigmas
Imperativo é ótimo para scripts pequenos e algoritmos. Procedural é melhor para programas de tamanho médio. Quando evitar imperativo? Em sistemas muito complexos. Também quando o código precisa de alta reutilização. A voz passiva é aplicada: “decisões são baseadas no problema”. Exemplo comparativo entre estilos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
# ========== ESTILO IMPERATIVO PURO ========== def estilo_imperativo(): """Cálculo de soma de quadrados estilo imperativo.""" numeros = [1, 2, 3, 4, 5] soma = 0 for i in range(len(numeros)): quadrado = numeros[i] * numeros[i] soma = soma + quadrado return soma # ========== ESTILO PROCEDURAL ========== def quadrado(x): return x * x def estilo_procedural(): """Cálculo de soma de quadrados estilo procedural.""" numeros = [1, 2, 3, 4, 5] soma = 0 for n in numeros: soma = soma + quadrado(n) return soma # ========== ESTILO FUNCIONAL (para comparação) ========== def estilo_funcional(): """Cálculo de soma de quadrados estilo funcional.""" return sum(map(lambda x: x * x, [1, 2, 3, 4, 5])) print("=== Comparação de Estilos ===") print(f"Imperativo: {estilo_imperativo()}") print(f"Procedural: {estilo_procedural()}") print(f"Funcional: {estilo_funcional()}") # Quando o imperativo brilha: algoritmos com estado complexo def ordenar_bolha(lista): """Ordenação por bolha (imperativo puro).""" n = len(lista) for i in range(n - 1): for j in range(0, n - i - 1): if lista[j] > lista[j + 1]: # Troca manual temp = lista[j] lista[j] = lista[j + 1] lista[j + 1] = temp return lista lista_desordenada = [64, 34, 25, 12, 22, 11, 90] print(f"\nOrdenação por bolha:") print(f"Original: {lista_desordenada}") print(f"Ordenada: {ordenar_bolha(lista_desordenada.copy())}") # Exemplo de jogo simples (imperativo) def jogo_adivinhacao(): """Jogo de adivinhar número (imperativo).""" import random secreto = random.randint(1, 20) tentativas = 0 acertou = False print("Adivinhe o número entre 1 e 20!") while not acertou and tentativas < 5: palpite = int(input(f"Tentativa {tentativas + 1}: ")) tentativas += 1 if palpite == secreto: acertou = True print(f"Parabéns! Você acertou em {tentativas} tentativas!") elif palpite < secreto: print("Muito baixo!") else: print("Muito alto!") if not acertou: print(f"Fim de jogo! O número era {secreto}") # Demonstração sem input para não travar print("\n=== Jogo de Adivinhação (Simulado) ===") print("(Em um programa real, você digitaria os palpites)") print("O imperativo é ideal para este tipo de lógica com estado") # Fórmula da complexidade ciclomática (medida de complexidade) # [latex]M = E - N + 2P[/latex] # Onde E = arestas, N = nós, P = componentes conexos print("\nProgramação imperativa é a base de tudo.") print("Domine-a antes de partir para outros paradigmas.") |
Programação imperativa é fundamental para qualquer programador. A fórmula da complexidade imperativa pode ser expressa: \(C = \text{sequência} + \text{decisão} + \text{repetição}\) Comece com imperativo para algoritmos simples. Evolua para procedural quando o código crescer. Use outros paradigmas quando apropriado. A base sólida em imperativo nunca será substituída.