Python – Modules – Módulos

Voltar para página principal do blog

Todas as aulas desse curso

Aula 12                 Aula 14

Que fazer esse curso com certificação?

Acesse:

https://workover.com.br/python-codigo-fluente

Automatize tarefas do dia a dia com python:

Curso Python Bot

Módulos são arquivos com código python que podem ser importados por outros arquivos python.

Podem ter qualquer estrutura do Python e são executados quando são importados ou executados diretamente.

Um módulo é então, um arquivo contendo definições e instruções Python.

O nome do arquivo é o nome do módulo com o sufixo .py

Dentro de um módulo, o nome do módulo (em string) está disponível no valor da variável global __name__.

Um módulo pode conter instruções executáveis, bem como definições de funções.

Estas instruções destinam-se a inicializar o módulo e são executadas apenas na primeira vez que o nome do módulo é encontrado em uma instrução de importação.

Um módulo pode também ser executado como um script.

Crie um o /Python_codes/modulos/fatorial.py com o código abaixo:

def fat_recursiva(n):
    if n < 2:
        print("Eu uso recursividade")
        return 1
    else:
        return n * fat_recursiva(n - 1)

def fat_sem_recursividade(n):
    print("Eu não uso recursividade")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

Abra um cmd (shell) e entre na pasta: cd /Python_codes/modulos/

Digite: python

Pronto, agora você tá em um shell python, veja que mudou o prompt para:

Python 3.6.2rc2 (v3.6.2rc2:8913311, Jul 8 2017, 02:12:29) [MSC v.1900 64 bit (AMD64)] on win32
Type “help”, “copyright”, “credits” or “license” for more information.
>>>

Podemos fazer alguns testes então.

Faça o import do fatorial.py com:
import fatorial

Agora você pode acessar a função fat_recursiva e fat_sem_recursividade definida no fatorial.py passando algum número para que ela retorne o fatorial desse número.
fatorial.fat_recursiva(5) #Saída 120

Se for usar essa função com frequência, pode atribuí-la a uma variável local:

f = fatorial.fat_recursiva

f(6) #saída 720

Tabela de símbolos privada

Cada módulo possui sua própria tabela de símbolos privada, que é usada como a tabela de símbolos global por todas as funções definidas no módulo.

Assim, o autor de um módulo pode usar variáveis globais no módulo sem se preocupar com conflitos acidentais com as variáveis globais de um usuário.

Por outro lado, se você sabe o que está fazendo, pode acessar as variáveis globais de um módulo com a mesma notação usada para se referir a suas funções, nomeDoModulo.itemDoModulo.

Módulos podem importar outros módulos. É costume, mas não obrigatório, colocar todas as declarações de importação no início de um módulo.

Os nomes dos módulos importados são colocados na tabela de símbolos globais do módulo.

Há uma variante da instrução de importação que importa nomes de um módulo diretamente para a tabela de símbolos do módulo.

from fatorial import fat_recursiva, fat_sem_recursividade

Isso não introduz o nome do módulo fatorial do qual as importações são feitas, na tabela de símbolos local, portanto, no exemplo acima, o módulo fatorial não está definido.

Pra chamar fat_recursiva e fat_sem_recursividade  é só acessar diretamente, já que o módulo fatorial não está definido:
fat_recursiva(5) #Saída 120

fat_sem_recursividade(5) #Saída 120

Existe até uma variante para importar todos os nomes que um módulo define:

from fatorial import *

fat_recursiva(5) #Saída 120

fat_sem_recursividade(5) #Saída 120

Isso importa todos os nomes, exceto aqueles que começam com um sublinhado (_).

Na maioria dos casos, os programadores Python não usam esse recurso, pois introduz um conjunto desconhecido de nomes no interpretador, possivelmente ocultando algumas coisas que você já definiu.

Observe que, em geral, a prática de importar * de um módulo ou pacote é desaprovada, pois geralmente deixa o código mal legível.

No entanto, não há problema em usá-lo para digitar menos em sessões interativas.

Se o nome do módulo for seguido por as, o nome a seguir será vinculado diretamente ao módulo importado, funciona como um apelido para o módulo.

import fatorial as fa
fa.fat_recursiva(5) #Saída 120

Isso está efetivamente importando o módulo fatorial da mesma forma que o import fatorial, com a única diferença de estar disponível como fa.

Também pode ser utilizado com from:
from fatorial import fat_recursiva as fato
fato(5)

Executando módulos como scripts

Afinal, o que é e pra que serve essa linha de código tão comum em python:

if __name__ == "__main__":

Quando você executa um módulo Python com: python fatorial.py <arguments>

o código no módulo será executado, como se você tivesse sido importado, mas com o __name__ definido como “__main__“.

Para ilustrar, crie dois arquivos /Python_codes/modulos/arquivo1.py e /Python_codes/modulos/arquivo2.py:

/Python_codes/modulos/arquivo1.py

if __name__ == "__main__": 
    print("arquivo1 está sendo executado diretamente")
    print("A variável __name__ é nesse caso: " + __name__)
else: 
    print("arquivo1 está sendo importado")
    print("A variável __name__ é nesse caso: " + __name__)

