importlib — La implementación de import

Nuevo en la versión 3.1.

Código fuente: Lib/importlib/__init__.py

Introducción

El propósito del paquete importlib es doble. Uno es proveer la implementación de la declaración de import, (y así, por extensión, el método __import__() ) en el código fuente de Python. Esto provee una implementación de la import la cual es compatible con cualquier interprete de Python. También provee una implementación que es más fácil de comprender que otras implementaciones, en lenguajes diferentes a Python.

Dos, los componentes incluidos para implementar import están expuestos en este paquete para que sea más fácil para los usuarios crear sus propios objetos (conocidos de forma genérica como importer) para participar en el proceso de importación.

Ver también

La declaración import

La referencia en el lenguaje para la declaración de import.

Especificaciones de paquetes

Especificaciones originales de los paquetes. Algunas semánticas han cambiado desde que este documento fue escrito (ejemplo, redirección de acuerdo a None en sys.modules).

La función __import__()

La declaración de import es una decoración sintáctica para esta función.

PEP 235

Importar en sistemas que no distinguen entre mayúsculas y minúsculas

PEP 263

Definiendo las codificaciones del código fuente de Python

PEP 302

Nuevos ganchos de importación

pep:328

Importaciones: Multilíneas, y absolutos/relativos

PEP 366

Importaciones relativas, explicitas, del módulo principal

PEP 420

Paquetes implícitos en el espacio de nombres

PEP 451

Un tipo de ModuleSpec para el sistema de importación

PEP 488

Eliminación de archivos PYO

PEP 489

Inicialización de extensión de módulo en múltiples fases

PEP 552

Pycs determinísticos

PEP 3120

Usando UTF-8 como la codificación fuente por defecto

PEP 3147

Repositorio de directorios PYC

Funciones

importlib.__import__(name, globals=None, locals=None, fromlist=(), level=0)

Una implementación de la función __import__() incorporada.

Nota

La importación programática los módulos debe usar import_module() en lugar de esta función.

importlib.import_module(name, package=None)

Importar un módulo. El argumento llamado name especifica qué módulo importar en términos absolutos o relativos (ejemplo, puede ser pkg.mod o ..mod). Si el nombre fuera especificado en términos relativos, entonces el argumento llamado package debe ser igual al nombre del paquete que será el ancla para resolver el nombre del paquete (ejemplo import_module('..mod', 'pkg.subpkg') importará pkg.mod).

La función import_module() actúa como un envoltorio simplificador alrededor de importlib.__import__(). Esto quiere decir que las semánticas de la función son derivadas de importlib.__import__(). La diferencia más importante entre las dos funciones es que import_module() retorna el paquete especificado o el módulo (ejemplo pkg.mod), mientras que __import__() retorna el paquete o módulo del nivel superior (ejemplo pkg).

Si está importando dinámicamente un módulo que se creó desde que el intérprete comenzó la ejecución (por ejemplo, creó un archivo fuente de Python), es posible que deba llamar a invalidate_caches() para que el nuevo módulo sea detectado por el sistema de importación.

Distinto en la versión 3.3: Paquetes padres son importados automáticamente.

importlib.find_loader(name, path=None)

