antonino, Autor em Área de Trampo

Sequência em Python

22/05/202622/04/2026 Por antonino

Sequência é a estrutura mais básica da programação imperativa. Ela executa comandos um após o outro, na ordem escrita. Primeiramente, cada linha aguarda a anterior terminar. Por exemplo, três atribuições rodam em sequência estrita. Além disso, a sequência é a base de todo programa Python. Assim, você precisa dominá-la antes de tudo. Consequentemente, a depuração se torna muito mais simples. Quando utilizar sequência pura? Em scripts lineares e simples. Também em cálculos diretos sem decisões ou repetições. Por outro lado, para lógica complexa, adicione condicionais. Toda programação começa com a compreensão da sequência. Então, vamos explorar características, exemplos e aplicações. Três subtítulos guiarão você pela execução linear. Portanto, ao final, você dominará o fluxo mais fundamental.

Execução linear: passo a passo

Python executa o código de cima para baixo. Cada comando completa antes do próximo começar. Quando usar execução linear? Em cálculos sequenciais. Por exemplo, fórmulas matemáticas ou processamento de dados. Além disso, você pode rastrear facilmente cada etapa. Exemplo de execução sequencial:

# Execução linha a linha (sequência pura)
print("=== Sequência Pura ===")

# Passo 1: Definir variáveis
x = 10
y = 5

# Passo 2: Realizar operações
soma = x + y
subtracao = x - y
multiplicacao = x * y
divisao = x / y

# Passo 3: Exibir resultados
print(f"x = {x}, y = {y}")
print(f"Soma: {soma}")
print(f"Subtração: {subtracao}")
print(f"Multiplicação: {multiplicacao}")
print(f"Divisão: {divisao}")

# Sequência em cálculos encadeados
print("\n=== Cálculos Encadeados ===")
a = 5
b = 3
c = a + b  # Primeiro calcula a+b
d = c * 2  # Depois usa o resultado
e = d - 4  # Depois usa o resultado anterior
print(f"a={a}, b={b}, c={c}, d={d}, e={e}")

# Sequência com entrada e saída
print("\n=== Interação Sequencial ===")
nome = input("Digite seu nome: ")
idade = input("Digite sua idade: ")
print(f"Olá {nome}, você tem {idade} anos!")

# Execução linha a linha (sequência pura)

print("=== Sequência Pura ===")

# Passo 1: Definir variáveis

x = 10

y = 5

# Passo 2: Realizar operações

soma = x + y

subtracao = x - y

multiplicacao = x * y

divisao = x / y

# Passo 3: Exibir resultados

print(f"x = {x}, y = {y}")

print(f"Soma: {soma}")

print(f"Subtração: {subtracao}")

print(f"Multiplicação: {multiplicacao}")

print(f"Divisão: {divisao}")

# Sequência em cálculos encadeados

print("\n=== Cálculos Encadeados ===")

a = 5

b = 3

c = a + b # Primeiro calcula a+b

d = c * 2 # Depois usa o resultado

e = d - 4 # Depois usa o resultado anterior

print(f"a={a}, b={b}, c={c}, d={d}, e={e}")

# Sequência com entrada e saída

print("\n=== Interação Sequencial ===")

nome = input("Digite seu nome: ")

idade = input("Digite sua idade: ")

print(f"Olá {nome}, você tem {idade} anos!")

Sequência é intuitiva e fácil de depurar. Cada passo pode ser verificado individualmente. Portanto, comece seus programas sempre com sequência.

Sequência em algoritmos do dia a dia

Muitos problemas reais seguem uma sequência natural. Por exemplo, fazer um bolo segue uma receita passo a passo. Quando usar sequência no dia a dia? Em tarefas lineares. Também em scripts de automação e processamento de dados. Assim, você resolve problemas sem complicação desnecessária. Exemplo de algoritmos sequenciais:

# Conversão de temperatura (sequência pura)
print("=== Conversão de Temperatura ===")
celsius = 25
fahrenheit = (celsius * 9/5) + 32
kelvin = celsius + 273.15
print(f"{celsius}°C = {fahrenheit}°F = {kelvin}K")

# Cálculo do IMC (sequência pura)
print("\n=== Cálculo do IMC ===")
peso = 70  # kg
altura = 1.75  # metros
imc = peso / (altura ** 2)
print(f"Peso: {peso}kg, Altura: {altura}m")
print(f"IMC: {imc:.2f}")

