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 1n")
    arquivo.write("Linha 2n")
# 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 1n")

arquivo.write("Linha 2n")

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

A orientação a objetos (OO) é um paradigma de programação amplamente usado. Em Python, tudo é tratado como objeto, desde números até funções. Portanto, dominar a OO torna seu código mais modular e reutilizável. Primeiramente, entenda que classes são “fábricas” de objetos. Já os objetos representam entidades do mundo real com atributos e comportamentos. Por exemplo, uma classe Cachorro pode ter o método latir(). Assim, a OO organiza o software de forma mais intuitiva e escalável. Muitos projetos de médio porte são beneficiados por essa abordagem. Ademais, Python oferece suporte nativo e elegante aos quatro pilares da OO. Vamos explorar cada um deles a seguir.

Classes e objetos: a base estrutural

Uma classe é como um molde ou projeto para criar instâncias. Objetos são as instâncias concretas que ocupam memória. Geralmente, usamos classes quando precisamos de múltiplos itens similares. Por exemplo, em um sistema bancário, cada conta é um objeto. A classe ContaBancaria define atributos como saldo e titular. Métodos como depositar(valor) representam ações possíveis. É recomendado criar classes sempre que houver dados e comportamentos fortemente acoplados. Além disso, objetos isolam o estado interno do resto do programa. Isso reduz efeitos colaterais indesejados em sistemas complexos. A sintaxe em Python usa class Nome: e o método __init__ como construtor. O self explicita a referência ao próprio objeto. Muitas linguagens ocultam esse detalhe, mas Python o torna explícito. Assim, iniciantes estranham, mas intermediários apreciam a clareza. Veja um exemplo simples:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    def saudacao(self):
        return f"Olá, meu nome é {self.nome}."
# Criando objetos
p1 = Pessoa("Ana", 30)
print(p1.saudacao())

class Pessoa:

def __init__(self, nome, idade):

self.nome = nome

self.idade = idade

def saudacao(self):

return f"Olá, meu nome é {self.nome}."

# Criando objetos

p1 = Pessoa("Ana", 30)

print(p1.saudacao())

No código acima, a classe Pessoa é reutilizável para várias pessoas. Cada objeto tem seu próprio nome e idade. Isso é muito útil em listas de usuários ou cadastros.

Encapsulamento e propriedades

Encapsulamento esconde detalhes internos de implementação. Em Python, usamos convenção de nomes com sublinhado (_atributo) para indicar proteção. Atributos privados de verdade usam dois sublinhados (__atributo), causando name mangling. Isso é feito para evitar acesso acidental fora da classe. Quando devemos usar encapsulamento? Sempre que um atributo não deve ser alterado livremente. Por exemplo, um saldo bancário só pode mudar via métodos sacar ou depositar. Propriedades com @property permitem controle sobre leitura e escrita. Elas são frequentemente usadas para validação de dados. Caso contrário, o usuário da classe poderia corromper seu estado interno. A voz passiva é empregada aqui: “o acesso é bloqueado por convenção”. Transições como “por exemplo” e “além disso” ajudam a fluir a explicação. Foi dito anteriormente que Python confia no programador, mas oferece ferramentas. Então, use encapsulamento para interfaces claras e seguras. Um bom indicador: se um atributo pode ficar inconsistente, proteja-o. Veja a aplicação prática:

class Conta:
    def __init__(self, saldo_inicial):
        self.__saldo = saldo_inicial  # atributo privado
    @property
    def saldo(self):
        return self.__saldo
    def depositar(self, valor):
        if valor > 0:
            self.__saldo += valor
        else:
            print("Valor inválido.")
conta = Conta(100)
print(conta.saldo)   # Acesso permitido via property
# conta.__saldo      # Erro! Atributo privado

class Conta:

def __init__(self, saldo_inicial):

self.__saldo = saldo_inicial # atributo privado

@property

def saldo(self):

return self.__saldo

def depositar(self, valor):

if valor > 0:

self.__saldo += valor

else:

print("Valor inválido.")

conta = Conta(100)

print(conta.saldo) # Acesso permitido via property

# conta.__saldo # Erro! Atributo privado

Herança e polimorfismo

Herança permite criar uma classe filha a partir de uma classe mãe. A classe filha reaproveita métodos e atributos da mãe. Isso é útil quando há uma relação “é um” entre os conceitos. Por exemplo, Caminhao e Carro herdam de Veiculo. Assim, evitamos duplicação de código para comportamentos comuns. O polimorfismo vem em seguida: objetos de diferentes classes respondem à mesma mensagem. Em Python, isso é natural com duck typing. Mas a herança formal com métodos sobrescritos também é suportada. Sobrescrever um método significa redefinir seu comportamento na classe filha. Isso é feito com a mesma assinatura do método original. Geralmente, a herança é aplicada quando há especialização genuína. Caso contrário, prefira composição (ter um objeto dentro de outro). Foi observado que herança em excesso gera hierarquias frágeis. Portanto, use-a com moderação e apenas para is-a relationships. Polimorfismo permite escrever funções genéricas como fazer_som(animal). Cada animal (cachorro, gato) emite seu próprio som. Isso é poderoso para código flexível e extensível. Veja um exemplo clássico:

class Animal:
    def som(self):
        pass  # método abstrato na prática
class Cachorro(Animal):
    def som(self):
        return "Au au"
class Gato(Animal):
    def som(self):
        return "Miau"
def emitir_som(animal):
    print(animal.som())
emitir_som(Cachorro())  # Au au
emitir_som(Gato())      # Miau

class Animal:

def som(self):

pass # método abstrato na prática

class Cachorro(Animal):

def som(self):

return "Au au"

class Gato(Animal):

def som(self):

return "Miau"

def emitir_som(animal):

print(animal.som())

emitir_som(Cachorro()) # Au au

emitir_som(Gato()) # Miau

Nesse código, a função emitir_som não precisa saber o tipo exato. Ela confia que qualquer Animal tem um método som. Isso é polimorfismo por subtipagem. Quando usar? Em sistemas que precisam tratar famílias de objetos uniformemente. Por exemplo, editores gráficos com formas (círculo, retângulo) e método desenhar(). Por fim, lembre-se: a orientação a objetos não é a única solução. Contudo, para domínios ricos em entidades e regras de negócio, ela brilha. Python torna tudo isso simples, direto e pragmático. Aplique esses conceitos em seu próximo projeto!