importlib
— A implementação de import
¶
Novo na versão 3.1.
Código-fonte: Lib/importlib/__init__.py
Introdução¶
The purpose of the importlib
package is two-fold. One is to provide the
implementation of the import
statement (and thus, by extension, the
__import__()
function) in Python source code. This provides an
implementation of import
which is portable to any Python
interpreter. This also provides an implementation which is easier to
comprehend than one implemented in a programming language other than Python.
Dois, os componentes para implementar import
são expostos neste pacote, tornando mais fácil para os usuários criarem seus próprios objetos personalizados (conhecidos genericamente como importador) para participar do processo de importação.
Ver também
- A instrução import
A referência da linguagem para a instrução
import
.- Especificação dos pacotes
Especificação original dos pacotes. Algumas semânticas mudaram desde a redação deste documento (por exemplo, redirecionamento baseado em
None
emsys.modules
).- A função
__import__()
A instrução
import
é um açúcar sintático para esta função.- PEP 235
Importação em plataformas que diferenciam maiúsculo de minúsculo
- PEP 263
Definindo codificações do código-fonte do Python
- PEP 302
Novos ganchos de importação
- PEP 328
Importações: Multilinha e Absoluto/Relativo
- PEP 366
Importações relativas explícitas do módulo principal
- PEP 420
Pacotes de espaço de nomes implícitos
- PEP 451
Um tipo de ModuleSpec para o sistema de importação
- PEP 488
Eliminação de arquivos PYO
- PEP 489
Inicialização de módulo extensão multifase
- PEP 552
pycs determinísticos
- PEP 3120
Usando UFT-8 como fonte padrão de codificação
- PEP 3147
Diretórios de repositório de PYC
Funções¶
-
importlib.
__import__
(name, globals=None, locals=None, fromlist=(), level=0)¶ Uma implementação da função embutida
__import__()
.Nota
A importação programática de módulos deve usar
import_module()
em vez desta função.
-
importlib.
import_module
(name, package=None)¶ Importa um módulo. O argumento name especifica qual módulo importar em termos absolutos ou relativos (por exemplo,
pkg.mod
ou..mod
). Se o nome for especificado em termos relativos, então o argumento package deve ser definido como o nome do pacote que atuará como âncora para resolver o nome do pacote (por exemplo,import_module('..mod', 'pkg.subpkg')
importarápkg.mod
).A função
import_module()
atua como um wrapper simplificador em torno deimportlib.__import__()
. Isso significa que toda a semântica da função é derivada deimportlib.__import__()
. A diferença mais importante entre essas duas funções é queimport_module()
retorna o pacote ou módulo especificado (por exemplo,pkg.mod
), enquanto__import__()
retorna o pacote ou módulo de nível superior (por exemplo,pkg
).Se você estiver importando dinamicamente um módulo que foi criado desde que o interpretador iniciou a execução (por exemplo, criou um arquivo fonte Python), você pode precisar chamar
invalidate_caches()
para que o novo módulo seja notado pelo sistema de importação.Alterado na versão 3.3: Os pacotes pai são importados automaticamente.
-
importlib.
find_loader
(name, path=None)¶ Find the loader for a module, optionally within the specified path. If the module is in
sys.modules
, thensys.modules[name].__loader__
is returned (unless the loader would beNone
or is not set, in which caseValueError
is raised). Otherwise a search usingsys.meta_path
is done.None
is returned if no loader is found.A dotted name does not have its parents implicitly imported as that requires loading them and that may not be desired. To properly import a submodule you will need to import all parent packages of the submodule and use the correct argument to path.
Novo na versão 3.3.
Alterado na versão 3.4: If
__loader__
is not set, raiseValueError
, just like when the attribute is set toNone
.Obsoleto desde a versão 3.4: Use
importlib.util.find_spec()
instead.
-
importlib.
invalidate_caches
()¶ Invalida os caches internos dos localizadores armazenados em
sys.meta_path
. Se um localizador implementarinvalidate_caches()
então ele será chamado para realizar a invalidação. Esta função deve ser chamada se algum módulo for criado/instalado enquanto seu programa estiver em execução para garantir que todos os localizadores notarão a existência do novo módulo.Novo na versão 3.3.
-
importlib.
reload
(module)¶ Recarrega um module importado anteriormente. O argumento deve ser um objeto módulo, portanto deve ter sido importado com êxito antes. Isso é útil se você editou o arquivo fonte do módulo usando um editor externo e deseja experimentar a nova versão sem sair do interpretador Python. O valor de retorno é o objeto módulo (que pode ser diferente se a reimportação fizer com que um objeto diferente seja colocado em
sys.modules
).Quando
reload()
é executado:O código do módulo Python é recompilado e o código em nível de módulo é reexecutado, definindo um novo conjunto de objetos que são vinculados a nomes no dicionário do módulo reutilizando o carregador que originalmente carregou o módulo. A função
init
dos módulos de extensão não é chamada uma segunda vez.Tal como acontece com todos os outros objetos em Python, os objetos antigos só são recuperados depois que suas contagens de referências caem para zero.
Os nomes no espaço de nomes do módulo são atualizados para apontar para quaisquer objetos novos ou alterados.
Outras referências aos objetos antigos (como nomes externos ao módulo) não são religadas para se referir aos novos objetos e devem ser atualizadas em cada espaço de nomes onde ocorrem, se isso for desejado.
Existem várias outras ressalvas:
Quando um módulo é recarregado, seu dicionário (contendo as variáveis globais do módulo) é retido. As redefinições de nomes vão substituir as definições antigas, portanto isso geralmente não é um problema. Se a nova versão de um módulo não definir um nome definido pela versão antiga, a definição antiga permanecerá. Este recurso pode ser usado para vantagem do módulo se ele mantiver uma tabela global ou cache de objetos – com uma instrução
try
ele pode testar a presença da tabela e pular sua inicialização se desejar:try: cache except NameError: cache = {}
Geralmente não é muito útil recarregar módulos embutidos ou carregados dinamicamente. Recarregar
sys
,__main__
,builtins
e outros módulos principais não é recomendado. Em muitos casos, os módulos de extensão não são projetados para serem inicializados mais de uma vez e podem falhar de maneiras arbitrárias quando recarregados.Se um módulo importa objetos de outro módulo usando
from
…import
…, chamarreload()
para o outro módulo não redefine os objetos importados dele – uma maneira de contornar isso é executar novamente a instruçãofrom
, outra é usarimport
e nomes qualificados (module.name).Se um módulo instancia instâncias de uma classe, recarregar o módulo que define a classe não afeta as definições de método das instâncias – elas continuam a usar a definição de classe antiga. O mesmo se aplica às classes derivadas.
Novo na versão 3.4.
Alterado na versão 3.7:
ModuleNotFoundError
é levantada quando o módulo que está sendo recarregado não possui umModuleSpec
.
importlib.abc
– classes base abstratas relacionadas a importação¶
Código-fonte: Lib/importlib/abc.py
O módulo importlib.abc
contém todas as principais classes base abstratas usadas por import
. Algumas subclasses das classes base abstratas principais também são fornecidas para ajudar na implementação dss ABCs principais.
Hierarquia de ABC:
object
+-- Finder (deprecated)
+-- MetaPathFinder
+-- PathEntryFinder
+-- Loader
+-- ResourceLoader --------+
+-- InspectLoader |
+-- ExecutionLoader --+
+-- FileLoader
+-- SourceLoader
-
class
importlib.abc.
Finder
¶ An abstract base class representing a finder.
Obsoleto desde a versão 3.3: Use
MetaPathFinder
orPathEntryFinder
instead.-
abstractmethod
find_module
(fullname, path=None)¶ An abstract method for finding a loader for the specified module. Originally specified in PEP 302, this method was meant for use in
sys.meta_path
and in the path-based import subsystem.Alterado na versão 3.4: Returns
None
when called instead of raisingNotImplementedError
.Obsoleto desde a versão 3.10: Implement
MetaPathFinder.find_spec()
orPathEntryFinder.find_spec()
instead.
-
abstractmethod
-
class
importlib.abc.
MetaPathFinder
¶ Uma classe base abstrata que representa um localizador de metacaminho.
Novo na versão 3.3.
Alterado na versão 3.10: No longer a subclass of
Finder
.-
find_spec
(fullname, path, target=None)¶ Um método abstrato para encontrar um spec para o módulo especificado. Se esta for uma importação de nível superior, path será
None
. Caso contrário, esta é uma busca por um subpacote ou módulo e path será o valor de__path__
do pacote pai. Se uma especificação não puder ser encontrada,None
será retornado. Quando passado,target
é um objeto de módulo que o localizador pode usar para fazer uma estimativa mais informada sobre qual especificação retornar.importlib.util.spec_from_loader()
pode ser útil para implementarMetaPathFinders
concretos.Novo na versão 3.4.
-
find_module
(fullname, path)¶ A legacy method for finding a loader for the specified module. If this is a top-level import, path will be
None
. Otherwise, this is a search for a subpackage or module and path will be the value of__path__
from the parent package. If a loader cannot be found,None
is returned.If
find_spec()
is defined, backwards-compatible functionality is provided.Alterado na versão 3.4: Returns
None
when called instead of raisingNotImplementedError
. Can usefind_spec()
to provide functionality.Obsoleto desde a versão 3.4: Use
find_spec()
instead.
-
invalidate_caches
()¶ Um método opcional que, quando chamado, deve invalidar qualquer cache interno usado pelo localizador. Usado por
importlib.invalidate_caches()
ao invalidar os caches de todos os localizadores emsys.meta_path
.Alterado na versão 3.4: Returns
None
when called instead ofNotImplemented
.
-
-
class
importlib.abc.
PathEntryFinder
¶ Uma classe base abstrata que representa um localizador de entrada de caminho. Embora tenha algumas semelhanças com
MetaPathFinder
,PathEntryFinder
deve ser usado apenas dentro do subsistema de importação baseado em caminho fornecido porimportlib.machinery.PathFinder
.Novo na versão 3.3.
Alterado na versão 3.10: No longer a subclass of
Finder
.-
find_spec
(fullname, target=None)¶ Um método abstrato para encontrar um spec para o módulo especificado. O localizador irá procurar pelo módulo apenas dentro do entrada de caminho ao qual ele está atribuído. Se um spec não puder ser encontrado,
None
será retornado. Quando passado,target
é um objeto de módulo que o localizador pode usar para fazer uma estimativa mais informada sobre qual spec retornar.importlib.util.spec_from_loader()
pode ser útil para implementarPathEntryFinders
concretos.Novo na versão 3.4.
-
find_loader
(fullname)¶ A legacy method for finding a loader for the specified module. Returns a 2-tuple of
(loader, portion)
whereportion
is a sequence of file system locations contributing to part of a namespace package. The loader may beNone
while specifyingportion
to signify the contribution of the file system locations to a namespace package. An empty list can be used forportion
to signify the loader is not part of a namespace package. Ifloader
isNone
andportion
is the empty list then no loader or location for a namespace package were found (i.e. failure to find anything for the module).If
find_spec()
is defined then backwards-compatible functionality is provided.Alterado na versão 3.4: Returns
(None, [])
instead of raisingNotImplementedError
. Usesfind_spec()
when available to provide functionality.Obsoleto desde a versão 3.4: Use
find_spec()
instead.
-
find_module
(fullname)¶ A concrete implementation of
Finder.find_module()
which is equivalent toself.find_loader(fullname)[0]
.Obsoleto desde a versão 3.4: Use
find_spec()
instead.
-
invalidate_caches
()¶ Um método opcional que, quando chamado, deve invalidar qualquer cache interno usado pelo localizador. Usado por
importlib.machinery.PathFinder.invalidate_caches()
ao invalidar os caches de todos os localizadores em cache.
-
-
class
importlib.abc.
Loader
¶ Uma classe base abstrata para um carregador. Veja PEP 302 para a definição exata de um carregador.
Loaders that wish to support resource reading should implement a
get_resource_reader(fullname)
method as specified byimportlib.abc.ResourceReader
.Alterado na versão 3.7: Introduced the optional
get_resource_reader()
method.-
create_module
(spec)¶ Um método que retorna o objeto do módulo a ser usado ao importar um módulo. Este método pode retornar
None
, indicando que a semântica padrão de criação do módulo deve ocorrer.Novo na versão 3.4.
Alterado na versão 3.5: Starting in Python 3.6, this method will not be optional when
exec_module()
is defined.
-
exec_module
(module)¶ An abstract method that executes the module in its own namespace when a module is imported or reloaded. The module should already be initialized when
exec_module()
is called. When this method exists,create_module()
must be defined.Novo na versão 3.4.
Alterado na versão 3.6:
create_module()
precisa ser definida.
-
load_module
(fullname)¶ A legacy method for loading a module. If the module cannot be loaded,
ImportError
is raised, otherwise the loaded module is returned.If the requested module already exists in
sys.modules
, that module should be used and reloaded. Otherwise the loader should create a new module and insert it intosys.modules
before any loading begins, to prevent recursion from the import. If the loader inserted a module and the load fails, it must be removed by the loader fromsys.modules
; modules already insys.modules
before the loader began execution should be left alone (seeimportlib.util.module_for_loader()
).The loader should set several attributes on the module. (Note that some of these attributes can change when a module is reloaded):
__name__
O nome do módulo.
__file__
The path to where the module data is stored (not set for built-in modules).
__cached__
The path to where a compiled version of the module is/should be stored (not set when the attribute would be inappropriate).
__path__
A list of strings specifying the search path within a package. This attribute is not set on modules.
__package__
The fully qualified name of the package under which the module was loaded as a submodule (or the empty string for top-level modules). For packages, it is the same as
__name__
. Theimportlib.util.module_for_loader()
decorator can handle the details for__package__
.
__loader__
The loader used to load the module. The
importlib.util.module_for_loader()
decorator can handle the details for__package__
.
Quando
exec_module()
está disponível, então a funcionalidade compatível com versões anteriores é fornecida.Alterado na versão 3.4: Raise
ImportError
when called instead ofNotImplementedError
. Functionality provided whenexec_module()
is available.Obsoleto desde a versão 3.4: The recommended API for loading a module is
exec_module()
(andcreate_module()
). Loaders should implement it instead of load_module(). The import machinery takes care of all the other responsibilities of load_module() when exec_module() is implemented.
-
module_repr
(module)¶ A legacy method which when implemented calculates and returns the given module’s repr, as a string. The module type’s default repr() will use the result of this method as appropriate.
Novo na versão 3.3.
Alterado na versão 3.4: Made optional instead of an abstractmethod.
Obsoleto desde a versão 3.4: The import machinery now takes care of this automatically.
-
-
class
importlib.abc.
ResourceReader
¶ Substituída por TraversableResources
Uma classe base abstrata para fornecer a capacidade de ler recursos.
Da perspectiva deste ABC, um recurso é um artefato binário que é enviado dentro de um pacote. Normalmente isso é algo como um arquivo de dados que fica próximo ao arquivo
__init__.py
do pacote. O objetivo desta classe é ajudar a abstrair o acesso a tais arquivos de dados para que não importe se o pacote e seu(s) arquivo(s) de dados estão armazenados em um arquivo, por exemplo, zip versus no sistema de arquivos.Para qualquer um dos métodos desta classe, espera-se que o argumento resource seja um objeto caminho ou similar que representa conceitualmente apenas um nome de arquivo. Isso significa que nenhum caminho de subdiretório deve ser incluído no argumento resource. Isso ocorre porque a localização do pacote para o qual o leitor se destina, atua como o “diretório”. Portanto, a metáfora para diretórios e nomes de arquivos são pacotes e recursos, respectivamente. É também por isso que se espera que as instâncias dessa classe se correlacionem diretamente a um pacote específico (em vez de representar potencialmente vários pacotes ou um módulo).
Carregadores que desejam oferecer suporte à leitura de recursos devem fornecer um método chamado
get_resource_reader(nomecompleto)
que retorna um objeto implementando esta interface ABC. Se o módulo especificado por nomecompleto não for um pacote, este método deve retornarNone
. Um objeto compatível com este ABC só deve ser retornado quando o módulo especificado for um pacote.Novo na versão 3.7.
-
abstractmethod
open_resource
(resource)¶ Retorna um objeto arquivo ou similar aberto para leitura binária de resource.
Se o recurso não puder ser encontrado,
FileNotFoundError
é levantada.
-
abstractmethod
resource_path
(resource)¶ Retorna o caminho do sistema de arquivos para resource.
Se o recurso não existir concretamente no sistema de arquivos, levanta
FileNotFoundError
.
-
abstractmethod
is_resource
(name)¶ Retorna
True
se o name nomeado for considerado um recurso.FileNotFoundError
é levantada se name não existir.
-
abstractmethod
contents
()¶ Retorna um iterável de strings sobre o conteúdo do pacote. Observe que não é necessário que todos os nomes retornados pelo iterador sejam recursos reais, por exemplo, é aceitável retornar nomes para os quais
is_resource()
seria falso.Permitir que nomes que não são recursos sejam retornados é permitir situações em que a forma como um pacote e seus recursos são armazenados é conhecida a priori e os nomes que não são recursos seriam úteis. Por exemplo, o retorno de nomes de subdiretórios é permitido para que, quando se souber que o pacote e os recursos estão armazenados no sistema de arquivos, esses nomes de subdiretórios possam ser usados diretamente.
O método abstrato retorna um iterável sem itens.
-
abstractmethod
-
class
importlib.abc.
ResourceLoader
¶ Uma classe base abstrata para um carregador que implementa o protocolo opcional PEP 302 para carregar recursos arbitrários do back-end de armazenamento.
Obsoleto desde a versão 3.7: This ABC is deprecated in favour of supporting resource loading through
importlib.abc.ResourceReader
.-
abstractmethod
get_data
(path)¶ Um método abstrato para retornar os bytes dos dados localizados em path. Carregadores que possuem um backend de armazenamento arquivo ou similar que permite o armazenamento de dados arbitrários podem implementar esse método abstrato para fornecer acesso direto aos dados armazenados.
OSError
deve ser levantada se o path não puder ser encontrado. Espera-se que o path seja construído usando o atributo__file__
de um módulo ou um item de__path__
de um pacote.Alterado na versão 3.4: Levanta
OSError
em vez deNotImplementedError
.
-
abstractmethod
-
class
importlib.abc.
InspectLoader
¶ Uma classe base abstrata para um carregador que implementa o protocolo opcional da PEP 302 para carregadores que inspecionam módulos.
-
get_code
(fullname)¶ Retorna o objeto de código para um módulo, ou
None
se o módulo não tiver um objeto código (como seria o caso, por exemplo, para um módulo embutido). Levanta umImportError
se o carregador não conseguir encontrar o módulo solicitado.Nota
Embora o método tenha uma implementação padrão, sugere-se que ele seja substituído, se possível, para desempenho.
Alterado na versão 3.4: Não é mais abstrato e uma implementação concreta é fornecida.
-
abstractmethod
get_source
(fullname)¶ Um método abstrato para retornar a fonte de um módulo. Ele é retornado como uma string de texto usando novas linhas universais, traduzindo todos os separadores de linha reconhecidos em caracteres
'\n'
. RetornaNone
se nenhuma fonte estiver disponível (por exemplo, um módulo embutido). LevantaImportError
se o carregador não puder encontrar o módulo especificado.Alterado na versão 3.4: Levanta
ImportError
em vez deNotImplementedError
.
-
is_package
(fullname)¶ Um método opcional para retornar um valor verdadeiro se o módulo for um pacote, um valor falso caso contrário.
ImportError
é levantada se o carregador não puder encontrar o módulo.Alterado na versão 3.4: Levanta
ImportError
em vez deNotImplementedError
.
-
static
source_to_code
(data, path='<string>')¶ Cria um objeto código a partir de código-fonte Python
O argumento data pode ser qualquer coisa a qual a função
compile()
tenha suporte (por exemplo, string ou bytes). O argumento path deve ser o “caminho” de onde o código-fonte se originou, o que pode ser um conceito abstrato (por exemplo, local em um arquivo zip).Com o objeto de código subsequente, é possível executá-lo em um módulo executando
exec(code, module.__dict__)
.Novo na versão 3.4.
Alterado na versão 3.5: O método foi tornado estático.
-
exec_module
(module)¶ Implementação de
Loader.exec_module()
.Novo na versão 3.4.
-
load_module
(fullname)¶ Implementação de
Loader.load_module()
.Obsoleto desde a versão 3.4: use
exec_module()
.
-
-
class
importlib.abc.
ExecutionLoader
¶ Uma classe base abstrata que herda de
InspectLoader
que, quando implementada, ajuda um módulo a ser executado como um script. A ABC representa um protocolo opcional da PEP 302.-
abstractmethod
get_filename
(fullname)¶ Um método abstrato que deve retornar o valor de
__file__
para o módulo especificado. Se nenhum caminho estiver disponível,ImportError
é levantada.Se o código-fonte estiver disponível, o método deverá retornar o caminho para o arquivo fonte, independentemente de um bytecode ter sido usado para carregar o módulo.
Alterado na versão 3.4: Levanta
ImportError
em vez deNotImplementedError
.
-
abstractmethod
-
class
importlib.abc.
FileLoader
(fullname, path)¶ Uma classe base abstrata que herda de
ResourceLoader
eExecutionLoader
, fornecendo implementações concretas deResourceLoader.get_data()
eExecutionLoader.get_filename()
.O argumento fullname é um nome totalmente resolvido do módulo que o carregador deve manipular. O argumento path é o caminho para o arquivo do módulo.
Novo na versão 3.3.
-
name
¶ O nome do módulo que o carregador pode manipular.
-
path
¶ Caminho para o arquivo do módulo
-
load_module
(fullname)¶ Chama
load_module()
do super.Obsoleto desde a versão 3.4: Use
Loader.exec_module()
-
abstractmethod
get_data
(path)¶ Lê caminho como um arquivo binário e retorna os bytes dele.
-
-
class
importlib.abc.
SourceLoader
¶ Uma classe base abstrata para implementar o carregamento de arquivo fonte (e opcionalmente bytecode). A classe herda de
ResourceLoader
eExecutionLoader
, exigindo a implementação de:ExecutionLoader.get_filename()
Deve retornar apenas o caminho para o arquivo fonte; o carregamento sem fonte não é suportado.
Os métodos abstratos definidos por esta classe são para adicionar suporte opcional ao arquivo bytecode. Não implementar esses métodos opcionais (ou fazer com que eles levantem
NotImplementedError
) faz com que o carregador funcione apenas com código-fonte. Implementar os métodos permite que o carregador funcione com arquivos de código-fonte e bytecode; ele não permite carregamento sem fonte onde apenas o bytecode é fornecido. Arquivos de bytecode são uma otimização para acelerar o carregamento removendo a etapa de análise do compilador do Python e, portanto, nenhuma API específica de bytecode é exposta.-
path_stats
(path)¶ Método abstrato opcional que retorna um
dict
contendo metadados sobre o caminho especificado. As chaves de dicionário suportadas são:'mtime'
(obrigatório): um número inteiro ou de ponto flutuante que representa o tempo de modificação do código-fonte;'size'
(opcional): o tamanho em bytes do código-fonte.
Quaisquer outras chaves no dicionário são ignoradas, para permitir extensões futuras. Se o caminho não puder ser manipulado,
OSError
é levantada.Novo na versão 3.3.
Alterado na versão 3.4: Levanta
OSError
em vez deNotImplementedError
.
-
path_mtime
(path)¶ Método abstrato opcional que retorna o horário de modificação do caminho especificado.
Obsoleto desde a versão 3.3: Este método foi descontinuado em favor de
path_stats()
. Você não precisa implementá-lo, mas ele ainda está disponível para fins de compatibilidade. LevantaOSError
se o caminho não puder ser manipulado.Alterado na versão 3.4: Levanta
OSError
em vez deNotImplementedError
.
-
set_data
(path, data)¶ Método abstrato opcional que grava os bytes especificados em um caminho de arquivo. Quaisquer diretórios intermediários que não existam devem ser criados automaticamente.
When writing to the path fails because the path is read-only (
errno.EACCES
/PermissionError
), do not propagate the exception.Alterado na versão 3.4: Não mais levanta
NotImplementedError
quando chamado.
-
get_code
(fullname)¶ Implementação concreta de
InspectLoader.get_code()
.
-
exec_module
(module)¶ Implementação concreta de
Loader.exec_module()
.Novo na versão 3.4.
-
load_module
(fullname)¶ Implementação concreta de
Loader.load_module()
.Obsoleto desde a versão 3.4: Use
exec_module()
.
-
get_source
(fullname)¶ Implementação concreta de
InspectLoader.get_source()
.
-
is_package
(fullname)¶ Implementação concreta de
InspectLoader.is_package()
. Um módulo é determinado como um pacote se seu caminho de arquivo (conforme fornecido porExecutionLoader.get_filename()
) for um arquivo chamado__init__
quando a extensão do arquivo for removida e o nome do módulo em si não terminar em__init__
.
-
class
importlib.abc.
Traversable
¶ Um objeto com um subconjunto de métodos de
pathlib.Path
adequados para percorrer diretórios e abrir arquivos.Para uma representação do objeto no sistema de arquivos, use
importlib.resources.as_file()
.Novo na versão 3.9.
-
abstractmethod
name
()¶ The base name of this object without any parent references.
-
abstractmethod
iterdir
()¶ Produz objetos Traversable em self.
-
abstractmethod
is_dir
()¶ Retorna True se self for um diretório.
-
abstractmethod
is_file
()¶ Retorna True se self for um arquivo.
-
abstractmethod
joinpath
(child)¶ Retorna o filho Traversable em self.
-
abstractmethod
__truediv__
(child)¶ Retorna o filho Traversable em self.
-
abstractmethod
open
(mode='r', *args, **kwargs)¶ mode pode ser ‘r’ ou ‘rb’ para abrir como texto ou binário. Retorna um manipulador adequado para leitura (o mesmo que
pathlib.Path.open
).Ao abrir como texto, aceita parâmetros de codificação como os aceitos por
io.TextIOWrapper
.
-
read_bytes
()¶ Lê o conteúdo de self como bytes.
-
read_text
(encoding=None)¶ Lê o conteúdo de self como texto.
Note: In Python 3.11 and later, this class is found in
importlib.resources.abc
.-
abstractmethod
-
class
importlib.abc.
TraversableResources
¶ An abstract base class for resource readers capable of serving the
files
interface. Subclasses ResourceReader and provides concrete implementations of the ResourceReader’s abstract methods. Therefore, any loader supplying TraversableResources also supplies ResourceReader.Espera-se que os carregadores que desejam oferecer suporte à leitura de recursos implementem essa interface.
Novo na versão 3.9.
Note: In Python 3.11 and later, this class is found in
importlib.resources.abc
.
importlib.resources
– Resources¶
Source code: Lib/importlib/resources.py
Novo na versão 3.7.
This module leverages Python’s import system to provide access to resources within packages. If you can import a package, you can access resources within that package. Resources can be opened or read, in either binary or text mode.
Resources are roughly akin to files inside directories, though it’s important to keep in mind that this is just a metaphor. Resources and packages do not have to exist as physical files and directories on the file system.
Nota
This module provides functionality similar to pkg_resources Basic Resource Access without the performance overhead of that package. This makes reading resources included in packages easier, with more stable and consistent semantics.
The standalone backport of this module provides more information on using importlib.resources and migrating from pkg_resources to importlib.resources.
Loaders that wish to support resource reading should implement a
get_resource_reader(fullname)
method as specified by
importlib.abc.ResourceReader
.
The following types are defined.
-
importlib.resources.
Package
¶ The
Package
type is defined asUnion[str, ModuleType]
. This means that where the function describes accepting aPackage
, you can pass in either a string or a module. Module objects must have a resolvable__spec__.submodule_search_locations
that is notNone
.
-
importlib.resources.
Resource
¶ This type describes the resource names passed into the various functions in this package. This is defined as
Union[str, os.PathLike]
.
The following functions are available.
-
importlib.resources.
files
(package)¶ Returns an
importlib.abc.Traversable
object representing the resource container for the package (think directory) and its resources (think files). A Traversable may contain other containers (think subdirectories).package é um nome ou um objeto módulo que está em conformidade com os requisitos de
Package
.Novo na versão 3.9.
-
importlib.resources.
as_file
(traversable)¶ Given a
importlib.abc.Traversable
object representing a file, typically fromimportlib.resources.files()
, return a context manager for use in awith
statement. The context manager provides apathlib.Path
object.Exiting the context manager cleans up any temporary file created when the resource was extracted from e.g. a zip file.
Use
as_file
when the Traversable methods (read_text
, etc) are insufficient and an actual file on the file system is required.Novo na versão 3.9.
-
importlib.resources.
open_binary
(package, resource)¶ Abre para leitura binária o resource dentro do package.
package é um nome ou um objeto módulo que está em conformidade com os requisitos do
Package
. resource é o nome do recurso a ser aberto dentro de package; ele não pode conter separadores de caminho e não pode ter sub-recursos (ou seja, não pode ser um diretório). Essa função retorna uma instância detyping.BinaryIO
, um fluxo de E/S binário aberto para leitura.
-
importlib.resources.
open_text
(package, resource, encoding='utf-8', errors='strict')¶ Abre para leitura de texto o resource dentro do package. Por padrão, o recurso é aberto para leitura como UTF-8.
package é um nome ou um objeto módulo que está em conformidade com os requisitos do
Package
. resource é o nome do recurso a ser aberto dentro de package; ele não pode conter separadores de caminho e não pode ter sub-recursos (ou seja, não pode ser um diretório). encoding e errors têm o mesmo significado que comopen()
embutido.Essa função retorna uma instância de
typing.TextIO
, um fluxo de E/S de texto aberto para leitura.
-
importlib.resources.
read_binary
(package, resource)¶ Lê e retorna o conteúdo do resource dentro do package como
bytes
.package é um nome ou um objeto módulo que está em conformidade com os requisitos do
Package
. resource é o nome do recurso a ser aberto dentro de package; ele não pode conter separadores de caminho e não pode ter sub-recursos (ou seja, não pode ser um diretório). Essa função retorna o conteúdo do recurso comobytes
.
-
importlib.resources.
read_text
(package, resource, encoding='utf-8', errors='strict')¶ Lê e retorna o conteúdo de resource em package como
str
. Por padrão, o conteúdo é lido como UTF-8 estrito.package é um nome ou um objeto módulo que está em conformidade com os requisitos do
Package
. resource é o nome do recurso a ser aberto dentro de package; ele não pode conter separadores de caminho e não pode ter sub-recursos (ou seja, não pode ser um diretório). encoding e errors têm o mesmo significado que comopen()
embutido. Esta função retorna o conteúdo do recurso comostr
.
-
importlib.resources.
path
(package, resource)¶ Retorna o caminho para o resource como um caminho real do sistema de arquivos. Essa função retorna um gerenciador de contexto para uso em uma instrução
with
. O gerenciador de contexto fornece um objetopathlib.Path
.Sair do gerenciador de contexto limpa qualquer arquivo temporário criado quando o recurso precisa ser extraído, por exemplo, de um arquivo zip.
package é um nome ou um objeto módulo que está em conformidade com os requisitos do
Package
. resource é o nome do recurso a ser aberto dentro de package; ele não pode conter separadores de caminho e não pode ter sub-recursos (ou seja, não pode ser um diretório).
-
importlib.resources.
is_resource
(package, name)¶ Return
True
if there is a resource named name in the package, otherwiseFalse
. Remember that directories are not resources! package is either a name or a module object which conforms to thePackage
requirements.
-
importlib.resources.
contents
(package)¶ Retorna um iterável sobre os itens nomeados no pacote. O iterável retorna
str
recursos (por exemplo, arquivos) e não recursos (por exemplo, diretórios). O iterável não recorre a subdiretórios.package é um nome ou um objeto módulo que está em conformidade com os requisitos de
Package
.
importlib.machinery
– Importadores e ganchos de caminho¶
Código-fonte: Lib/importlib/machinery.py
Este módulo contém vários objetos que ajudam o import
a localizar e carregar módulos.
-
importlib.machinery.
SOURCE_SUFFIXES
¶ Uma lista de strings representando os sufixos de arquivo reconhecidos para módulos em código-fonte.
Novo na versão 3.3.
-
importlib.machinery.
DEBUG_BYTECODE_SUFFIXES
¶ Uma lista de strings representando os sufixos de arquivo para módulos em bytecode não otimizado.
Novo na versão 3.3.
Obsoleto desde a versão 3.5: Use
BYTECODE_SUFFIXES
.
-
importlib.machinery.
OPTIMIZED_BYTECODE_SUFFIXES
¶ Uma lista de strings representando os sufixos de arquivo para módulos em bytecode otimizado.
Novo na versão 3.3.
Obsoleto desde a versão 3.5: Use
BYTECODE_SUFFIXES
.
-
importlib.machinery.
BYTECODE_SUFFIXES
¶ Uma lista de strings representando os sufixos de arquivo reconhecidos para módulos em bytecode (incluindo com ponto no início).
Novo na versão 3.3.
Alterado na versão 3.5: O valor não mais depende de
__debug__
.
-
importlib.machinery.
EXTENSION_SUFFIXES
¶ Uma lista de strings representando os sufixos de arquivo reconhecidos para módulos de extensão.
Novo na versão 3.3.
-
importlib.machinery.
all_suffixes
()¶ Retorna uma lista combinada de strings representando todos os sufixos de arquivo para módulos reconhecidos pelo maquinário de importação padrão. Este é um auxiliar para código que simplesmente precisa saber se um caminho de sistema de arquivos potencialmente se refere a um módulo sem precisar de detalhes sobre o tipo de módulo (por exemplo,
inspect.getmodulename()
).Novo na versão 3.3.
-
class
importlib.machinery.
BuiltinImporter
¶ Um importador para módulos embutidos. Todos os módulos embutidos conhecidos estão listados em
sys.builtin_module_names
. Esta classe implementa os ABCsimportlib.abc.MetaPathFinder
eimportlib.abc.InspectLoader
.Somente métodos de classe são definidos por esta classe para aliviar a necessidade de instanciação.
Alterado na versão 3.5: Como parte da PEP 489, o importador embutido agora implementa
Loader.create_module()
eLoader.exec_module()
-
class
importlib.machinery.
FrozenImporter
¶ Um importador para módulos congelados. Esta classe implementa os ABCs
importlib.abc.MetaPathFinder
eimportlib.abc.InspectLoader
.Somente métodos de classe são definidos por esta classe para aliviar a necessidade de instanciação.
Alterado na versão 3.4: Ganhou os métodos
create_module()
eexec_module()
.
-
class
importlib.machinery.
WindowsRegistryFinder
¶ Localizador para módulos declarados no registro do Windows. Esta classe implementa a ABC
importlib.abc.MetaPathFinder
.Somente métodos de classe são definidos por esta classe para aliviar a necessidade de instanciação.
Novo na versão 3.3.
Obsoleto desde a versão 3.6: Use a configuração de
site
em vez disso. Versões futuras do Python podem não habilitar esse localizador por padrão.
-
class
importlib.machinery.
PathFinder
¶ Um Localizador para atributos
sys.path
e pacote__path__
. Esta classe implementa a ABCimportlib.abc.MetaPathFinder
.Somente métodos de classe são definidos por esta classe para aliviar a necessidade de instanciação.
-
classmethod
find_spec
(fullname, path=None, target=None)¶ Método de classe que tenta encontrar um spec para o módulo especificado por fullname em
sys.path
ou, se definido, em path. Para cada entrada de caminho pesquisada,sys.path_importer_cache
é verificado. Se um objeto não falso for encontrado, ele será usado como o localizador de entrada de caminho para procurar o módulo que está sendo pesquisado. Se nenhuma entrada for encontrada emsys.path_importer_cache
, entãosys.path_hooks
será pesquisado para um localizador para a entrada de caminho e, se encontrado, será armazenado emsys.path_importer_cache
junto com a consulta sobre o módulo. Se nenhum localizador for encontrado, entãoNone
será armazenado no cache e retornado.Novo na versão 3.4.
Alterado na versão 3.5: Se o diretório de trabalho atual — representado por uma string vazia — não for mais válido,
None
será retornado, mas nenhum valor será armazenado em cache emsys.path_importer_cache
.
-
classmethod
find_module
(fullname, path=None)¶ A legacy wrapper around
find_spec()
.Obsoleto desde a versão 3.4: Use
find_spec()
instead.
-
classmethod
invalidate_caches
()¶ Chama
importlib.abc.PathEntryFinder.invalidate_caches()
em todos os localizadores armazenados emsys.path_importer_cache
que definem o método. Caso contrário, as entradas emsys.path_importer_cache
definidas comoNone
são excluídas.Alterado na versão 3.7: Entradas de
None
emsys.path_importer_cache
são excluídas.
Alterado na versão 3.4: Chama objetos em
sys.path_hooks
com o diretório de trabalho atual para''
(ou seja, a string vazia).-
classmethod
-
class
importlib.machinery.
FileFinder
(path, *loader_details)¶ Uma implementação concreta de
importlib.abc.PathEntryFinder
que armazena em cache os resultados do sistema de arquivos.O argumento path é o diretório que o localizador é responsável por pesquisar.
O argumento loader_details é um número variável de tuplas de 2 itens, cada uma contendo um carregador e uma sequência de sufixos de arquivo que o carregador reconhece. Espera-se que os carregadores sejam chamáveis que aceitam dois argumentos do nome do módulo e o caminho para o arquivo encontrado.
O localizador armazenará em cache o conteúdo do diretório conforme necessário, fazendo chamadas de “stat” para cada pesquisa de módulo para verificar se o cache não está desatualizado. Como a obsolescência do cache depende da granularidade das informações de estado do sistema operacional do sistema de arquivos, há uma condição de corrida potencial de busca por um módulo, criação de um novo arquivo e, em seguida, busca pelo módulo que o novo arquivo representa. Se as operações ocorrerem rápido o suficiente para caber na granularidade das chamadas de “stat”, a pesquisa do módulo falhará. Para evitar que isso aconteça, ao criar um módulo dinamicamente, certifique-se de chamar
importlib.invalidate_caches()
.Novo na versão 3.3.
-
path
¶ O caminho que o localizador irá procurar.
-
find_spec
(fullname, target=None)¶ Tenta encontrar o spec para manipular fullname dentro de
path
.Novo na versão 3.4.
-
find_loader
(fullname)¶ Attempt to find the loader to handle fullname within
path
.Obsoleto desde a versão 3.10: Use
find_spec()
instead.
-
invalidate_caches
()¶ Limpa o cache interno.
-
classmethod
path_hook
(*loader_details)¶ A class method which returns a closure for use on
sys.path_hooks
. An instance ofFileFinder
is returned by the closure using the path argument given to the closure directly and loader_details indirectly.Se o argumento para a clausura não for um diretório existente,
ImportError
será levantada.
-
-
class
importlib.machinery.
SourceFileLoader
(fullname, path)¶ Uma implementação concreta de
importlib.abc.SourceLoader
subclassificandoimportlib.abc.FileLoader
e fornecendo algumas implementações concretas de outros métodos.Novo na versão 3.3.
-
name
¶ O nome do módulo que este carregador irá manipular.
-
path
¶ O caminho para o arquivo fonte.
-
path_stats
(path)¶ Implementação concreta de
importlib.abc.SourceLoader.path_stats()
.
-
set_data
(path, data)¶ Implementação concreta de
importlib.abc.SourceLoader.set_data()
.
-
load_module
(name=None)¶ Implementação concreta de
importlib.abc.Loader.load_module()
onde a especificação do nome do módulo para carregar é opcionalObsoleto desde a versão 3.6: Use
importlib.abc.Loader.exec_module()
.
-
-
class
importlib.machinery.
SourcelessFileLoader
(fullname, path)¶ Uma implementação concreta de
importlib.abc.FileLoader
que pode importar arquivos de bytecode (ou seja, não existem arquivos de código-fonte).Observe que o uso direto de arquivos de bytecode (e, portanto, não de arquivos de código-fonte) impede que seus módulos sejam utilizáveis por todas as implementações do Python ou novas versões do Python que alteram o formato do bytecode.
Novo na versão 3.3.
-
name
¶ O nome do módulo que o carregador vai manipular.
-
path
¶ O caminho para o arquivo de bytecode.
-
get_source
(fullname)¶ Retorna
None
, pois os arquivos de bytecode não têm código-fonte quando este carregador é usado.
-
load_module
(name=None)¶
Implementação concreta de
importlib.abc.Loader.load_module()
onde a especificação do nome do módulo para carregar é opcionalObsoleto desde a versão 3.6: Use
importlib.abc.Loader.exec_module()
.-
-
class
importlib.machinery.
ExtensionFileLoader
(fullname, path)¶ Uma implementação concreta de
importlib.abc.ExecutionLoader
para módulos de extensão.O argumento fullname especifica o nome do módulo ao qual o carregador deve dar suporte. O argumento path é o caminho para o arquivo do módulo de extensão.
Novo na versão 3.3.
-
name
¶ Nome do módulo ao qual o carregador dá suporte.
-
path
¶ Caminho para o módulo de extensão.
-
create_module
(spec)¶ Cria o objeto do módulo a partir da especificação fornecida de acordo com a PEP 489.
Novo na versão 3.5.
-
exec_module
(module)¶ Inicializa o objeto do módulo fornecido de acordo com a PEP 489.
Novo na versão 3.5.
-
is_package
(fullname)¶ Retorna
True
se o caminho do arquivo aponta para o módulo__init__
de um pacote com base emEXTENSION_SUFFIXES
.
-
get_code
(fullname)¶ Retorna
None
, pois os módulos de extensão não possuem um objeto código.
-
get_source
(fullname)¶ Retorna
None
pois os módulos de extensão não possuem código-fonte.
-
-
class
importlib.machinery.
ModuleSpec
(name, loader, *, origin=None, loader_state=None, is_package=None)¶ A specification for a module’s import-system-related state. This is typically exposed as the module’s
__spec__
attribute. In the descriptions below, the names in parentheses give the corresponding attribute available directly on the module object. E.g.module.__spec__.origin == module.__file__
. Note however that while the values are usually equivalent, they can differ since there is no synchronization between the two objects. Thus it is possible to update the module’s__path__
at runtime, and this will not be automatically reflected in__spec__.submodule_search_locations
.Novo na versão 3.4.
-
name
¶
(
__name__
)A string for the fully qualified name of the module.
-
loader
¶
(
__loader__
)The Loader that should be used when loading the module. Finders should always set this.
-
origin
¶
(
__file__
)Name of the place from which the module is loaded, e.g. “builtin” for built-in modules and the filename for modules loaded from source. Normally “origin” should be set, but it may be
None
(the default) which indicates it is unspecified (e.g. for namespace packages).-
submodule_search_locations
¶
(
__path__
)List of strings for where to find submodules, if a package (
None
otherwise).-
loader_state
¶
Container of extra module-specific data for use during loading (or
None
).-
cached
¶
(
__cached__
)String for where the compiled module should be stored (or
None
).-
parent
¶
(
__package__
)(Read-only) The fully qualified name of the package under which the module should be loaded as a submodule (or the empty string for top-level modules). For packages, it is the same as
__name__
.-
has_location
¶
Boolean indicating whether or not the module’s “origin” attribute refers to a loadable location.
-
importlib.util
– Utility code for importers¶
Source code: Lib/importlib/util.py
This module contains the various objects that help in the construction of an importer.
-
importlib.util.
MAGIC_NUMBER
¶ The bytes which represent the bytecode version number. If you need help with loading/writing bytecode then consider
importlib.abc.SourceLoader
.Novo na versão 3.4.
-
importlib.util.
cache_from_source
(path, debug_override=None, *, optimization=None)¶ Return the PEP 3147/PEP 488 path to the byte-compiled file associated with the source path. For example, if path is
/foo/bar/baz.py
the return value would be/foo/bar/__pycache__/baz.cpython-32.pyc
for Python 3.2. Thecpython-32
string comes from the current magic tag (seeget_tag()
; ifsys.implementation.cache_tag
is not defined thenNotImplementedError
will be raised).The optimization parameter is used to specify the optimization level of the bytecode file. An empty string represents no optimization, so
/foo/bar/baz.py
with an optimization of''
will result in a bytecode path of/foo/bar/__pycache__/baz.cpython-32.pyc
.None
causes the interpreter’s optimization level to be used. Any other value’s string representation is used, so/foo/bar/baz.py
with an optimization of2
will lead to the bytecode path of/foo/bar/__pycache__/baz.cpython-32.opt-2.pyc
. The string representation of optimization can only be alphanumeric, elseValueError
is raised.The debug_override parameter is deprecated and can be used to override the system’s value for
__debug__
. ATrue
value is the equivalent of setting optimization to the empty string. AFalse
value is the same as setting optimization to1
. If both debug_override an optimization are notNone
thenTypeError
is raised.Novo na versão 3.4.
Alterado na versão 3.5: The optimization parameter was added and the debug_override parameter was deprecated.
Alterado na versão 3.6: Aceita um objeto caminho ou similar.
-
importlib.util.
source_from_cache
(path)¶ Given the path to a PEP 3147 file name, return the associated source code file path. For example, if path is
/foo/bar/__pycache__/baz.cpython-32.pyc
the returned path would be/foo/bar/baz.py
. path need not exist, however if it does not conform to PEP 3147 or PEP 488 format, aValueError
is raised. Ifsys.implementation.cache_tag
is not defined,NotImplementedError
is raised.Novo na versão 3.4.
Alterado na versão 3.6: Aceita um objeto caminho ou similar.
-
importlib.util.
decode_source
(source_bytes)¶ Decode the given bytes representing source code and return it as a string with universal newlines (as required by
importlib.abc.InspectLoader.get_source()
).Novo na versão 3.4.
-
importlib.util.
resolve_name
(name, package)¶ Resolve a relative module name to an absolute one.
If name has no leading dots, then name is simply returned. This allows for usage such as
importlib.util.resolve_name('sys', __spec__.parent)
without doing a check to see if the package argument is needed.ImportError
is raised if name is a relative module name but package is a false value (e.g.None
or the empty string).ImportError
is also raised a relative name would escape its containing package (e.g. requesting..bacon
from within thespam
package).Novo na versão 3.3.
Alterado na versão 3.9: To improve consistency with import statements, raise
ImportError
instead ofValueError
for invalid relative import attempts.
-
importlib.util.
find_spec
(name, package=None)¶ Find the spec for a module, optionally relative to the specified package name. If the module is in
sys.modules
, thensys.modules[name].__spec__
is returned (unless the spec would beNone
or is not set, in which caseValueError
is raised). Otherwise a search usingsys.meta_path
is done.None
is returned if no spec is found.If name is for a submodule (contains a dot), the parent module is automatically imported.
name and package work the same as for
import_module()
.Novo na versão 3.4.
Alterado na versão 3.7: Raises
ModuleNotFoundError
instead ofAttributeError
if package is in fact not a package (i.e. lacks a__path__
attribute).
-
importlib.util.
module_from_spec
(spec)¶ Create a new module based on spec and
spec.loader.create_module
.If
spec.loader.create_module
does not returnNone
, then any pre-existing attributes will not be reset. Also, noAttributeError
will be raised if triggered while accessing spec or setting an attribute on the module.This function is preferred over using
types.ModuleType
to create a new module as spec is used to set as many import-controlled attributes on the module as possible.Novo na versão 3.5.
-
@
importlib.util.
module_for_loader
¶ A decorator for
importlib.abc.Loader.load_module()
to handle selecting the proper module object to load with. The decorated method is expected to have a call signature taking two positional arguments (e.g.load_module(self, module)
) for which the second argument will be the module object to be used by the loader. Note that the decorator will not work on static methods because of the assumption of two arguments.The decorated method will take in the name of the module to be loaded as expected for a loader. If the module is not found in
sys.modules
then a new one is constructed. Regardless of where the module came from,__loader__
set to self and__package__
is set based on whatimportlib.abc.InspectLoader.is_package()
returns (if available). These attributes are set unconditionally to support reloading.If an exception is raised by the decorated method and a module was added to
sys.modules
, then the module will be removed to prevent a partially initialized module from being in left insys.modules
. If the module was already insys.modules
then it is left alone.Alterado na versão 3.3:
__loader__
and__package__
are automatically set (when possible).Alterado na versão 3.4: Set
__name__
,__loader__
__package__
unconditionally to support reloading.Obsoleto desde a versão 3.4: The import machinery now directly performs all the functionality provided by this function.
-
@
importlib.util.
set_loader
¶ A decorator for
importlib.abc.Loader.load_module()
to set the__loader__
attribute on the returned module. If the attribute is already set the decorator does nothing. It is assumed that the first positional argument to the wrapped method (i.e.self
) is what__loader__
should be set to.Alterado na versão 3.4: Set
__loader__
if set toNone
, as if the attribute does not exist.Obsoleto desde a versão 3.4: The import machinery takes care of this automatically.
-
@
importlib.util.
set_package
¶ A decorator for
importlib.abc.Loader.load_module()
to set the__package__
attribute on the returned module. If__package__
is set and has a value other thanNone
it will not be changed.Obsoleto desde a versão 3.4: The import machinery takes care of this automatically.
-
importlib.util.
spec_from_loader
(name, loader, *, origin=None, is_package=None)¶ A factory function for creating a
ModuleSpec
instance based on a loader. The parameters have the same meaning as they do for ModuleSpec. The function uses available loader APIs, such asInspectLoader.is_package()
, to fill in any missing information on the spec.Novo na versão 3.4.
-
importlib.util.
spec_from_file_location
(name, location, *, loader=None, submodule_search_locations=None)¶ A factory function for creating a
ModuleSpec
instance based on the path to a file. Missing information will be filled in on the spec by making use of loader APIs and by the implication that the module will be file-based.Novo na versão 3.4.
Alterado na versão 3.6: Aceita um objeto caminho ou similar.
-
importlib.util.
source_hash
(source_bytes)¶ Return the hash of source_bytes as bytes. A hash-based
.pyc
file embeds thesource_hash()
of the corresponding source file’s contents in its header.Novo na versão 3.7.
-
class
importlib.util.
LazyLoader
(loader)¶ A class which postpones the execution of the loader of a module until the module has an attribute accessed.
This class only works with loaders that define
exec_module()
as control over what module type is used for the module is required. For those same reasons, the loader’screate_module()
method must returnNone
or a type for which its__class__
attribute can be mutated along with not using slots. Finally, modules which substitute the object placed intosys.modules
will not work as there is no way to properly replace the module references throughout the interpreter safely;ValueError
is raised if such a substitution is detected.Nota
For projects where startup time is critical, this class allows for potentially minimizing the cost of loading a module if it is never used. For projects where startup time is not essential then use of this class is heavily discouraged due to error messages created during loading being postponed and thus occurring out of context.
Novo na versão 3.5.
Alterado na versão 3.6: Began calling
create_module()
, removing the compatibility warning forimportlib.machinery.BuiltinImporter
andimportlib.machinery.ExtensionFileLoader
.-
classmethod
factory
(loader)¶ A class method which returns a callable that creates a lazy loader. This is meant to be used in situations where the loader is passed by class instead of by instance.
suffixes = importlib.machinery.SOURCE_SUFFIXES loader = importlib.machinery.SourceFileLoader lazy_loader = importlib.util.LazyLoader.factory(loader) finder = importlib.machinery.FileFinder(path, (lazy_loader, suffixes))
-
classmethod
Exemplos¶
Importing programmatically¶
To programmatically import a module, use importlib.import_module()
.
import importlib
itertools = importlib.import_module('itertools')
Checando se o módulo pode ser importado¶
If you need to find out if a module can be imported without actually doing the
import, then you should use importlib.util.find_spec()
.
Note that if name
is a submodule (contains a dot),
importlib.util.find_spec()
will import the parent module.
import importlib.util
import sys
# For illustrative purposes.
name = 'itertools'
if name in sys.modules:
print(f"{name!r} already in sys.modules")
elif (spec := importlib.util.find_spec(name)) is not None:
# If you chose to perform the actual import ...
module = importlib.util.module_from_spec(spec)
sys.modules[name] = module
spec.loader.exec_module(module)
print(f"{name!r} has been imported")
else:
print(f"can't find the {name!r} module")
Importa o arquivo de origem diretamente¶
Importação um arquivo Python diretamente da fonte, use o seguinte caminho (Somente versões Python 3.5 acima)
import importlib.util
import sys
# For illustrative purposes.
import tokenize
file_path = tokenize.__file__
module_name = tokenize.__name__
spec = importlib.util.spec_from_file_location(module_name, file_path)
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)
Implementing lazy imports¶
The example below shows how to implement lazy imports:
>>> import importlib.util
>>> import sys
>>> def lazy_import(name):
... spec = importlib.util.find_spec(name)
... loader = importlib.util.LazyLoader(spec.loader)
... spec.loader = loader
... module = importlib.util.module_from_spec(spec)
... sys.modules[name] = module
... loader.exec_module(module)
... return module
...
>>> lazy_typing = lazy_import("typing")
>>> #lazy_typing is a real module object,
>>> #but it is not loaded in memory yet.
>>> lazy_typing.TYPE_CHECKING
False
Setting up an importer¶
For deep customizations of import, you typically want to implement an
importer. This means managing both the finder and loader
side of things. For finders there are two flavours to choose from depending on
your needs: a meta path finder or a path entry finder. The
former is what you would put on sys.meta_path
while the latter is what
you create using a path entry hook on sys.path_hooks
which works
with sys.path
entries to potentially create a finder. This example will
show you how to register your own importers so that import will use them (for
creating an importer for yourself, read the documentation for the appropriate
classes defined within this package):
import importlib.machinery
import sys
# For illustrative purposes only.
SpamMetaPathFinder = importlib.machinery.PathFinder
SpamPathEntryFinder = importlib.machinery.FileFinder
loader_details = (importlib.machinery.SourceFileLoader,
importlib.machinery.SOURCE_SUFFIXES)
# Setting up a meta path finder.
# Make sure to put the finder in the proper location in the list in terms of
# priority.
sys.meta_path.append(SpamMetaPathFinder)
# Setting up a path entry finder.
# Make sure to put the path hook in the proper location in the list in terms
# of priority.
sys.path_hooks.append(SpamPathEntryFinder.path_hook(loader_details))
Approximating importlib.import_module()
¶
Import itself is implemented in Python code, making it possible to
expose most of the import machinery through importlib. The following
helps illustrate the various APIs that importlib exposes by providing an
approximate implementation of
importlib.import_module()
(Python 3.4 and newer for the importlib usage,
Python 3.6 and newer for other parts of the code).
import importlib.util
import sys
def import_module(name, package=None):
"""An approximate implementation of import."""
absolute_name = importlib.util.resolve_name(name, package)
try:
return sys.modules[absolute_name]
except KeyError:
pass
path = None
if '.' in absolute_name:
parent_name, _, child_name = absolute_name.rpartition('.')
parent_module = import_module(parent_name)
path = parent_module.__spec__.submodule_search_locations
for finder in sys.meta_path:
spec = finder.find_spec(absolute_name, path)
if spec is not None:
break
else:
msg = f'No module named {absolute_name!r}'
raise ModuleNotFoundError(msg, name=absolute_name)
module = importlib.util.module_from_spec(spec)
sys.modules[absolute_name] = module
spec.loader.exec_module(module)
if path is not None:
setattr(parent_module, child_name, module)
return module