Encuentra el cargador de un módulo, opcionalmente con el especificado en path.Si el módulo esta en sys.modules, entonces retorna el sys.modules[name].__loader__` (a menos que el cargador sea None o no haya uno especificado, en tal caso se lanza un ValueError).Si no se encuentra ahí, se hace una búsqueda usando sys.meta_path. Se retorna None si no se encuentra un cargador.

Un nombre con puntos no tiene sus ascendientes importados implícitamente, ya que eso requeriría cargarlo y eso podría no ser deseado. Para importar un sub-módulo correctamente debes importar todos los paquetes ascendientes del sub-módulo y pase el argumento correcto a path.

Nuevo en la versión 3.3.

Distinto en la versión 3.4: Si el __loader__ no está configurado, lanza un ValueError, igual a si el atributo fuera None.

Obsoleto desde la versión 3.4: Utilice importlib.util.find_spec() en su lugar.

importlib.invalidate_caches()

Invalide los cache internos de ubicadores encontrados en sys.meta_path.Si un buscador implementa invalidate_caches() entonces será llamado para realizar la invalidación.Esta función debe ser llamada si cualquier módulo ha sido creado/instalado mientras tu programa esta siendo ejecutado para garantizar que todos los buscadores noten la existencia del nuevo módulo.

Nuevo en la versión 3.3.

importlib.reload(module)

Recarga un modulo previamente importado. El argumento debe ser un objeto módulo, por lo que debe haber sido importado exitosamente. Esto es útil cuando has editado el código fuente de un archivo usando un editor externo y deseas probar la nueva versión sin abandonar el interprete de Python. El valor retornado es el objeto módulo (que puede ser diferente si la reimportación crea un nuevo objeto en sys.modules).

Cuando reload() es ejecutada:

  • El código de un módulo de Python es recompilado y el código del módulo reejecutado, definiendo un nuevo conjunto de objetos que son asignados a los nombres de los módulos en el diccionario, reusando el loader que originalmente carga los módulos. El método init de los módulos de extension no es llamado de nuevo.

  • Al igual que con todos los demás objetos en Python, los objetos antiguos solo se recuperan después de que sus recuentos de referencias caen a cero.

  • Los nombres en el espacio de nombres del módulo se actualizan para señalar cualquier objeto nuevo o modificado.

  • Otras referencias a los objetos antiguos (como los nombres externos al módulo) no se vuelven a vincular para hacer referencia a los nuevos objetos y deben actualizarse en cada espacio de nombres donde se produzcan si se desea.

Hay una serie de otras advertencias:

Cuando se vuelve a cargar un módulo, se conserva su diccionario (que contiene las variables globales del módulo). Las redefiniciones de nombres anularán las antiguas definiciones, por lo que generalmente esto no es un problema. Si la nueva versión de un módulo no define un nombre que fue definido por la versión anterior, la definición anterior permanece. Esta característica se puede utilizar en beneficio del módulo si mantiene una tabla global o caché de objetos — con una declaración try puede probar la presencia de la tabla y omitir su inicialización si lo desea:

try:
    cache
except NameError:
    cache = {}

Por lo general, no es muy útil recargar módulos integrados o cargados dinámicamente. No se recomienda recargar sys, __main__, builtins y otros módulos clave. En muchos casos, los módulos de extensión no están diseñados para inicializarse más de una vez y pueden fallar de manera arbitraria cuando se vuelven a cargar.

Si un módulo importa objetos de otro módulo usando from … import …, al llamar a reload() para el otro módulo no redefine los objetos importados de él — una forma de evitar esto es volver a ejecutar la instrucción from, otra es usar import y nombres calificados (module.name) en su lugar.

Si un módulo crea instancias de una clase, volver a cargar el módulo que define la clase no afecta las definiciones de método de las instancias — continúan usando la definición de clase anterior. Lo mismo ocurre con las clases derivadas.

Nuevo en la versión 3.4.

Distinto en la versión 3.7: ModuleNotFoundError se lanza cuando el módulo que se está recargando carece de ModuleSpec.

importlib.abc – Clases base abstractas relacionadas con la importación

Código fuente: Lib/importlib/abc.py

El módulo importlib.abc contiene todas las clases base abstractas principales utilizadas por import. También se proporcionan algunas subclases de las clases base abstractas centrales para ayudar a implementar los ABC centrales.

Jerarquía ABC:

object
 +-- Finder (deprecated)
 +-- MetaPathFinder
 +-- PathEntryFinder
 +-- Loader
      +-- ResourceLoader --------+
      +-- InspectLoader          |
           +-- ExecutionLoader --+
                                 +-- FileLoader
                                 +-- SourceLoader
class importlib.abc.Finder

Una clase base abstracta que representa finder.

Obsoleto desde la versión 3.3: Utilice MetaPathFinder o PathEntryFinder en su lugar.

abstractmethod find_module(fullname, path=None)

Un método abstracto para encontrar un loader para el módulo especificado. Originalmente especificado en PEP 302, este método estaba destinado a ser utilizado en sys.meta_path y en el subsistema de importación basado en rutas.

Distinto en la versión 3.4: Retorna None cuando se llama en lugar de generar NotImplementedError.

Obsoleto desde la versión 3.10: Implemente MetaPathFinder.find_spec() o PathEntryFinder.find_spec() en su lugar.

class importlib.abc.MetaPathFinder

An abstract base class representing a meta path finder.

Nuevo en la versión 3.3.

Distinto en la versión 3.10: Ya no hereda de Finder.

find_spec(fullname, path, target=None)

Un método abstracto para encontrar un spec para el módulo especificado. Si se trata de una importación de nivel superior, el path será None. De lo contrario, esta es una búsqueda de un subpaquete o módulo y path será el valor de __path__ del paquete principal. Si no se puede encontrar una especificación, se retorna None. Cuando se pasa, target es un objeto de módulo que el buscador puede usar para hacer una suposición más informada sobre qué especificación retornar. importlib.util.spec_from_loader() puede ser útil para implementar MetaPathFinders concretos.

Nuevo en la versión 3.4.

find_module(fullname, path)

Un método heredado para encontrar un loader para el módulo especificado. Si se trata de una importación de nivel superior, el path será None. De lo contrario, esta es una búsqueda de un subpaquete o módulo y path será el valor de __path__ del paquete principal. Si no se puede encontrar un cargador, se retorna None.

Si se define find_spec(), se proporciona una funcionalidad compatible con versiones anteriores.

Distinto en la versión 3.4: Retorna None cuando se llama en lugar de generar NotImplementedError. Puede usar find_spec() para proporcionar funcionalidad.

Obsoleto desde la versión 3.4: Use find_spec() en su lugar.

invalidate_caches()

Un método opcional que, cuando se llama, debería invalidar cualquier caché interno utilizado por el buscador. Utilizado por importlib.invalidate_caches() al invalidar los cachés de todos los buscadores en sys.meta_path.

Distinto en la versión 3.4: Retorna None cuando se llama en lugar de NotImplemented.

class importlib.abc.PathEntryFinder

Una clase base abstracta que representa un buscador de entradas de ruta. Aunque tiene algunas similitudes con MetaPathFinder, PathEntryFinder está diseñado para usarse solo dentro del subsistema de importación basado en rutas proporcionado por importlib.machinery.PathFinder.

Nuevo en la versión 3.3.

Distinto en la versión 3.10: Ya no hereda de Finder.

find_spec(fullname, target=None)

Un método abstracto para encontrar un spec para el módulo especificado. El buscador buscará el módulo solo dentro del path entry a la que está asignado. Si no se puede encontrar una especificación, se retorna None. Cuando se pasa, target es un objeto de módulo que el buscador puede usar para hacer una suposición más informada sobre qué especificación retornar. importlib.util.spec_from_loader() puede ser útil para implementar PathEntryFinders concretos.

Nuevo en la versión 3.4.

find_loader(fullname)

Un método heredado para encontrar un loader para el módulo especificado. Retorna una tupla de 2 de (loader, portion) donde portion es una secuencia de ubicaciones del sistema de archivos que contribuyen a parte de un paquete de espacio de nombres. El cargador puede ser None mientras se especifica portion para indicar la contribución de las ubicaciones del sistema de archivos a un paquete de espacio de nombres. Se puede usar una lista vacía para portion para indicar que el cargador no es parte de un paquete de espacio de nombres. Si loader es None y portion es la lista vacía, entonces no se encontró ningún cargador o ubicación para un paquete de espacio de nombres (es decir, no se pudo encontrar nada para el módulo).

Si se define find_spec(), se proporciona una funcionalidad compatible con versiones anteriores.

Distinto en la versión 3.4: Retorna (None, []) en lugar de lanzar NotImplementedError. Usa find_spec() cuando está disponible para proporcionar funcionalidad.

Obsoleto desde la versión 3.4: Use find_spec() en su lugar.

find_module(fullname)

Una implementación concreta de Finder.find_module() que es equivalente a self.find_loader(fullname)[0].

Obsoleto desde la versión 3.4: Use find_spec() en su lugar.

invalidate_caches()

Un método opcional que, cuando se llama, debería invalidar cualquier caché interno utilizado por el buscador. Usado por importlib.machinery.PathFinder.invalidate_caches() al invalidar las cachés de todos los buscadores en caché.

class importlib.abc.Loader

Una clase base abstracta para un loader. Consulte PEP 302 para obtener la definición exacta de cargador.

Los cargadores que deseen admitir la lectura de recursos deben implementar un método get_resource_reader(fullname) según lo especificado por importlib.abc.ResourceReader.

Distinto en la versión 3.7: Introdujo el método opcional get_resource_reader().

create_module(spec)

Un método que retorna el objeto de módulo que se utilizará al importar un módulo. Este método puede retornar None, lo que indica que se debe llevar a cabo la semántica de creación de módulos predeterminada.

Nuevo en la versión 3.4.

Distinto en la versión 3.5: A partir de Python 3.6, este método no será opcional cuando se defina exec_module().

exec_module(module)

Un método abstracto que ejecuta el módulo en su propio espacio de nombres cuando se importa o se vuelve a cargar un módulo. El módulo ya debería estar inicializado cuando se llama a exec_module(). Cuando existe este método, se debe definir create_module().

Nuevo en la versión 3.4.

Distinto en la versión 3.6: create_module() también debe definirse.

load_module(fullname)

Un método heredado para cargar un módulo. Si el módulo no se puede cargar, se lanza ImportError; de lo contrario, se retorna el módulo cargado.

Si el módulo solicitado ya existe en sys.modules, ese módulo debe usarse y recargarse. De lo contrario, el cargador debe crear un nuevo módulo e insertarlo en sys.modules antes de que comience la carga, para evitar la recursividad de la importación. Si el cargador insertó un módulo y la carga falla, el cargador debe eliminarlo de sys.modules; los módulos que ya están en sys.modules antes de que el cargador comenzara a ejecutarse deben dejarse en paz (ver importlib.util.module_for_loader()).

El cargador debe establecer varios atributos en el módulo. (Tenga en cuenta que algunos de estos atributos pueden cambiar cuando se recarga un módulo):

  • __name__

    El nombre del módulo.

  • __file__

    La ruta hacia donde se almacenan los datos del módulo (no configurada para módulos integrados).

  • __cached__

    La ruta a la que se debe almacenar una versión compilada del módulo (no se establece cuando el atributo sería inapropiado).

  • __path__

    Una lista de cadenas de caracteres que especifican la ruta de búsqueda dentro de un paquete. Este atributo no se establece en módulos.

  • __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__. The importlib.util.module_for_loader() decorator can handle the details for __package__.

  • __loader__

    El cargador utilizado para cargar el módulo. El decorador importlib.util.module_for_loader() puede manejar los detalles de __package__.

Cuando exec_module() está disponible, se proporciona una funcionalidad compatible con versiones anteriores.

Distinto en la versión 3.4: Lanza ImportError cuando se llama en lugar de NotImplementedError. Funcionalidad proporcionada cuando exec_module() está disponible.

Obsoleto desde la versión 3.4: La API recomendada para cargar un módulo es exec_module() (y create_module()). Los cargadores deberían implementarlo en lugar de load_module(). La maquinaria de importación se encarga de todas las demás responsabilidades de load_module() cuando se implementa exec_module().

module_repr(module)

Un método heredado que, cuando se implementa, calcula y retorna la repr del módulo dado, como una cadena. El repr() predeterminado del tipo de módulo utilizará el resultado de este método según corresponda.

Nuevo en la versión 3.3.

Distinto en la versión 3.4: Hecho opcional en vez de un método abstracto (abstractmethod)

Obsoleto desde la versión 3.4: La maquinaria de importación ahora se encarga de esto automáticamente.

class importlib.abc.ResourceReader

Reemplazada por TraversableResources

Un abstract base class para proporcionar la capacidad de leer resources.

Desde la perspectiva de este ABC, un resource es un artefacto binario que se envía dentro de un paquete. Por lo general, esto es algo así como un archivo de datos que se encuentra junto al archivo __init__.py del paquete. El propósito de esta clase es ayudar a abstraer el acceso a dichos archivos de datos de modo que no importe si el paquete y sus archivos de datos se almacenan en un, por ejemplo, zip en comparación con el sistema de archivos.

Para cualquiera de los métodos de esta clase, se espera que un argumento resource sea un path-like object que representa conceptualmente solo un nombre de archivo. Esto significa que no se deben incluir rutas de subdirectorio en el argumento resource. Esto se debe a que la ubicación del paquete para el que está ubicado el lector actúa como el «directorio». Por lo tanto, la metáfora de los directorios y los nombres de los archivos son los paquetes y los recursos, respectivamente. Esta es también la razón por la que se espera que las instancias de esta clase se correlacionen directamente con un paquete específico (en lugar de representar potencialmente varios paquetes o un módulo).

Se espera que los cargadores que deseen admitir la lectura de recursos proporcionen un método llamado get_resource_reader(fullname) que retorna un objeto que implementa la interfaz de este ABC. Si el módulo especificado por fullname no es un paquete, este método debería devolver None. Un objeto compatible con este ABC solo debe retornarse cuando el módulo especificado es un paquete.

Nuevo en la versión 3.7.

abstractmethod open_resource(resource)

Retorna un, file-like object abierto para la lectura binaria del resource.

Si no se puede encontrar el recurso, se lanza FileNotFoundError.

abstractmethod resource_path(resource)

Retorna la ruta del sistema de archivos al resource.

Si el recurso no existe concretamente en el sistema de archivos, lanza FileNotFoundError.

abstractmethod is_resource(name)

Retorna True si el name nombrado se considera un recurso. FileNotFoundError se lanza si name no existe.

abstractmethod contents()

Retorna un iterable de cadenas de caracteres sobre el contenido del paquete. Tenga en cuenta que no es necesario que todos los nombres retornados por el iterador sean recursos reales, por ejemplo, es aceptable retornar nombres para los que is_resource() sería falso.

Al permitir que se retornen nombres que no son de recursos es para permitir situaciones en las que se conoce a priori cómo se almacenan un paquete y sus recursos y los nombres que no son de recursos serían útiles. Por ejemplo, se permite el retorno de nombres de subdirectorios para que cuando se sepa que el paquete y los recursos están almacenados en el sistema de archivos, esos nombres de subdirectorios se puedan usar directamente.

El método abstracto retorna un iterable de ningún elemento.

class importlib.abc.ResourceLoader

Una clase base abstracta para un loader que implementa el protocolo opcional PEP 302 para cargar recursos arbitrarios desde el back-end de almacenamiento.

Obsoleto desde la versión 3.7: Este ABC está en desuso a favor de admitir la carga de recursos a través de importlib.abc.ResourceReader.

abstractmethod get_data(path)

Un método abstracto para devolver los bytes de los datos ubicados en path. Los cargadores que tienen un back-end de almacenamiento similar a un archivo que permite almacenar datos arbitrarios pueden implementar este método abstracto para dar acceso directo a los datos almacenados. OSError se lanza si no se puede encontrar el path. Se espera que la path se construya utilizando el atributo __file__ de un módulo o un elemento de un paquete __path__.

Distinto en la versión 3.4: Lanza OSError en vez de NotImplementedError.

class importlib.abc.InspectLoader

Una clase base abstracta para un loader que implementa el protocolo opcional PEP 302 para cargadores que inspeccionan módulos.

get_code(fullname)

Retorna el objeto código para un módulo, o None si el módulo no tiene un objeto código (como sería el caso, por ejemplo, para un módulo integrado). Lanza un ImportError si el cargador no puede encontrar el módulo solicitado.

Nota

Si bien el método tiene una implementación predeterminada, se sugiere que se anule si es posible para mejorar el rendimiento.

Distinto en la versión 3.4: Ya no es un método abstracto y se proporciona una implementación concreta.

abstractmethod get_source(fullname)

Un método abstracto para retornar la fuente de un módulo. Se retorna como una cadena de caracteres de texto usando universal newlines, traduciendo todos los separadores de línea reconocidos en caracteres ' '. Retorna None si no hay una fuente disponible (por ejemplo, un módulo integrado). Lanza ImportError si el cargador no puede encontrar el módulo especificado.

Distinto en la versión 3.4: Lanza ImportError en vez de NotImplementedError.

is_package(fullname)

Un método opcional para retornar un valor verdadero si el módulo es un paquete, un valor falso en caso contrario. Se lanza ImportError si el cargador no puede encontrar el módulo.

Distinto en la versión 3.4: Lanza ImportError en vez de NotImplementedError.

static source_to_code(data, path='<string>')

Cree un objeto de código a partir de la fuente de Python.

El argumento data puede ser cualquier cosa que admita la función compile() (es decir, cadena de caracteres o bytes). El argumento path debe ser la «ruta» de donde se originó el código fuente, que puede ser un concepto abstracto (por ejemplo, ubicación en un archivo zip).

Con el objeto de código subsiguiente, uno puede ejecutarlo en un módulo ejecutando exec(code, module.__dict__).

Nuevo en la versión 3.4.

Distinto en la versión 3.5: Hace el método estático.

exec_module(module)

Implementación de Loader.exec_module().

Nuevo en la versión 3.4.

load_module(fullname)

Implementación de Loader.load_module().

Obsoleto desde la versión 3.4: use exec_module() en su lugar.

class importlib.abc.ExecutionLoader

Una clase base abstracta que hereda de InspectLoader que, cuando se implementa, ayuda a que un módulo se ejecute como un script. El ABC representa un protocolo opcional PEP 302.

abstractmethod get_filename(fullname)

Un método abstracto que retorna el valor de __file__ para el módulo especificado. Si no hay una ruta disponible, se lanza ImportError.

Si el código fuente está disponible, entonces el método debe devolver la ruta al archivo fuente, independientemente de si se utilizó un código de bytes para cargar el módulo.

Distinto en la versión 3.4: Lanza ImportError en vez de NotImplementedError.

class importlib.abc.FileLoader(fullname, path)

Una clase base abstracta que hereda de ResourceLoader y ExecutionLoader, proporcionando implementaciones concretas de ResourceLoader.get_data() y ExecutionLoader.get_filename().

El argumento fullname es un nombre completamente resuelto del módulo que el cargador debe manejar. El argumento path es la ruta al archivo del módulo.

Nuevo en la versión 3.3.

name

El nombre del módulo que puede manejar el cargador.

path

Ruta al archivo del módulo.

load_module(fullname)

Llama a super’s load_module().

Obsoleto desde la versión 3.4: Utilice Loader.exec_module() en su lugar.

abstractmethod get_filename(fullname)

Retorna path.

abstractmethod get_data(path)

Lee path como un archivo binario y devuelve los bytes de él.

class importlib.abc.SourceLoader

Una clase base abstracta para implementar la carga de archivos fuente (y opcionalmente bytecode). La clase hereda tanto de ResourceLoader como de ExecutionLoader, lo que requiere la implementación de:

Los métodos abstractos definidos por esta clase son para agregar soporte de archivo de código de bytes opcional. No implementar estos métodos opcionales (o hacer que se lance NotImplementedError) hace que el cargador solo funcione con el código fuente. La implementación de los métodos permite que el cargador trabaje con archivos fuente y código de bytes; no permite la carga sin fuente donde solo se proporciona un código de bytes. Los archivos de código de bytes son una optimización para acelerar la carga al eliminar el paso de análisis del compilador de Python, por lo que no se expone ninguna API específica de código de bytes.

path_stats(path)

Método abstracto opcional que devuelve un dict que contiene metadatos sobre la ruta especificada. Las claves de diccionario admitidas son:

  • 'mtime' (obligatorio): un número entero o de punto flotante que representa la hora de modificación del código fuente;

  • 'size' (opcional): el tamaño en bytes del código fuente.

Cualquier otra clave del diccionario se ignora para permitir futuras extensiones. Si no se puede manejar la ruta, se genera OSError.

Nuevo en la versión 3.3.

Distinto en la versión 3.4: Lanza OSError en vez de NotImplementedError.

path_mtime(path)

Método abstracto opcional que retorna la hora de modificación de la ruta especificada.

Obsoleto desde la versión 3.3: Este método está obsoleto en favor de path_stats(). No tiene que implementarlo, pero aún está disponible para fines de compatibilidad. Lanza OSError si la ruta no se puede manejar.

Distinto en la versión 3.4: Lanza OSError en vez de NotImplementedError.

set_data(path, data)

Método abstracto opcional que escribe los bytes especificados en una ruta de archivo. Los directorios intermedios que no existan se crearán automáticamente.

Cuando la escritura en la ruta falla porque la ruta es de solo lectura (errno.EACCES/PermissionError), no propague la excepción.

Distinto en la versión 3.4: Ya no lanza NotImplementedError cuando se llama.

get_code(fullname)

Implementación concreta de InspectLoader.get_code().

exec_module(module)

Implementación concreta de Loader.exec_module().

Nuevo en la versión 3.4.

load_module(fullname)

Implementación concreta de Loader.load_module().

Obsoleto desde la versión 3.4: Utilice exec_module() en su lugar.

get_source(fullname)

Implementación concreta de InspectLoader.get_source().

is_package(fullname)

Implementación concreta de InspectLoader.is_package(). Se determina que un módulo es un paquete si su ruta de archivo (proporcionada por ExecutionLoader.get_filename()) es un archivo llamado __init__ cuando se elimina la extensión del archivo y el nombre del módulo sí lo hace no termina en __init__.

class importlib.abc.Traversable

An object with a subset of pathlib.Path methods suitable for traversing directories and opening files.

For a representation of the object on the file-system, use importlib.resources.as_file().

Nuevo en la versión 3.9.

abstractmethod name()

The base name of this object without any parent references.

abstractmethod iterdir()

Yield Traversable objects in self.

abstractmethod is_dir()

Return True if self is a directory.

abstractmethod is_file()

Return True if self is a file.

abstractmethod joinpath(child)

Return Traversable child in self.

abstractmethod __truediv__(child)

Return Traversable child in self.

abstractmethod open(mode='r', *args, **kwargs)

mode may be “r” or “rb” to open as text or binary. Return a handle suitable for reading (same as pathlib.Path.open).

When opening as text, accepts encoding parameters such as those accepted by io.TextIOWrapper.

read_bytes()

Read contents of self as bytes.

read_text(encoding=None)

Read contents of self as text.

Note: In Python 3.11 and later, this class is found in importlib.resources.abc.

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.

Se espera que los cargadores que deseen admitir la lectura de recursos implementen esta interfaz.

Nuevo en la versión 3.9.

Note: In Python 3.11 and later, this class is found in importlib.resources.abc.

importlib.resources – Recursos

Código fuente: Lib/importlib/resources.py

Nuevo en la versión 3.7.

Este módulo aprovecha el sistema de importación de Python para proporcionar acceso a resources dentro de packages. Si puede importar un paquete, puede acceder a los recursos dentro de ese paquete. Los recursos se pueden abrir o leer, ya sea en modo binario o texto.

Los recursos son similares a los archivos dentro de los directorios, aunque es importante tener en cuenta que esto es solo una metáfora. Los recursos y paquetes no tienen que existir como archivos y directorios físicos en el sistema de archivos.

Nota

Este módulo proporciona una funcionalidad similar a pkg_resources Acceso Básico a Recursos sin la sobrecarga de rendimiento de ese paquete. Esto facilita la lectura de los recursos incluidos en los paquetes, con una semántica más estable y coherente.

El backport independiente de este módulo proporciona más información sobre usar importlib.resources y migrar desde pkg_resources a importlib.resources.

Los cargadores que deseen admitir la lectura de recursos deben implementar un método get_resource_reader(fullname) según lo especificado por importlib.abc.ResourceReader.

Se definen los siguientes tipos.

importlib.resources.Package

El tipo Package se define como Union[str, ModuleType]. Esto significa que cuando la función describe la aceptación de un Package, puede pasar una cadena de caracteres o un módulo. Los objetos de módulo deben tener un __spec__.submodule_search_locations que se pueda resolver que no sea None.

importlib.resources.Resource

Este tipo describe los nombres de los recursos que se pasan a las distintas funciones de este paquete. Esto se define como Union[str, os.PathLike].

Están disponibles las siguientes funciones.

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 es un nombre o un objeto de módulo que cumple con los requisitos de Package.

Nuevo en la versión 3.9.

importlib.resources.as_file(traversable)

Given a importlib.abc.Traversable object representing a file, typically from importlib.resources.files(), return a context manager for use in a with statement. The context manager provides a pathlib.Path object.

Salir del gestor de contexto limpia cualquier archivo temporal creado cuando se extrajo el recurso de, por ejemplo, un archivo zip.

Use as_file` cuando los métodos Traversable (``read_text, etc) sean insuficientes y se requiera un archivo real en el sistema de archivos.

