Skip to main content

Introdução parte 3



Gerenciamento de Arquivo​

O gerenciamento de arquivos em Python permite que você abra, leia, escreva, crie, edite e exclua arquivos de forma simples e direta, usando a função open() e métodos associados. Ele serve para lidar com arquivos de texto, binários, logs, configurações, entre outros.



Abrindo um arquivo​

A função básica é:

open(caminho, modo)

Os modos mais comuns são:

  • 'r' – leitura (read)
  • 'w' – escrita (write, sobrescreve)
  • 'a' – anexar (append, adiciona no fim)
  • 'x' – criar (erro se já existir)
  • 'b' – modo binário (usar junto: 'rb', 'wb')
  • '+' – leitura e escrita ('r+', 'w+')


Leitura​

Para ler um arquivo, podemos fazer:

with open("arquivo.txt", "r") as f:
    conteudo = f.read()
    print(conteudo)

Você também pode ler linha por linha:

with open("arquivo.txt") as f:
    for linha in f:
        print(linha.strip())


Escrita​

Para escrever em um arquivo, podemos fazer:

with open("arquivo.txt", "w") as f:
    f.write("Primeira linha\n")
    f.write("Segunda linha\n")

O modo 'w' apaga o conteúdo anterior. Se quiser manter o que já tem, use 'a':

with open("arquivo.txt", "a") as f:
    f.write("Nova linha ao final\n")


Escrever várias linhas​

Para escrever várias linhas em um arquivo, podemos fazer:

linhas = ["linha1\n", "linha2\n", "linha3\n"]
with open("arquivo.txt", "w") as f:
    f.writelines(linhas)


Modo seguro: with​

O with é o jeito mais seguro de lidar com arquivos. Ele faz,

  • Abre o arquivo
  • Fecha automaticamente (mesmo com erro)
  • Libera o recurso corretamente

Sem with, você teria que fechar manualmente:

f = open("arquivo.txt", "r")
dados = f.read()
f.close()

Se você esquecer o close(), o arquivo pode ficar bloqueado.



Leitura e escrita juntas​

with open("arquivo.txt", "r+") as f:
    conteudo = f.read()
    f.seek(0)
    f.write("Novo conteúdo\n")

O seek(0) reposiciona o cursor no início do arquivo.



Arquivos binários​

Para ler ou escrever arquivos binários (imagens, áudio, etc.):

with open("foto.jpg", "rb") as f:
    dados = f.read()

with open("saida.jpg", "wb") as f:
    f.write(dados)


Trabalhar com caminhos​

Use o módulo os ou pathlib para criar caminhos seguros:

from pathlib import Path

arquivo = Path("dados") / "registro.txt"

with open(arquivo, "r") as f:
    print(f.read())


Verificar se arquivo existe​

import os

if os.path.exists("arquivo.txt"):
    print("Arquivo existe")

Ou com Path:

from pathlib import Path

if Path("arquivo.txt").is_file():
    print("Existe")


Remover arquivos​

import os

os.remove("arquivo.txt")

Ou:

from pathlib import Path

Path("arquivo.txt").unlink()


DocStrings​

