Paradigma imperativo e procedural

O paradigma imperativo descreve o programa como sequência de comandos. Ele foca em “como fazer” passo a passo. Variáveis, loops e condicionais são seus blocos básicos. Quando usar? Em scripts simples e algoritmos diretos. Por exemplo, calcular a média de uma lista de números. A programação procedural é uma evolução do imperativo. Ela organiza o código em funções reutilizáveis. Isso evita repetição e melhora a legibilidade. Foi observado que C e Python inicial seguem esse estilo. A principal vantagem é a clareza para iniciantes. Contudo, projetos grandes ficam confusos sem objetos. Portanto, use o imperativo para roteiros curtos. E prefira o procedural quando há lógica repetitiva. Veja um exemplo de estilo procedural em Python:

# Paradigma procedural (imperativo estruturado)
def calcular_media(numeros):
    soma = 0
    for n in numeros:
        soma += n
    return soma / len(numeros)

def main():
    dados = [10, 20, 30, 40]
    media = calcular_media(dados)
    print(f"Média: {media}")

main()

# Paradigma procedural (imperativo estruturado)

def calcular_media(numeros):

soma = 0

for n in numeros:

soma += n

return soma / len(numeros)

def main():

dados = [10, 20, 30, 40]

media = calcular_media(dados)

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

main()

No código, as funções organizam a lógica em etapas. Não há objetos nem herança, apenas dados e funções. Esse estilo é ótimo para processamento de dados linear. Além disso, é fácil de testar cada função isoladamente.

Paradigma orientado a objetos

A orientação a objetos organiza o código em entidades. Cada objeto contém dados (atributos) e comportamentos (métodos). Esse paradigma favorece a reutilização e o encapsulamento. Quando utilizar? Em sistemas complexos com muitas entidades. Por exemplo, jogos, interfaces gráficas ou simuladores. Herança permite criar hierarquias de classes especializadas. Polimorfismo trata objetos diferentes de forma uniforme. A voz passiva é aplicada: “o estado interno é protegido por encapsulamento”. Assim, mudanças locais não afetam o resto do sistema. Isso é crucial em equipes grandes e projetos longos. Porém, a sobrecarga de planejar classes pode ser excessiva. Então, evite OO para scripts pequenos ou cálculos puros. Veja um exemplo de classe em Python:

class Retangulo:
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def area(self):
        return self.largura * self.altura
    
    def perimetro(self):
        return 2 * (self.largura + self.altura)

r = Retangulo(5, 3)
print(f"Área: {r.area()}, Perímetro: {r.perimetro()}")

class Retangulo:

def __init__(self, largura, altura):

self.largura = largura

self.altura = altura

def area(self):

return self.largura * self.altura

def perimetro(self):

return 2 * (self.largura + self.altura)

r = Retangulo(5, 3)

print(f"Área: {r.area()}, Perímetro: {r.perimetro()}")

Aqui, o retângulo é um objeto com dados e operações. Podemos criar vários retângulos independentes facilmente. Isso mostra como a OO modela o mundo real.

Paradigma funcional

O paradigma funcional evita estado mutável e efeitos colaterais. Ele trata a computação como avaliação de funções matemáticas. Funções são de primeira classe e podem ser passadas como argumentos. Quando usar? Em processamento de dados em pipelines. Por exemplo, transformações de listas com map e filter. Também é excelente para sistemas concorrentes. Isso ocorre porque não há variáveis compartilhadas. A fórmula da composição de funções é: \((f \circ g)(x) = f(g(x))\). Portanto, cada função produz a mesma saída para a mesma entrada. Isso facilita testes e raciocínio sobre o código. Python suporta funcional com lambda, map, filter e reduce. No entanto, não é puramente funcional como Haskell. Use o funcional quando a imutabilidade traz benefícios claros. Por exemplo, análise de dados ou expressões regulares. Evite-o quando houver muitas interações com I/O ou estado global. Veja um exemplo funcional em Python:

# Paradigma funcional com funções puras
from functools import reduce

numeros = [1, 2, 3, 4, 5]

# Mapear: dobro de cada número
dobros = list(map(lambda x: x * 2, numeros))

# Filtrar: apenas pares
pares = list(filter(lambda x: x % 2 == 0, numeros))

# Reduzir: soma total
soma = reduce(lambda a, b: a + b, numeros)

print(f"Dobros: {dobros}")   # [2,4,6,8,10]
print(f"Pares: {pares}")     # [2,4]
print(f"Soma: {soma}")       # 15

# Paradigma funcional com funções puras

from functools import reduce

numeros = [1, 2, 3, 4, 5]

# Mapear: dobro de cada número

dobros = list(map(lambda x: x * 2, numeros))

# Filtrar: apenas pares

pares = list(filter(lambda x: x % 2 == 0, numeros))

# Reduzir: soma total

soma = reduce(lambda a, b: a + b, numeros)

print(f"Dobros: {dobros}") # [2,4,6,8,10]

print(f"Pares: {pares}") # [2,4]

print(f"Soma: {soma}") # 15

Nesse código, nenhuma variável é alterada após criada. Cada função transforma uma lista em outra lista nova. Isso é declarativo: dizemos “o que” fazer, não “como”. Por fim, lembre-se: paradigmas são ferramentas complementares. Misturá-los bem é a chave para software de qualidade. Python permite essa mistura de forma natural e poderosa.

– Python
– Conhecimento Base
0 – Configuracoes
1 – Tipos de Dados
2 – Declaração de Variáveis
3 – Declaração de Constantes
4 – Funções e Módulos
5 – Orientação a Objetos
6 – Módulos e Pacotes
7 – Entrada e Saída
8 – Bibliotecas Integradas – Pypi
9 – Paradgmas de Programação
10 – Frameworks Populares (ecosistema)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Entrada e Saída com Python: Trabalhando com Dados