Nuevo en la versión 3.9.

importlib.resources.open_binary(package, resource)

Abra para lectura binaria el resource dentro del package.

package es un nombre o un objeto de módulo que cumple con los requisitos de Package. resource es el nombre del recurso a abrir dentro de package; puede que no contenga separadores de ruta y puede que no tenga sub-recursos (es decir, no puede ser un directorio). Esta función retorna una instancia de typing.BinaryIO, un flujo de E/S binario abierto para lectura.

importlib.resources.open_text(package, resource, encoding='utf-8', errors='strict')

Se abre para leer el texto del resource dentro del package. De forma predeterminada, el recurso está abierto para lectura como UTF-8.

package es un nombre o un objeto de módulo que cumple con los requisitos de Package. resource es el nombre del recurso a abrir dentro de package; puede que no contenga separadores de ruta y puede que no tenga sub-recursos (es decir, no puede ser un directorio). encoding y errors tienen el mismo significado que con la función integrada open().

Esta función retorna una instancia de typing.TextIO, un flujo de E/S de texto abierto para lectura.

importlib.resources.read_binary(package, resource)

Lee y retorna el contenido del resource dentro del package como bytes.

package es un nombre o un objeto de módulo que cumple con los requisitos de Package. resource es el nombre del recurso a abrir dentro de package; puede que no contenga separadores de ruta y puede que no tenga sub-recursos (es decir, no puede ser un directorio). Esta función retorna el contenido del recurso como bytes.