/Python_codes/modulos/arquivo2.py

import arquivo1

Agora faça o seguinte teste, no shell digite:

python arquivo1.py

Saída:

arquivo1 está sendo executado diretamente
A variável __name__ é nesse caso: __main__

python arquivo2.py

Saída:

arquivo1 está sendo importado
A variável __name__ é nesse caso: arquivo1

Voltando ao módulo fatorial, insira no final dele o seguinte código.

if __name__ == "__main__":
    import sys
    print(fat_recursiva(int(sys.argv[1])))

Dessa forma você deixa o arquivo utilizável como um script e também como módulo importável, porque o código que analisa a linha de comando só é executado se o módulo for executado como main:

Então insira o código acima no final do /Python_codes/modulos/fatorial.py:

def fat_recursiva(n):
    if n < 2:
        print("Eu uso recursividade")
        return 1
    else:
        return n * fat_recursiva(n - 1)

def fat_sem_recursividade(n):
    print("Eu não uso recursividade")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

if __name__ == "__main__":
    import sys
    print(fat_recursiva(int(sys.argv[1])))

Rode no cmd:

python fatorial.py 5

No shell python, se o módulo for importado, o código não será executado:

import fatorial

O caminho de pesquisa do módulo

Quando um módulo chamado spam é importado, o interpretador primeiro procura por um módulo interno com esse nome.

Se não for encontrado, ele procurará um arquivo chamado spam.py em uma lista de diretórios fornecida pela variável sys.path.

sys.path é inicializado a partir desses locais:

• O diretório que contém o script de entrada (ou o diretório atual quando nenhum arquivo é especificado).
• PYTHONPATH (uma lista de nomes de diretório, com a mesma sintaxe da variável de shell PATH).
• O diretório padrão da instalação de dependências.

Após a inicialização, os programas em Python podem modificar o sys.path.

O diretório que contém o script sendo executado é colocado no início do caminho de pesquisa, à frente do caminho da biblioteca padrão.

Isso significa que os scripts nesse diretório serão carregados em vez de módulos com o mesmo nome no diretório da biblioteca.

Isso é um erro, a menos que a substituição seja intencional.

Módulos padrão

O Python vem com uma biblioteca de módulos padrão.

Alguns módulos são construídos no interpretador, eles fornecem acesso a operações que não fazem parte do núcleo do idioma, mas que são integradas, seja para eficiência ou para fornecer acesso a primitivas do sistema operacional, como chamadas do sistema.

O conjunto desses módulos é uma opção de configuração que também depende da plataforma subjacente.

Por exemplo, o módulo winreg é fornecido apenas em sistemas Windows.

Um módulo em particular merece atenção:

o sys, que é construído em todos os interpretadores do Python.

As variáveis sys.ps1 e sys.ps2 definem as strings usadas como prompts primários e secundários.

No shell python digite:
import sys
sys.ps1 #Saída: '>>> '
sys.ps2 #Saída: '... '

Essas duas variáveis são definidas apenas se o interpretador estiver no modo interativo.

A variável sys.path é uma lista sequencial, que determina o caminho de pesquisa do interpretador para os módulos.

Ele é inicializado para um caminho padrão retirado da variável de ambiente PYTHONPATH ou de um padrão interno, se PYTHONPATH não estiver configurado.

Você pode modificá-lo pelo shell python usando operações de lista padrão:
import sys
sys.path.append('/ufs/guido/lib/python')

A função dir()

A função interna ( built-in ) dir () é usada para descobrir quais nomes um módulo define.

Ele retorna uma lista classificada de strings:
import fatorial
dir(fatorial)

Saída:

[‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘fat_recursiva’, ‘fat_sem_recursividade’]

import sys
dir(sys)

Saída:

[‘__displayhook__’, ‘__doc__’, ‘__excepthook__’, ‘__interactivehook__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘__stderr__’, ‘__stdin__’, ‘__stdout__’, ‘_clear_type_cache’, ‘_current_frames’, ‘_debugmallocstats’, ‘_enablelegacywindowsfsencoding’, ‘_getframe’, ‘_git’, ‘_home’, ‘_xoptions’, ‘api_version’, ‘argv’, ‘base_exec_prefix’, ‘base_prefix’, ‘builtin_module_names’, ‘byteorder’, ‘call_tracing’, ‘callstats’, ‘copyright’, ‘displayhook’, ‘dllhandle’, ‘dont_write_bytecode’, ‘exc_info’, ‘excepthook’, ‘exec_prefix’, ‘executable’, ‘exit’, ‘flags’, ‘float_info’, ‘float_repr_style’, ‘get_asyncgen_hooks’, ‘get_coroutine_wrapper’, ‘getallocatedblocks’, ‘getcheckinterval’, ‘getdefaultencoding’, ‘getfilesystemencodeerrors’, ‘getfilesystemencoding’, ‘getprofile’, ‘getrecursionlimit’, ‘getrefcount’, ‘getsizeof’, ‘getswitchinterval’, ‘gettrace’, ‘getwindowsversion’, ‘hash_info’, ‘hexversion’, ‘implementation’, ‘int_info’, ‘intern’, ‘is_finalizing’, ‘maxsize’, ‘maxunicode’, ‘meta_path’, ‘modules’, ‘path’, ‘path_hooks’, ‘path_importer_cache’, ‘platform’, ‘prefix’, ‘ps1’, ‘ps2’, ‘set_asyncgen_hooks’, ‘set_coroutine_wrapper’, ‘setcheckinterval’, ‘setprofile’, ‘setrecursionlimit’, ‘setswitchinterval’, ‘settrace’, ‘stderr’, ‘stdin’, ‘stdout’, ‘thread_info’, ‘version’, ‘version_info’, ‘warnoptions’, ‘winver’]

