Bibliotecas padrão em Python

Um dos grandes pontos fortes do Python é sua rica biblioteca padrão, que oferece uma coleção de módulos prontos para uso, cobrindo uma ampla gama de funcionalidades. Esses módulos estão disponíveis em qualquer instalação do Python, sem necessidade de downloads adicionais, o que faz do Python uma linguagem “batteries included” (baterias incluídas).

Neste tutorial, vamos explorar alguns dos módulos mais úteis da biblioteca padrão do Python e ver como usá-los para resolver diversos problemas comuns.

Exploração dos módulos essenciais

datetime - Manipulação de datas e horas

O módulo datetime fornece classes para manipular datas e horas.

from datetime import datetime, timedelta, date

# Data e hora atuais
maintenant = datetime.now()
print(f"Date et heure actuelles : {maintenant}")

# Formatar uma data
date_formatee = maintenant.strftime("%d/%m/%Y %H:%M:%S")
print(f"Date formatée : {date_formatee}")

# Criar uma data específica
date_specifique = datetime(2023, 12, 31, 23, 59, 59)
print(f"Réveillon du Nouvel An : {date_specifique}")

# Calcular a diferença entre duas datas
difference = date_specifique - maintenant
print(f"Jours jusqu'au Nouvel An : {difference.days}")

# Adicionar um intervalo a uma data
dans_une_semaine = maintenant + timedelta(days=7)
print(f"Dans une semaine : {dans_une_semaine}")

random - Geração de números aleatórios

O módulo random é útil para gerar números aleatórios e fazer seleções aleatórias.

import random

# Número aleatório entre 0 e 1
nombre_aleatoire = random.random()
print(f"Nombre aléatoire entre 0 et 1 : {nombre_aleatoire}")

# Número inteiro aleatório em um intervalo
entier_aleatoire = random.randint(1, 100)
print(f"Entier aléatoire entre 1 et 100 : {entier_aleatoire}")

# Escolha aleatória em uma lista
fruits = ["pomme", "banane", "orange", "fraise", "kiwi"]
fruit_aleatoire = random.choice(fruits)
print(f"Fruit aléatoire : {fruit_aleatoire}")

# Embaralhar uma lista
random.shuffle(fruits)
print(f"Liste mélangée : {fruits}")

# Selecionar k elementos únicos aleatórios
selection = random.sample(range(1, 51), 6)  # 6 números para um sorteio de loteria
print(f"Tirage du loto : {selection}")

math - Funções matemáticas

O módulo math fornece funções matemáticas avançadas.

import math

# Constantes matemáticas
print(f"Pi : {math.pi}")
print(f"e : {math.e}")

# Funções trigonométricas (em radianos)
print(f"sin(π/2) : {math.sin(math.pi/2)}")
print(f"cos(π) : {math.cos(math.pi)}")

# Logaritmos
print(f"log(10) (base e) : {math.log(10)}")
print(f"log10(100) : {math.log10(100)}")

# Raiz quadrada e potência
print(f"Racine carrée de 16 : {math.sqrt(16)}")
print(f"2 puissance 10 : {math.pow(2, 10)}")

# Arredondamento
print(f"Arrondi inférieur de 3.7 : {math.floor(3.7)}")
print(f"Arrondi supérieur de 3.7 : {math.ceil(3.7)}")

collections - Estruturas de dados especializadas

O módulo collections fornece alternativas às estruturas de dados integradas.

from collections import Counter, defaultdict, namedtuple, deque

# Counter - Contar ocorrências
texte = "Mississippi"
compteur = Counter(texte)
print(f"Occurrences des lettres : {compteur}")
print(f"Lettres les plus fréquentes : {compteur.most_common(2)}")

# defaultdict - Dicionário com valor padrão
dd = defaultdict(list)  # O valor padrão é uma lista vazia
dd["fruits"].append("pomme")
dd["fruits"].append("banane")
dd["legumes"].append("carotte")
print(f"defaultdict : {dict(dd)}")

# namedtuple - Tuplas com campos nomeados
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(f"Point : {p}, Coordonnées : x={p.x}, y={p.y}")

# deque - Double-ended queue (fila de duas pontas)
d = deque(["a", "b", "c"])
d.append("d")         # Adicionar à direita
d.appendleft("z")     # Adicionar à esquerda
print(f"deque : {d}")

re - Expressões regulares

O módulo re permite trabalhar com expressões regulares para busca e manipulação de texto.

import re

texte = "Contactez-moi à john.doe@example.com ou jane_smith@company.org"