importlib.resources.read_text(package, resource, encoding='utf-8', errors='strict')

Lee y retorna el contenido de resource dentro de package como un str. De forma predeterminada, los contenidos se leen como UTF-8 estricto.

package es un nombre o un objeto de módulo que cumple con los requisitos de Package. resource es el nombre del recurso a abrir dentro de package; puede que no contenga separadores de ruta y puede que no tenga sub-recursos (es decir, no puede ser un directorio). encoding y errors tienen el mismo significado que con la función integrada open(). Esta función retorna el contenido del recurso como str.

importlib.resources.path(package, resource)

Retorna la ruta al resource como una ruta real del sistema de archivos. Esta función retorna un administrador de contexto para usar en una declaración with. El administrador de contexto proporciona un objeto pathlib.Path.

Salir del administrador de contexto limpia cualquier archivo temporal creado cuando el recurso necesita ser extraído, por ejemplo, un archivo zip.

package es un nombre o un objeto de módulo que cumple con los requisitos de Package. resource es el nombre del recurso a abrir dentro de package; puede que no contenga separadores de ruta y puede que no tenga sub-recursos (es decir, no puede ser un directorio).

importlib.resources.is_resource(package, name)

Retorna True si hay un recurso llamado name en el paquete; de lo contrario, False. ¡Recuerde que los directorios no son recursos! package es un nombre o un objeto de módulo que cumple con los requisitos de Package.

