Arquivo de Imperativa ou Procedural

Funções como Sub-rotinas

25/04/202622/04/2026 Por antonino

– Python
– Imperativa / Procedural
1 – Sequencia (linha a linha)
2 – Condicionais (if/elif/else)
3 – Lacos (for, while)
4 – Funcoes como sub-rotinas

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Funções são blocos de código reutilizáveis com um nome. Elas funcionam como sub-rotinas que executam uma tarefa específica. Primeiramente, funções evitam repetição de código (DRY). Por exemplo, você escreve uma fórmula uma vez e reutiliza. Além disso, funções dividem problemas grandes em partes menores. A voz passiva é usada aqui: “o código é organizado em blocos lógicos”. Quando utilizar funções como sub-rotinas? Em praticamente todo programa. Também para isolar funcionalidades e facilitar testes. Python usa def para definir funções. Vamos explorar criação, parâmetros e retorno de valores. Três subtítulos guiarão você pelo mundo das funções. Ao final, você escreverá código modular e reutilizável.

Criando e chamando funções básicas

Use def nome(): para definir uma função. O corpo da função fica indentado abaixo da definição. Para executar a função, chame-a pelo nome com parênteses. Quando usar funções simples? Para agrupar instruções relacionadas. A voz passiva é aplicada: “os argumentos são passados entre parênteses”. Exemplo de funções básicas:

# Função simples sem parâmetros
def saudacao():
    """Exibe uma saudação simples."""
    print("Olá, bem-vindo ao Python!")

# Função com um parâmetro
def saudacao_personalizada(nome):
    """Saudação com o nome do usuário."""
    print(f"Olá, {nome}!")

# Função com retorno
def somar(a, b):
    """Retorna a soma de dois números."""
    return a + b

# Função com múltiplos parâmetros
def area_retangulo(largura, altura):
    """Calcula a área de um retângulo."""
    return largura * altura

# Chamando as funções
print("=== Funções Básicas ===")
saudacao()
saudacao_personalizada("Ana")

resultado = somar(10, 5)
print(f"Soma: {resultado}")

area = area_retangulo(8, 6)
print(f"Área do retângulo: {area}")

# Função com valor padrão
def cumprimentar(nome, saudacao="Olá"):
    """Saudação com valor padrão."""
    return f"{saudacao}, {nome}!"

print(cumprimentar("Carlos"))
print(cumprimentar("Maria", "Bom dia"))

# Função que retorna múltiplos valores
def operacoes_basicas(a, b):
    """Retorna soma, subtração, multiplicação e divisão."""
    soma = a + b
    subtracao = a - b
    multiplicacao = a * b
    divisao = a / b if b != 0 else None
    return soma, subtracao, multiplicacao, divisao

s, sub, m, d = operacoes_basicas(10, 3)
print(f"\nOperações: soma={s}, sub={sub}, mult={m}, div={d:.2f}")

# Função simples sem parâmetros

def saudacao():

"""Exibe uma saudação simples."""

print("Olá, bem-vindo ao Python!")

# Função com um parâmetro

def saudacao_personalizada(nome):

"""Saudação com o nome do usuário."""

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

# Função com retorno

def somar(a, b):

"""Retorna a soma de dois números."""

return a + b

# Função com múltiplos parâmetros

def area_retangulo(largura, altura):

"""Calcula a área de um retângulo."""

return largura * altura

# Chamando as funções

print("=== Funções Básicas ===")

saudacao()

saudacao_personalizada("Ana")

resultado = somar(10, 5)

print(f"Soma: {resultado}")

area = area_retangulo(8, 6)

print(f"Área do retângulo: {area}")

# Função com valor padrão

def cumprimentar(nome, saudacao="Olá"):

"""Saudação com valor padrão."""

return f"{saudacao}, {nome}!"

print(cumprimentar("Carlos"))

print(cumprimentar("Maria", "Bom dia"))

# Função que retorna múltiplos valores

def operacoes_basicas(a, b):

"""Retorna soma, subtração, multiplicação e divisão."""

soma = a + b