# Procurar uma correspondência
if re.search(r"@example\.com", texte):
    print("Adresse e-mail example.com trouvée!")

# Encontrar todos os endereços de e-mail
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(pattern, texte)
print(f"Adresses e-mail trouvées : {emails}")

# Substituir texto
texte_anonymise = re.sub(pattern, "[EMAIL REMOVED]", texte)
print(f"Texte anonymisé : {texte_anonymise}")

# Separação de uma string
date = "2023-11-24"
annee, mois, jour = re.split(r"-", date)
print(f"Année : {annee}, Mois : {mois}, Jour : {jour}")

os - Interface com o sistema operacional

O módulo os fornece funções para interagir com o sistema operacional.

import os

# Informações sobre o sistema
print(f"Nom du système d'exploitation : {os.name}")
print(f"Répertoire de travail actuel : {os.getcwd()}")
print(f"Contenu du répertoire : {os.listdir('.')}")

# Variáveis de ambiente
print(f"Variable PATH : {os.environ.get('PATH')}")

# Manipulação de caminhos (veja também o módulo os.path)
chemin = os.path.join("dossier", "sous_dossier", "fichier.txt")
print(f"Chemin joint : {chemin}")
print(f"Nom de base : {os.path.basename(chemin)}")
print(f"Répertoire : {os.path.dirname(chemin)}")

sys - Configuração específica do sistema

O módulo sys fornece funções e variáveis específicas do sistema Python.

import sys

# Informações sobre o interpretador Python
print(f"Version de Python : {sys.version}")
print(f"Plateforme : {sys.platform}")

# Argumentos de linha de comando
print(f"Arguments : {sys.argv}")

# Caminhos de busca de módulos
print(f"Chemins de recherche : {sys.path}")

# Entrada/saída padrão
sys.stdout.write("Ceci est écrit sur la sortie standard\n")
sys.stderr.write("Ceci est un message d'erreur\n")

json - Manipulação de dados JSON

O módulo json permite trabalhar com dados no formato JSON.

import json

# Dicionário Python
donnees = {
    "nom": "Alice",
    "age": 30,
    "langages": ["Python", "JavaScript", "Go"],
    "adresse": {
        "rue": "123 Rue Principale",
        "ville": "Paris",
        "code_postal": "75001"
    }
}

# Conversão Python -> JSON (serialização)
json_str = json.dumps(donnees, indent=4)
print(f"JSON formaté :\n{json_str}")

# Conversão JSON -> Python (desserialização)
obj = json.loads(json_str)
print(f"Prénom : {obj['nom']}, Âge : {obj['age']}")

# Escrever em um arquivo JSON
with open("donnees.json", "w") as f:
    json.dump(donnees, f, indent=4)

# Ler de um arquivo JSON
with open("donnees.json", "r") as f:
    donnees_lues = json.load(f)
    print(f"Données lues du fichier : {donnees_lues['nom']}")

time - Funções relacionadas ao tempo

O módulo time fornece funções para trabalhar com tempo.

import time

# Timestamp atual (segundos desde a época Unix)
timestamp = time.time()
print(f"Timestamp actuel : {timestamp}")

# Converter timestamp em hora local
temps_local = time.localtime(timestamp)
print(f"Année : {temps_local.tm_year}, Mois : {temps_local.tm_mon}, Jour : {temps_local.tm_mday}")

# Formatar o tempo
temps_formate = time.strftime("%Y-%m-%d %H:%M:%S", temps_local)
print(f"Temps formaté : {temps_formate}")

# Medir o tempo de execução
debut = time.time()
# Simular uma operação demorada
time.sleep(1)
fin = time.time()
print(f"Temps d'exécution : {fin - debut} secondes")

argparse - Análise de argumentos de linha de comando

O módulo argparse facilita a criação de interfaces de linha de comando amigáveis.

import argparse

def main():
    # Criar um parser de argumentos
    parser = argparse.ArgumentParser(description='Un exemple de programme en ligne de commande')
    
    # Adicionar argumentos
    parser.add_argument('fichier', help='fichier à traiter')
    parser.add_argument('-v', '--verbose', action='store_true', help='activer la verbosité')
    parser.add_argument('-o', '--output', help='fichier de sortie')
    parser.add_argument('-n', '--number', type=int, default=1, help='nombre d\'itérations')
    
    # Analisar os argumentos
    args = parser.parse_args()
    
    # Usar os argumentos
    print(f"Fichier à traiter : {args.fichier}")
    if args.verbose:
        print("Mode verbeux activé")
    if args.output:
        print(f"Fichier de sortie : {args.output}")
    print(f"Nombre d'itérations : {args.number}")

