11 Módulos e Bibliotecas em Python

De uma receita solta para um livro de receitas organizado: organizando seu código!

11.1 O que você vai aprender neste capítulo?

O que são módulos e por que todo programador precisa deles
Como criar seus próprios módulos e organizar código em arquivos separados
Diferentes formas de importar: import, from ... import, import ... as
Bibliotecas que já vêm com Python: datetime, random, math, os, pathlib
Como instalar bibliotecas externas com pip install
Estruturar projetos maiores de forma organizada
Convenções e boas práticas para módulos

🎓 Vindo do Capítulo 10? Ótimo! Agora que você já sabe lidar com erros, vamos organizar seu código de forma profissional.

🎯 Meta: Ao final deste capítulo, você vai conseguir criar módulos próprios, usar bibliotecas externas e organizar projetos Python como um desenvolvedor experiente.

⚠️ Por que isso importa: Sem módulos, você teria que repetir código infinitamente. Aqui você aprende a criar “receitas” reutilizáveis!

11.2 De uma Receita Solta para um Livro de Receitas

Lembra quando falamos sobre receitas de bolo? Até agora você tem uma receita aqui, outra ali… Mas e se você quisesse criar um livro completo de receitas?

Imagine que você tem:

Uma receita de bolo de chocolate
Uma receita de brigadeiro
Uma receita de coxinha
Uma receita de café

O problema: Cada receita está em um papel separado, espalhada pela casa. Quando você quer fazer um bolo, tem que procurar a receita. Quando quer fazer brigadeiro, tem que procurar outra receita.

A solução: Organizar tudo em um livro de receitas!

📖 Índice no início (para encontrar rapidamente)
📄 Cada receita em uma página separada
🔗 Referências entre receitas (“veja também a receita de cobertura na página 15”)

💡 Em programação, isso se chama MÓDULOS! Cada arquivo .py é como uma página do seu livro de receitas, e o import é como consultar o índice para encontrar a receita que você quer!

11.3 O que são Módulos?

Módulo é simplesmente um arquivo Python (.py) que contém código que você pode usar em outros programas.

11.3.1 Analogia Perfeita

Pense em um livro de receitas:

Livro de Receitas	Módulo Python
📖 Livro completo	📁 Projeto Python
📄 Página com receita de bolo	📄 arquivo `bolo.py`
📄 Página com receita de brigadeiro	📄 arquivo `brigadeiro.py`
📑 Índice no início	📑 `import` statements
🔍 “Veja página 15”	🔍 `from bolo import fazer_cobertura`

11.3.2 Por que usar módulos?

Sem módulos (o problema):

# arquivo_principal.py - TUDO em um arquivo só
def calcular_area_circulo(raio):
    return 3.14159 * raio ** 2

def calcular_area_retangulo(largura, altura):
    return largura * altura

def calcular_imc(peso, altura):
    return peso / (altura ** 2)

# ... mais 50 funções aqui ...
# Arquivo gigante, difícil de encontrar coisas!

Com módulos (a solução):

# arquivo_principal.py - Limpo e organizado
from geometria import calcular_area_circulo, calcular_area_retangulo
from saude import calcular_imc

# Usar as funções normalmente
area = calcular_area_circulo(5)
imc = calcular_imc(70, 1.75)

💡 Vantagens dos módulos:

✅ Organização: Cada arquivo tem uma responsabilidade

✅ Reutilização: Use o mesmo módulo em vários projetos

✅ Manutenção: Mais fácil encontrar e corrigir problemas

✅ Colaboração: Várias pessoas podem trabalhar em arquivos diferentes

11.4 Criando seu Primeiro Módulo

Vamos criar um módulo simples para cálculos matemáticos!

11.4.1 Passo 1: Criar o arquivo do módulo

Primeiro, vamos criar um arquivo chamado matematica.py:

# matematica.py - Nosso primeiro módulo!

def somar(a, b):
    """Soma dois números"""
    return a + b

def subtrair(a, b):
    """Subtrai dois números"""
    return a - b

def multiplicar(a, b):
    """Multiplica dois números"""
    return a * b

def dividir(a, b):
    """Divide dois números"""
    if b != 0:
        return a / b
    else:
        return "Erro: Divisão por zero!"

def potencia(base, expoente):
    """Calcula base elevada ao expoente"""
    return base ** expoente