As docstrings (document strings) são strings de documentação usadas para explicar o propósito de um módulo, classe, função ou método em Python. Elas são escritas logo após a definição de algo (usando aspas triplas """) e servem para documentar o código de forma clara e acessível, tanto para humanos quanto para ferramentas automáticas, como o help() e geradores de documentação.


def somar(a, b):
    """Soma dois números e retorna o resultado."""
    return a + b

Agora, se você fizer:

help(somar)

A saída será:

Help on function somar in module __main__:

somar(a, b)
    Soma dois números e retorna o resultado.

class Conta:
    """Representa uma conta bancária com saldo."""

    def __init__(self, saldo):
        """Inicializa a conta com o saldo informado."""
        self.saldo = saldo

    def depositar(self, valor):
        """Adiciona um valor ao saldo."""
        self.saldo += valor


Docstring com descrição dos parâmetros​

def dividir(a, b):
    """
    Divide a por b.

    Parâmetros:
        a (float): O numerador.
        b (float): O denominador (não pode ser zero).

    Retorna:
        float: O resultado da divisão.

    Levanta:
        ValueError: Se b for zero.
    """
    if b == 0:
        raise ValueError("O denominador não pode ser zero.")
    return a / b


Enum​

O enum.Enum é uma forma de criar conjuntos de constantes nomeadas. Ele faz parte do módulo enum, incluído na biblioteca padrão desde o Python 3.4. Usar enum.Enum é útil quando você tem valores fixos e limitados que fazem sentido ter nomes simbólicos, como dias da semana, estados de um sistema, tipos de erro, etc. Ao invés de usar strings ou números soltos, você organiza essas opções em uma estrutura clara, segura e legível.


from enum import Enum

class Cor(Enum):
    VERMELHO = 1
    VERDE = 2
    AZUL = 3

Agora você pode usar essas cores assim:

print(Cor.VERMELHO)         # Cor.VERMELHO
print(Cor.VERMELHO.name)    # VERMELHO
print(Cor.VERMELHO.value)   # 1

Você pode iterar sobre os membros do Enum:

for cor in Cor:
    print(cor.name, cor.value)

E também pode acessar assim:

Cor['VERMELHO']  # retorna Cor.VERMELHO
Cor(1)           # retorna Cor.VERMELHO

Se você tentar acessar um valor que não existe, dá erro:

Cor(4)  # ValueError

Um enum não é igual à string ou ao número diretamente:

Cor.VERMELHO == "VERMELHO"  # False
Cor.VERMELHO == 1           # False

Só funciona assim:

Cor.VERMELHO.name == "VERMELHO"     # True
Cor.VERMELHO.value == 1             # True


Datetime​

O módulo datetime serve para trabalhar com datas e horários, de forma precisa, estruturada e segura. Ele é parte da biblioteca padrão e fornece classes para representar:

  • Data (date)
  • Hora (time)
  • Data e hora combinadas (datetime)
  • Diferença entre datas (timedelta)
  • Informações sobre fuso horário (timezone)

É uma ferramenta essencial para qualquer sistema que lide com datas, agendamentos, logs, relatórios ou controle de tempo.



Classe datetime​

A mais usada é datetime.datetime, que representa data + hora:

from datetime import datetime

agora = datetime.now()
print(agora)  # Exemplo: 2025-06-21 14:36:00.123456

Você pode acessar partes específicas:

print(agora.year)   # Ano
print(agora.month)  # Mês
print(agora.day)    # Dia
print(agora.hour)   # Hora
print(agora.minute) # Minuto
print(agora.second) # Segundo


Criar uma data/hora específica​

dt = datetime(2024, 12, 25, 10, 30)
print(dt)  # 2024-12-25 10:30:00


Formatando datas​

print(agora.strftime('%d/%m/%Y'))         # 21/06/2025
print(agora.strftime('%H:%M:%S'))         # 14:36:00
print(agora.strftime('%d de %B de %Y'))   # 21 de June de 2025


Convertendo string para data​

texto = '21/06/2025 14:30'
dt = datetime.strptime(texto, '%d/%m/%Y %H:%M')
print(dt)  # 2025-06-21 14:30:00


Diferença entre datas: timedelta​

from datetime import timedelta

agora = datetime.now()

amanha = agora + timedelta(days=1)
ontem = agora - timedelta(days=1)

print(amanha)
print(ontem)

Você pode usar timedelta para somar/subtrair dias, horas, minutos, etc.



Comparando datas​

data1 = datetime(2025, 6, 21)
data2 = datetime(2025, 6, 22)

if data2 > data1:
    print("data2 é depois de data1")


Trabalhando com só data (date) ou só hora (time)​

from datetime import date, time

d = date.today()       # Somente data
t = time(14, 30)       # Somente hora

print(d)  # 2025-06-21
print(t)  # 14:30:00


Fuso horário (timezone)​

O datetime também suporta fuso horário com tzinfo, mas isso pode ficar mais fácil com módulos como pytz ou zoneinfo (a partir do Python 3.9):

from datetime import timezone

agora_utc = datetime.now(timezone.utc)
print(agora_utc)


Timestamp​

O timestamp é uma forma de representar um instante no tempo como um número inteiro ou decimal, geralmente contando segundos desde 1º de janeiro de 1970 às 00:00:00 UTC (conhecido como a Época Unix, ou Unix Epoch).


É uma medida precisa e padronizada que facilita o armazenamento, comparação e cálculo de datas e horários em sistemas computacionais.



Para que serve um timestamp​

  • Armazenar datas de forma compacta e sem ambiguidade.
  • Comparar dois momentos facilmente (quem veio antes ou depois).
  • Calcular a diferença de tempo entre eventos.
  • Fazer ordenação cronológica (ex: logs, bancos de dados).
  • Transmitir datas em APIs e sistemas distribuídos de forma universal (geralmente em UTC).


Obtendo um timestamp com Python​

from datetime import datetime

agora = datetime.now()
timestamp = agora.timestamp()

print(timestamp)  # Ex: 1729599326.894377

Esse número é a quantidade de segundos (com frações) desde a epoch. Se você quiser o timestamp inteiro (em segundos):

int(timestamp)  # Ex: 1729599326


Convertendo timestamp de volta para datetime​

from datetime import datetime

ts = 1729599326

data = datetime.fromtimestamp(ts)

print(data)  # Ex: 2025-06-21 14:35:26 (horário local)

Para converter para horário UTC:

data_utc = datetime.utcfromtimestamp(ts)
print(data_utc)  # Ex: 2025-06-21 17:35:26


Armazenar e comparar timestamps​

Timestamps são ideais para:

  • Armazenar tempos em banco de dados ou arquivos.
  • Fazer cálculos simples com > ou < para saber se um evento expirou, por exemplo.
  • Verificar tempo decorrido:

import time

inicio = time.time()
# ... alguma operação ...
fim = time.time()

print(f'Demorou {fim - inicio:.2f} segundos')

O timestamp() sempre considera a data como se estivesse em UTC, mesmo que o datetime tenha um fuso horário local. Para evitar confusão, use datetime.now(timezone.utc) ou zoneinfo para trabalhar com horários timezone-aware.