subtracao = a - b

multiplicacao = a * b

divisao = a / b if b != 0 else None

return soma, subtracao, multiplicacao, divisao

s, sub, m, d = operacoes_basicas(10, 3)

print(f"\nOperações: soma={s}, sub={sub}, mult={m}, div={d:.2f}")

Funções tornam o código mais organizado e legível. Cada função deve ter uma única responsabilidade clara.

Parâmetros: passando dados para funções

Parâmetros são variáveis que a função recebe para processar. Python suporta parâmetros posicionais e nomeados. Argumentos padrão tornam parâmetros opcionais. Quando usar diferentes tipos? Para flexibilidade na chamada. A voz passiva é aplicada: “os valores são passados na ordem definida”. Exemplo de parâmetros:

# Parâmetros posicionais (ordem importa)
def descrever_pessoa(nome, idade, cidade):
    return f"{nome}, {idade} anos, mora em {cidade}"

print("=== Parâmetros Posicionais ===")
print(descrever_pessoa("Ana", 25, "São Paulo"))

# Parâmetros nomeados (ordem não importa)
print("\n=== Parâmetros Nomeados ===")
print(descrever_pessoa(cidade="Rio", idade=30, nome="Carlos"))

# Parâmetros com valores padrão
def criar_usuario(nome, ativo=True, nivel="comum"):
    """Cria usuário com valores padrão."""
    return {"nome": nome, "ativo": ativo, "nivel": nivel}

print("\n=== Valores Padrão ===")
print(criar_usuario("Ana"))
print(criar_usuario("Carlos", ativo=False))
print(criar_usuario("Beatriz", nivel="admin"))

# *args (número variável de argumentos posicionais)
def soma_varios(*numeros):
    """Soma qualquer quantidade de números."""
    return sum(numeros)

print("\n=== *args (múltiplos argumentos) ===")
print(f"soma_varios(1,2,3): {soma_varios(1, 2, 3)}")
print(f"soma_varios(10,20,30,40): {soma_varios(10, 20, 30, 40)}")

# **kwargs (número variável de argumentos nomeados)
def exibir_dados(**dados):
    """Exibe dados nomeados recebidos."""
    for chave, valor in dados.items():
        print(f"  {chave}: {valor}")

print("\n=== **kwargs ===")
exibir_dados(nome="Ana", idade=25, cidade="São Paulo")

# Combinando parâmetros
def funcao_completa(a, b, *args, opcao="padrao", **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"opcao={opcao}")
    print(f"kwargs={kwargs}")

print("\n=== Função Completa ===")
funcao_completa(1, 2, 3, 4, 5, opcao="especial", x=10, y=20)

# Parâmetros posicionais (ordem importa)

def descrever_pessoa(nome, idade, cidade):

return f"{nome}, {idade} anos, mora em {cidade}"

print("=== Parâmetros Posicionais ===")

print(descrever_pessoa("Ana", 25, "São Paulo"))

# Parâmetros nomeados (ordem não importa)

print("\n=== Parâmetros Nomeados ===")

print(descrever_pessoa(cidade="Rio", idade=30, nome="Carlos"))

# Parâmetros com valores padrão

def criar_usuario(nome, ativo=True, nivel="comum"):

"""Cria usuário com valores padrão."""

return {"nome": nome, "ativo": ativo, "nivel": nivel}

print("\n=== Valores Padrão ===")

print(criar_usuario("Ana"))

print(criar_usuario("Carlos", ativo=False))

print(criar_usuario("Beatriz", nivel="admin"))

# *args (número variável de argumentos posicionais)

def soma_varios(*numeros):

"""Soma qualquer quantidade de números."""

return sum(numeros)

print("\n=== *args (múltiplos argumentos) ===")

print(f"soma_varios(1,2,3): {soma_varios(1, 2, 3)}")

print(f"soma_varios(10,20,30,40): {soma_varios(10, 20, 30, 40)}")

# **kwargs (número variável de argumentos nomeados)

def exibir_dados(**dados):

"""Exibe dados nomeados recebidos."""

for chave, valor in dados.items():