# Constantes úteis
PI = 3.14159265359
E = 2.71828182846

print("Módulo matematica.py carregado!")

11.4.2 Passo 2: Usar o módulo em outro arquivo

Agora vamos criar um arquivo calculadora.py que usa nosso módulo:

# calculadora.py - Usando nosso módulo matematica

# Importar o módulo inteiro
import matematica

# Usar as funções do módulo
resultado1 = matematica.somar(10, 5)
resultado2 = matematica.multiplicar(3, 4)
resultado3 = matematica.potencia(2, 3)

print(f"10 + 5 = {resultado1}")
print(f"3 × 4 = {resultado2}")
print(f"2³ = {resultado3}")
print(f"Valor de PI = {matematica.PI}")

11.4.3 Passo 3: Executar e ver o resultado

Quando você executar calculadora.py, verá:

Módulo matematica.py carregado!
10 + 5 = 15
3 × 4 = 12
2³ = 8
Valor de PI = 3.14159265359

💡 O que aconteceu? 1. Python encontrou o arquivo matematica.py 2. Executou todo o código do módulo (por isso apareceu “Módulo matematica.py carregado!”) 3. Disponibilizou as funções e variáveis para uso 4. Nosso programa principal usou as funções normalmente

11.5 Diferentes Formas de Importar

Existem várias maneiras de importar módulos. Cada uma tem suas vantagens!

11.5.1 Forma 1: `import modulo` (Importar tudo)

import matematica

# Usar com o nome do módulo
resultado = matematica.somar(5, 3)
print(f"PI = {matematica.PI}")

Vantagens:

✅ Sempre sabe de onde vem a função
✅ Evita conflitos de nomes
✅ Mais claro e explícito

Desvantagens:

❌ Mais verboso (tem que escrever matematica. sempre)

11.5.2 Forma 2: `from modulo import funcao` (Importar específico)

from matematica import somar, multiplicar, PI

# Usar diretamente, sem o nome do módulo
resultado = somar(5, 3)
print(f"PI = {PI}")

Vantagens:

✅ Mais limpo e direto
✅ Não precisa escrever o nome do módulo

Desvantagens:

❌ Pode causar conflitos se importar muitas coisas
❌ Menos claro de onde vem a função

11.5.3 Forma 3: `import modulo as apelido` (Importar com apelido)

import matematica as math

# Usar com o apelido
resultado = math.somar(5, 3)
print(f"PI = {math.PI}")

Vantagens:

✅ Nome mais curto
✅ Evita conflitos com nomes existentes
✅ Mais legível

11.5.4 Forma 4: `from modulo import *` (Importar tudo - CUIDADO!)

from matematica import *

# Usar diretamente
resultado = somar(5, 3)
print(f"PI = {PI}")

⚠️ CUIDADO: Esta forma pode causar problemas! Evite usar import * em projetos grandes.

11.5.5 Comparação Prática

# Forma 1: Mais explícita
import matematica
print(matematica.somar(2, 3))

# Forma 2: Mais direta
from matematica import somar
print(somar(2, 3))

# Forma 3: Mais concisa
import matematica as m
print(m.somar(2, 3))

# Forma 4: Mais perigosa
from matematica import *
print(somar(2, 3))

💡 Recomendação: Use a Forma 1 (import modulo) para projetos pequenos e a Forma 2 (from modulo import funcao) quando souber exatamente o que precisa!

11.6 A Variável `name` - O Guardião dos Módulos

11.6.1 O Problema

Imagine que você tem um módulo matematica.py que faz cálculos, mas também tem um código de teste no final:

# matematica.py
def somar(a, b):
    return a + b

def multiplicar(a, b):
    return a * b

# Código de teste (problema!)
print("Testando o módulo...")
print(f"2 + 3 = {somar(2, 3)}")
print(f"4 × 5 = {multiplicar(4, 5)}")

Problema: Toda vez que alguém importar seu módulo, esse código de teste vai executar! 😱

11.6.2 A Solução: `if name == "main"`

A variável __name__ é especial em Python:

Quando o arquivo é executado diretamente: __name__ == "__main__"
Quando o arquivo é importado: __name__ == "nome_do_modulo"

# matematica.py - Versão corrigida!
def somar(a, b):
    return a + b