if __name__ == "__main__":
    main()

itertools - Funções para iteradores eficientes

O módulo itertools fornece funções que criam iteradores para laços eficientes.

import itertools

# Gerar combinações
nombres = [1, 2, 3]
for combo in itertools.combinations(nombres, 2):
    print(f"Combinaison : {combo}")

# Gerar permutações
for perm in itertools.permutations([1, 2, 3], 2):
    print(f"Permutation : {perm}")

# Produto cartesiano
for prod in itertools.product("AB", "12"):
    print(f"Produit : {''.join(prod)}")

# Ciclos infinitos
cycleur = itertools.cycle(["rouge", "vert", "bleu"])
for _ in range(6):
    print(f"Couleur : {next(cycleur)}")

# Agrupar elementos
donnees = [("A", 1), ("A", 2), ("B", 1), ("B", 2)]
for cle, groupe in itertools.groupby(donnees, lambda x: x[0]):
    print(f"Groupe {cle} : {list(groupe)}")

logging - Registro de logs

O módulo logging fornece um sistema flexível de registro de logs.

import logging

# Configuração básica
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='app.log'
)

# Diferentes níveis de log
logging.debug("Ce message est au niveau DEBUG")
logging.info("Ce message est au niveau INFO")
logging.warning("Ce message est au niveau WARNING")
logging.error("Ce message est au niveau ERROR")
logging.critical("Ce message est au niveau CRITICAL")

# Usar um logger específico
logger = logging.getLogger('mon_application')
logger.info("Information de mon_application")

# Registro de exceções
try:
    1 / 0
except Exception as e:
    logging.exception("Une erreur s'est produite")

urllib - URL handling modules

O módulo urllib permite trabalhar com URLs e fazer requisições HTTP.

import urllib.request
import urllib.parse
import json

# Fazer uma requisição GET simples
with urllib.request.urlopen('https://httpbin.org/get') as response:
    data = json.loads(response.read().decode())
    print(f"URL : {data['url']}")

# Fazer uma requisição POST
params = urllib.parse.urlencode({'name': 'John', 'age': 30}).encode()
req = urllib.request.Request('https://httpbin.org/post', data=params, method='POST')
with urllib.request.urlopen(req) as response:
    data = json.loads(response.read().decode())
    print(f"Données envoyées : {data['form']}")

# Analisar uma URL
url = "https://www.example.com/path?param1=value1&param2=value2"
parsed_url = urllib.parse.urlparse(url)
print(f"Schéma : {parsed_url.scheme}, Domaine : {parsed_url.netloc}, Chemin : {parsed_url.path}")
print(f"Paramètres : {urllib.parse.parse_qs(parsed_url.query)}")

functools - Funções de ordem superior e operações sobre funções

O módulo functools fornece ferramentas para trabalhar com funções e callables.

import functools

# Decorador para armazenar em cache os resultados de uma função
@functools.lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(f"Fibonacci de 30 : {fibonacci(30)}")
print(f"Statistiques du cache : {fibonacci.cache_info()}")

# Função parcial (fixa alguns argumentos)
def multiplier(x, y):
    return x * y

doubler = functools.partial(multiplier, 2)
tripler = functools.partial(multiplier, 3)

print(f"Doubler 5 : {doubler(5)}")
print(f"Tripler 5 : {tripler(5)}")

# reduce - Aplicar uma função cumulativamente
nombres = [1, 2, 3, 4, 5]
somme = functools.reduce(lambda x, y: x + y, nombres)
print(f"Somme : {somme}")

Módulos para casos de uso específicos

statistics - Funções estatísticas

O módulo statistics fornece funções para calcular estatísticas básicas.

import statistics

donnees = [2, 4, 4, 4, 5, 5, 7, 9]

print(f"Moyenne : {statistics.mean(donnees)}")
print(f"Médiane : {statistics.median(donnees)}")
print(f"Mode : {statistics.mode(donnees)}")
print(f"Écart-type : {statistics.stdev(donnees)}")
print(f"Variance : {statistics.variance(donnees)}")

sqlite3 - Interface para SQLite

O módulo sqlite3 fornece uma interface para usar o banco de dados SQLite.

import sqlite3

# Conexão com um banco de dados (será criado se não existir)
conn = sqlite3.connect('exemple.db')
cursor = conn.cursor()