print(f" {chave}: {valor}")

print("\n=== **kwargs ===")

exibir_dados(nome="Ana", idade=25, cidade="São Paulo")

# Combinando parâmetros

def funcao_completa(a, b, *args, opcao="padrao", **kwargs):

print(f"a={a}, b={b}")

print(f"args={args}")

print(f"opcao={opcao}")

print(f"kwargs={kwargs}")

print("\n=== Função Completa ===")

funcao_completa(1, 2, 3, 4, 5, opcao="especial", x=10, y=20)

Parâmetros flexíveis tornam funções reutilizáveis. Escolha o tipo certo para cada situação.

Escopo, docstrings e boas práticas

Variáveis dentro da função são locais (escopo local). Variáveis fora são globais (use global para modificar). Docstrings documentam o propósito da função. Quando usar escopo global? Evite ao máximo. Prefira passar valores como parâmetros e retornar resultados. A voz passiva é aplicada: “a documentação é gerada automaticamente”. Exemplo de escopo e documentação:

# Escopo de variáveis
mensagem_global = "Fora da função"

def exemplo_escopo():
    mensagem_local = "Dentro da função"
    global mensagem_global
    mensagem_global = "Modificada globalmente"
    print(f"Local: {mensagem_local}")
    print(f"Global dentro: {mensagem_global}")

print("=== Escopo ===")
print(f"Global antes: {mensagem_global}")
exemplo_escopo()
print(f"Global depois: {mensagem_global}")

# Docstrings (documentação)
def calcular_imposto(valor, aliquota=0.1):
    """
    Calcula o imposto sobre um valor.
    
    Parâmetros:
    valor (float): O valor base para cálculo
    aliquota (float): Percentual do imposto (padrão 0.1 = 10%)
    
    Retorna:
    float: O valor do imposto calculado
    
    Exemplo:
    >>> calcular_imposto(1000, 0.15)
    150.0
    """
    return valor * aliquota

print("\n=== Docstrings ===")
print(f"Imposto: R${calcular_imposto(1000):.2f}")
print(f"Ajuda da função: {calcular_imposto.__doc__[:80]}...")

# Boas práticas: funções pequenas e focadas
def validar_email(email):
    """Valida formato básico de e-mail."""
    return "@" in email and "." in email

def formatar_nome(nome):
    """Formata nome com primeira letra maiúscula."""
    return nome.strip().title()

def criar_saudacao_completa(nome, email):
    """Cria saudação completa com validação."""
    if not validar_email(email):
        return f"Olá {formatar_nome(nome)}, e-mail inválido!"
    return f"Olá {formatar_nome(nome)}, seu e-mail {email} está válido!"

print("\n=== Boas Práticas ===")
print(criar_saudacao_completa("ana silva", "ana@email.com"))
print(criar_saudacao_completa("carlos", "carlos_invalido"))

# Função como sub-rotina em pipeline
def extrair_dados(texto):
    return texto.split()

def limpar_dados(palavras):
    return [p.strip(".,!?").lower() for p in palavras]

def contar_palavras(palavras):
    return len(palavras)

def processar_texto(texto):
    """Pipeline de processamento de texto."""
    dados = extrair_dados(texto)
    limpos = limpar_dados(dados)
    return contar_palavras(limpos)

texto_exemplo = "Python é incrível! Python é poderoso."
print(f"\nPipeline: {processar_texto(texto_exemplo)} palavras")

# Escopo de variáveis

mensagem_global = "Fora da função"

def exemplo_escopo():

mensagem_local = "Dentro da função"

global mensagem_global

mensagem_global = "Modificada globalmente"

print(f"Local: {mensagem_local}")

print(f"Global dentro: {mensagem_global}")

print("=== Escopo ===")

print(f"Global antes: {mensagem_global}")

exemplo_escopo()

print(f"Global depois: {mensagem_global}")

# Docstrings (documentação)

def calcular_imposto(valor, aliquota=0.1):

