Módulos do Python

Neste artigo, você aprenderá como criar e importar módulos personalizados no Python. Além disso, você descobrirá diferentes técnicas para importar e usar módulos personalizados e integrados no Python.

O que são módulos no Python?

Módulo é um arquivo que contém instruções e definições Python.

Os arquivos que contêm código Python, como example.py, chamados de módulos, cujo nome de módulo é example.

Usamos módulos para dividir programas grandes em arquivos pequenos e gerenciáveis. Além disso, os módulos fornecem reutilização de código.

Podemos definir as funções mais usadas no módulo e importá-las, em vez de copiar a definição para outros programas.

Vamos criar um módulo. Insira o seguinte e salve como example.py.

# Exemplo de módulo do Python
def add(a, b):
　　　"""Este programa adiciona dois números"
　　　　　　　e retorna o resultado da adição ""
　　　result = a　+　b
　　　return result

Aqui, definimos uma função chamada add() no módulo exampleFunção. A função aceita dois números e retorna sua soma.

Como importar módulos no Python?

Podemos importar definições internas de um módulo para outro módulo ou para o interpretador interativo do Python.

Usamos a palavra-chave import para fazer isso. Para importar o módulo definido anteriormente, digite o seguinte no prompt do Python.

>>> import example

Isso não insere diretamente o nome da função definida no símbolo atual. Ele apenas insere o nome do módulo aqui.

Usando o nome do módulo, podemos usar o operador de ponto. Para acessar funções. Por exemplo:

>>> example.add(4,5.5)
9.5

O Python tem muitos módulos padrão disponíveis.

Você pode verificarMódulos padrão do Pythona lista completa e suas respectivas utilizações. Esses arquivos estão localizados no diretório Lib dentro da localização de instalação do Python.

Pode importar módulos padrão da mesma forma que módulos definidos pelo usuário.

Existem várias maneiras de importar módulos. Eles são listados a seguir.

Declaração de importação do Python

Podemos usar a declaração import para importar módulos e, como mencionado acima, acessar suas definições internas com o operador de ponto. Este é um exemplo.

# Exemplo de declaração de importação
# Importa o módulo padrão matemático
import math
print("valor de π", math.pi)

Quando executamos o programa, a saída será:

valor de π　3.141592653589793

Renomeia o módulo importado

Podemos renomear o módulo importado da seguinte forma.

# Renomeia o módulo importado
import math as m
print("valor de π", m.pi)

Nós renomeamos o módulo math para m. Em alguns casos, isso pode economizar nosso tempo de escrita.

Observe que o nome math não é reconhecível em nosso escopo. Portanto, math.pi é inválido, enquanto m.pi é a forma correta de usar.

Expressão from ... import do Python

Podemos importar nomes específicos do módulo sem importar o módulo inteiro. Este é um exemplo.

# Importar apenas pi do módulo matemático
from math import pi
print("O valor de π", pi)

Importamos apenas a propriedade pi do módulo.

Neste caso, não usamos o operador de ponto. Podemos importar várias propriedades da seguinte forma.

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045

Importar todos os nomes

Podemos usar a seguinte construção para importar todos os nomes (definições) do módulo.

# Importar todos os nomes do módulo padrão math
from math import　*
print("O valor de pi", pi)

Importamos todas as definições do módulo matemático. Isso faz com que todos os nomes, exceto os começando com sublinhado, sejam visíveis em nosso escopo.

Importar com asterisco (*Todo o conteúdo entre os símbolos de parênteses não é um bom hábito de programação. Isso pode levar a definições duplicadas de identificadores. Isso também afeta a legibilidade do nosso código.

Caminho de busca de módulos Python

Ao importar módulos, o Python verifica várias posições. O interpretador primeiro busca um módulo embutido, e, se não encontrar, entra na lista de diretórios definida em sys.path. A busca é feita nesta ordem.

• Pasta atual.

• PYTHONPATH (variável de ambiente com lista de pastas).

• Pastas padrão relacionadas à instalação.

>>> import sys
>>> sys.path
['',
'C:\\Python33\\Lib\\idlelib',
'C:\\Windows\\system32\\python33.zip',
'C:\\Python33\\DLLs',
'C:\\Python33\\lib',
'C:\\Python33',
'C:\\Python33\\lib\\site-pacotes'

Podemos adicionar ou modificar esta lista para adicionar nossos próprios caminhos.

Recarregar o módulo

O interpretador Python importa o módulo apenas uma vez durante a sessão. Isso torna as coisas mais eficientes. Este é um exemplo que ilustra como isso funciona.

Suponha que haja o seguinte código em um módulo chamado my_module.

# Este módulo mostra
# Múltiplas importações e reimportação
print("Este código foi executado")

Agora, vimos o efeito de várias importações.

>>> import my_module
Este código foi executado
>>> import my_module
>>> import my_module

Podemos ver que nosso código foi executado apenas uma vez. Isso indica que nosso módulo foi importado apenas uma vez.

Agora, se nosso módulo mudar durante a execução do programa, teremos que recarregá-lo. Uma maneira é reiniciar o interpretador. Mas isso não ajuda muito.

O Python oferece um método simples. Podemos usar a função imp interna do módulo reload() para recarregar o módulo. Como fazer isso?

>>> import imp
>>> import my_module
Este código foi executado
>>> import my_module
>>> imp.reload(my_module)
Este código foi executado
<módulo 'my_module' do arquivo '.\\my_module.py'>

Função interna dir()

Podemos usar a função dir() para encontrar os nomes definidos dentro do módulo.

Por exemplo, definimos uma função add() no módulo example inicial.

>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',
'add'

Aqui, podemos ver uma lista ordenada de nomes (e add). Todos os nomes começando com sublinhado são atributos padrão do Python associados ao módulo (nós não os definimos).

Por exemplo, a propriedade __name__ contém o nome do módulo.

>>> import example
>>> example.__name__
'example'

Pode-se usar a função dir() sem qualquer parâmetro para encontrar todos os nomes definidos no espaço de nomes atual.

>>> a =　1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']