Introdução
Os módulos em Python são arquivos com extensão ".py" codificados em Python. Qualquer arquivo escrito em Python pode ser referenciado como um módulo.
Vários módulos estão disponíveis após a instalação da linguagem Python. Alguns módulos precisam ser instalados manualmente.
A instalação manual de módulos foi abordada em nosso guia sobre importação de módulos para o Python 3.
Com este guia, você entenderá como:
- Escrever um módulo;
- Acessar módulos de outros diretórios;
- Usar uma variável de ambiente;
- Módulo em variável de ambiente do Python 3.
Preparação para o trabalho
Você deve ter uma distribuição baseada em Debian/CentOS//Ubuntu configurada, configurando um usuário com privilégios sudo. Configuração do ambiente virtual da linguagem Python. Recomendamos que você se prepare com antecedência antes de começar a trabalhar.
Escrevendo e importando módulos
A primeira etapa é verificar a versão do Python com:
No momento, a versão atual é 3.10.6. Se você tiver uma versão mais antiga, atualize o índice de pacotes e os pacotes de software usando:
Vamos iniciar o ambiente virtual e usar o editor de texto Vim para criar um novo arquivo chamado testingFile.py e adicionar as seguintes linhas de código logo no início, especificando o shebang. Shebang - usando #! especifique o caminho para o interpretador Python, consulte nossas instruções para obter mais detalhes.
# Function definition
def test():
print(“This is test file”)
Se executarmos com:
Obteremos um resultado vazio. Precisamos criar um segundo arquivo e chamá-lo de test2.py, abri-lo com o vim e importar testingFile.py para o arquivo test2.py e chamar a função de teste.
#!/usr/bin/env python3
#File import
import testingFile
#Calling a function from testingFile
testingFile.test()
Obtemos o seguinte resultado, como na Tela 1.
Estamos importando o módulo sem usar "from testingFile import test", precisamos chamar a função usando o nome do módulo. O uso de from ... import pode ser considerado em nossas instruções.
Considere o uso de variáveis em nosso módulo, adicione uma linha na parte inferior:
# Function definition
def test():
print("This is test file")
#Assigning a value to a variable
name = "serverspace"
Em seguida, no arquivo test2.py, no final, adicione uma linha alterando nosso código para a seguinte forma:
#File import
import testingFile
#Calling a function from testingFile
testingFile.test()
#Calling a print function using a variable
print(testingFile.name)
A saída é mostrada na Figura 2.
Depois de considerar a possibilidade de chamar a função e a variável print, vamos dar uma olhada na criação de uma classe e adicionar alguns atributos à classe usando os seguintes comandos.
# Function definition
def test():
print("This is test file")
#Assigning a value to a variable
name="serverspace"
#Class definition
class TestingClass:
def __init__(self, name, age):
self.name = name
self.age = age
def tell_me_about_TestingClass(self):
print("this class is " + self.name + ".")
print(self.name + "is the testing's name")
Agora, usando o arquivo test2.py, chamaremos a função de inicialização e as informações sobre a classe:
#Import module
import testingFile
#Function call
testingFile.test()
#Output information from another module
print(testingFile.name)
#Calling functions from a class
server = testingFile.TestingClass("testingserver", "30 y.o.")
server.tell_me_about_TestingClass()
O resultado é mostrado na Tela 3.
Primeiro, criamos uma variável chamada "server", chamamos a classe do módulo testingFile.py, atribuímos valores para o nome da variável "testingserver" e o valor "30 y.o." para a variável idade.
É importante ter em mente que um módulo é uma definição, mas, ao mesmo tempo, é possível implementar código. Considere um novo exemplo de módulo em test3.py
def TestHello():
print("Testing Hello, World!")
#Calling a function in a module
TestHello()
Importe o módulo para o arquivo test4.py e verifique a chamada da função TestHello:
import test3
Obtemos o resultado de acordo com a Tela 4.
O motivo é simples: dentro do arquivo test3.py, criamos uma função chamada TestHello e, dentro dela, implementamos a função de impressão de texto. Em seguida, chamamos a função criada e a importamos para o arquivo test4.py. Assim, ao executar o test4.py, chamamos a função de impressão de texto a partir da função TestHello.
Acesso a módulos de outros diretórios
Às vezes, alguns módulos são úteis não apenas para um projeto, mas também para outros projetos. Por esse motivo, não é necessário armazenar o módulo no mesmo diretório do projeto. Você pode criar um diretório compartilhado e fazer referência a esse diretório usando vários métodos.
Usando uma variável de ambiente
Se o módulo estiver fora do projeto, use o módulo sys e use-o para especificar o caminho para o ambiente em que o arquivo com o módulo desejado está localizado. Por exemplo, se criarmos o arquivo test5.py no diretório home, não poderemos importar o arquivo test3.py localizado no diretório do ambiente virtual. Considere como especificar o caminho para o arquivo test3.py:
sys.path.append(‘/root/testing/’)
import test3
E obteremos um resultado bem-sucedido, conforme mostrado na Tela 5.
Podemos obter um resultado bem-sucedido especificando o caminho correto para o test3.
Módulo na variável de ambiente do Python 3
Esse método é considerado uma solução eficaz, pois o módulo fica disponível para todo o ambiente e sistema. Verificando qual caminho o Python verifica com comandos
import sys
print(sys.path)
Como resultado, obteremos os caminhos de teste do interpretador Python, conforme mostrado na Tela 6.
Selecione o caminho desejado e copie o arquivo test3.py para o caminho desejado.
python3 test5.py
No arquivo test5.py, remova a importação do módulo sys. Vamos executar o código:
cat test5.py #to make sure the sys import line is removed or commented out
python3 test5.py
Obtemos a saída como na Tela 7.
Copiar o módulo para o caminho de checkout comum do interpretador Python provou ser o mais eficiente. O motivo é que, para não importar o módulo sys nos arquivos de código todas as vezes e especificar o caminho para o módulo desejado, vale a pena copiar o módulo desejado para o caminho comum. Não se esqueça do backup dos módulos necessários, pois ninguém exclui a remoção de módulos não padrão após a atualização dos pacotes Python.
Conclusões
Neste guia, abordamos as seguintes opções:
- Criação de um módulo;
- Importar o módulo criado;
- Referir-se ao módulo importando o módulo sys de estar em outro diretório;
- Adicionar o módulo criado ao caminho comum do interpretador Python;
- Obteve informações sobre caminhos comuns ao procurar um módulo usando o shell do Python.