importlib.resources.contents(package)

Retorna un iterable sobre los elementos nombrados dentro del paquete. El iterable retorna recursos str (por ejemplo, archivos) y no-recursos (por ejemplo, directorios). El iterable no recurre a subdirectorios.

package es un nombre o un objeto de módulo que cumple con los requisitos de Package.

importlib.machinery – Importadores y enlaces de ruta

Código fuente: Lib/importlib/machinery.py

Este módulo contiene varios objetos que ayudan import buscar y cargar módulos.

importlib.machinery.SOURCE_SUFFIXES

Una lista de cadenas de caracteres que representan los sufijos de archivo reconocidos para los módulos de origen.

Nuevo en la versión 3.3.

importlib.machinery.DEBUG_BYTECODE_SUFFIXES

Una lista de cadenas que representan los sufijos de archivo para módulos de código de bytes no optimizados.

Nuevo en la versión 3.3.

Obsoleto desde la versión 3.5: Utilice BYTECODE_SUFFIXES en su lugar.

importlib.machinery.OPTIMIZED_BYTECODE_SUFFIXES

Una lista de cadenas de caracteres que representan los sufijos de archivo para módulos de código de bytes optimizados.

Nuevo en la versión 3.3.

Obsoleto desde la versión 3.5: Utilice BYTECODE_SUFFIXES en su lugar.

importlib.machinery.BYTECODE_SUFFIXES

Una lista de cadenas de caracteres que representan los sufijos de archivo reconocidos para los módulos de código de bytes (incluido el punto inicial).

Nuevo en la versión 3.3.

Distinto en la versión 3.5: El valor ya no depende de __debug__.

importlib.machinery.EXTENSION_SUFFIXES

Una lista de cadenas de caracteres que representan los sufijos de archivo reconocidos para los módulos de extensión.

Nuevo en la versión 3.3.

importlib.machinery.all_suffixes()

Retorna una lista combinada de cadenas de caracteres que representan todos los sufijos de archivo para módulos reconocidos por la maquinaria de importación estándar. Este es un ayudante para el código que simplemente necesita saber si una ruta del sistema de archivos potencialmente se refiere a un módulo sin necesidad de detalles sobre el tipo de módulo (por ejemplo, inspect.getmodulename()).

Nuevo en la versión 3.3.

class importlib.machinery.BuiltinImporter