def multiplicar(a, b):
    return a * b

# Código de teste só executa quando rodamos o arquivo diretamente
if __name__ == "__main__":
    print("Testando o módulo...")
    print(f"2 + 3 = {somar(2, 3)}")
    print(f"4 × 5 = {multiplicar(4, 5)}")

11.6.3 Testando na Prática

Cenário 1: Executar matematica.py diretamente

python matematica.py

Saída:

Testando o módulo...
2 + 3 = 5
4 × 5 = 20

Cenário 2: Importar o módulo em outro arquivo

# calculadora.py
import matematica

resultado = matematica.somar(10, 5)
print(f"10 + 5 = {resultado}")

Saída:

10 + 5 = 15

(Sem os prints de teste!)

11.6.4 Analogia Perfeita

Pense em um livro de receitas:

📖 Quando você abre o livro para ler: Você vê as receitas, mas não cozinha automaticamente
👨‍🍳 Quando você quer testar uma receita: Você vai para a cozinha e faz a receita

if __name__ == "__main__" é como dizer: “Só cozinhe quando eu estiver testando a receita, não quando alguém estiver apenas lendo o livro!”

💡 Regra de Ouro: Sempre use if __name__ == "__main__" quando tiver código de teste ou demonstração no final do seu módulo!

11.7 Bibliotecas Built-in - O que já vem com Python

Python já vem com muitas bibliotecas úteis! É como ter uma cozinha equipada desde o início. Vamos conhecer as principais:

11.7.1 `datetime` - Trabalhando com Datas e Horas

import datetime

# Data e hora atual
agora = datetime.datetime.now()
print(f"Agora são: {agora}")

# Data específica
nascimento = datetime.date(1990, 5, 15)
print(f"Nascimento: {nascimento}")

# Calcular idade
hoje = datetime.date.today()
idade = hoje - nascimento
print(f"Você tem {idade.days} dias de vida!")

# Formatar data
print(f"Data formatada: {agora.strftime('%d/%m/%Y %H:%M')}")

11.7.2 `random` - Números Aleatórios

import random

# Número aleatório entre 1 e 10
numero = random.randint(1, 10)
print(f"Número aleatório: {numero}")

# Escolher item aleatório de uma lista
frutas = ["maçã", "banana", "laranja", "uva"]
fruta_escolhida = random.choice(frutas)
print(f"Fruta sorteada: {fruta_escolhida}")

# Embaralhar lista
cartas = ["Ás", "Rei", "Dama", "Valete"]
random.shuffle(cartas)
print(f"Cartas embaralhadas: {cartas}")

# Número decimal aleatório entre 0 e 1
decimal = random.random()
print(f"Número decimal: {decimal}")

11.7.3 `math` - Operações Matemáticas Avançadas

import math

# Constantes matemáticas
print(f"PI = {math.pi}")
print(f"E = {math.e}")

# Funções matemáticas
print(f"Raiz quadrada de 16: {math.sqrt(16)}")
print(f"2 elevado a 8: {math.pow(2, 8)}")
print(f"Logaritmo de 100: {math.log10(100)}")
print(f"Seno de 90 graus: {math.sin(math.radians(90))}")

# Arredondamentos
numero = 3.7
print(f"Arredondar para cima: {math.ceil(numero)}")
print(f"Arredondar para baixo: {math.floor(numero)}")

11.7.4 `os` - Interagindo com o Sistema Operacional

import os

# Informações do sistema
print(f"Sistema operacional: {os.name}")
print(f"Diretório atual: {os.getcwd()}")

# Listar arquivos do diretório atual
arquivos = os.listdir('.')
print(f"Arquivos no diretório: {arquivos}")

# Criar diretório
os.makedirs('meu_diretorio', exist_ok=True)
print("Diretório criado!")

# Verificar se arquivo existe
if os.path.exists('README.md'):
    print("README.md existe!")
else:
    print("README.md não encontrado!")

11.7.5 `pathlib` - Manipulação Moderna de Caminhos

from pathlib import Path

# Criar objeto Path
arquivo = Path('documentos/relatorio.txt')

# Informações do arquivo
print(f"Nome do arquivo: {arquivo.name}")
print(f"Extensão: {arquivo.suffix}")
print(f"Diretório pai: {arquivo.parent}")

