A biblioteca padrão: os, sys, math, random

1. Introdução à biblioteca padrão do Python

A biblioteca padrão do Python é um conjunto de módulos e pacotes que acompanham a instalação oficial da linguagem. Ela oferece soluções prontas para tarefas comuns de programação, desde manipulação de arquivos até operações matemáticas complexas, sem necessidade de instalar pacotes externos. Sua principal vantagem é a portabilidade: o mesmo código funciona em Windows, Linux e macOS.

Para usar qualquer módulo da biblioteca padrão, utilizamos a instrução import. Existem três formas principais de importação:

# Importação completa
import os
print(os.getcwd())

# Importação seletiva
from math import sqrt, pi
print(sqrt(25))

# Importação com alias
import random as rnd
print(rnd.randint(1, 10))

Neste artigo, exploraremos quatro módulos fundamentais: os (sistema operacional), sys (interpretador), math (matemática) e random (aleatoriedade). Cada um deles resolve problemas específicos e, combinados, permitem criar scripts poderosos e portáveis.

2. Módulo os: Interagindo com o sistema operacional

O módulo os fornece uma interface para funcionalidades do sistema operacional. Ele permite navegar por diretórios, manipular arquivos e acessar variáveis de ambiente.

Navegação e manipulação de diretórios:

import os

# Diretório atual
diretorio_atual = os.getcwd()
print(f"Diretório atual: {diretorio_atual}")

# Listar arquivos e pastas
itens = os.listdir()
print(f"Itens no diretório: {itens}")

# Criar um novo diretório
os.mkdir("novo_diretorio")

# Mudar de diretório
os.chdir("novo_diretorio")
print(f"Agora estamos em: {os.getcwd()}")

# Remover um arquivo
os.remove("arquivo_temporario.txt")

Informações do sistema e variáveis de ambiente:

import os

# Nome do sistema operacional
print(f"Sistema: {os.name}")  # 'posix' (Linux/macOS) ou 'nt' (Windows)

# Acessar variáveis de ambiente
caminho = os.environ.get("PATH")
print(f"PATH: {caminho[:50]}...")

# Obter valor específico
home = os.getenv("HOME")  # ou "USERPROFILE" no Windows
print(f"Home: {home}")

Trabalhando com caminhos (os.path):

import os

# Construir caminhos de forma portável
caminho = os.path.join("pasta", "subpasta", "arquivo.txt")
print(f"Caminho construído: {caminho}")

# Verificar existência
print(f"Existe? {os.path.exists(caminho)}")
print(f"É diretório? {os.path.isdir('pasta')}")
print(f"É arquivo? {os.path.isfile('arquivo.txt')}")

3. Módulo sys: Parâmetros e funções do interpretador

O módulo sys fornece acesso a variáveis e funções relacionadas ao interpretador Python. É essencial para scripts que precisam processar argumentos da linha de comando ou controlar a execução.

Argumentos da linha de comando:

import sys

# sys.argv[0] é o nome do script
# sys.argv[1:] são os argumentos passados
if len(sys.argv) < 2:
    print("Uso: python script.py <nome>")
    sys.exit(1)

nome = sys.argv[1]
print(f"Olá, {nome}!")

Controle de fluxo e saída:

import sys

# Saída padrão e erro
sys.stdout.write("Mensagem normal\n")
sys.stderr.write("Mensagem de erro\n")

# Entrada padrão
print("Digite algo:")
entrada = sys.stdin.readline().strip()
print(f"Você digitou: {entrada}")

# Encerrar programa com código de erro
if entrada == "erro":
    sys.exit(1)  # Código 1 indica erro

Informações do runtime:

import sys

# Versão do Python
print(f"Versão: {sys.version}")

# Plataforma
print(f"Plataforma: {sys.platform}")  # 'linux', 'win32', 'darwin'

# Caminhos de busca de módulos
for caminho in sys.path[:3]:
    print(f"Caminho de busca: {caminho}")

# Adicionar diretório personalizado
sys.path.append("/meu/caminho/personalizado")

4. Módulo math: Operações matemáticas avançadas

O módulo math oferece funções matemáticas de alto desempenho e constantes importantes.

Constantes e funções básicas:

import math

# Constantes
print(f"Pi: {math.pi}")
print(f"Euler: {math.e}")

# Funções básicas
print(f"Raiz quadrada de 25: {math.sqrt(25)}")
print(f"2 elevado a 10: {math.pow(2, 10)}")
print(f"Valor absoluto de -5.5: {math.fabs(-5.5)}")

Funções trigonométricas e logarítmicas:

import math

# Trigonometria (ângulos em radianos)
angulo = math.radians(45)  # Converte graus para radianos
print(f"Seno de 45°: {math.sin(angulo):.4f}")
print(f"Cosseno de 45°: {math.cos(angulo):.4f}")
print(f"Tangente de 45°: {math.tan(angulo):.4f}")

# Logaritmos
print(f"Log natural de 10: {math.log(10):.4f}")
print(f"Log base 10 de 100: {math.log10(100)}")

Arredondamento e utilidades:

import math

# Arredondamento
print(f"Teto de 4.2: {math.ceil(4.2)}")
print(f"Piso de 4.8: {math.floor(4.8)}")
print(f"Truncamento de 4.8: {math.trunc(4.8)}")

# Fatorial e MDC
print(f"Fatorial de 5: {math.factorial(5)}")
print(f"MDC de 12 e 18: {math.gcd(12, 18)}")

5. Módulo random: Geração de números aleatórios