Un importer para módulos integrados. Todos los módulos integrados conocidos se enumeran en sys.builtin_module_names. Esta clase implementa los ABC importlib.abc.MetaPathFinder y importlib.abc.InspectLoader.

Esta clase solo define los métodos de clase para aliviar la necesidad de instanciación.

Distinto en la versión 3.5: Como parte de PEP 489, el importador integrado ahora implementa Loader.create_module() y Loader.exec_module()

class importlib.machinery.FrozenImporter

Un importer para módulos congelados. Esta clase implementa los ABC importlib.abc.MetaPathFinder y importlib.abc.InspectLoader.

Esta clase solo define los métodos de clase para aliviar la necesidad de instanciación.

Distinto en la versión 3.4: Métodos obtenidos create_module() y exec_module().

class importlib.machinery.WindowsRegistryFinder

Finder para los módulos declarados en el registro de Windows. Esta clase implementa el importlib.abc.MetaPathFinder ABC.

Esta clase solo define los métodos de clase para aliviar la necesidad de instanciación.

Nuevo en la versión 3.3.

Obsoleto desde la versión 3.6: Utilice la configuración de site en su lugar. Es posible que las versiones futuras de Python no habiliten este buscador de forma predeterminada.

class importlib.machinery.PathFinder

Un Finder para sys.path y atributos del paquete __path__. Esta clase implementa el importlib.abc.MetaPathFinder ABC.

Esta clase solo define los métodos de clase para aliviar la necesidad de instanciación.

classmethod find_spec(fullname, path=None, target=None)

Método de clase que intenta encontrar un spec para el módulo especificado por fullname en sys.path o, si está definido, en path. Para cada entrada de ruta que se busca, se comprueba sys.path_importer_cache. Si se encuentra un objeto que no es falso, se utiliza como path entry finder para buscar el módulo que se está buscando. Si no se encuentra ninguna entrada en sys.path_importer_cache, entonces sys.path_hooks se busca un buscador para la entrada de ruta y, si se encuentra, se almacena en sys.path_importer_cache junto con ser consultado sobre el módulo. Si nunca se encuentra ningún buscador, entonces None se almacena en el caché y se retorna.

Nuevo en la versión 3.4.

Distinto en la versión 3.5: Si el directorio de trabajo actual, representado por una cadena de caracteres vacía, ya no es válido, se retorna``None`` pero no se almacena ningún valor en sys.path_importer_cache.

classmethod find_module(fullname, path=None)

Una envoltura heredada alrededor de find_spec().

Obsoleto desde la versión 3.4: Use find_spec() en su lugar.

classmethod invalidate_caches()

Llama importlib.abc.PathEntryFinder.invalidate_caches() en todos los buscadores almacenados en sys.path_importer_cache que definen el método. De lo contrario, las entradas en sys.path_importer_cache establecidas en None se eliminan.

Distinto en la versión 3.7: Se eliminan las entradas de None en sys.path_importer_cache.

Distinto en la versión 3.4: Llama a objetos en sys.path_hooks con el directorio de trabajo actual para '' (es decir, la cadena de caracteres vacía).

class importlib.machinery.FileFinder(path, *loader_details)

Una implementación concreta de importlib.abc.PathEntryFinder que almacena en caché los resultados del sistema de archivos.

El argumento path es el directorio que el buscador se encarga de buscar.

El argumento loader_details es un número variable de tuplas de 2 elementos, cada una de las cuales contiene un cargador y una secuencia de sufijos de archivo que el cargador reconoce. Se espera que los cargadores sean invocables que acepten dos argumentos del nombre del módulo y la ruta al archivo encontrado.

El buscador almacenará en caché el contenido del directorio según sea necesario, haciendo llamadas estadísticas para cada búsqueda de módulo para verificar que la caché no esté desactualizada. Debido a que la obsolescencia de la caché se basa en la granularidad de la información de estado del sistema operativo del sistema de archivos, existe una condición de carrera potencial de buscar un módulo, crear un nuevo archivo y luego buscar el módulo que representa el nuevo archivo. Si las operaciones ocurren lo suficientemente rápido como para ajustarse a la granularidad de las llamadas estadísticas, la búsqueda del módulo fallará. Para evitar que esto suceda, cuando cree un módulo dinámicamente, asegúrese de llamar a importlib.invalidate_caches().

Nuevo en la versión 3.3.

path

La ruta en la que buscará el buscador.

find_spec(fullname, target=None)

Intente encontrar la especificación para manejar fullname dentro de path.

Nuevo en la versión 3.4.

find_loader(fullname)

Intente encontrar el cargador para manejar fullname dentro de path.

Obsoleto desde la versión 3.10: Use find_spec() en su lugar.

invalidate_caches()

Borrar el caché interno.

classmethod path_hook(*loader_details)

Un método de clase que devuelve un cierre para su uso en sys.path_hooks. Una instancia de FileFinder es retornada por el cierre usando el argumento de ruta dado al cierre directamente y loader_details indirectamente.

Si el argumento del cierre no es un directorio existente, se lanza ImportError.

class importlib.machinery.SourceFileLoader(fullname, path)

Una implementación concreta de importlib.abc.SourceLoader subclasificando importlib.abc.FileLoader y proporcionando algunas implementaciones concretas de otros métodos.

Nuevo en la versión 3.3.

name

El nombre del módulo que manejará este cargador.

path

La ruta al archivo de origen.

is_package(fullname)

Devuelve True si path parece ser para un paquete.

path_stats(path)

Implementación concreta de importlib.abc.SourceLoader.path_stats().

set_data(path, data)

Implementación concreta de importlib.abc.SourceLoader.set_data().

load_module(name=None)

Implementación concreta de importlib.abc.Loader.load_module() donde especificar el nombre del módulo a cargar es opcional.

Obsoleto desde la versión 3.6: Utilice importlib.abc.Loader.exec_module() en su lugar.

class importlib.machinery.SourcelessFileLoader(fullname, path)

Una implementación concreta de importlib.abc.FileLoader que puede importar archivos de código de bytes (es decir, no existen archivos de código fuente).

Tenga en cuenta que el uso directo de archivos de código de bytes (y, por lo tanto, no de archivos de código fuente) impide que sus módulos sean utilizables por todas las implementaciones de Python o las nuevas versiones de Python que cambian el formato de código de bytes.

Nuevo en la versión 3.3.

name

El nombre del módulo que manejará el cargador.

path

La ruta al archivo de código de bytes.

is_package(fullname)

Determina si el módulo es un paquete basado en path.

get_code(fullname)

Retorna el objeto de código para name creado a partir de path.

get_source(fullname)

Devuelve None ya que los archivos de código de bytes no tienen fuente cuando se usa este cargador.

load_module(name=None)

Implementación concreta de importlib.abc.Loader.load_module() donde especificar el nombre del módulo a cargar es opcional.

Obsoleto desde la versión 3.6: Utilice importlib.abc.Loader.exec_module() en su lugar.

