Módulos são arquivos contendo definições e instruções Python que podem ser reutilizados em outros programas. Eles permitem organizar o código em partes lógicas, facilitar a manutenção e evitar repetição. Nesta aula, veremos como importar módulos, as diferentes sintaxes disponíveis, o padrão if __name__ == "__main__" e como estruturar projetos com múltiplos módulos.

import

A instrução import é usada para carregar um módulo inteiro no namespace atual. Quando você escreve import nome_do_modulo, o Python executa o arquivo correspondente e disponibiliza todas as funções, classes e variáveis definidas nele através do nome do módulo. Por exemplo, o módulo math da biblioteca padrão fornece funções matemáticas.

Exemplo:

import math
print(math.sqrt(16))  # 4.0
print(math.pi)        # 3.141592653589793

Após o import, você deve usar o nome do módulo como prefixo para acessar seus conteúdos. Isso evita conflitos de nomes com outros módulos ou com o código principal.

Formas de importar

Além do import simples, Python oferece variações para maior flexibilidade:

  • from ... import ...: Importa itens específicos de um módulo diretamente para o namespace atual, permitindo usá-los sem prefixo.
  • from ... import *: Importa todos os nomes públicos do módulo (definidos em __all__). É desencorajado por poluir o namespace e causar ambiguidades.
  • import ... as ...: Cria um apelido (alias) para o módulo ou item importado, útil para nomes longos ou evitar conflitos.

Exemplos:

# Importando item específico
from math import sqrt, pi
print(sqrt(25))  # 5.0
print(pi)        # 3.141592653589793

# Importando com alias
import numpy as np
array = np.array([1, 2, 3])

# Importar tudo (cuidado!)
from math import *
print(sin(0))  # 0.0

__name__ == "__main__"

Todo módulo Python possui um atributo __name__. Quando o arquivo é executado diretamente, __name__ é definido como "__main__". Quando é importado, __name__ assume o nome do módulo. O bloco if __name__ == "__main__": permite executar código apenas quando o arquivo é executado diretamente, não quando importado.

Isso é útil para testes ou scripts que não devem rodar ao importar o módulo.

Exemplo (salvo como meu_modulo.py):

def saudacao(nome):
    return f"Olá, {nome}!"

if __name__ == "__main__":
    print(saudacao("Mundo"))

Ao executar python meu_modulo.py, imprime "Olá, Mundo!". Ao importar em outro arquivo (import meu_modulo), a mensagem não aparece.

Organização

Módulos podem ser organizados em pacotes (diretórios contendo um arquivo __init__.py). Um pacote é uma hierarquia de módulos. Por exemplo:

meu_projeto/
    __init__.py
    modulo1.py
    subpacote/
        __init__.py
        modulo2.py

Para importar de um pacote:

import meu_projeto.modulo1
from meu_projeto.subpacote import modulo2

Boas práticas de organização:

  • Agrupe funcionalidades relacionadas em um módulo.
  • Use nomes descritivos e em minúsculas para módulos.
  • Evite módulos muito grandes; divida em partes coesas.
  • Utilize __init__.py para controle de importações e inicialização.
  • Prefira importações explícitas a from ... import *.

Boas práticas e observações finais

Sempre coloque os imports no topo do arquivo, após a docstring e comentários. Organize-os em grupos: bibliotecas padrão, bibliotecas de terceiros e módulos locais, separados por linhas em branco. Evite imports circulares e use aliases com moderação. Lembre-se de que módulos são executados apenas uma vez (na primeira importação) e ficam em cache em sys.modules.

Referências

Exercícios

  1. Crie um módulo chamado operacoes.py com funções soma(a, b), subtrai(a, b), multiplica(a, b) e divide(a, b). Em outro arquivo, importe o módulo e use as funções.

    2. ✓ Resposta: 
    # operacoes.py
def soma(a, b):
    return a + b

def subtrai(a, b):
    return a - b

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

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Erro: divisão por zero"

# main.py
import operacoes

print(operacoes.soma(10, 5))
print(operacoes.subtrai(10, 5))
print(operacoes.multiplica(10, 5))
print(operacoes.divide(10, 5))
  2. Utilizando o módulo math, calcule a raiz quadrada de 144 e o seno de 90 graus (converta para radianos).

    3. ✓ Resposta: 
    import math

print(math.sqrt(144))  # 12.0
print(math.sin(math.radians(90)))  # 1.0
  3. Crie um módulo saudacao.py que contenha uma função dizer_ola(nome) e um bloco if __name__ == "__main__" que teste a função. Em seguida, importe o módulo em outro arquivo e use a função sem executar o teste.

    4. ✓ Resposta: 
    # saudacao.py
def dizer_ola(nome):
    return f"Olá, {nome}!"

if __name__ == "__main__":
    print(dizer_ola("Mundo"))

# outro_arquivo.py
import saudacao

print(saudacao.dizer_ola("João"))
  4. Importe a função sqrt do módulo math com o alias raiz e calcule a raiz quadrada de 225.

    5. ✓ Resposta: 
    from math import sqrt as raiz
print(raiz(225))  # 15.0
  5. Crie um pacote chamado util com dois módulos: texto.py (com função maiusculas) e numeros.py (com função dobro). No __init__.py, importe essas funções. Em seguida, use o pacote em um script externo.

    6. ✓ Resposta: 
    # Estrutura:
# util/
#   __init__.py
#   texto.py
#   numeros.py

# util/texto.py
def maiusculas(s):
    return s.upper()

# util/numeros.py
def dobro(n):
    return n * 2

# util/__init__.py
from .texto import maiusculas
from .numeros import dobro

# script.py
from util import maiusculas, dobro

print(maiusculas("olá"))  # OLÁ
print(dobro(5))           # 10