# Criar diretório se não existir
arquivo.parent.mkdir(parents=True, exist_ok=True)

# Verificar se existe
if arquivo.exists():
    print("Arquivo existe!")
else:
    print("Arquivo não existe!")

# Listar arquivos Python no diretório atual
python_files = list(Path('.').glob('*.py'))
print(f"Arquivos Python: {python_files}")

💡 Dica: pathlib é mais moderno que os.path. Use pathlib para novos projetos!

11.8 Módulo `collections` - Ferramentas Avançadas para Coleções

📌 Quando ler esta seção: Esta seção é importante para resolver exercícios de níveis 4-5. O módulo collections oferece ferramentas poderosas para trabalhar com coleções de dados.

11.8.1 O que é o módulo `collections`?

O módulo collections do Python oferece ferramentas especializadas para trabalhar com diferentes tipos de coleções de dados. Uma das mais úteis é o Counter.

11.8.2 Importando Counter

from collections import Counter

11.8.3 Counter - Contando Elementos

O Counter é uma subclasse de dicionário especializada em contar elementos. É perfeito para:

Contar frequência de elementos em uma lista
Encontrar elementos mais comuns
Comparar distribuições de dados

11.8.4 Exemplos Práticos

11.8.4.1 1. Contar letras em uma palavra

from collections import Counter

palavra = "python"
contador = Counter(palavra)
print(contador)
# Resultado: Counter({'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1})

11.8.4.2 2. Contar números em uma lista

from collections import Counter

numeros = [1, 2, 3, 2, 1, 3, 3, 1, 2, 1]
contador = Counter(numeros)
print(contador)
# Resultado: Counter({1: 4, 2: 3, 3: 3})

11.8.4.3 3. Contar palavras em uma frase

from collections import Counter

frase = "python é uma linguagem python é poderosa"
palavras = frase.split()
contador = Counter(palavras)
print(contador)
# Resultado: Counter({'python': 2, 'é': 2, 'uma': 1, 'linguagem': 1, 'poderosa': 1})

11.8.5 Métodos Úteis do Counter

11.8.5.1 1. `most_common(n)` - Encontrar elementos mais comuns

from collections import Counter

dados = [1, 2, 3, 2, 1, 3, 3, 1, 2, 1, 3, 3, 3]
contador = Counter(dados)

# Os 3 mais comuns
print(contador.most_common(3))
# Resultado: [(3, 5), (1, 4), (2, 3)]

# O mais comum
print(contador.most_common(1))
# Resultado: [(3, 5)]

11.8.5.2 2. Acessar contagens individuais

from collections import Counter

numeros = [1, 2, 3, 2, 1, 3]
contador = Counter(numeros)

print(f"Número 1 aparece {contador[1]} vezes")
print(f"Número 2 aparece {contador[2]} vezes")
print(f"Número 3 aparece {contador[3]} vezes")
print(f"Número 4 aparece {contador[4]} vezes")  # Retorna 0 se não existir

11.8.5.3 3. Operações matemáticas

from collections import Counter

# Counter 1
dados1 = [1, 2, 3, 2, 1]
contador1 = Counter(dados1)

# Counter 2
dados2 = [2, 3, 4, 3, 2]
contador2 = Counter(dados2)

# Somar counters
soma = contador1 + contador2
print("Soma:", soma)
# Resultado: Counter({2: 4, 3: 3, 1: 2, 4: 1})

# Subtrair counters
diferenca = contador1 - contador2
print("Diferença:", diferenca)
# Resultado: Counter({1: 2})

11.8.6 Exemplos dos Exercícios

Muitos exercícios usam Counter. Aqui estão exemplos:

# Exemplo do exercício de análise de dados
from collections import Counter

# Simular lançamentos de dados
import random
lancamentos = [random.randint(1, 6) for _ in range(100)]
frequencia = Counter(lancamentos)

print("Frequência dos lançamentos:")
for face, count in sorted(frequencia.items()):
    print(f"Face {face}: {count} vezes")

# Exemplo do exercício de análise de texto
texto = "python é uma linguagem incrível python é fácil de aprender"
palavras = texto.split()
contador_palavras = Counter(palavras)

print("Palavras mais comuns:")
for palavra, count in contador_palavras.most_common(3):
    print(f"'{palavra}': {count} vezes")