class importlib.machinery.ExtensionFileLoader(fullname, path)

Una implementación concreta de importlib.abc.ExecutionLoader para módulos de extensión.

El argumento fullname especifica el nombre del módulo que el cargador debe admitir. El argumento path es la ruta al archivo del módulo de extensión.

Nuevo en la versión 3.3.

name

Nombre del módulo que admite el cargador.

path

Ruta al módulo de extensión.

create_module(spec)

Crea el objeto de módulo a partir de la especificación dada de acuerdo con PEP 489.

Nuevo en la versión 3.5.

exec_module(module)

Inicializa el objeto de módulo dado de acuerdo con PEP 489.

Nuevo en la versión 3.5.

is_package(fullname)

Retorna True si la ruta del archivo apunta al módulo __init__ de un paquete basado en EXTENSION_SUFFIXES.

get_code(fullname)

Retorna None ya que los módulos de extensión carecen de un objeto de código.

get_source(fullname)

Retorna None ya que los módulos de extensión no tienen código fuente.

get_filename(fullname)

Retorna path.

Nuevo en la versión 3.4.

class importlib.machinery.ModuleSpec(name, loader, *, origin=None, loader_state=None, is_package=None)

Una especificación para el estado relacionado con el sistema de importación de un módulo. Esto generalmente se expone como el atributo __spec__ del módulo. En las descripciones siguientes, los nombres entre paréntesis dan el atributo correspondiente disponible directamente en el objeto del módulo, por ejemplo, module.__spec__.origin == module.__file__. Sin embargo, tenga en cuenta que, si bien los values suelen ser equivalentes, pueden diferir ya que no hay sincronización entre los dos objetos. Por lo tanto, es posible actualizar el __path__ del módulo en tiempo de ejecución, y esto no se reflejará automáticamente en __spec__.submodule_search_locations.

Nuevo en la versión 3.4.

name

(__name__)

A string for the fully qualified name of the module.

loader

(__loader__)

El Loader que debe usarse al cargar el módulo. Finders siempre debe establecer esto.

origin

(__file__)

Nombre del lugar desde el que se carga el módulo, por ejemplo «incorporado» (builtin) para los módulos incorporados y el nombre de archivo para los módulos cargados desde la fuente. Normalmente se debe establecer «origen», pero puede ser None (el valor predeterminado), lo que indica que no está especificado (por ejemplo, para paquetes de espacio de nombres).

submodule_search_locations

(__path__)

Lista de cadenas de caracteres de dónde encontrar submódulos, si es un paquete (None de lo contrario).

loader_state

Contenedor de datos adicionales específicos del módulo para usar durante la carga (o None).

cached

(__cached__)

