Módulos Python

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

Vídeo:Módulos Python

O que são módulos em Python?

Módulos referem-se a um arquivo contendo instruções e definições do Python.

Um arquivo contendo código Python, por exemplo:example.py , é chamado de módulo, e seu nome de módulo seria example .

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

Podemos definir nossas funções mais usadas em um módulo e importá-lo, em vez de copiar suas definições em programas diferentes.

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

# Python Module example

def add(a, b):
   """This program adds two
   numbers and return the result"""

   result = a + b
   return result

Aqui, definimos uma função add() dentro de um módulo chamado example . A função recebe dois números e retorna sua soma.

Como importar módulos em Python?

Podemos importar as definições dentro de um módulo para outro módulo ou para o interpretador interativo em Python.

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

>>> import example

Isso não importa os nomes das funções definidas em example diretamente na tabela de símbolos atual. Importa apenas o nome do módulo example lá.

Usando o nome do módulo podemos acessar a função usando o ponto . operador. Por exemplo:

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

Python tem toneladas de módulos padrão. Você pode conferir a lista completa de módulos padrão do Python e seus casos de uso. Esses arquivos estão no diretório Lib dentro do local onde você instalou o Python.

Módulos padrão podem ser importados da mesma forma que importamos nossos módulos definidos pelo usuário.

Existem várias maneiras de importar módulos. Eles estão listados abaixo..

Instrução de importação do Python

Podemos importar um módulo usando o import e acesse as definições dentro dela usando o operador ponto conforme descrito acima. Aqui está um exemplo.

# import statement example
# to import standard module math

import math
print("The value of pi is", math.pi)

Ao executar o programa, a saída será:

The value of pi is 3.141592653589793

Importar com renomeação

Podemos importar um módulo renomeando-o da seguinte forma:

# import module by renaming it

import math as m
print("The value of pi is", m.pi)

Renomeamos o math módulo como m . Isso pode nos poupar tempo de digitação em alguns casos.

Observe que o nome math não é reconhecido em nosso escopo. Portanto, math.pi é inválido e m.pi é a implementação correta.

Python de... declaração de importação

Podemos importar nomes específicos de um módulo sem importar o módulo como um todo. Aqui está um exemplo.

# import only pi from math module

from math import pi
print("The value of pi is", pi)

Aqui, importamos apenas o pi atributo do math módulo.

Nesses casos, não usamos o operador ponto. Também podemos importar vários atributos da seguinte forma:

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

Importar todos os nomes

Podemos importar todos os nomes (definições) de um módulo usando a seguinte construção:

# import all names from the standard module math

from math import *
print("The value of pi is", pi)

Aqui, importamos todas as definições do módulo math. Isso inclui todos os nomes visíveis em nosso escopo, exceto aqueles que começam com um sublinhado (definições privadas).

Importar tudo com o símbolo de asterisco (*) não é uma boa prática de programação. Isso pode levar a definições duplicadas para um identificador. Isso também dificulta a legibilidade do nosso código.

Caminho de pesquisa do módulo Python

Ao importar um módulo, o Python examina vários lugares. O intérprete primeiro procura por um módulo embutido. Então (se o módulo embutido não for encontrado), o Python procura uma lista de diretórios definidos em sys.path . A pesquisa está nesta ordem.

O diretório atual.
PYTHONPATH (uma variável de ambiente com uma lista de diretórios).
O diretório padrão dependente da 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-packages']

Podemos adicionar e modificar esta lista para adicionar nosso próprio caminho.

Recarregando um módulo

O interpretador Python importa um módulo apenas uma vez durante uma sessão. Isso torna as coisas mais eficientes. Aqui está um exemplo para mostrar como isso funciona.

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

# This module shows the effect of
#  multiple imports and reload

print("This code got executed")

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

>>> import my_module
This code got executed
>>> import my_module
>>> import my_module

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

Agora, se nosso módulo mudasse durante o curso do programa, teríamos que recarregá-lo. Uma maneira de fazer isso é reiniciar o interpretador. Mas isso não ajuda muito.

Python fornece uma maneira mais eficiente de fazer isso. Podemos usar o reload() função dentro do imp módulo para recarregar um módulo. Podemos fazer das seguintes maneiras:

>>> import imp
>>> import my_module
This code got executed
>>> import my_module
>>> imp.reload(my_module)
This code got executed
<module 'my_module' from '.\\my_module.py'>

A função interna dir()

Podemos usar o dir() função para descobrir nomes que são definidos dentro de um módulo.

Por exemplo, definimos uma função add() no módulo example que tínhamos no início.

Podemos usar dir em example módulo da seguinte forma:

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

Aqui, podemos ver uma lista ordenada de nomes (junto com add ). Todos os outros nomes que começam com um sublinhado são atributos padrão do Python associados ao módulo (não definidos pelo usuário).

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

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

Todos os nomes definidos em nosso namespace atual podem ser encontrados usando o dir() função sem argumentos.

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

Palavra-chave global do Python Pacote Python

python