# Área de figuras geométricas
print("\n=== Área de Figuras ===")
# Retângulo
largura = 10
altura_ret = 5
area_retangulo = largura * altura_ret
print(f"Retângulo {largura}x{altura_ret}: área = {area_retangulo}")

# Círculo
import math
raio = 4
area_circulo = math.pi * raio ** 2
print(f"Círculo raio {raio}: área = {area_circulo:.2f}")

# Triângulo
base = 8
altura_tri = 6
area_triangulo = (base * altura_tri) / 2
print(f"Triângulo base {base}, altura {altura_tri}: área = {area_triangulo}")

# Sequência em processamento de strings
print("\n=== Processamento de Strings ===")
frase = "  Python é incrível  "
frase_limpa = frase.strip()  # Remove espaços
frase_maiuscula = frase_limpa.upper()  # Converte para maiúsculo
palavras = frase_maiuscula.split()  # Divide em palavras
print(f"Original: '{frase}'")
print(f"Após strip: '{frase_limpa}'")
print(f"Após upper: '{frase_maiuscula}'")
print(f"Palavras: {palavras}")

# Conversão de temperatura (sequência pura)

print("=== Conversão de Temperatura ===")

celsius = 25

fahrenheit = (celsius * 9/5) + 32

kelvin = celsius + 273.15

print(f"{celsius}°C = {fahrenheit}°F = {kelvin}K")

# Cálculo do IMC (sequência pura)

print("\n=== Cálculo do IMC ===")

peso = 70 # kg

altura = 1.75 # metros

imc = peso / (altura ** 2)

print(f"Peso: {peso}kg, Altura: {altura}m")

print(f"IMC: {imc:.2f}")

# Área de figuras geométricas

print("\n=== Área de Figuras ===")

# Retângulo

largura = 10

altura_ret = 5

area_retangulo = largura * altura_ret

print(f"Retângulo {largura}x{altura_ret}: área = {area_retangulo}")

# Círculo

import math

raio = 4

area_circulo = math.pi * raio ** 2

print(f"Círculo raio {raio}: área = {area_circulo:.2f}")

# Triângulo

base = 8

altura_tri = 6

area_triangulo = (base * altura_tri) / 2

print(f"Triângulo base {base}, altura {altura_tri}: área = {area_triangulo}")

# Sequência em processamento de strings

print("\n=== Processamento de Strings ===")

frase = " Python é incrível "

frase_limpa = frase.strip() # Remove espaços

frase_maiuscula = frase_limpa.upper() # Converte para maiúsculo

palavras = frase_maiuscula.split() # Divide em palavras

print(f"Original: '{frase}'")

print(f"Após strip: '{frase_limpa}'")

print(f"Após upper: '{frase_maiuscula}'")

print(f"Palavras: {palavras}")

A sequência reflete o pensamento linear humano. Ela é perfeita para problemas que não exigem ramificações. Portanto, use sequência para tarefas diretas.

Depuração e rastreamento sequencial

Depurar código sequencial é simples e direto. Você pode adicionar prints entre cada passo. Quando usar depuração sequencial? Em código linear. Também para entender o fluxo de valores passo a passo. Além disso, você inspeciona cada estado intermediário. Exemplo de rastreamento sequencial:

# Rastreamento com prints
print("=== Rastreamento Sequencial ===")

# Função para simular processamento
def processar_dados(dados):
    print(f"1. Entrada: {dados}")
    
    # Passo 1: Filtrar valores negativos
    dados_positivos = [x for x in dados if x > 0]
    print(f"2. Após filtro (positivos): {dados_positivos}")
    
    # Passo 2: Calcular quadrados
    quadrados = [x ** 2 for x in dados_positivos]
    print(f"3. Quadrados: {quadrados}")
    
    # Passo 3: Calcular soma
    soma = sum(quadrados)
    print(f"4. Soma dos quadrados: {soma}")
    
    # Passo 4: Calcular média
    media = soma / len(quadrados) if quadrados else 0
    print(f"5. Média: {media:.2f}")
    
    return media

dados_teste = [-3, 2, -5, 4, 6, -1, 8]
resultado = processar_dados(dados_teste)
print(f"Resultado final: {resultado:.2f}")