11.8.7 Outras Classes do módulo collections

11.8.7.1 1. `defaultdict` - Dicionário com valores padrão

from collections import defaultdict

# Lista vazia como valor padrão
dd = defaultdict(list)
dd['frutas'].append('maçã')
dd['frutas'].append('banana')
print(dd['frutas'])  # ['maçã', 'banana']
print(dd['legumes'])  # [] (lista vazia, não erro!)

11.8.7.2 2. `deque` - Lista com operações eficientes nas extremidades

from collections import deque

# Criar uma deque
fila = deque([1, 2, 3])

# Adicionar no final
fila.append(4)

# Adicionar no início
fila.appendleft(0)

# Remover do início (eficiente!)
primeiro = fila.popleft()
print(fila)  # deque([1, 2, 3, 4])

11.8.8 Dicas Importantes

Use Counter quando precisar contar frequências
Use most_common() para encontrar elementos mais comuns
Counter funciona com qualquer iterável (listas, strings, tuplas)
Counter herda de dict, então você pode usar métodos de dicionário

11.8.9 Quando Usar Counter

Use Counter quando: - ✅ Precisar contar frequências de elementos - ✅ Quiser encontrar elementos mais comuns - ✅ Estiver analisando distribuições de dados - ✅ Quiser comparar duas coleções

Exemplos práticos: - Análise de texto (contar palavras) - Análise de dados (contar ocorrências) - Jogos (contar resultados) - Estatísticas (distribuições)

💡 Dica: Counter é uma ferramenta muito poderosa para análise de dados. Muitos exercícios avançados usam ela para resolver problemas de contagem e frequência!

11.9 Estruturas de Dados Complexas - Dicionários e Listas Aninhadas

📌 Quando ler esta seção: Esta seção é importante para exercícios de níveis 4-5. Python permite criar estruturas de dados complexas combinando listas e dicionários.

11.9.1 O que são Estruturas Aninhadas?

Estruturas aninhadas são estruturas de dados que contêm outras estruturas dentro delas. É como ter “caixas dentro de caixas” - você pode ter listas dentro de dicionários, dicionários dentro de listas, e assim por diante.

11.9.2 Dicionários Aninhados

11.9.2.1 Estrutura básica

# Dicionário com dicionários dentro
empresa = {
    "nome": "Tech Corp",
    "endereco": {
        "rua": "Rua das Flores, 123",
        "cidade": "São Paulo",
        "cep": "01234-567"
    },
    "contato": {
        "telefone": "(11) 99999-9999",
        "email": "contato@techcorp.com"
    }
}

# Acessando dados aninhados
print(empresa["nome"])                    # "Tech Corp"
print(empresa["endereco"]["cidade"])      # "São Paulo"
print(empresa["contato"]["email"])        # "contato@techcorp.com"

11.9.2.2 Exemplo prático: Sistema de biblioteca

biblioteca = {
    "nome": "Biblioteca Central",
    "livros": [
        {
            "titulo": "Python para Iniciantes",
            "autor": "João Silva",
            "ano": 2023,
            "disponivel": True,
            "categoria": "Programação"
        },
        {
            "titulo": "Algoritmos e Estruturas de Dados",
            "autor": "Maria Santos",
            "ano": 2022,
            "disponivel": False,
            "categoria": "Ciência da Computação"
        }
    ],
    "usuarios": {
        "001": {
            "nome": "Ana Costa",
            "email": "ana@email.com",
            "livros_emprestados": ["Python para Iniciantes"]
        },
        "002": {
            "nome": "Carlos Oliveira",
            "email": "carlos@email.com",
            "livros_emprestados": []
        }
    }
}

# Acessando dados
print(f"Biblioteca: {biblioteca['nome']}")
print(f"Primeiro livro: {biblioteca['livros'][0]['titulo']}")
print(f"Usuário 001: {biblioteca['usuarios']['001']['nome']}")

11.9.3 Listas de Dicionários

11.9.3.1 Estrutura básica

# Lista contendo dicionários
funcionarios = [
    {
        "nome": "João",
        "cargo": "Desenvolvedor",
        "salario": 5000,
        "departamento": "TI"
    },
    {
        "nome": "Maria",
        "cargo": "Designer",
        "salario": 4500,
        "departamento": "Design"
    },
    {
        "nome": "Pedro",
        "cargo": "Gerente",
        "salario": 7000,
        "departamento": "Administração"
    }
]

# Acessando dados
print(funcionarios[0]["nome"])        # "João"
print(funcionarios[1]["salario"])     # 4500
print(funcionarios[2]["departamento"]) # "Administração"

11.9.4 Manipulando Estruturas Complexas

11.9.4.1 1. Filtrar dados

# Filtrar funcionários do departamento TI
funcionarios_ti = [f for f in funcionarios if f["departamento"] == "TI"]
print("Funcionários de TI:")
for func in funcionarios_ti:
    print(f"- {func['nome']}: {func['cargo']}")

11.9.4.2 2. Buscar informações específicas

# Encontrar funcionário por nome
def encontrar_funcionario(nome):
    for func in funcionarios:
        if func["nome"] == nome:
            return func
    return None

joao = encontrar_funcionario("João")
if joao:
    print(f"João trabalha como {joao['cargo']} ganhando R$ {joao['salario']}")

11.9.4.3 3. Calcular estatísticas

# Calcular salário médio por departamento
departamentos = {}
for func in funcionarios:
    dept = func["departamento"]
    if dept not in departamentos:
        departamentos[dept] = []
    departamentos[dept].append(func["salario"])

print("Salário médio por departamento:")
for dept, salarios in departamentos.items():
    media = sum(salarios) / len(salarios)
    print(f"{dept}: R$ {media:.2f}")

11.9.5 Exemplos dos Exercícios

Muitos exercícios usam estruturas complexas. Aqui estão exemplos:

11.9.5.1 Exemplo 1: Sistema de hotel

hotel = {
    "nome": "Hotel Python",
    "quartos": [
        {"numero": "101", "tipo": "Simples", "preco": 150, "disponivel": True},
        {"numero": "102", "tipo": "Duplo", "preco": 200, "disponivel": False},
        {"numero": "201", "tipo": "Suíte", "preco": 350, "disponivel": True}
    ],
    "reservas": []
}

# Quartos disponíveis
quartos_disponiveis = [q for q in hotel["quartos"] if q["disponivel"]]
print("Quartos disponíveis:")
for quarto in quartos_disponiveis:
    print(f"- Quarto {quarto['numero']}: {quarto['tipo']} - R$ {quarto['preco']}")

11.9.5.2 Exemplo 2: Sistema de vendas

vendas = [
    {"produto": "Notebook", "quantidade": 2, "preco_unitario": 2500, "cliente": "João"},
    {"produto": "Mouse", "quantidade": 5, "preco_unitario": 50, "cliente": "Maria"},
    {"produto": "Teclado", "quantidade": 3, "preco_unitario": 120, "cliente": "João"}
]

# Calcular total por cliente
total_por_cliente = {}
for venda in vendas:
    cliente = venda["cliente"]
    total = venda["quantidade"] * venda["preco_unitario"]
    
    if cliente not in total_por_cliente:
        total_por_cliente[cliente] = 0
    total_por_cliente[cliente] += total

print("Total por cliente:")
for cliente, total in total_por_cliente.items():
    print(f"{cliente}: R$ {total:,.2f}")

11.9.6 Dicas Importantes

Use chaves consistentes nos dicionários
Acesse dados aninhados com múltiplos colchetes: dados["chave1"]["chave2"]
Use list comprehensions para filtrar estruturas complexas
Valide se as chaves existem antes de acessá-las

11.9.7 Quando Usar Estruturas Complexas

Use quando: - ✅ Precisar organizar dados relacionados - ✅ Quiser criar sistemas mais realistas - ✅ Estiver trabalhando com dados hierárquicos - ✅ Quiser simular estruturas de banco de dados

Exemplos práticos: - Sistemas de gerenciamento - APIs com dados complexos - Simulação de bancos de dados - Organização de informações relacionadas

💡 Dica: Estruturas aninhadas são fundamentais para criar programas mais realistas e organizados. Elas permitem representar dados complexos de forma estruturada!

📌 Nota sobre Análise de Texto Avançada: Para análise avançada de texto, validação de formatos complexos e extração de informações usando expressões regulares, consulte o Capítulo 16 - Expressões Regulares. Este capítulo cobre em profundidade todas as técnicas de busca e manipulação de texto com regex.