"""

Calcula o imposto sobre um valor.

Parâmetros:

valor (float): O valor base para cálculo

aliquota (float): Percentual do imposto (padrão 0.1 = 10%)

Retorna:

float: O valor do imposto calculado

Exemplo:

>>> calcular_imposto(1000, 0.15)

150.0

"""

return valor * aliquota

print("\n=== Docstrings ===")

print(f"Imposto: R${calcular_imposto(1000):.2f}")

print(f"Ajuda da função: {calcular_imposto.__doc__[:80]}...")

# Boas práticas: funções pequenas e focadas

def validar_email(email):

"""Valida formato básico de e-mail."""

return "@" in email and "." in email

def formatar_nome(nome):

"""Formata nome com primeira letra maiúscula."""

return nome.strip().title()

def criar_saudacao_completa(nome, email):

"""Cria saudação completa com validação."""

if not validar_email(email):

return f"Olá {formatar_nome(nome)}, e-mail inválido!"

return f"Olá {formatar_nome(nome)}, seu e-mail {email} está válido!"

print("\n=== Boas Práticas ===")

print(criar_saudacao_completa("ana silva", "ana@email.com"))

print(criar_saudacao_completa("carlos", "carlos_invalido"))

# Função como sub-rotina em pipeline

def extrair_dados(texto):

return texto.split()

def limpar_dados(palavras):

return [p.strip(".,!?").lower() for p in palavras]

def contar_palavras(palavras):

return len(palavras)

def processar_texto(texto):

"""Pipeline de processamento de texto."""

dados = extrair_dados(texto)

limpos = limpar_dados(dados)

return contar_palavras(limpos)

texto_exemplo = "Python é incrível! Python é poderoso."

print(f"\nPipeline: {processar_texto(texto_exemplo)} palavras")

Funções são o bloco de construção da programação modular. A fórmula da reutilização com funções: $R = \frac{\text{código reutilizado}}{\text{código total}} \times 100\%$ Quanto maior, melhor o design do seu programa. Use funções para evitar repetição e organizar lógica. Cada função deve fazer uma coisa e fazer bem. Seu código será mais fácil de testar e manter.

Laços em Python

25/04/202622/04/2026 Por antonino

– Python
– Imperativa / Procedural
1 – Sequencia (linha a linha)
2 – Condicionais (if/elif/else)
3 – Lacos (for, while)
4 – Funcoes como sub-rotinas

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Laços (loops) executam um bloco de código múltiplas vezes. Eles são essenciais para processar coleções e repetir tarefas. Primeiramente, for itera sobre sequências como listas. Por exemplo, for item in lista: print(item). Além disso, while repete enquanto uma condição for verdadeira. Assim, você evita escrever o mesmo código várias vezes. Consequentemente, programas ficam mais curtos e manuteníveis. Quando utilizar cada laço? for para número conhecido de iterações. while para repetições baseadas em condição. Por outro lado, evite loops infinitos sem controle. Python também tem break e continue para controle. Então, vamos explorar sintaxe, padrões e boas práticas. Três subtítulos guiarão você pelos laços em Python. Portanto, ao final, você dominará a repetição de código eficiente.

For: iterando sobre sequências

for percorre qualquer iterável: listas, strings, ranges. Ele atribui cada elemento à variável do laço. Quando usar for? Em coleções de tamanho conhecido. Também para processar arquivos linha a linha. Além disso, for é mais legível que while para coleções. Exemplo de for:

# For com lista
frutas = ["maçã", "banana", "laranja", "uva"]
print("=== For com lista ===")
for fruta in frutas:
    print(f"Fruta: {fruta}")

# For com range
print("\n=== For com range ===")
for i in range(5):
    print(f"i = {i}")

# For com range (início, fim, passo)
print("\n=== For com passo ===")
for i in range(2, 10, 2):
    print(f"Par: {i}")

# For com string
print("\n=== For com string ===")
palavra = "Python"
for letra in palavra:
    print(f"Letra: {letra}")

# For com enumerate (índice e valor)
print("\n=== For com enumerate ===")
for indice, fruta in enumerate(frutas):
    print(f"{indice}: {fruta}")

