Notícias
Novos modelos de linguagem da API Serverspace GPT
DF
fevereiro 27, 2023
Atualizado janeiro 31, 2025

Como escrever um módulo em Python 3

Debian Linux Ubuntu

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:

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.

Chamando uma função de um módulo importado
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.

Calling a variable from a module
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.

Chamando funções da classe TestingClass
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.

4Chamando uma função de um módulo
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.

The result
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.

Common ways to check the Python interpreter
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.

Acessando um módulo a partir de um caminho compartilhado
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:

  • 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.
Avaliação:
5 fora de 5
Аverage rating : 5
Avaliado por: 1
CEP 01311-930 São Paulo Avenida Paulista, nº 1765, 7º andar, Cj. 72, CV 10172, Bela Vista
+ 55 11 5118-1047
ITGLOBAL.COM BR LTDA
Usamos cookies para melhorar sua experiência no Serverspace. Ao continuar a navegar em nosso site, você concorda com o Uso de Cookies e com a Política de Privacidade.