.jpg)
Seja muito bem-vindo à Academy Code Christ!
Python 🐍 Etapa 09
Módulos, Pacotes e Organização
🌍 Academy Code Christ está disponível em vários idiomas.Fique à vontade para usar o tradutor na Barra lateral (Sidebar) e aprender no seu idioma.
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
🎯 Por que organizar o código?
Imagine que seu programa cresceu e agora possui centenas de linhas.
Tudo está em um único arquivo (main.py).
Nesse ponto, localizar partes
específicas se torna um pesadelo.
Pior: qualquer modificação em uma parte do código pode gerar erros em lugares totalmente diferentes.
É por isso que existe o conceito de modularização.
Modularizar significa dividir um grande programa em pequenas partes (módulos), cada uma responsável por uma função específica.
As vantagens:
● 🔹 facilita a manutenção;
● 🔹 permite a reutilização de código;
● 🔹 melhora a legibilidade;
● 🔹 viabiliza o trabalho em equipe;
● 🔹 acelera testes e correções.
Em Python, essa divisão é feita naturalmente com módulos e pacotes.
O que é um módulo?
Um módulo nada mais é do que um arquivo Python (.py) contendo funções, classes e variáveis.
Você pode importar esse arquivo e usar
seu conteúdo em outro programa.
Exemplo 1 – Criando e
importando um módulo
Crie um arquivo operacoes.py com o conteúdo:
def somar(a, b):
return a + b
def subtrair(a, b):
return a - b
Agora, em outro arquivo (por exemplo, main.py):
import operacoes
print(operacoes.somar(10, 5))
print(operacoes.subtrair(20, 8))
Saída:
15
12
Pronto — você acabou de dividir seu código em partes organizadas.
Importações específicas
Em vez de importar o módulo inteiro, você pode trazer só o que precisa:
from operacoes import somar
print(somar(2, 3))
Ou importar várias funções de uma vez:
from operacoes import somar, subtrair
Cuidado com from modulo import * — embora permitido, ele torna o código confuso e dificulta entender o que está sendo usado.
Dando apelidos a módulos ou funções
Você pode usar o comando as para criar um apelido:
import operacoes as op
print(op.somar(5, 7))
Isso é comum em bibliotecas grandes:
import numpy as np
import pandas as pd
Módulos internos do Python (standard library)
Python vem com centenas de módulos prontos na chamada biblioteca padrão (standard library).
Alguns exemplos essenciais:
|
Módulo |
O que faz |
Exemplo |
|
math |
Funções matemáticas |
math.sqrt(25) → 5.0 |
|
random |
Geração de números aleatórios |
random.randint(1, 10) |
|
datetime |
Manipulação de datas e horários |
datetime.date.today() |
|
os |
Acesso ao sistema operacional |
os.listdir() |
|
sys |
Interação com o interpretador |
sys.version |
|
json |
Comunicação com dados no formato JSON |
json.dumps(obj) |
Exemplo prático:
import math
raiz = math.sqrt(81)
print("Raiz quadrada de 81:", raiz)
Saída:
Raiz quadrada de 81: 9.0
Explorando o módulo math
O math fornece operações matemáticas avançadas:
import math
print(math.pow(2, 3)) # potência
print(math.pi) # número π
print(math.ceil(7.1)) # arredonda para cima
print(math.floor(7.9)) # arredonda para baixo
Resultados:
8.0
3.141592653589793
8
7
Explorando o módulo random
Gera números pseudoaleatórios — muito usado em jogos, sorteios e testes.
import random
print(random.randint(1, 6)) # inteiro entre 1 e 6
print(random.choice(["a", "b", "c"])) # escolha aleatória
print(random.random()) # número de 0 a 1
Explorando o módulo datetime
Trabalhar com datas e horários é simples e poderoso:
from datetime import datetime, timedelta
agora = datetime.now()
print("Data e hora atuais:", agora)
amanha = agora + timedelta(days=1)
print("Amanhã será:", amanha.strftime("%d/%m/%Y"))
Saída exemplo:
Data e hora atuais: 2024-09-30 15:23:45
Amanhã será: 01/10/2024
O módulo os: interagindo com o
sistema operacional
Permite criar, mover e apagar arquivos, acessar variáveis de ambiente e muito mais.
import os
print("Diretório atual:", os.getcwd())
os.mkdir("nova_pasta")
print("Pastas:", os.listdir())
Sempre tenha cuidado ao usar funções que alteram o sistema de arquivos (como excluir ou mover).
Criando pacotes
Quando você organiza múltiplos módulos, usa pacotes.
Um pacote é simplesmente uma pasta contendo vários módulos Python e um arquivo especial chamado __init__.py.
Estrutura:
meu_projeto/
│
├── calculos/
│ ├── __init__.py
│ ├── soma.py
│ ├── subtracao.py
│
└── main.py
Conteúdo de soma.py:
def somar(a, b):
return a + b
Conteúdo de subtracao.py:
def subtrair(a, b):
return a - b
Conteúdo de main.py:
from calculos import soma, subtracao
print(soma.somar(10, 5))
print(subtracao.subtrair(20, 8))
Saída:
15
12
Por que o __init__.py é importante?
O arquivo __init__.py
transforma uma pasta em um pacote reconhecido pelo Python.
Mesmo vazio, ele é necessário quando se planeja importar módulos que estão dentro da pasta.
Você também pode usar __init__.py para definir exportações automáticas:
# dentro do __init__.py
from .soma import somar
from .subtracao import subtrair
Assim, basta importar diretamente:
from calculos import somar, subtrair
Criando módulos reutilizáveis
Depois de modularizar bem o código, você pode reutilizá‑lo em outros projetos:
1. Guarde seus módulos em uma pasta fixa.
2. Em novos projetos, importe usando o caminho completo.
3. Ou instale localmente como pacote (pip install -e . em projetos estruturados).
Onde o Python procura módulos?
Quando você usa import, o Python segue uma ordem interna de busca:
1. O diretório atual (onde o script está rodando).
2. Diretórios listados em sys.path (caminhos configurados).
3. A biblioteca padrão e pacotes instalados via pip.
Você pode verificar:
import sys
print(sys.path)
Se precisar adicionar um caminho manualmente:
sys.path.append("C:/meus_modulos")
Importando módulos externos (via pip)
Milhares de bibliotecas externas podem ser adicionadas facilmente com o gerenciador pip.
Exemplo: instalar a biblioteca requests para fazer requisições web.
No terminal:
pip install requests
Depois, use no seu programa:
import requests
resposta = requests.get("https://api.github.com")
print("Status:", resposta.status_code)
Python exibirá:
Status: 200
O pip é o portal principal para expandir o poder da linguagem, permitindo integrar o Python a bancos de dados, APIs, web e muito mais.
Boas práticas de modularização
1. Um módulo = um propósito
Código de cálculo em calculos.py, funções
de texto em strings.py,
etc.
2. Nomes claros e em minúsculas
Evite letras maiúsculas ou acentos
no nome do arquivo.
3. Evite funções com dependências desnecessárias
Um módulo deve funcionar de forma
independente quando possível.
4. Use comentários e docstrings
Documente o que cada módulo faz,
para facilitar o reuso.
5. Organize a estrutura do projeto
Uma boa estrutura facilita a
escalabilidade.
Exemplo:
projeto/
│
├── data/ # arquivos de dados
├── modules/ # seus módulos Python
├── tests/ # scripts de teste
└── main.py
6. Evite importações cíclicas
Um módulo não deve depender de outro
que também o importa — isso gera erros de referência circular.
Mini‑projeto prático: Calculadora modular
Estrutura de diretório
calculadora/
│
├── __init__.py
├── funcoes.py
└── main.py
funcoes.py
def somar(a, b): return a + b
def subtrair(a, b): return a - b
def multiplicar(a, b): return a * b
def dividir(a, b):
if b == 0:
raise ValueError("Divisão por zero!")
return a / b
main.py
from funcoes import somar, subtrair, multiplicar, dividir
print("=== Calculadora Modular ===")
a = float(input("Primeiro número: "))
b = float(input("Segundo número: "))
op = input("Operação (+, -, *, /): ")
if op == "+":
print("Resultado:", somar(a, b))
elif op == "-":
print("Resultado:", subtrair(a, b))
elif op == "*":
print("Resultado:", multiplicar(a, b))
elif op == "/":
print("Resultado:", dividir(a, b))
else:
print("Operação inválida!")
Ao executar main.py, o sistema chama funções de outro módulo, demonstrando como separar código com clareza.
Resumo
Nesta etapa, você aprendeu:
✅ Como
dividir o código em módulos e pacotes.
✅ A diferença entre import, from import e as.
✅ Como aproveitar a biblioteca
padrão do Python (math, random, os, etc).
✅ A instalar e usar módulos externos via
pip.
✅ Práticas recomendadas de organização
e estrutura de projetos.
Agora, seus programas podem ser mantidos, escalados e reaproveitados com facilidade, tal como em projetos profissionais.
Na próxima etapa, avançaremos para o universo da Programação Orientada a Objetos (POO) — um dos pilares mais poderosos da ciência da computação, que permitirá a você criar classes, objetos, herança e encapsulamento em Python, elevando definitivamente o nível dos seus projetos. 🚀
.png)
.png)
Postar um comentário