Cadena de caracteres para el lugar donde se debe almacenar el módulo compilado (o 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

Booleano que indica si el atributo «origen» del módulo se refiere a una ubicación cargable.

importlib.util – Código de utilidad para importadores

Código fuente: Lib/importlib/util.py

Este módulo contiene los diversos objetos que ayudan en la construcción de un importer.

importlib.util.MAGIC_NUMBER

Los bytes que representan el número de versión del código de bytes. Si necesita ayuda para cargar/escribir código de bytes, considere importlib.abc.SourceLoader.

Nuevo en la versión 3.4.

importlib.util.cache_from_source(path, debug_override=None, *, optimization=None)

Retorna la ruta PEP 3147/PEP 488 al archivo compilado por bytes asociado con la path de origen. Por ejemplo, si path es /foo/bar/baz.py, el valor de retorno sería /foo/bar/__pycache__/baz.cpython-32.pyc para Python 3.2. La cadena de caracteres cpython-32 proviene de la etiqueta mágica actual (ver get_tag(); si sys.implementation.cache_tag no está definido, se lanzará NotImplementedError).

El parámetro optimization se utiliza para especificar el nivel de optimización del archivo de código de bytes. Una cadena de caracteres vacía no representa optimización, por lo que /foo/bar/baz.py con una optimization de '' dará como resultado una ruta de código de bytes de /foo/bar/__pycache__/baz.cpython-32.pyc. None hace que se utilice el nivel de optimización del intérprete. Se usa la representación de cadena de caracteres de cualquier otro valor, por lo que /foo/bar/baz.py con una optimization de 2 conducirá a la ruta del código de bytes de /foo/bar/__pycache__/baz.cpython-32.opt-2.pyc. La representación de cadena de caracteres optimization solo puede ser alfanumérica, de lo contrario se lanza ValueError.

El parámetro debug_override está obsoleto y se puede usar para anular el valor del sistema para __debug__. Un valor True es el equivalente a establecer optimization en la cadena de caracteres vacía. Un valor False es lo mismo que establecer optimization en 1. Si tanto debug_override como optimization no es None, entonces se lanza TypeError.

Nuevo en la versión 3.4.

Distinto en la versión 3.5: Se agregó el parámetro optimization y el parámetro debug_override quedó obsoleto.

Distinto en la versión 3.6: Acepta un path-like object.

importlib.util.source_from_cache(path)

Dado el path a un nombre de archivo PEP 3147, retorna la ruta del archivo del código fuente asociado. Por ejemplo, si path es /foo/bar/__pycache__/baz.cpython-32.pyc, la ruta retornada sería /foo/bar/baz.py. path no necesita existir, sin embargo, si no se ajusta al formato PEP 3147 o PEP 488, se lanza un ValueError. Si sys.implementation.cache_tag no está definido, se lanza NotImplementedError.

Nuevo en la versión 3.4.

Distinto en la versión 3.6: Acepta un path-like object.

importlib.util.decode_source(source_bytes)

Decodifica los bytes dados que representan el código fuente y los retorna como una cadena de caracteres con nuevas líneas universales (como lo requiere importlib.abc.InspectLoader.get_source()).

Nuevo en la versión 3.4.

importlib.util.resolve_name(name, package)

Resuelve un nombre de módulo relativo a uno absoluto.

Si name no tiene puntos iniciales, entonces name simplemente se retorna. Esto permite el uso como importlib.util.resolve_name('sys', __spec__.parent) sin hacer una verificación para ver si se necesita el argumento package.

ImportError se lanza si name es un nombre de módulo relativo pero package es un valor falso (por ejemplo, None o la cadena de caracteres vacía). También se lanza ImportError un nombre relativo que escaparía del paquete que lo contiene (por ejemplo, solicitando ..bacon desde el paquete spam).

Nuevo en la versión 3.3.

Distinto en la versión 3.9: Para mejorar la coherencia con las declaraciones de importación, aumente ImportError en lugar de ValueError para intentos de importación relativa no válidos.

importlib.util.find_spec(name, package=None)

Busca el spec para un módulo, opcionalmente relativo al nombre del package especificado. Si el módulo está en sys.modules, se retorna sys.modules[name].__spec__ (a menos que la especificación sea None o no esté establecida, en cuyo caso se lanza ValueError). De lo contrario, se realiza una búsqueda utilizando sys.meta_path. Se retorna None si no se encuentra ninguna especificación.

Si name es para un submódulo (contiene un punto), el módulo principal se importa automáticamente.

name y package funcionan igual que para import_module().

Nuevo en la versión 3.4.

Distinto en la versión 3.7: Lanza ModuleNotFoundError en lugar de AttributeError si package no es de hecho un paquete (es decir, carece de un atributo __path__).

importlib.util.module_from_spec(spec)

Cree un nuevo módulo basado en spec y spec.loader.create_module.

Si spec.loader.create_module no retorna None, no se restablecerán los atributos preexistentes. Además, no se lanzará AttributeError si se activa mientras se accede a spec o se establece un atributo en el módulo.

Esta función es preferible a usar types.ModuleType para crear un nuevo módulo ya que spec se usa para establecer tantos atributos de importación controlados en el módulo como sea posible.

Nuevo en la versión 3.5.

@importlib.util.module_for_loader

Un decorator para importlib.abc.Loader.load_module() para manejar la selección del objeto de módulo adecuado para cargar. Se espera que el método decorado tenga una firma de llamada que tome dos argumentos posicionales (por ejemplo, load_module(self, module)) para los cuales el segundo argumento será el módulo object que usará el cargador. Tenga en cuenta que el decorador no funcionará con métodos estáticos debido a la suposición de dos argumentos.

El método decorado tomará el name del módulo que se cargará como se esperaba para un loader. Si el módulo no se encuentra en sys.modules, se construye uno nuevo. Independientemente de la procedencia del módulo, __loader__ se establece en self y __package__ se establece en función de lo que retorna importlib.abc.InspectLoader.is_package() (si está disponible) . Estos atributos se establecen incondicionalmente para admitir la recarga.

Si el método decorado lanza una excepción y se agrega un módulo a sys.modules, entonces el módulo se eliminará para evitar que un módulo parcialmente inicializado quede en sys.modules. Si el módulo ya estaba en sys.modules entonces se deja solo.

Distinto en la versión 3.3: __loader__ y __package__ se configuran automáticamente (cuando es posible).

Distinto en la versión 3.4: Establece __name__, __loader__ __package__ incondicionalmente para apoyar la recarga.

Obsoleto desde la versión 3.4: La maquinaria de importación ahora realiza directamente toda la funcionalidad proporcionada por esta función.

@importlib.util.set_loader

Un decorator para importlib.abc.Loader.load_module() para establecer el atributo __loader__ en el módulo retornado. Si el atributo ya está configurado, el decorador no hace nada. Se asume que el primer argumento posicional del método envuelto (es decir, self) es lo que se debe establecer en __loader__.

Distinto en la versión 3.4: Establece __loader__ si está configurado como None, como si el atributo no existiera.

Obsoleto desde la versión 3.4: La maquinaria de importación se encarga de esto automáticamente.

@importlib.util.set_package

Un decorator para importlib.abc.Loader.load_module() para establecer el atributo __package__ en el módulo retornado. Si __package__ está configurado y tiene un valor diferente a None, no se cambiará.

Obsoleto desde la versión 3.4: La maquinaria de importación se encarga de esto automáticamente.

importlib.util.spec_from_loader(name, loader, *, origin=None, is_package=None)

Una función de fábrica para crear una instancia de ModuleSpec basada en un cargador. Los parámetros tienen el mismo significado que para ModuleSpec. La función utiliza APIs disponibles de loader, tal como InspectLoader.is_package(), para completar cualquier información que falte en la especificación.

Nuevo en la versión 3.4.

importlib.util.spec_from_file_location(name, location, *, loader=None, submodule_search_locations=None)

Una función de fábrica para crear una instancia de ModuleSpec basada en la ruta a un archivo. La información que falte se completará en la especificación mediante el uso de las API de loader y la implicación de que el módulo estará basado en archivos.

Nuevo en la versión 3.4.

Distinto en la versión 3.6: Acepta un path-like object.

importlib.util.source_hash(source_bytes)

Retorna el hash de source_bytes como bytes. Un archivo .pyc basado en hash incrusta source_hash() del contenido del archivo fuente correspondiente en su encabezado.

Nuevo en la versión 3.7.

class importlib.util.LazyLoader(loader)

Una clase que pospone la ejecución del cargador de un módulo hasta que el módulo tiene acceso a un atributo.

Esta clase solo funciona con cargadores que definen exec_module() ya que se requiere control sobre qué tipo de módulo se usa para el módulo. Por esas mismas razones, el método del cargador create_module() debe retornar None o un tipo para el cual su atributo __class__ se puede mutar junto con no usar slots. Finalmente, los módulos que sustituyen el objeto colocado en sys.modules no funcionarán ya que no hay forma de reemplazar correctamente las referencias del módulo en todo el intérprete de forma segura; ValueError se genera si se detecta tal sustitución.

Nota

Para proyectos donde el tiempo de inicio es crítico, esta clase permite minimizar potencialmente el costo de cargar un módulo si nunca se usa. Para proyectos en los que el tiempo de inicio no es esencial, el uso de esta clase se desaconseja en gran medida debido a que los mensajes de error creados durante la carga se posponen y, por lo tanto, ocurren fuera de contexto.

Nuevo en la versión 3.5.

Distinto en la versión 3.6: Comenzó a llamar create_module(), eliminando la advertencia de compatibilidad para importlib.machinery.BuiltinImporter y importlib.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))

Ejemplos

Importar programáticamente

Para importar un módulo mediante programación, use importlib.import_module().

import importlib

itertools = importlib.import_module('itertools')

Comprobando si se puede importar un módulo

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")

Importar un archivo fuente directamente

Para importar un archivo fuente de Python directamente, use la siguiente receta (solo Python 3.5 y más reciente):

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)

Implementar importaciones diferidas

El ejemplo de abajo muestra cómo implementar importaciones diferidas:

>>> 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

Configurar un importador

Para personalizaciones profundas de la importación, normalmente desea implementar un importador. Esto significa administrar tanto el lado finder como loader de las cosas. Para los buscadores, hay dos sabores para elegir según sus necesidades: un meta path finder o un path entry finder. El primero es lo que pondrías en sys.meta_path mientras que el segundo es lo que creas usando un path entry hook en sys.path_hooks que funciona con sys .path entradas para crear potencialmente un buscador. Este ejemplo le mostrará cómo registrar sus propios importadores para que import los utilice (para crear un importador para usted, lea la documentación de las clases apropiadas definidas dentro de este paquete):

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))

Aproximando importlib.import_module()

La importación en sí está implementada en código Python, lo que permite exponer la mayor parte de la maquinaria de importación a través de importlib. Lo siguiente ayuda a ilustrar las diversas API que importlib expone al proporcionar una implementación aproximada de importlib.import_module() (Python 3.4 y más reciente para el uso de importlib, Python 3.6 y más reciente para otras partes del código).

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