# Criar uma tabela
cursor.execute('''
CREATE TABLE IF NOT EXISTS utilisateurs (
    id INTEGER PRIMARY KEY,
    nom TEXT NOT NULL,
    email TEXT UNIQUE,
    age INTEGER
)
''')

# Inserir dados
cursor.execute("INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)",
                ("Alice", "alice@example.com", 30))
cursor.execute("INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)",
                ("Bob", "bob@example.com", 25))

# Confirmar as alterações
conn.commit()

# Consulta SELECT
cursor.execute("SELECT * FROM utilisateurs")
for row in cursor.fetchall():
    print(f"Utilisateur : {row}")

# Fechar a conexão
conn.close()

uuid - Geração de identificadores universalmente únicos

O módulo uuid permite gerar identificadores universalmente únicos.

import uuid

# Gerar diferentes tipos de UUID
print(f"UUID1 (basé sur l'horloge) : {uuid.uuid1()}")
print(f"UUID4 (aléatoire) : {uuid.uuid4()}")

# Criar um UUID a partir de um nome
namespace = uuid.NAMESPACE_DNS
nom = "example.com"
uuid5 = uuid.uuid5(namespace, nom)
print(f"UUID5 (basé sur un nom) : {uuid5}")

hashlib - Funções de hash criptográfico

O módulo hashlib implementa diversas funções de hash criptográfico.

import hashlib

# Gerar o hash de uma string com diferentes algoritmos
texte = "Bonjour, monde!"
print(f"MD5 : {hashlib.md5(texte.encode()).hexdigest()}")
print(f"SHA-1 : {hashlib.sha1(texte.encode()).hexdigest()}")
print(f"SHA-256 : {hashlib.sha256(texte.encode()).hexdigest()}")
print(f"SHA-512 : {hashlib.sha512(texte.encode()).hexdigest()}")

# Hash incremental
h = hashlib.sha256()
h.update(b"Partie 1 du message")
h.update(b"Partie 2 du message")
print(f"Hachage incrémental : {h.hexdigest()}")

concurrent.futures - Execução paralela de tarefas

O módulo concurrent.futures fornece interfaces para a execução assíncrona de tarefas.

import concurrent.futures
import time

def tache_longue(n):
    """Simule une tâche qui prend du temps"""
    time.sleep(n)
    return f"Tâche {n} terminée après {n} secondes"

# Exécution en parallèle avec ThreadPoolExecutor
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    taches = [1, 2, 3, 4, 5]
    futurs = {executor.submit(tache_longue, t): t for t in taches}
    
    for futur in concurrent.futures.as_completed(futurs):
        tache = futurs[futur]
        try:
            resultat = futur.result()
            print(f"Résultat de la tâche {tache}: {resultat}")
        except Exception as e:
            print(f"Tâche {tache} a généré une exception: {e}")

shutil - Operações de alto nível sobre arquivos

O módulo shutil fornece operações de alto nível sobre arquivos e coleções de arquivos.

import shutil
import os

# Criar um diretório para os testes
os.makedirs("test_dossier", exist_ok=True)
with open("test_dossier/test.txt", "w") as f:
    f.write("Contenu de test")

# Copiar um arquivo
shutil.copy("test_dossier/test.txt", "test_dossier/test_copie.txt")

# Copiar um diretório inteiro
shutil.copytree("test_dossier", "test_dossier_copie")

# Mover um arquivo
shutil.move("test_dossier/test_copie.txt", "test_dossier/test_deplace.txt")

# Remover um diretório e seu conteúdo
shutil.rmtree("test_dossier_copie")

# Arquivar um diretório
shutil.make_archive("archive_test", "zip", "test_dossier")

Conclusão

A biblioteca padrão do Python é vasta e cobre uma infinidade de funcionalidades. Este tutorial apenas arranhou a superfície do que está disponível. Ao se familiarizar com esses módulos, você pode resolver muitos problemas comuns sem precisar instalar pacotes de terceiros.

Aqui estão algumas dicas para aproveitar ao máximo a biblioteca padrão:

1. Consulte a documentação oficial: A documentação do Python contém informações detalhadas sobre todos os módulos da biblioteca padrão.

2. Prefira as soluções padrão: Antes de instalar um pacote externo, verifique se a biblioteca padrão já oferece uma solução.

3. Explore as novidades: A cada nova versão do Python, novos módulos ou funcionalidades são adicionados à biblioteca padrão.

No próximo e último tutorial desta série, vamos colocar em prática tudo o que aprendemos criando um projeto Python completo que utilizará vários dos conceitos e módulos que exploramos até agora.