Passo 1 de 6
Por que importar pode iniciar um programa?
Preveja quais instruções de um módulo são executadas quando ele é importado pela primeira vez.
Trilha de aprendizado · Nível 5 · Tutorial 2
Fazer um arquivo funcionar tanto como programa executável quanto como módulo reutilizável, sem iniciar interações ou cálculos indevidos durante a importação.
Por que importar pode iniciar um programa?
Preveja quais instruções de um módulo são executadas quando ele é importado pela primeira vez. 2 min
O que muda ao importar novamente?
Distinguir o reaproveitamento de um módulo no mesmo processo da primeira importação realizada em uma nova execução do Python. 1 min
Dois modos de executar, dois valores de __name__
Associe o valor de __name__ ao papel de cada arquivo: iniciar o programa ou ser importado como módulo. 2 min
Proteger o início com if __name__
Use uma condição para iniciar interações somente na execução direta, mantendo as definições disponíveis durante a importação. 2 min
Deixar a coordenação em main
Organize a conversão como recurso reutilizável e concentre a interação em uma função main chamada somente pela proteção. 2 min
Aplicar e conferir nos dois modos
Prática final para verificar a execução direta, a importação sem efeitos colaterais e a reutilização explícita de uma função. 3 min
Passo 1 de 6
Preveja quais instruções de um módulo são executadas quando ele é importado pela primeira vez.
Na primeira importação bem-sucedida de um módulo, o Python executa suas instruções de nível superior, de cima para baixo. Isso inclui atribuições, instruções def e chamadas escritas fora das funções.
Uma instrução def cria a função, mas não executa seu corpo. Já uma chamada no nível superior executa o corpo da função naquele momento.
Observe o que está fora das funções e o que está dentro de cada corpo.
FATOR = 100
def metros_para_centimetros(metros):
return metros * FATOR
def anunciar_carregamento():
print("Módulo de medidas carregado")
anunciar_carregamento()Considere outro arquivo que solicita somente metros_para_centimetros. A forma from medidas import metros_para_centimetros ainda precisa carregar e executar medidas.py. Ela não executa apenas a definição selecionada.
A mensagem deste arquivo só aparece depois que a execução necessária de medidas.py termina.
from medidas import metros_para_centimetros
print("Importação concluída")O programa importador pausa enquanto o módulo é executado. Depois que o nome solicitado fica disponível, o importador continua.
Primeiro o módulo é carregado e executado; depois o programa importador segue para a próxima instrução.
Atenção
Se houver chamadas de print(), input() ou de cálculos no nível superior, elas poderão apresentar resultados, solicitar uma entrada ou iniciar processamento durante a importação — mesmo que o arquivo importador não tenha pedido essas ações explicitamente.
Dica
Leia o módulo de cima para baixo. Para cada instrução no nível superior, pergunte: ela apenas atribui ou define um nome, ou chama algo? Corpos de funções definidas permanecem sem execução até que alguma chamada os alcance.
Considerando os dois arquivos mostrados e a primeira importação bem-sucedida de medidas, o que aparece no terminal ao executar usar_medidas.py?
Passo 2 de 6
Distinguir o reaproveitamento de um módulo no mesmo processo da primeira importação realizada em uma nova execução do Python.
Depois que um módulo é importado com sucesso, uma nova importação pelo mesmo nome no mesmo processo normalmente reaproveita o módulo já carregado. Por isso, o código de nível superior não é executado outra vez. Isso não elimina efeitos colaterais: eles ainda acontecem na primeira importação.
A chamada no nível superior apresenta uma mensagem quando o módulo é executado pela primeira vez no processo.
FATOR = 100
def metros_para_centimetros(metros):
return metros * FATOR
def anunciar_carregamento():
print("Módulo de medidas carregado")
anunciar_carregamento()
As duas instruções de importação pertencem ao mesmo script e, portanto, à mesma execução do Python.
import medidas
import medidas
print("Importações concluídas")
No mesmo processo, somente a primeira importação alcança e executa o código de nível superior de medidas.py. Em processos separados, cada processo realiza sua própria primeira importação.
O reaproveitamento vale dentro do mesmo processo. Uma nova execução do Python começa sem esse módulo previamente carregado.
Exemplo
Ao executar usar_medidas.py, as duas importações estão no mesmo processo:
Módulo de medidas carregado
Importações concluídasSe você encerrar essa execução e iniciar usar_medidas.py novamente, será criado outro processo. Nele, a primeira importação poderá executar novamente medidas.py, produzindo a mesma saída outra vez.
Em uma única execução de usar_medidas.py, a mensagem Módulo de medidas carregado aparece duas vezes porque há duas instruções import medidas.
Se usar_medidas.py for executado duas vezes, encerrando a primeira execução antes de iniciar a segunda, a mensagem do módulo poderá aparecer uma vez em cada execução.
Passo 3 de 6
Associe o valor de name ao papel de cada arquivo: iniciar o programa ou ser importado como módulo.
Quando um arquivo Python é executado, o próprio Python define a variável __name__ no espaço de nomes desse módulo. O valor depende do papel desempenhado pelo arquivo: iniciar o programa ou ser carregado por uma importação.
Esta instrução de nível superior permite observar o valor atribuído pelo Python.
print(f"Em medidas.py: {__name__}")Ao executar medidas.py diretamente, ele é o arquivo que inicia o programa e seu __name__ vale "__main__". Quando outro script importa esse arquivo como medidas, o valor dentro do módulo passa a ser "medidas", sem a extensão .py.
O contexto muda o valor: o arquivo inicial recebe __main__; o módulo importado recebe seu nome de importação.
Considere este script na mesma pasta de medidas.py. A importação executa a instrução de nível superior do módulo antes de o script continuar.
import medidas
print(f"Em usar_medidas.py: {__name__}")Exemplo
Em medidas.py: medidas
Em usar_medidas.py: __main__Os dois valores coexistem: medidas.py sabe que foi importado, enquanto usar_medidas.py sabe que iniciou o programa.
Dica
__name__ não é um valor único compartilhado pelo programa inteiro. Cada módulo possui sua própria variável __name__.
Associe cada situação ao valor observado no arquivo indicado.
Toque em um item e depois no par correspondente.
Passo 4 de 6
Use uma condição para iniciar interações somente na execução direta, mantendo as definições disponíveis durante a importação.
Como você já viu, __name__ vale "__main__" quando o próprio arquivo inicia o programa. Podemos usar esse valor em um if comum para proteger as instruções que iniciam interações ou cálculos.
As definições reutilizáveis permanecem fora do bloco. Assim, elas ficam disponíveis tanto na execução direta quanto na importação.
A leitura e a apresentação do resultado estão indentadas dentro da condição.
def metros_para_centimetros(metros):
return metros * 100
if __name__ == "__main__":
metros = float(input("Metros: "))
resultado = metros_para_centimetros(metros)
print(f"Centímetros: {resultado}")Dica
Somente as três instruções indentadas pertencem ao if. A função metros_para_centimetros continua definida no nível do módulo e pode ser importada.
Na execução direta, a comparação é verdadeira e o Python entra no bloco protegido. Durante a importação de medidas, a comparação é falsa: o bloco é ignorado, mas as definições anteriores continuam disponíveis para o programa importador.
A proteção altera apenas o caminho seguido pelo bloco indentado.
A condição não protege o arquivo inteiro. Uma chamada colocada no nível superior e fora do bloco continua sujeita à execução durante a importação.
Compare a indentação das duas chamadas de print.
print("Módulo medidas carregado")
def metros_para_centimetros(metros):
return metros * 100
if __name__ == "__main__":
print("Programa iniciado diretamente")Atenção
Ao importar esse arquivo pela primeira vez, Módulo medidas carregado será apresentado porque essa chamada está fora da proteção. A segunda mensagem só aparece na execução direta.
Complete somente a condição:
if ____:
Considere o código da tela anterior. O que aparece quando medidas é importado pela primeira vez?
Passo 5 de 6
Organize a conversão como recurso reutilizável e concentre a interação em uma função main chamada somente pela proteção.
main é um nome convencional para a função que coordena o início do programa. Ela pode reunir a leitura da entrada, a chamada da conversão e a apresentação do resultado. main não é uma palavra reservada e não recebe comportamento automático do Python: defini-la apenas cria a função; é preciso chamá-la para executar seu corpo.
A conversão permanece disponível no nível do módulo. A função main coordena a interação, e somente sua chamada fica dentro da proteção.
def metros_para_centimetros(metros):
return metros * 100
def main():
valor = float(input("Metros: "))
resultado = metros_para_centimetros(valor)
print(f"{resultado} cm")
if __name__ == "__main__":
main()
Dica
A definição de main fica fora da proteção para que o Python conheça a função antes de alcançar sua chamada. A interação só começa quando main() é chamada dentro do bloco protegido.
Antes, as instruções de entrada, conversão e saída podiam ficar diretamente dentro do if. Agora, essas responsabilidades são coordenadas por main, enquanto a proteção contém apenas a chamada que inicia o programa. A função metros_para_centimetros continua separada e pode ser importada sem iniciar a interação.
Compare a concentração das responsabilidades nas duas estruturas.
Na estrutura organizada, a proteção decide se o programa começa; main coordena a interação; e a conversão permanece reutilizável.
Ordene os três blocos. As duas definições foram agrupadas para representar uma estrutura inequívoca.
Passo 6 de 6
Prática final para verificar a execução direta, a importação sem efeitos colaterais e a reutilização explícita de uma função.
Crie medidas.py e usar_medidas.py na mesma pasta. Copie os códigos abaixo e salve os arquivos. A função de conversão ficará disponível nos dois modos, enquanto a chamada de main só iniciará a interação na execução direta.
A conversão é reutilizável, e a coordenação do programa fica em main.
def metros_para_centimetros(metros):
return metros * 100
def main():
valor = float(input("Metros: "))
resultado = metros_para_centimetros(valor)
print(f"{resultado} cm")
if __name__ == "__main__":
main()
Este script primeiro confirma que a importação terminou e depois chama intencionalmente a função reutilizável.
import medidas
print("Importação concluída")
resultado = medidas.metros_para_centimetros(2)
print(f"2 m correspondem a {resultado} cm")
Abra o terminal na pasta dos arquivos e execute o comando abaixo. Essa execução inicia um novo processo do Python. Quando aparecer Metros:, digite 1.5 e pressione Enter. Se o comando configurado no seu computador for py, use py medidas.py.
python medidas.pyExemplo
Metros: 1.5
150.0 cmA interação aconteceu porque, na execução direta de medidas.py, seu __name__ vale "__main__" e a chamada protegida de main() é alcançada.
Agora execute o outro arquivo com o comando abaixo. Essa verificação também começa em um novo processo, evitando que uma importação anterior já reaproveitada esconda o comportamento inicial do módulo. Se você usou py medidas.py, execute agora py usar_medidas.py.
Na execução direta, o caminho alcança a interação coordenada por main. Na importação, a proteção desvia desse início e deixa a função de conversão disponível para uma chamada explícita.
Importar disponibiliza a função; executar diretamente também permite iniciar main.
python usar_medidas.pyExemplo
Importação concluída
2 m correspondem a 200 cmNão aparece Metros: nem um resultado produzido por main. A segunda linha é intencional: ela só existe porque usar_medidas.py chamou explicitamente medidas.metros_para_centimetros(2).
Com base no que você observou no terminal, explique por que main() foi chamada na execução direta de medidas.py, mas não durante a importação feita por usar_medidas.py. Diferencie também o resultado intencional da conversão de um efeito colateral da importação.
Escreva pelo menos 80 caracteres (0/80).
Resumo
A proteção permite combinar um programa executável com um módulo reutilizável.
__name__ não vale "__main__".main() inicia a interação.Parabéns! Você concluiu: Controlar a execução de módulos com __name__
Você concluiu o tutorial! Agora sabe prever efeitos de uma importação, interpretar __name__ e proteger o início de um programa com if __name__ == "__main__".
100 XP
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