A entrada e saída (E/S) é essencial em qualquer programa. Em Python, isso envolve ler dados do usuário ou arquivos. Também inclui exibir resultados na tela ou gravá-los. Primeiramente, a função input() captura texto do teclado. Por exemplo, nome = input("Digite seu nome: ") espera uma resposta. Todo dado vindo de input() é uma string por padrão. Portanto, conversões como int() ou float() são necessárias. Isso é feito quando esperamos números para cálculos. Além disso, a saída padrão usa print() para mostrar informações. Podemos formatar a saída de várias maneiras elegantes. Por exemplo, f-strings permitem inserir variáveis diretamente: print(f"Olá {nome}"). Outro método é o str.format() ou formatação com %. A escolha depende da legibilidade e da versão do Python. A voz passiva é aplicada aqui: “os dados são lidos como strings”. Assim, lembre-se sempre de validar a entrada do usuário.

Leitura e escrita em arquivos

Trabalhar com arquivos é comum em aplicações reais. Usamos a função open() para acessar arquivos no disco. O modo 'r' significa leitura, e 'w' escrita (sobrescreve). Já 'a' adiciona conteúdo ao final do arquivo. Um arquivo deve ser fechado com .close() após o uso. No entanto, a prática recomendada é o bloco with open(...) as f:. Isso garante fechamento automático, mesmo com erros. Quando usar arquivos? Sempre que precisar persistir dados entre execuções. Por exemplo, salvar configurações, logs ou resultados de processamento. A leitura linha a linha é feita com for linha in arquivo:. Isso é eficiente para arquivos grandes, pois não carrega tudo na memória. Já .read() lê o arquivo inteiro como uma string. Então, prefira iteração para arquivos com milhões de linhas. Foi observado que muitos iniciantes esquecem de fechar arquivos. Por isso, o gerenciador de contexto with é tão valioso. Veja um exemplo prático de leitura e escrita:

# Escrevendo em um arquivo
with open("dados.txt", "w") as arquivo:
    arquivo.write("Linha 1\n")
    arquivo.write("Linha 2\n")

# Lendo o arquivo
with open("dados.txt", "r") as arquivo:
    for linha in arquivo:
        print(linha.strip())  # strip remove quebra de linha

# Escrevendo em um arquivo

with open("dados.txt", "w") as arquivo:

arquivo.write("Linha 1\n")

arquivo.write("Linha 2\n")

# Lendo o arquivo

with open("dados.txt", "r") as arquivo:

for linha in arquivo:

print(linha.strip()) # strip remove quebra de linha

No código acima, o arquivo é criado e lido corretamente. Cada linha é processada individualmente sem sobrecarga. Esse padrão é usado em processamento de logs ou CSVs. Ademais, podemos trabalhar com arquivos binários (modo 'rb' ou 'wb'). Isso é útil para imagens, áudio ou qualquer dado não textual.

Entrada e saída com tratamento de erros

Entradas externas são fontes frequentes de erros. O usuário pode digitar texto onde esperamos um número. O arquivo pode não existir ou faltar permissão de leitura. Portanto, todo código de E/S deve ser protegido com try/except. Por exemplo, ValueError ocorre quando a conversão de tipo falha. Já FileNotFoundError surge ao abrir um arquivo inexistente. Quando utilizar esse tratamento? Sempre que houver interação externa. Isso inclui input(), open() ou leitura de rede. Uma boa prática é informar o erro de forma clara ao usuário. Evite silenciar exceções sem registrar ou tratar adequadamente. A voz passiva é vista aqui: “o erro deve ser capturado e tratado”. Além disso, podemos usar else para código sem erro. E o finally para ações obrigatórias (fechar recursos). Por exemplo, fechar um arquivo manualmente se não usou with. Então, um programa robusto antecipa falhas de E/S. Isso é ainda mais crítico em scripts automatizados ou servidores. Veja um exemplo completo com tratamento:

def ler_numero():
    while True:
        try:
            valor = input("Digite um número: ")
            return float(valor)
        except ValueError:
            print("Erro: isso não é um número válido!")

def ler_arquivo_seguro(caminho):
    try:
        with open(caminho, "r") as f:
            return f.read()
    except FileNotFoundError:
        print(f"Arquivo {caminho} não encontrado.")
        return None
    except PermissionError:
        print(f"Sem permissão para ler {caminho}.")
        return None

numero = ler_numero()
print(f"Você digitou {numero}")
conteudo = ler_arquivo_seguro("inexistente.txt")

def ler_numero():

while True:

try:

valor = input("Digite um número: ")

return float(valor)

except ValueError:

print("Erro: isso não é um número válido!")

def ler_arquivo_seguro(caminho):

try:

with open(caminho, "r") as f:

return f.read()

except FileNotFoundError:

print(f"Arquivo {caminho} não encontrado.")

return None

except PermissionError:

print(f"Sem permissão para ler {caminho}.")

return None

numero = ler_numero()

print(f"Você digitou {numero}")

conteudo = ler_arquivo_seguro("inexistente.txt")

Esse código jamais quebra com entradas inválidas. Ele tenta converter o texto e repete até obter um número. Para arquivos, retorna None silenciosamente em vez de travar. Isso é chamado de “fail gracefully” – falhar com elegância. Use essa abordagem em qualquer programa interativo. Por fim, lembre-se: a E/S conecta seu programa ao mundo exterior. Portanto, trate-a com o respeito que merece, sempre prevendo o inesperado.