# For com dicionário
pessoa = {"nome": "Ana", "idade": 25, "cidade": "São Paulo"}
print("\n=== For com dicionário ===")
for chave, valor in pessoa.items():
    print(f"{chave}: {valor}")

# For aninhado
print("\n=== For aninhado (tabuada) ===")
for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i} x {j} = {i*j}")
    print("---")

# For com lista

frutas = ["maçã", "banana", "laranja", "uva"]

print("=== For com lista ===")

for fruta in frutas:

print(f"Fruta: {fruta}")

# For com range

print("\n=== For com range ===")

for i in range(5):

print(f"i = {i}")

# For com range (início, fim, passo)

print("\n=== For com passo ===")

for i in range(2, 10, 2):

print(f"Par: {i}")

# For com string

print("\n=== For com string ===")

palavra = "Python"

for letra in palavra:

print(f"Letra: {letra}")

# For com enumerate (índice e valor)

print("\n=== For com enumerate ===")

for indice, fruta in enumerate(frutas):

print(f"{indice}: {fruta}")

# For com dicionário

pessoa = {"nome": "Ana", "idade": 25, "cidade": "São Paulo"}

print("\n=== For com dicionário ===")

for chave, valor in pessoa.items():

print(f"{chave}: {valor}")

# For aninhado

print("\n=== For aninhado (tabuada) ===")

for i in range(1, 4):

for j in range(1, 4):

print(f"{i} x {j} = {i*j}")

print("---")

for é o laço mais usado em Python. Ele é limpo, legível e evita erros de índice. Portanto, prefira for sempre que possível.

While: repetindo baseado em condição

while executa enquanto a condição for verdadeira. Cuidado com loops infinitos: a condição precisa mudar. Quando usar while? Em número desconhecido de repetições. Por exemplo, aguardar entrada do usuário ou processar dados. Assim, você tem controle total sobre quando parar. Exemplo de while:

# While básico
print("=== While básico ===")
contador = 0
while contador < 5:
    print(f"Contador: {contador}")
    contador += 1

# While com input do usuário
print("\n=== While com validação ===")
senha_correta = "1234"
tentativas = 0
senha = ""

# Simulação sem input para demonstração
senha = "1234"  # Simulando acerto
while senha != senha_correta and tentativas < 3:
    tentativas += 1
    print(f"Tentativa {tentativas}")
    # senha = input("Digite a senha: ")  # Em programa real
    if senha == senha_correta:
        print("Acesso permitido!")
    elif tentativas >= 3:
        print("Acesso bloqueado!")
    else:
        print("Senha incorreta, tente novamente")
    break  # Para não repetir na simulação

# While com break
print("\n=== While com break ===")
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
i = 0
while i < len(numeros):
    if numeros[i] == 5:
        print(f"Encontrado 5 na posição {i}")
        break
    i += 1

# While com continue
print("\n=== While com continue ===")
i = 0
while i < 10:
    i += 1
    if i % 2 == 0:
        continue  # Pula pares
    print(f"Ímpar: {i}")

# While com else (executa se não houve break)
print("\n=== While com else ===")
busca = 10
i = 0
while i < 5:
    if i == busca:
        print(f"Encontrado {busca}")
        break
    i += 1
else:
    print(f"{busca} não encontrado na faixa")

# While básico

print("=== While básico ===")

contador = 0

while contador < 5:

print(f"Contador: {contador}")

contador += 1

# While com input do usuário

print("\n=== While com validação ===")

senha_correta = "1234"

tentativas = 0

senha = ""

# Simulação sem input para demonstração

senha = "1234" # Simulando acerto

while senha != senha_correta and tentativas < 3:

tentativas += 1

print(f"Tentativa {tentativas}")

# senha = input("Digite a senha: ") # Em programa real

if senha == senha_correta:

print("Acesso permitido!")

elif tentativas >= 3:

print("Acesso bloqueado!")

else:

print("Senha incorreta, tente novamente")

break # Para não repetir na simulação

# While com break

print("\n=== While com break ===")

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

i = 0

while i < len(numeros):

