Passo 1 de 7
Entender a separação em módulos
Reconheça como um script pode ser dividido em arquivos Python com responsabilidades e espaços de nomes próprios.
Trilha de aprendizado · Nível 5 · Tutorial 1
Separar funções e constantes em arquivos reutilizáveis e acessar esses recursos por meio de importações que deixam clara a origem dos nomes.
Entender a separação em módulos
Reconheça como um script pode ser dividido em arquivos Python com responsabilidades e espaços de nomes próprios. 2 min
Extrair funções e definir constantes
Mova as regras de conversão e o valor compartilhado para um módulo local sem alterar os cálculos. 3 min
Conectar os arquivos com import
Importe um módulo local, acesse seus recursos com nomes qualificados e confirme que a separação preservou o resultado do conversor. 3 min
Importar apenas os nomes necessários
Use from ... import para selecionar recursos de um módulo e acesse esses nomes diretamente, preservando os resultados do conversor. 2 min
Usar aliases e evitar nomes ambíguos
Aplique aliases a módulos e recursos importados e escolha formas explícitas de distinguir nomes que poderiam colidir. 3 min
Conferir a localização e o nome do módulo
Diagnostique falhas simples de importação local verificando a pasta, o nome e a extensão do arquivo, além de reconhecer módulos ocultados por arquivos de mesmo nome. 3 min
Aplicação final: refatorar um pequeno conversor
Separe um conversor de durações em módulo e consumidor, execute os dois formatos e confirme que a organização mudou sem alterar os resultados. 3 min
Passo 1 de 7
Reconheça como um script pode ser dividido em arquivos Python com responsabilidades e espaços de nomes próprios.
Um módulo local é um arquivo .py que reúne recursos relacionados, como funções e constantes. Em vez de manter todo o conversor em um único script, podemos separar as regras reutilizáveis da parte que usa essas regras e apresenta os resultados.
A divisão muda a organização interna, mas mantém a finalidade do conversor.
Antes, cálculos e apresentação ficam juntos. Depois, as regras de conversão ficam separadas do código que usa e apresenta os resultados.
No exemplo deste tutorial, conversoes.py reúne os recursos reutilizáveis, incluindo as funções metros_para_centimetros e centimetros_para_metros. Já principal.py mantém os dados usados nas conversões e as instruções que apresentam os resultados com print.
O espaço de nomes de um módulo é o conjunto de nomes definidos naquele arquivo. Se uma função for definida em conversoes.py, seu nome pertence ao espaço de nomes desse módulo e não fica automaticamente disponível em principal.py. A forma de conectar os arquivos será apresentada nas próximas etapas.
Dica
Pergunte qual código representa uma regra reutilizável e qual apenas coordena o uso dessa regra ou apresenta resultados. Essa distinção ajuda a decidir o que pertence a cada arquivo.
Associe cada elemento à descrição adequada.
Toque em um item e depois no par correspondente.
Passo 2 de 7
Mova as regras de conversão e o valor compartilhado para um módulo local sem alterar os cálculos.
Separar o código não exige mudar as regras que já funcionam. As funções devem conservar os mesmos nomes, parâmetros, retornos e cálculos. No script original abaixo, CM_POR_METRO é um valor compartilhado pelas duas funções.
Neste ponto, regras de conversão, dados e apresentação ainda estão no mesmo arquivo.
CM_POR_METRO = 100
def metros_para_centimetros(metros):
return metros * CM_POR_METRO
def centimetros_para_metros(centimetros):
return centimetros / CM_POR_METRO
metros = 2.5
centimetros = 340
resultado_em_cm = metros_para_centimetros(metros)
resultado_em_m = centimetros_para_metros(centimetros)
print(f"{metros} m = {resultado_em_cm} cm")
print(f"{centimetros} cm = {resultado_em_m} m")
print(f"Fator usado: {CM_POR_METRO} cm por metro")As duas funções devem ir para conversoes.py. Como seus corpos consultam CM_POR_METRO, essa constante também precisa acompanhar as funções. Se o valor ficasse apenas no script original, o novo módulo não teria esse nome em seu próprio espaço de nomes. Os dados metros e centimetros e as linhas de apresentação continuam sob responsabilidade de principal.py.
A constante acompanha as funções que dependem dela; os dados e a apresentação permanecem separados.
A extração muda a localização do código, não as regras de cálculo.
O módulo extraído mantém a constante no nível superior e preserva integralmente as duas funções.
CM_POR_METRO = 100
def metros_para_centimetros(metros):
return metros * CM_POR_METRO
def centimetros_para_metros(centimetros):
return centimetros / CM_POR_METRODica
O nome CM_POR_METRO usa letras maiúsculas e sublinhados para comunicar que o valor deve ser tratado como constante. Python, porém, não impede que esse nome receba outro valor. A escrita em maiúsculas é uma convenção, não uma garantia de imutabilidade.
Complete a definição no nível superior de conversoes.py: CM_POR_METRO = ____
Complete sem alterar a regra original: return metros * ____
Complete sem alterar a regra original: return centimetros / ____
Definir CM_POR_METRO com letras maiúsculas impede que o nome receba outro valor em Python.
Passo 3 de 7
Importe um módulo local, acesse seus recursos com nomes qualificados e confirme que a separação preservou o resultado do conversor.
Em principal.py, a declaração import conversoes importa o módulo usando o nome do arquivo sem a extensão .py. Essa declaração disponibiliza o nome conversoes no arquivo consumidor.
Os recursos do módulo são acessados com nomes qualificados: conversoes.metros_para_centimetros, conversoes.centimetros_para_metros e conversoes.CM_POR_METRO. O prefixo deixa visível a origem de cada nome.
O ponto conecta o nome do módulo ao recurso definido nele.
Após import conversoes, principal.py chega aos recursos pelo caminho conversoes.nome.
No seu computador, crie uma pasta e salve nela os dois arquivos abaixo. O módulo mantém a constante e as funções extraídas; o script principal mantém exatamente os mesmos dados e as mesmas linhas de apresentação usadas antes da separação.
Salve este conteúdo como conversoes.py.
CM_POR_METRO = 100
def metros_para_centimetros(metros):
return metros * CM_POR_METRO
def centimetros_para_metros(centimetros):
return centimetros / CM_POR_METROA importação cria o nome conversoes; por isso, funções e constante são acessadas com esse prefixo.
import conversoes
metros = 2.5
centimetros = 340
resultado_em_cm = conversoes.metros_para_centimetros(metros)
resultado_em_m = conversoes.centimetros_para_metros(centimetros)
print(f"{metros} m = {resultado_em_cm} cm")
print(f"{centimetros} cm = {resultado_em_m} m")
print(f"Fator usado: {conversoes.CM_POR_METRO} cm por metro")Abra o terminal nessa pasta e execute principal.py com o comando que você já usa para scripts, como python principal.py. Como os dados, os cálculos e as linhas de apresentação foram preservados, a saída completa deve coincidir com a do script anterior à separação.
Compare as três linhas, incluindo seus valores.
2.5 m = 250.0 cm
340 cm = 3.4 m
Fator usado: 100 cm por metroDica
Em conversoes.CM_POR_METRO, conversoes identifica o módulo e CM_POR_METRO identifica o recurso procurado nele. A mesma leitura vale para as chamadas de função.
Complete a chamada: resultado = conversoes.____(2.5)
Complete o acesso: fator = ____.CM_POR_METRO
Execute principal.py no seu computador. Qual comando você usou? Os três resultados coincidiram com a saída de referência?
Escreva pelo menos 40 caracteres (0/40).
Passo 4 de 7
Use from ... import para selecionar recursos de um módulo e acesse esses nomes diretamente, preservando os resultados do conversor.
Com from conversoes import ..., você informa explicitamente quais recursos deseja usar em principal.py. Os nomes selecionados ficam disponíveis diretamente, sem o prefixo conversoes.. Se essa for a única forma de importação usada, o nome conversoes não estará disponível no arquivo consumidor.
Mantenha conversoes.py como na etapa anterior e substitua o conteúdo de principal.py pelo código abaixo. Os dados continuam sendo 2.5 e 340; somente a forma de importação e acesso muda.
from conversoes import (
CM_POR_METRO,
centimetros_para_metros,
metros_para_centimetros,
)
metros = 2.5
centimetros = 340
resultado_em_cm = metros_para_centimetros(metros)
resultado_em_m = centimetros_para_metros(centimetros)
print(f"{metros} m = {resultado_em_cm} cm")
print(f"{centimetros} cm = {resultado_em_m} m")
print(f"Fator usado: {CM_POR_METRO} cm por metro")Execute principal.py e confirme que a mudança na importação não alterou nenhuma das três linhas.
2.5 m = 250.0 cm
340 cm = 3.4 m
Fator usado: 100 cm por metroCom import conversoes, fica disponível o nome conversoes, e o acesso usa conversoes.nome. Com from conversoes import CM_POR_METRO, fica disponível diretamente CM_POR_METRO; essa declaração, sozinha, não disponibiliza o nome conversoes. Prefira importar o módulo quando quiser manter a origem visível em cada acesso. Se o contexto já for claro, selecionar poucos nomes pode deixar o código mais direto.
A comparação mostra que cada declaração cria nomes diferentes no arquivo consumidor.
A declaração de importação e a forma de acesso precisam corresponder.
Associe cada declaração à forma de acesso correspondente em principal.py.
Toque em um item e depois no par correspondente.
Complete o único nome que falta nesta declaração: from conversoes import metros_para_centimetros, centimetros_para_metros, ____
Após usar from conversoes import centimetros_para_metros, complete: resultado_em_m = ____(centimetros)
Passo 5 de 7
Aplique aliases a módulos e recursos importados e escolha formas explícitas de distinguir nomes que poderiam colidir.
A palavra as define o nome que será usado no arquivo consumidor.
import conversoes as conv disponibiliza o módulo pelo alias conv.from conversoes import metros_para_centimetros as para_cm disponibiliza a função pelo alias para_cm.O arquivo continua se chamando conversoes.py, e a função continua definida como metros_para_centimetros. O alias existe somente no arquivo que fez a importação.
Observe como cada declaração determina o nome usado no acesso. Estes blocos representam alternativas, não importações que precisam ser usadas juntas.
# Alternativa A: alias para o módulo
import conversoes as conv
print(conv.metros_para_centimetros(2.5))
print(conv.CM_POR_METRO)
# Alternativa B: alias para um recurso específico
from conversoes import metros_para_centimetros as para_cm
print(para_cm(2.5))Um alias cria um caminho alternativo no consumidor, mas não altera o módulo de origem nem a definição importada.
Os apelidos pertencem ao consumidor; o módulo e seus recursos mantêm os nomes originais.
Mesmo importações de nomes específicos podem colidir. Se dois módulos oferecem uma função chamada formatar, associar ambas ao nome formatar no mesmo consumidor deixa a origem ambígua e o segundo vínculo substitui o primeiro.
Prefira importar os módulos e usar nomes qualificados ou atribuir aliases descritivos aos recursos.
Compare o caso ambíguo com formas que preservam a identidade de cada função.
# Evite: o segundo nome formatar substitui o primeiro
from moeda import formatar
from data import formatar
# Correção 1: origem visível em cada acesso
import moeda
import data
print(moeda.formatar(29.9))
print(data.formatar("2026-04-10"))
# Correção 2: aliases descritivos
from moeda import formatar as formatar_moeda
from data import formatar as formatar_data
print(formatar_moeda(29.9))
print(formatar_data("2026-04-10"))Atenção
from modulo import * traz vários nomes sem mostrar claramente suas origens e pode ocultar nomes que já existiam no consumidor. Liste os recursos necessários ou importe o módulo. Ainda assim, nomes específicos também exigem cuidado: importar o mesmo nome de duas origens pode causar colisão.
Complete a importação para que a chamada conv.metros_para_centimetros(3) funcione:
import conversoes as ____
Complete a importação para que a chamada para_cm(3) funcione:
from conversoes import metros_para_centimetros as ____
Os módulos moeda e data oferecem uma função chamada formatar. Qual opção evita a colisão e mantém a origem evidente em cada chamada?
Passo 6 de 7
Diagnostique falhas simples de importação local verificando a pasta, o nome e a extensão do arquivo, além de reconhecer módulos ocultados por arquivos de mesmo nome.
Na execução usual de um script .py, a pasta em que esse script está participa da busca de módulos. Por isso, se principal.py contém import conversoes, o caso mais simples é manter conversoes.py na mesma pasta.
Não confunda essa pasta com qualquer pasta que esteja aberta no terminal. Você pode executar um script informando seu caminho; para a importação local deste exemplo, o que importa é a localização do próprio script e do módulo.
Mesmo que o terminal esteja em outra pasta, principal.py encontra o módulo local quando conversoes.py está ao lado dele neste exemplo.
Neste exemplo, o erro informa que o módulo solicitado por import conversoes não foi localizado.
Traceback (most recent call last):
File "principal.py", line 1, in <module>
import conversoes
ModuleNotFoundError: No module named 'conversoes'Confira se:
principal.py;import, inclusive maiúsculas e minúsculas;.py, e não algo como .py.txt;import não inclui .py.Prefira nomes importáveis em minúsculas e com sublinhados, como calculos_tempo.py. Evite espaços, hífens e nomes iniciados por dígito, pois eles não formam identificadores válidos na sintaxe comum de import.
Dica
Para os casos locais deste tutorial, renomeie ou mova o arquivo e ajuste o import. Não é necessário instalar dependências nem modificar caminhos de busca.
Atenção
Um arquivo local chamado random.py, por exemplo, pode ser encontrado quando o programa pretendia importar outro módulo com esse mesmo nome. Nesse caso, a importação pode até acontecer, mas acessar o recurso esperado falhará porque o arquivo local foi carregado.
Dê ao arquivo local um nome específico, como sorteio_local.py, e atualize as importações que apontavam para ele. A correção deixa claro qual arquivo pertence ao projeto e evita que ele oculte outro módulo de mesmo nome.
Na mesma pasta estão principal.py e conversao.py. A primeira linha de principal.py é import conversoes, e a execução produz ModuleNotFoundError. Qual é a correção mais direta?
Um projeto contém principal.py e um arquivo local chamado random.py. O programa pretendia importar outro módulo com esse nome, mas acaba acessando o arquivo local. Explique o problema e proponha uma correção.
Escreva pelo menos 40 caracteres (0/40).
Passo 7 de 7
Separe um conversor de durações em módulo e consumidor, execute os dois formatos e confirme que a organização mudou sem alterar os resultados.
Crie uma pasta para a atividade e, dentro dela, salve o código abaixo como duracoes_inicial.py. Execute-o com o comando que você já usa para scripts, como python duracoes_inicial.py, e anote os dois resultados. Eles serão sua referência após a separação.
Este é o conversor ainda organizado em um único arquivo.
SEGUNDOS_POR_MINUTO = 60
def minutos_para_segundos(minutos):
return minutos * SEGUNDOS_POR_MINUTO
def segundos_para_minutos(segundos):
return segundos / SEGUNDOS_POR_MINUTO
duracao_em_minutos = 2.5
duracao_em_segundos = 210
print(
f"{duracao_em_minutos} minutos = "
f"{minutos_para_segundos(duracao_em_minutos)} segundos"
)
print(
f"{duracao_em_segundos} segundos = "
f"{segundos_para_minutos(duracao_em_segundos)} minutos"
)Exemplo
A execução deve apresentar:
2.5 minutos = 150.0 segundos
210 segundos = 3.5 minutos
Na mesma pasta, crie conversoes_duracao.py para reunir a constante e as duas funções. Crie também principal.py para manter os dados e a apresentação dos resultados.
Escolha uma importação explícita e ajuste os acessos. Um alias é opcional: use-o somente se tornar os nomes mais claros. Preserve os parâmetros, retornos e cálculos das funções. Antes de consultar a solução de referência, tente realizar a separação no seu editor.
As regras de conversão saem do script consumidor, mas as entradas e a apresentação permanecem nele.
Depois da separação, principal.py depende de conversoes_duracao.py; os dois arquivos precisam permanecer na mesma pasta para esta atividade.
A solução abaixo usa um alias curto, mas descritivo. O alias existe apenas em principal.py: ele não altera o nome do arquivo nem os nomes definidos no módulo. Compare com sua escolha e corrija o necessário.
O módulo concentra a constante e as regras reutilizáveis.
SEGUNDOS_POR_MINUTO = 60
def minutos_para_segundos(minutos):
return minutos * SEGUNDOS_POR_MINUTO
def segundos_para_minutos(segundos):
return segundos / SEGUNDOS_POR_MINUTO
O consumidor usa o alias duracao para manter visível a origem de cada função.
import conversoes_duracao as duracao
duracao_em_minutos = 2.5
duracao_em_segundos = 210
print(
f"{duracao_em_minutos} minutos = "
f"{duracao.minutos_para_segundos(duracao_em_minutos)} segundos"
)
print(
f"{duracao_em_segundos} segundos = "
f"{duracao.segundos_para_minutos(duracao_em_segundos)} minutos"
)Dica
Execute principal.py na mesma pasta de conversoes_duracao.py. Compare cada linha com os resultados de referência. Se houver diferença ou o módulo não for localizado, confira a grafia dos nomes, a extensão .py, a importação e a pasta dos arquivos.
Como você organizou os arquivos? Registre a importação escolhida e um acesso correspondente, justifique por que os nomes ficaram claros e informe se os dois resultados coincidiram com a referência.
Escreva pelo menos 80 caracteres (0/80).
Resumo
Sua refatoração está concluída quando a organização muda, mas o comportamento observado permanece igual.
SEGUNDOS_POR_MINUTO.Parabéns! Você concluiu: Separar código em módulos e usar importações explícitas
Você concluiu “Separar código em módulos e usar importações explícitas”. No próximo tutorial, verá como controlar a execução de módulos com __name__.
Milhares de cursos online em vídeo, ebooks e áudiobooks.
Para testar seus conhecimentos no decorrer dos cursos online
Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail
Baixe nosso aplicativo pelo QR Code ou pelos links abaixo:.
Leve o conhecimento no seu bolso.
Baixe o aplicativo Cursa.
São centenas de Cursos gratuitos a disposição, com Certificado de conclusão gratuito que é salvo em sua galeria de imagens do celular.
Baixe o app para ter acesso ao Certificado de conclusão de Curso Gratuitamente.
+ de 10 milhões
de alunos
Certificado grátis e
válido em todo o Brasil
60 mil exercícios
gratuitos
4,8/5 classificação
nas lojas de apps
Cursos gratuitos em
vídeo, ebooks e audiobooks