Sem argumentos, dir() lista os nomes que você definiu:

dir()

[‘__annotations__’, ‘__builtins__’, ‘__doc__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘fatorial’, ‘sys’]

Note que ele lista todos os tipos de nomes: variáveis, módulos, funções, etc.

dir() não lista os nomes das funções e variáveis built-in. Se você quiser essa lista de built-ins faça:

import builtins
dir(builtins)

Saída:

[‘ArithmeticError’, ‘AssertionError’, ‘AttributeError’, ‘BaseException’, ‘BlockingIOError’, ‘BrokenPipeError’, ‘BufferError’, ‘BytesWarning’, ‘ChildProcessError’, ‘ConnectionAbortedError’, ‘ConnectionError’, ‘ConnectionRefusedError’, ‘ConnectionResetError’, ‘DeprecationWarning’, ‘EOFError’, ‘Ellipsis’, ‘EnvironmentError’, ‘Exception’, ‘False’, ‘FileExistsError’, ‘FileNotFoundError’, ‘FloatingPointError’, ‘FutureWarning’, ‘GeneratorExit’, ‘IOError’, ‘ImportError’, ‘ImportWarning’, ‘IndentationError’, ‘IndexError’, ‘InterruptedError’, ‘IsADirectoryError’, ‘KeyError’, ‘KeyboardInterrupt’, ‘LookupError’, ‘MemoryError’, ‘ModuleNotFoundError’, ‘NameError’, ‘None’, ‘NotADirectoryError’, ‘NotImplemented’, ‘NotImplementedError’, ‘OSError’, ‘OverflowError’, ‘PendingDeprecationWarning’, ‘PermissionError’, ‘ProcessLookupError’, ‘RecursionError’, ‘ReferenceError’, ‘ResourceWarning’, ‘RuntimeError’, ‘RuntimeWarning’, ‘StopAsyncIteration’, ‘StopIteration’, ‘SyntaxError’, ‘SyntaxWarning’, ‘SystemError’, ‘SystemExit’, ‘TabError’, ‘TimeoutError’, ‘True’, ‘TypeError’, ‘UnboundLocalError’, ‘UnicodeDecodeError’, ‘UnicodeEncodeError’, ‘UnicodeError’, ‘UnicodeTranslateError’, ‘UnicodeWarning’, ‘UserWarning’, ‘ValueError’, ‘Warning’, ‘WindowsError’, ‘ZeroDivisionError’, ‘_’, ‘__build_class__’, ‘__debug__’, ‘__doc__’, ‘__import__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘abs’, ‘all’, ‘any’, ‘ascii’, ‘bin’, ‘bool’, ‘bytearray’, ‘bytes’, ‘callable’, ‘chr’, ‘classmethod’, ‘compile’, ‘complex’, ‘copyright’, ‘credits’, ‘delattr’, ‘dict’, ‘dir’, ‘divmod’, ‘enumerate’, ‘eval’, ‘exec’, ‘exit’, ‘filter’, ‘float’, ‘format’, ‘frozenset’, ‘getattr’, ‘globals’, ‘hasattr’, ‘hash’, ‘help’, ‘hex’, ‘id’, ‘input’, ‘int’, ‘isinstance’, ‘issubclass’, ‘iter’, ‘len’, ‘license’, ‘list’, ‘locals’, ‘map’, ‘max’, ‘memoryview’, ‘min’, ‘next’, ‘object’, ‘oct’, ‘open’, ‘ord’, ‘pow’, ‘print’, ‘property’, ‘quit’, ‘range’, ‘repr’, ‘reversed’, ‘round’, ‘set’, ‘setattr’, ‘slice’, ‘sorted’, ‘staticmethod’, ‘str’, ‘sum’, ‘super’, ‘tuple’, ‘type’, ‘vars’, ‘zip’]

É isso, na próxima a gente vai falar sobre packages (pacotes)

Voltar para página principal do blog

Todas as aulas desse curso

Aula 12                 Aula 14

Aproveito para deixar meu link de afiliados na Hostinger, tá valendo a pena, dêem uma olhada: Hostinger

Dêem um joinha ? na página do Código Fluente no Facebook
Facebook

Esse é meu link de referidos na digitalocean pra vocês.

Quem se cadastrar por esse link, ganha $100.00 dólares de crédito na digitalocean:

Digital Ocean

Esse outro link é da one.com:

One.com

Obrigado, até a próxima e bons estudos. 😉