if numeros[i] == 5:

print(f"Encontrado 5 na posição {i}")

break

i += 1

# While com continue

print("\n=== While com continue ===")

i = 0

while i < 10:

i += 1

if i % 2 == 0:

continue # Pula pares

print(f"Ímpar: {i}")

# While com else (executa se não houve break)

print("\n=== While com else ===")

busca = 10

i = 0

while i < 5:

if i == busca:

print(f"Encontrado {busca}")

break

i += 1

else:

print(f"{busca} não encontrado na faixa")

while é poderoso para loops baseados em condição. Sempre garanta que a condição eventualmente se torne falsa. Portanto, use while quando o número de iterações for incerto.

Break, continue e else em laços

break encerra o laço imediatamente. continue pula para a próxima iteração. else executa se o laço terminou sem break. Quando usar esses comandos? Para controle fino de fluxo. Além disso, eles tornam o código mais expressivo. Exemplo completo:

# Break: parar antecipadamente
print("=== Break ===")
for i in range(10):
    if i == 5:
        print("Parando no 5")
        break
    print(i)

# Continue: pular iteração
print("\n=== Continue ===")
for i in range(10):
    if i % 2 == 0:
        continue
    print(f"Ímpar: {i}")

# Else em for (executa se não houve break)
print("\n=== Else em for ===")
for i in range(5):
    print(i)
else:
    print("Laço completou normalmente (sem break)")

# Else com break (não executa)
print("\n=== Else com break ===")
for i in range(5):
    if i == 3:
        print("Break no 3")
        break
    print(i)
else:
    print("Este else não executa")

# Exemplo prático: buscar em lista
print("\n=== Busca com break/else ===")
def buscar(lista, alvo):
    for item in lista:
        if item == alvo:
            print(f"Encontrado {alvo}")
            break
    else:
        print(f"{alvo} não encontrado")

buscar([1, 2, 3, 4, 5], 3)
buscar([1, 2, 3, 4, 5], 10)

# For com range reverso
print("\n=== Range reverso ===")
for i in range(5, 0, -1):
    print(f"Contagem regressiva: {i}")

# While infinito controlado (com break)
print("\n=== While com break controlado ===")
contador = 0
while True:
    print(f"Loop {contador}")
    contador += 1
    if contador >= 3:
        print("Saindo do loop infinito")
        break

# Break: parar antecipadamente

print("=== Break ===")

for i in range(10):

if i == 5:

print("Parando no 5")

break

print(i)

# Continue: pular iteração

print("\n=== Continue ===")

for i in range(10):

if i % 2 == 0:

continue

print(f"Ímpar: {i}")

# Else em for (executa se não houve break)

print("\n=== Else em for ===")

for i in range(5):

print(i)

else:

print("Laço completou normalmente (sem break)")

# Else com break (não executa)

print("\n=== Else com break ===")

for i in range(5):

if i == 3:

print("Break no 3")

break

print(i)

else:

print("Este else não executa")

# Exemplo prático: buscar em lista

print("\n=== Busca com break/else ===")

def buscar(lista, alvo):

for item in lista:

if item == alvo:

print(f"Encontrado {alvo}")

break

else:

print(f"{alvo} não encontrado")

buscar([1, 2, 3, 4, 5], 3)

buscar([1, 2, 3, 4, 5], 10)

# For com range reverso

print("\n=== Range reverso ===")

for i in range(5, 0, -1):

print(f"Contagem regressiva: {i}")

# While infinito controlado (com break)

print("\n=== While com break controlado ===")

contador = 0

while True:

print(f"Loop {contador}")

contador += 1

if contador >= 3:

print("Saindo do loop infinito")

break

Laços são fundamentais para processamento repetitivo. A fórmula da complexidade de um laço é: $T = \text{iterações} \times \text{tempo\_por\_iteração}$ Use for para coleções e while para condições. break e continue dão controle refinado. Portanto, mantenha laços simples e evite aninhamento excessivo. Seu código será mais eficiente e fácil de entender. Finalmente, pratique com diferentes tipos de laços.