Python 3 - Módulos

Um módulo permite que você organize logicamente seu código Python. O agrupamento do código relacionado em um módulo torna o código mais fácil de entender e usar. Um módulo é um objeto Python com atributos nomeados arbitrariamente que você pode ligar e fazer referência.

Simplesmente, um módulo é um arquivo que consiste em código Python. Um módulo pode definir funções, classes e variáveis. Um módulo também pode incluir código executável.

Exemplo

O código Python para um módulo denominado aname normalmente reside em um arquivo denominado aname.py. Aqui está um exemplo de um módulo simples, support.py -

def print_func( par ):
   print "Hello : ", par
   return

A declaração de importação

Você pode usar qualquer arquivo de origem Python como um módulo, executando uma instrução de importação em algum outro arquivo de origem Python. oimport tem a seguinte sintaxe -

import module1[, module2[,... moduleN]

Quando o interpretador encontra uma instrução import, ele importa o módulo se o módulo estiver presente no caminho de pesquisa. Um caminho de pesquisa é uma lista de diretórios que o intérprete pesquisa antes de importar um módulo. Por exemplo, para importar o módulo hello.py, você precisa colocar o seguinte comando no topo do script -

#!/usr/bin/python3

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

Quando o código acima é executado, ele produz o seguinte resultado -

Hello : Zara

Um módulo é carregado apenas uma vez, independentemente do número de vezes que é importado. Isso evita que a execução do módulo aconteça repetidamente, se ocorrerem várias importações.

A declaração de ... import

Python's frominstrução permite importar atributos específicos de um módulo para o namespace atual. ofrom...import tem a seguinte sintaxe -

from modname import name1[, name2[, ... nameN]]

Por exemplo, para importar a função fibonacci do módulo fib, use a seguinte instrução -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Esta instrução não importa todo o módulo fib para o namespace atual; ele apenas introduz o item fibonacci do módulo fib na tabela de símbolos global do módulo de importação.

A declaração from ... import *

Também é possível importar todos os nomes de um módulo para o namespace atual usando a seguinte instrução de importação -

from modname import *

Isso fornece uma maneira fácil de importar todos os itens de um módulo para o namespace atual; no entanto, essa instrução deve ser usada com moderação.

Executando Módulos como Scripts

Dentro de um módulo, o nome do módulo (como uma string) está disponível como o valor da variável global __name__. O código no módulo será executado, como se você importasse, mas com o __name__ definido como "__main__".

Adicione este código no final do seu módulo -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

Ao executar o código acima, a seguinte saída será exibida.

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Localizando Módulos

Quando você importa um módulo, o interpretador Python procura o módulo nas seguintes sequências -

• O diretório atual.

• Se o módulo não for encontrado, o Python pesquisa cada diretório na variável shell PYTHONPATH.

• Se tudo mais falhar, o Python verifica o caminho padrão. No UNIX, esse caminho padrão é normalmente / usr / local / lib / python3 /.

O caminho de pesquisa do módulo é armazenado no módulo sys do sistema como o sys.pathvariável. A variável sys.path contém o diretório atual, PYTHONPATH, e o padrão dependente da instalação.

A variável PYTHONPATH

O PYTHONPATH é uma variável de ambiente que consiste em uma lista de diretórios. A sintaxe de PYTHONPATH é a mesma da variável shell PATH.

Aqui está um PYTHONPATH típico de um sistema Windows -

set PYTHONPATH = c:\python34\lib;

E aqui está um PYTHONPATH típico de um sistema UNIX -

set PYTHONPATH = /usr/local/lib/python

Namespaces e escopo

Variáveis ​​são nomes (identificadores) que mapeiam para objetos. Um namespace é um dicionário de nomes de variáveis ​​(chaves) e seus objetos correspondentes (valores).

• Uma instrução Python pode acessar variáveis ​​em um namespace local e no namespace global . Se uma variável local e uma global tiverem o mesmo nome, a variável local sombreia a variável global.

• Cada função tem seu próprio namespace local. Os métodos de classe seguem a mesma regra de escopo das funções comuns.

• Python faz suposições fundamentadas sobre se as variáveis ​​são locais ou globais. Ele assume que qualquer variável atribuída a um valor em uma função é local.

• Portanto, para atribuir um valor a uma variável global dentro de uma função, você deve primeiro usar a instrução global.

• A declaração global VarName informa ao Python que VarName é uma variável global. Python para de pesquisar o namespace local para a variável.

Por exemplo, definimos uma variável Money no namespace global. Dentro da função Money, atribuímos a Money um valor, portanto, Python assume Money como uma variável local.

No entanto, acessamos o valor da variável local Money antes de defini-la, portanto, um UnboundLocalError é o resultado. Descomentar a declaração global corrige o problema.

#!/usr/bin/python3

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print (Money)
AddMoney()
print (Money)

A função dir ()

A função interna dir () retorna uma lista classificada de strings contendo os nomes definidos por um módulo.

A lista contém os nomes de todos os módulos, variáveis ​​e funções que são definidas em um módulo. A seguir está um exemplo simples -

#!/usr/bin/python3

# Import built-in module math
import math

content = dir(math)
print (content)

Quando o código acima é executado, ele produz o seguinte resultado -

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

Aqui, a variável de string especial __name__ é o nome do módulo e __file__ é o nome do arquivo a partir do qual o módulo foi carregado.

As funções globals () e locals ()

o globals() e locals() funções podem ser usadas para retornar os nomes nos namespaces globais e locais, dependendo do local de onde são chamados.

• E se locals() é chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados ​​localmente a partir dessa função.

• E se globals() é chamado de dentro de uma função, ele retornará todos os nomes que podem ser acessados ​​globalmente a partir dessa função.

O tipo de retorno de ambas as funções é dicionário. Portanto, os nomes podem ser extraídos usando okeys() função.

A função reload ()

Quando um módulo é importado para um script, o código na parte de nível superior de um módulo é executado apenas uma vez.

Portanto, se você deseja reexecutar o código de nível superior em um módulo, pode usar a função reload () . A função reload () importa um módulo importado anteriormente novamente. A sintaxe da função reload () é esta -

reload(module_name)

Aqui, module_name é o nome do módulo que você deseja recarregar e não a string que contém o nome do módulo. Por exemplo, para recarregar o módulo hello, faça o seguinte -

reload(hello)

Pacotes em Python

Um pacote é uma estrutura de diretório de arquivo hierárquica que define um único ambiente de aplicativo Python que consiste em módulos e subpacotes e subpacotes e assim por diante.

Considere um arquivo Pots.py disponível no diretório Phone. Este arquivo possui a seguinte linha de código-fonte -

#!/usr/bin/python3

def Pots():
print ("I'm Pots Phone")

Similarmente, temos outros dois arquivos com funções diferentes com o mesmo nome acima. Eles são -

• Arquivo Phone / Isdn.py com a função Isdn ()

• Arquivo Phone / G3.py com função G3 ()

Agora, crie mais um arquivo __init__.py no diretório Phone -

• Phone/__init__.py

Para disponibilizar todas as suas funções ao importar o telefone, você precisa colocar instruções de importação explícitas em __init__.py da seguinte maneira -

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Depois de adicionar essas linhas a __init__.py, você terá todas essas classes disponíveis ao importar o pacote Phone.

#!/usr/bin/python3

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Quando o código acima é executado, ele produz o seguinte resultado -

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

No exemplo acima, pegamos o exemplo de uma única função em cada arquivo, mas você pode manter várias funções em seus arquivos. Você também pode definir diferentes classes Python nesses arquivos e, em seguida, criar seus pacotes a partir dessas classes.