11.10 Instalando Bibliotecas Externas com `pip`

11.10.1 O que é `pip`?

pip é o gerenciador de pacotes do Python. É como uma loja online de ingredientes para sua cozinha de programação!

🏪 PyPI (Python Package Index): A “loja” onde ficam todas as bibliotecas
📦 pip: O “entregador” que baixa e instala as bibliotecas
🍰 Bibliotecas: Os “ingredientes” prontos para usar

11.10.2 Como instalar bibliotecas

# Instalar uma biblioteca
pip install nome_da_biblioteca

# Exemplos práticos
pip install requests      # Para fazer requisições HTTP
pip install beautifulsoup4  # Para web scraping
pip install flask        # Para criar APIs web
pip install pandas       # Para análise de dados
pip install matplotlib   # Para gráficos

11.10.3 Exemplo Prático: Instalando `requests`

Vamos instalar a biblioteca requests para fazer requisições HTTP:

pip install requests

Depois podemos usar:

import requests

# Fazer uma requisição GET
response = requests.get('https://api.github.com/users/octocat')
print(f"Status: {response.status_code}")
print(f"Dados: {response.json()}")

11.10.4 Gerenciando Dependências com `requirements.txt`

Para projetos maiores, é boa prática criar um arquivo requirements.txt:

# requirements.txt
requests==2.28.1
beautifulsoup4==4.11.1
flask==2.2.2
pandas==1.5.2
matplotlib==3.6.2

Depois instalar tudo de uma vez:

pip install -r requirements.txt

11.10.5 Comandos Úteis do `pip`

# Listar bibliotecas instaladas
pip list

# Mostrar informações de uma biblioteca
pip show requests

# Atualizar uma biblioteca
pip install --upgrade requests

# Desinstalar uma biblioteca
pip uninstall requests

# Instalar versão específica
pip install requests==2.28.1

# Instalar em modo desenvolvimento (para desenvolvimento)
pip install -e .

11.10.6 Ambientes Virtuais (Bônus)

Para evitar conflitos entre projetos, use ambientes virtuais:

# Criar ambiente virtual
python -m venv meu_projeto

# Ativar ambiente virtual (Windows)
meu_projeto\\Scripts\\activate

# Ativar ambiente virtual (Linux/Mac)
source meu_projeto/bin/activate

# Instalar bibliotecas no ambiente virtual
pip install requests

# Desativar ambiente virtual
deactivate

💡 Dica: Sempre use ambientes virtuais para projetos separados! É como ter cozinhas diferentes para cada tipo de receita!

11.11 Exercícios Práticos (respostas no final da página)

🚀 Hora de praticar! Aqui estão 25 exercícios organizados por dificuldade. Cada exercício tem solução completa com explicação linha por linha!

11.11.1 MUITO FÁCIL (Nível 1)

1. Módulo de Cumprimentos Crie um módulo chamado cumprimentos.py com uma função dizer_oi() que retorna “Olá!”.

Exemplo: Output → "Olá!"

2. Teste do Módulo Crie um arquivo teste_cumprimentos.py que importa e usa a função do exercício anterior.

Exemplo: Input → import cumprimentos | Output → "Olá!"

3. Número Aleatório Use a biblioteca random para sortear um número entre 1 e 100.

Exemplo: Output → Número sorteado: 42

4. Data Atual Use a biblioteca datetime para mostrar a data atual no formato brasileiro (dd/mm/aaaa).

Exemplo: Output → Data atual: 15/01/2024

5. Raiz Quadrada Use a biblioteca math para calcular a raiz quadrada de 144.

Exemplo: Output → Raiz quadrada de 144: 12.0

11.11.2 FÁCIL (Nível 2)

6. Calculadora Avançada Crie um módulo calculadora_avancada.py com funções para calcular área de círculo, retângulo e triângulo.

Exemplo: Input → raio=5 | Output → Área do círculo: 78.54

7. Validadores Crie um módulo validadores.py com funções para validar email, CPF e telefone (apenas estrutura básica).

Exemplo: Input → "teste@email.com" | Output → Email válido: True

8. Sorteio de Brindes Use random.choice() para criar um sorteio de brindes entre uma lista de 5 itens.