O módulo random implementa geradores de números pseudoaleatórios para diversas distribuições.

Números aleatórios básicos:

import random

# Float entre 0 e 1
print(f"Aleatório [0,1): {random.random():.4f}")

# Float em intervalo específico
print(f"Aleatório [5,10]: {random.uniform(5, 10):.4f}")

# Inteiro em intervalo
print(f"Inteiro [1,6]: {random.randint(1, 6)}")

# Inteiro com passo
print(f"Inteiro [0,10] passo 2: {random.randrange(0, 11, 2)}")

Seleção e embaralhamento:

import random

# Escolha um elemento
cores = ["vermelho", "azul", "verde", "amarelo"]
print(f"Cor escolhida: {random.choice(cores)}")

# Escolha múltiplos elementos com reposição
print(f"Duas cores: {random.choices(cores, k=2)}")

# Amostra sem reposição
print(f"Amostra de 2 cores: {random.sample(cores, 2)}")

# Embaralhar lista
numeros = list(range(10))
random.shuffle(numeros)
print(f"Lista embaralhada: {numeros}")

Controle de semente e distribuições:

import random

# Fixar semente para reprodutibilidade
random.seed(42)
print(f"Com semente 42: {random.random():.4f}")

# Distribuição normal (gaussiana)
media, desvio = 0, 1
print(f"Gaussiana: {random.gauss(media, desvio):.4f}")

# Distribuição exponencial
lambda_ = 2
print(f"Exponencial: {random.expovariate(lambda_):.4f}")

6. Casos práticos combinando os módulos

Gerando nomes de arquivos aleatórios:

import os
import random
import string

def gerar_nome_arquivo(extensao=".txt", tamanho=8):
    """Gera um nome de arquivo aleatório único."""
    caracteres = string.ascii_lowercase + string.digits
    nome = ''.join(random.choices(caracteres, k=tamanho))
    return nome + extensao

# Criar 5 arquivos com nomes aleatórios
for _ in range(5):
    nome_arquivo = gerar_nome_arquivo()
    with open(nome_arquivo, 'w') as f:
        f.write("Conteúdo aleatório")
    print(f"Arquivo criado: {nome_arquivo}")

# Listar apenas arquivos .txt
arquivos_txt = [f for f in os.listdir() if f.endswith('.txt')]
print(f"Arquivos .txt: {arquivos_txt}")

Calculando estatísticas de diretórios:

import os
import sys
import math

def estatisticas_diretorio(caminho="."):
    """Calcula estatísticas dos arquivos em um diretório."""
    if not os.path.exists(caminho):
        print(f"Erro: {caminho} não existe", file=sys.stderr)
        sys.exit(1)

    tamanhos = []
    for item in os.listdir(caminho):
        caminho_completo = os.path.join(caminho, item)
        if os.path.isfile(caminho_completo):
            tamanho = os.path.getsize(caminho_completo)
            tamanhos.append(tamanho)

    if not tamanhos:
        print("Nenhum arquivo encontrado")
        return

    n = len(tamanhos)
    media = sum(tamanhos) / n
    variancia = sum((t - media) ** 2 for t in tamanhos) / n
    desvio = math.sqrt(variancia)

    print(f"Arquivos: {n}")
    print(f"Tamanho médio: {media:.2f} bytes")
    print(f"Desvio padrão: {desvio:.2f} bytes")
    print(f"Maior arquivo: {max(tamanhos)} bytes")
    print(f"Menor arquivo: {min(tamanhos)} bytes")

# Executar no diretório atual
estatisticas_diretorio()

Script de linha de comando para simulação:

import sys
import random
import math

def simular_lancamentos(num_lancamentos):
    """Simula lançamentos de moeda e calcula proporção."""
    caras = 0
    for _ in range(num_lancamentos):
        if random.random() < 0.5:
            caras += 1

    proporcao = caras / num_lancamentos
    erro = abs(proporcao - 0.5)
    return proporcao, erro

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Uso: python simulacao.py <numero_lancamentos>")
        sys.exit(1)

    try:
        n = int(sys.argv[1])
        if n <= 0:
            raise ValueError
    except ValueError:
        print("Erro: informe um número inteiro positivo")
        sys.exit(1)

    proporcao, erro = simular_lancamentos(n)
    print(f"Lançamentos: {n}")
    print(f"Proporção de caras: {proporcao:.4f}")
    print(f"Erro em relação a 0.5: {erro:.4f}")

7. Boas práticas e considerações finais

Quando usar cada módulo:

  • Use os para operações de sistema e manipulação de caminhos de arquivos
  • Use sys para argumentos de linha de comando, controle de fluxo e informações do interpretador
  • Use math para operações matemáticas avançadas (trigonometria, logaritmos, arredondamento)
  • Use random para simulações, jogos e testes que exigem aleatoriedade

Cuidados com segurança:

Evite os.system() para executar comandos externos; prefira o módulo subprocess, que oferece mais controle e segurança:

import subprocess
# Em vez de: os.system("ls -l")
resultado = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(resultado.stdout)

Para aplicações que exigem aleatoriedade criptograficamente segura (senhas, tokens), use secrets em vez de random:

import secrets
token = secrets.token_hex(16)
print(f"Token seguro: {token}")

Dominar a biblioteca padrão é um dos passos mais importantes para se tornar um programador Python eficiente. Os módulos os, sys, math e random são apenas o começo — explore outros como datetime, json, re e collections para ampliar ainda mais suas capacidades.

Referências