# Depuração com variáveis de rastreamento
print("\n=== Depuração com Acumulador ===")
def calcular_estatisticas_sequenciais(valores):
    """Calcula várias estatísticas sequencialmente."""
    print(f"Processando {len(valores)} valores...")
    
    # Soma e contagem (para média)
    soma = 0
    contador = 0
    for v in valores:
        soma += v
        contador += 1
        print(f"  Após adicionar {v}: soma={soma}, cont={contador}")
    
    media = soma / contador if contador > 0 else 0
    
    # Encontrar máximo e mínimo
    maximo = valores[0] if valores else 0
    minimo = valores[0] if valores else 0
    
    for v in valores:
        if v > maximo:
            print(f"  Novo máximo: {v} (era {maximo})")
            maximo = v
        if v < minimo:
            print(f"  Novo mínimo: {v} (era {minimo})")
            minimo = v
    
    return {"soma": soma, "media": media, "max": maximo, "min": minimo}

numeros = [5, 2, 8, 1, 9, 3]
stats = calcular_estatisticas_sequenciais(numeros)
print(f"\nResultados: {stats}")

# Ordem das operações importa
print("\n=== Importância da Ordem ===")
# Exemplo correto
a = 5
b = a + 2
c = b * 3
print(f"Ordem correta: a={a}, b={b}, c={c}")

# Ordem trocada (daria erro se executado)
# c = b * 3  # b ainda não foi definido
# b = a + 2
# a = 5
print("A ordem das instruções define o resultado!")

# Rastreamento com prints

print("=== Rastreamento Sequencial ===")

# Função para simular processamento

def processar_dados(dados):

print(f"1. Entrada: {dados}")

# Passo 1: Filtrar valores negativos

dados_positivos = [x for x in dados if x > 0]

print(f"2. Após filtro (positivos): {dados_positivos}")

# Passo 2: Calcular quadrados

quadrados = [x ** 2 for x in dados_positivos]

print(f"3. Quadrados: {quadrados}")

# Passo 3: Calcular soma

soma = sum(quadrados)

print(f"4. Soma dos quadrados: {soma}")

# Passo 4: Calcular média

media = soma / len(quadrados) if quadrados else 0

print(f"5. Média: {media:.2f}")

return media

dados_teste = [-3, 2, -5, 4, 6, -1, 8]

resultado = processar_dados(dados_teste)

print(f"Resultado final: {resultado:.2f}")

# Depuração com variáveis de rastreamento

print("\n=== Depuração com Acumulador ===")

def calcular_estatisticas_sequenciais(valores):

"""Calcula várias estatísticas sequencialmente."""

print(f"Processando {len(valores)} valores...")

# Soma e contagem (para média)

soma = 0

contador = 0

for v in valores:

soma += v

contador += 1

print(f" Após adicionar {v}: soma={soma}, cont={contador}")

media = soma / contador if contador > 0 else 0

# Encontrar máximo e mínimo

maximo = valores[0] if valores else 0

minimo = valores[0] if valores else 0

for v in valores:

if v > maximo:

print(f" Novo máximo: {v} (era {maximo})")

maximo = v

if v < minimo:

print(f" Novo mínimo: {v} (era {minimo})")

minimo = v

return {"soma": soma, "media": media, "max": maximo, "min": minimo}

numeros = [5, 2, 8, 1, 9, 3]

stats = calcular_estatisticas_sequenciais(numeros)

print(f"\nResultados: {stats}")

# Ordem das operações importa

print("\n=== Importância da Ordem ===")

# Exemplo correto

a = 5

b = a + 2

c = b * 3

print(f"Ordem correta: a={a}, b={b}, c={c}")

# Ordem trocada (daria erro se executado)

# c = b * 3 # b ainda não foi definido

# b = a + 2

# a = 5

print("A ordem das instruções define o resultado!")

Sequência é a base para entender fluxogramas. A fórmula da execução sequencial é trivial: \(S = \text{linha}_1 \to \text{linha}_2 \to \text{linha}_3 \to \dots\) Domine a sequência antes de aprender condicionais e loops. Todo programa é uma sequência de instruções executadas. Portanto, seu código será mais claro se você respeitar a ordem natural. Finalmente, pratique sequência em todos os seus primeiros programas.

Programação Imperativa e Procedural

22/05/202622/04/2026 Por antonino

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:

# 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}")

# 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:

# 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)

# 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:

# ========== 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.")

# ========== 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.