Exemplo: Input → ["Caneta", "Caderno", "Camiseta", "Livro", "Mousepad"] | Output → Brinde sorteado: Caneta

9. Dias para Aniversário Use datetime para calcular quantos dias faltam para o seu aniversário.

Exemplo: Input → nascimento: 15/05/1990 | Output → Dias para o próximo aniversário: 120

10. Listar Arquivos Use os.listdir() para listar todos os arquivos .txt do diretório atual.

Exemplo: Output → Arquivos .txt encontrados: ['arquivo1.txt', 'arquivo2.txt']

11.11.3 MÉDIO (Nível 3)

11. Gerador de Senhas Crie um módulo gerador_senhas.py que gera senhas aleatórias com diferentes níveis de segurança.

Exemplo: Input → nivel="alto" | Output → Senha gerada: A7bK9mP2

12. Conversor de Moedas Crie um módulo conversor_moedas.py que converte entre Real, Dólar e Euro (use valores fictícios).

Exemplo: Input → 100, "BRL", "USD" | Output → R$ 100.00 = $ 18.50

13. Estrutura de Diretórios Use pathlib para criar uma estrutura de diretórios: projetos/python/exercicios/.

Exemplo: Output → Estrutura criada: projetos/python/exercicios/

14. Estatísticas Crie um módulo estatisticas.py que calcula média, mediana e moda de uma lista de números.

Exemplo: Input → [1, 2, 3, 3, 4, 5] | Output → Média: 3.0, Mediana: 3.0, Moda: 3

15. Embaralhar Cartas Use random.shuffle() para embaralhar uma lista de cartas de baralho.

Exemplo: Input → ["Ás", "Rei", "Dama", "Valete"] | Output → ["Dama", "Ás", "Valete", "Rei"]

11.11.4 DIFÍCIL (Nível 4)

16. Agenda de Contatos Crie um módulo agenda.py que gerencia contatos com funções de adicionar, remover, buscar e listar.

Exemplo: Input → adicionar: "João", "11999999999" | Output → Contato adicionado: João - 11999999999

17. Jogo de Adivinhação Crie um módulo jogo_adivinhacao.py que implementa um jogo completo de adivinhar números.

Exemplo: Input → tentar: 50 | Output → Muito alto! Tente um número menor.

18. Gerador de Datas Use datetime e random para criar um gerador de datas aleatórias dentro de um período específico.

Exemplo: Input → 2024-01-01 até 2024-12-31 | Output → Data aleatória: 2024-06-15

19. Organizador de Arquivos Crie um módulo arquivo_utils.py que organiza arquivos por extensão em diretórios separados.

Exemplo: Input → arquivos: [a.txt, b.pdf, c.jpg] | Output → Arquivos organizados por extensão!

20. Calculadora Científica Crie um módulo calculadora_cientifica.py com funções trigonométricas, logarítmicas e exponenciais.

Exemplo: Input → sen(90) | Output → Seno de 90°: 1.0

11.11.5 MUITO DIFÍCIL (Nível 5)

21. Sistema de Biblioteca Crie um sistema modular completo de gerenciamento de biblioteca com módulos separados para livros, usuários e empréstimos.

Exemplo: Input → emprestar livro, usuário | Output → Livro emprestado com sucesso!

22. Criptografia Implemente um módulo crypto.py que criptografa e descriptografa textos usando cifra de César.

Exemplo: Input → "Python", chave=3 | Output → Texto criptografado: Sbwkrq

23. Simulador de Dados Crie um módulo simulador_dados.py que simula lançamentos de dados com diferentes tipos e probabilidades.

Exemplo: Input → dado de 6 faces, 100 lançamentos | Output → Frequência: {1: 16, 2: 18, 3: 15, 4: 17, 5: 16, 6: 18}

24. Analisador de Texto Implemente um módulo analisador_texto.py que analisa frequência de palavras, sentimento e estatísticas de texto.

Exemplo: Input → "Python é uma linguagem incrível" | Output → Palavras: 5, Caracteres: 35, Palavra mais comum: Python

25. Gerenciador de Projetos Crie um módulo gerenciador_projetos.py que organiza projetos em diretórios com templates e estruturas padronizadas.

Exemplo: Input → criar projeto "meu_app" | Output → Projeto 'meu_app' criado com estrutura padrão!