31.01.2025

Como escrever um módulo em Python 3

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:

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:

python3 --version

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:

sudo apt update && apt upgrade -y

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.

#!/usr/bin/env python
# Function definition
def test():
print(“This is test file”)

Se executarmos com:

python3 testingFile.py

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.

vim test2.py
#!/usr/bin/env python3
#File import
import testingFile
#Calling a function from testingFile
testingFile.test()

Obtemos o seguinte resultado, como na Tela 1.

Tela 1 - Chamando uma função de um módulo importado

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:

#!/usr/bin/env python3
# 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:

#!/usr/bin/env python3
#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.

Tela 2 - Chamando uma variável de um módulo

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.

#!/usr/bin/env python3
# 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:

#!/usr/bin/env python3
#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.

Tela 3 - Chamando funções da classe TestingClass

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

#!/usr/bin/env python3
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:

#!/usr/bin/env python3
import test3

Obtemos o resultado de acordo com a Tela 4.

Tela 4 - Chamando uma função de um módulo

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:

import sys
sys.path.append(‘/root/testing/’)
import test3

E obteremos um resultado bem-sucedido, conforme mostrado na Tela 5.

Tela 5 - O resultado

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

python3
import sys
print(sys.path)

Como resultado, obteremos os caminhos de teste do interpretador Python, conforme mostrado na Tela 6.

Tela 6 - Maneiras comuns de verificar o interpretador Python

Selecione o caminho desejado e copie o arquivo test3.py para o caminho desejado.

cp testing/test3.py /usr/lib/python3.10
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.

Tela 7 - Acessando um módulo a partir de um caminho compartilhado

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: