5. El sistema de importación
****************************

El código Python en un *módulo* obtiene acceso al código en otro
módulo por el proceso de *importarlo*.  La instrucción "import" es la
forma más común de invocar la maquinaria de importación, pero no es la
única manera.  Funciones como "importlib.import_module()" y built-in
"__import__()" también se pueden utilizar para invocar la maquinaria
de importación.

La instrucción "import" combina dos operaciones; busca el módulo con
nombre y, a continuación, enlaza los resultados de esa búsqueda a un
nombre en el ámbito local.  La operación de búsqueda de la instrucción
"import" se define como una llamada a la función "__import__()", con
los argumentos adecuados. El valor retornado de "__import__()" se
utiliza para realizar la operación de enlace de nombre de la
instrucción "import".  Consulte la instrucción "import" para obtener
los detalles exactos de esa operación de enlace de nombres.

Una llamada directa a "__import__()" realiza solo la búsqueda del
módulo y, si se encuentra, la operación de creación del módulo.
Aunque pueden producirse ciertos efectos secundarios, como la
importación de paquetes primarios y la actualización de varias
memorias caché (incluidas "sys.modules"), solo la instrucción "import"
realiza una operación de enlace de nombres.

Cuando se ejecuta una instrucción "import", se llama a la función
estándar incorporada "__import__()". Otros mecanismos para invocar el
sistema de importación (como "importlib.import_module()") pueden optar
por omitir "__import__()" y utilizar sus propias soluciones para
implementar la semántica de importación.

Cuando se importa un módulo por primera vez, Python busca el módulo y,
si se encuentra, crea un objeto de módulo [1], inicializándolo.  Si no
se encuentra el módulo con nombre, se genera un "ModuleNotFoundError".
Python implementa varias estrategias para buscar el módulo con nombre
cuando se invoca la maquinaria de importación.  Estas estrategias se
pueden modificar y ampliar mediante el uso de varios ganchos descritos
en las secciones siguientes.

Distinto en la versión 3.3: El sistema de importación se ha
actualizado para aplicar plenamente la segunda fase de **PEP 302**. Ya
no hay ninguna maquinaria de importación implícita: todo el sistema de
importación se expone a través de "sys.meta_path". Además, se ha
implementado la compatibilidad con paquetes de espacio de nombres
nativos (consulte **PEP 420**).


5.1. "importlib"
================

El módulo "importlib" proporciona una API enriquecida para interactuar
con el sistema de importación.  Por ejemplo
"importlib.import_module()" proporciona una API recomendada y más
sencilla que la integrada "__import__()" para invocar la maquinaria de
importación.  Consulte la documentación de la biblioteca "importlib"
para obtener más detalles.


5.2. Paquetes
=============

Python sólo tiene un tipo de objeto módulo, y todos los módulos son de
este tipo, independientemente de si el módulo está implementado en
Python, C, o en cualquier otro lenguaje.  Para ayudar a organizar los
módulos y proporcionar una jerarquía de nombres, Python tiene un
concepto de *paquete*.

Puedes pensar en los paquetes como los directorios de un sistema de
archivos y en los módulos como archivos dentro de los directorios,
pero no te tomes esta analogía demasiado literalmente, ya que los
paquetes y los módulos no tienen por qué originarse en el sistema de
archivos.  Para los propósitos de esta documentación, usaremos esta
conveniente analogía de directorios y archivos.  Al igual que los
directorios del sistema de archivos, los paquetes están organizados de
forma jerárquica, y los paquetes pueden contener subpaquetes, así como
módulos regulares.

Es importante tener en cuenta que todos los paquetes son módulos, pero
no todos los módulos son paquetes.  O dicho de otro modo, los paquetes
son sólo un tipo especial de módulo. Específicamente, cualquier módulo
que contenga un atributo "__path__" se considera un paquete.

Todos los módulos tienen un nombre. Los nombres de los subpaquetes
están separados de su nombre de paquete principal por un punto,
similar a la sintaxis de acceso de atributo estándar de Python. Por lo
tanto, podría tener un paquete llamado "email", que a su vez tiene un
subpaquete llamado "email.mime" y un módulo dentro de ese subpaquete
llamado "email.mime.text".


5.2.1. Paquetes regulares
-------------------------

Python define dos tipos de paquetes, *paquetes regulares* y *paquetes
de espacio de nombres*.  Los paquetes regulares son los paquetes
tradicionales tal y como existían en Python 3.2 y anteriores. Un
paquete regular se implementa típicamente como un directorio que
contiene un archivo "init__.py".  Cuando se importa un paquete
regular, este archivo "__init__.py" se ejecuta implícitamente, y los
objetos que define están vinculados a nombres en el espacio de nombres
del paquete.  El archivo "__init__.py" puede contener el mismo código
Python que puede contener cualquier otro módulo, y Python añadirá
algunos atributos adicionales al módulo cuando se importe.

Por ejemplo, la siguiente disposición del sistema de archivos define
un paquete "parent" de nivel superior con tres subpaquetes:

   parent/
       __init__.py
       one/
           __init__.py
       two/
           __init__.py
       three/
           __init__.py

Importando "parent.one" se ejecutará implícitamente
"parent/__init__.py" y "parent/one/__init__.py".  La importación
posterior de "parent.two" o "parent.three" ejecutará
"parent/two/__init__.py" y "parent/three/__init__.py" respectivamente.


5.2.2. Paquetes de espacio de nombres
-------------------------------------

Un paquete de espacio de nombres es un compuesto de varias
*porciones*, donde cada porción contribuye con un subpaquete al
paquete padre.  Las porciones pueden residir en diferentes lugares del
sistema de archivos.  Las porciones también pueden encontrarse en
archivos zip, en la red, o en cualquier otro lugar que Python busque
durante la importación.  Los paquetes de espacios de nombres pueden
corresponder o no directamente a objetos del sistema de archivos;
pueden ser módulos virtuales que no tienen una representación
concreta.

Los paquetes de espacios de nombres no usan una lista ordinaria para
su atributo "__path__". En su lugar utilizan un tipo iterable
personalizado que realizará automáticamente una nueva búsqueda de
porciones de paquete en el siguiente intento de importación dentro de
ese paquete si la ruta de su paquete padre (o "sys.path`" para un
paquete de nivel superior) cambia.

Con los paquetes de espacio de nombres, no hay ningún archivo
"parent/__init__.py".  De hecho, puede haber varios directorios
"padre" encontrados durante la búsqueda de importación, donde cada uno
de ellos es proporcionado por una parte diferente.  Por lo tanto,
"padre/one" no puede estar físicamente situado junto a "padre/two".
En este caso, Python creará un paquete de espacio de nombres para el
paquete "parent" de nivel superior siempre que se importe él o uno de
sus subpaquetes.

Consulte también **PEP 420** para conocer la especificación del
paquete de espacio de nombres.


5.3. Buscando
=============

Para comenzar la búsqueda, Python necesita el nombre *totalmente
calificado* del módulo (o paquete, pero para los fines de esta
discusión, la diferencia es irrelevante) que se está importando.  Este
nombre puede provenir de varios argumentos a la instrucción "import",
o de los parámetros de las funciones "importlib.import_module()" o
"__import__()".

Este nombre se utilizará en varias fases de la búsqueda de
importación, y puede ser la ruta de acceso punteada a un submódulo,
por ejemplo, "foo.bar.baz".  En este caso, Python primero intenta
importar "foo", luego "foo.bar", y finalmente "foo.bar.baz". Si se
produce un error en cualquiera de las importaciones intermedias, se
genera un "ModuleNotFoundError".


5.3.1. La caché del módulo
--------------------------

El primer lugar comprobado durante la búsqueda de importación es
"sys.modules".  Esta asignación sirve como caché de todos los módulos
que se han importado previamente, incluidas las rutas intermedias.
Por lo tanto, si "foo.bar.baz" se importó previamente, "sys.modules"
contendrá entradas para "foo", "foo.bar", y "foo.bar.baz".  Cada clave
tendrá como valor el objeto de módulo correspondiente.

Durante la importación, el nombre del módulo se busca en "sys.modules"
y si está presente, el valor asociado es el módulo que satisface la
importación y el proceso se completa.  Sin embargo, si el valor es
"None", se genera un "ModuleNotFoundError".  Si falta el nombre del
módulo, Python continuará buscando el módulo.

"sys.modules" se puede escribir.  La eliminación de una clave no puede
destruir el módulo asociado (ya que otros módulos pueden contener
referencias a él), pero invalidará la entrada de caché para el módulo
con nombre, lo que hará que Python busque de nuevo el módulo con
nombre en su próxima importación. La clave también se puede asignar a
"None", lo que obliga a la siguiente importación del módulo a dar como
resultado un "ModuleNotFoundError".

Tenga cuidado, sin embargo, como si mantiene una referencia al objeto
module, invalide su entrada de caché en "sys.modules" y, a
continuación, vuelva a importar el módulo con nombre, los dos objetos
de módulo *no* serán los mismos. Por el contrario,
"importlib.reload()" reutilizará el objeto de módulo *same* y
simplemente reinicializará el contenido del módulo volviendo a
ejecutar el código del módulo.


5.3.2. Buscadores y cargadores
------------------------------

Si el módulo con nombre no se encuentra en "sys.modules", se invoca el
protocolo de importación de Python para buscar y cargar el módulo.
Este protocolo consta de dos objetos conceptuales, *buscadores* y
*cargadores*. El trabajo de un buscador es determinar si puede
encontrar el módulo con nombre utilizando cualquier estrategia que
conozca. Los objetos que implementan ambas interfaces se conocen como
*importadores* se retornan a sí mismos cuando descubren que pueden
cargar el módulo solicitado.

Python incluye una serie de buscadores e importadores predeterminados.
El primero sabe cómo localizar módulos integrados, y el segundo sabe
cómo localizar módulos congelados.  Un tercer buscador predeterminado
busca módulos en *import path*.  El *import path* es una lista de
ubicaciones que pueden nombrar rutas del sistema de archivos o
archivos zip.  También se puede ampliar para buscar cualquier recurso
localizable, como los identificados por las direcciones URL.

La maquinaria de importación es extensible, por lo que se pueden
añadir nuevos buscadores para ampliar el alcance y el alcance de la
búsqueda de módulos.

En realidad, los buscadores no cargan módulos.  Si pueden encontrar el
módulo con nombre, retornan un *module spec*, una encapsulación de la
información relacionada con la importación del módulo, que la
maquinaria de importación utiliza al cargar el módulo.

En las secciones siguientes se describe el protocolo para buscadores y
cargadores con más detalle, incluido cómo puede crear y registrar
otros nuevos para ampliar la maquinaria de importación.

Distinto en la versión 3.4: En versiones anteriores de Python, los
buscadores retornaban *cargadores* directamente, mientras que ahora
retornen especificaciones de módulo que *contienen* cargadores. Los
cargadores todavía se utilizan durante la importación, pero tienen
menos responsabilidades.


5.3.3. Ganchos de importación
-----------------------------

La maquinaria de importación está diseñada para ser extensible; el
mecanismo principal para esto son los *ganchos de importación* (import
hooks).  Hay dos tipos de ganchos de importación: *meta hooks* (meta
ganchos) y *import path hooks* (ganchos de ruta de acceso de
importación).

Los meta ganchos se llaman al inicio del procesamiento de importación,
antes de que se haya producido cualquier otro procesamiento de
importación, que no sea búsqueda de caché de "sys.modules". Esto
permite que los metaganchos reemplacen el procesamiento de "sys.path",
módulos congelados o incluso módulos integrados.  Los meta ganchos se
registran agregando nuevos objetos de buscador a "sys.meta_path", como
se describe a continuación.

Los ganchos de ruta de acceso de importación se invocan como parte del
procesamiento "sys.path" (o "package.__path__"), en el punto donde se
encuentra su elemento de ruta de acceso asociado. Los ganchos de ruta
de acceso de importación se registran agregando nuevos invocables a
"sys.path_hooks" como se describe a continuación.


5.3.4. La meta ruta (*path*)
----------------------------

When the named module is not found in "sys.modules", Python next
searches "sys.meta_path", which contains a list of meta path finder
objects.  These finders are queried in order to see if they know how
to handle the named module.  Meta path finders must implement a method
called "find_spec()" which takes three arguments: a name, an import
path, and (optionally) a target module.  The meta path finder can use
any strategy it wants to determine whether it can handle the named
module or not.

Si el buscador de metarutas sabe cómo controlar el módulo con nombre,
retorna un objeto de especificación.  Si no puede controlar el módulo
con nombre, retorna "None".  Si el procesamiento de "sys.meta_path"
llega al final de su lista sin retornar una especificación, se genera
un "ModuleNotFoundError".  Cualquier otra excepción provocada
simplemente se propaga hacia arriba, anulando el proceso de
importación.

The "find_spec()" method of meta path finders is called with two or
three arguments.  The first is the fully qualified name of the module
being imported, for example "foo.bar.baz". The second argument is the
path entries to use for the module search.  For top-level modules, the
second argument is "None", but for submodules or subpackages, the
second argument is the value of the parent package's "__path__"
attribute. If the appropriate "__path__" attribute cannot be accessed,
a "ModuleNotFoundError" is raised.  The third argument is an existing
module object that will be the target of loading later. The import
system passes in a target module only during reload.

La metaruta se puede recorrer varias veces para una sola solicitud de
importación. Por ejemplo, suponiendo que ninguno de los módulos
implicados ya se haya almacenado en caché, la importación de
"foo.bar.baz" realizará primero una importación de nivel superior,
llamando a "mpf.find_spec("foo", None, None)" en cada buscador de
metarutas ("mpf"). Después de importar "foo" , "foo.bar" se importará
atravesando la meta ruta por segunda vez, llamando a
"mpf.find_spec("foo.bar", foo.__path__, None)". Una vez importado
"foo.bar", el recorrido final llamará a "mpf.find_spec("foo.bar.baz",
foo.bar.__path__, None)".

Algunos buscadores de metarutas solo admiten importaciones de nivel
superior. Estos importadores siempre retornarán "None" cuando se pase
algo distinto de "None" como segundo argumento.

El valor predeterminado de Python "sys.meta_path" tiene tres
buscadores de metarutas, uno que sabe cómo importar módulos
integrados, uno que sabe cómo importar módulos congelados y otro que
sabe cómo importar módulos desde un *import path* (es decir, el *path
based finder*).

Distinto en la versión 3.4: The "find_spec()" method of meta path
finders replaced "find_module()", which is now deprecated.  While it
will continue to work without change, the import machinery will try it
only if the finder does not implement "find_spec()".

Distinto en la versión 3.10: Use of "find_module()" by the import
system now raises "ImportWarning".

Distinto en la versión 3.12: "find_module()" has been removed. Use
"find_spec()" instead.


5.4. Cargando
=============

Si se encuentra una especificación de módulo, la maquinaria de
importación la utilizará (y el cargador que contiene) al cargar el
módulo.  Aquí está una aproximación de lo que sucede durante la
porción de carga de la importación:

   module = None
   if spec.loader is not None and hasattr(spec.loader, 'create_module'):
       # It is assumed 'exec_module' will also be defined on the loader.
       module = spec.loader.create_module(spec)
   if module is None:
       module = ModuleType(spec.name)
   # The import-related module attributes get set here:
   _init_module_attrs(spec, module)

   if spec.loader is None:
       # unsupported
       raise ImportError
   if spec.origin is None and spec.submodule_search_locations is not None:
       # namespace package
       sys.modules[spec.name] = module
   elif not hasattr(spec.loader, 'exec_module'):
       module = spec.loader.load_module(spec.name)
   else:
       sys.modules[spec.name] = module
       try:
           spec.loader.exec_module(module)
       except BaseException:
           try:
               del sys.modules[spec.name]
           except KeyError:
               pass
           raise
   return sys.modules[spec.name]

Tenga en cuenta los siguientes detalles:

* Si hay un objeto de módulo existente con el nombre dado en
  "sys.modules", la importación ya lo habrá retornado.

* El módulo existirá en "sys.modules" antes de que el cargador ejecute
  el código del módulo.  Esto es crucial porque el código del módulo
  puede (directa o indirectamente) importarse a sí mismo; agregándolo
  a "sys.modules" de antemano evita la recursividad sin límites en el
  peor de los casos y la carga múltiple en el mejor.

* Si se produce un error en la carga, el módulo con errores -- y solo
  el módulo con errores -- se elimina de "sys.modules".  Cualquier
  módulo que ya esté en la caché de "sys.modules" y cualquier módulo
  que se haya cargado correctamente como efecto secundario, debe
  permanecer en la memoria caché.  Esto contrasta con la recarga donde
  incluso el módulo que falla se deja en "sys.modules".

* Después de crear el módulo pero antes de la ejecución, la maquinaria
  de importación establece los atributos del módulo relacionados con
  la importación ("_init_module_attrs" en el ejemplo de pseudocódigo
  anterior), como se resume en una sección posterior.

* La ejecución del módulo es el momento clave de la carga en el que se
  rellena el espacio de nombres del módulo.  La ejecución se delega
  por completo en el cargador, lo que llega a decidir qué se rellena y
  cómo.

* El módulo creado durante la carga y pasado a exec_module() puede no
  ser el que se retorna al final de la importación [2].

Distinto en la versión 3.4: El sistema de importación se ha hecho
cargo de las responsabilidades reutilizables de los cargadores.  Estos
fueron realizados previamente por el método
"importlib.abc.Loader.load_module()".


5.4.1. Cargadores
-----------------

Los cargadores de módulos proporcionan la función crítica de carga:
ejecución del módulo. La maquinaria de importación llama al método
"importlib.abc.Loader.exec_module()" con un único argumento, el objeto
module que se va a ejecutar.  Se omite cualquier valor retornado de
"exec_module()".

Los cargadores deben cumplir los siguientes requisitos:

* Si el módulo es un módulo Python (a diferencia de un módulo
  integrado o una extensión cargada dinámicamente), el cargador debe
  ejecutar el código del módulo en el espacio de nombres global del
  módulo ("module.__dict__").

* Si el cargador no puede ejecutar el módulo, debe generar un
  "ImportError", aunque se propagará cualquier otra excepción
  provocada durante "exec_module()".

En muchos casos, el buscador y el cargador pueden ser el mismo objeto;
en tales casos, el método "find_spec()" simplemente retornaría una
especificación con el cargador establecido en "self".

Los cargadores de módulos pueden optar por crear el objeto de módulo
durante la carga mediante la implementación de un método
"create_module()". Toma un argumento, la especificación del módulo, y
retorna el nuevo objeto de módulo que se usará durante la carga.
"create_module()" no necesita establecer ningún atributo en el objeto
module.  Si el método retorna "None", la maquinaria de importación
creará el nuevo módulo en sí.

Added in version 3.4: El método de cargadores "create_module()".

Distinto en la versión 3.4: El método "load_module()" fue reemplazado
por "exec_module()" y la maquinaria de importación asumió todas las
responsabilidades reutilizables de la carga.Para la compatibilidad con
los cargadores existentes, la maquinaria de importación utilizará el
método de cargadores "load_module()" si existe y el cargador no
implementa también "exec_module()".  Sin embargo, "load_module()" ha
quedado obsoleto y los cargadores deben implementar "exec_module()" en
su lugar.El método "load_module()" debe implementar toda la
funcionalidad de carga reutilizable descrita anteriormente, además de
ejecutar el módulo.  Se aplican todas las mismas restricciones, con
algunas aclaraciones adicionales:

* Si hay un objeto de módulo existente con el nombre dado en
  "sys.modules", el cargador debe utilizar ese módulo existente. (De
  lo contrario, "importlib.reload()" no funcionará correctamente.)  Si
  el módulo con nombre no existe en "sys.modules", el cargador debe
  crear un nuevo objeto de módulo y agregarlo a "sys.modules".

* El módulo *debe* existir en "sys.modules" antes de que el cargador
  ejecute el código del módulo, para evitar la recursividad sin
  límites o la carga múltiple.

* Si se produce un error en la carga, el cargador debe quitar los
  módulos que ha insertado en "sys.modules", pero debe quitar **solo**
  los módulos con errores, y solo si el propio cargador ha cargado los
  módulos explícitamente.

Distinto en la versión 3.5: A "DeprecationWarning" se genera cuando se
define "exec_module()" pero "create_module()" no lo es.

Distinto en la versión 3.6: Un "ImportError" se genera cuando
"exec_module()" está definido, pero "create_module()" no lo es.

Distinto en la versión 3.10: El uso de "load_module()" lanzará
"ImportWarning".


5.4.2. Submódulos
-----------------

Cuando se carga un submódulo mediante cualquier mecanismo (por
ejemplo, API "importlib", las instrucciones "import" o "import-from",
o "__import__()") integradas, se coloca un enlace en el espacio de
nombres del módulo primario al objeto submodule. Por ejemplo, si el
paquete "spam" tiene un submódulo "foo", después de importar
"spam.foo", "spam" tendrá un atributo "foo" que está enlazado al
submódulo.  Supongamos que tiene la siguiente estructura de
directorios:

   spam/
       __init__.py
       foo.py

y "spam/__init__.py" tiene la siguiente línea:

   from .foo import Foo

a continuación, la ejecución de lo siguiente pone un nombre vinculante
para "foo" y "Foo" en el módulo "spam":

   >>> import spam
   >>> spam.foo
   <module 'spam.foo' from '/tmp/imports/spam/foo.py'>
   >>> spam.Foo
   <class 'spam.foo.Foo'>

Dadas las reglas de enlace de nombres familiares de Python, esto puede
parecer sorprendente, pero en realidad es una característica
fundamental del sistema de importación.  La retención invariable es
que si tiene "sys.modules[`spam`]" y "sys.modules[`spam.foo`]" (como
lo haría después de la importación anterior), este último debe
aparecer como el atributo "foo" de la primera.


5.4.3. Module specs
-------------------

La maquinaria de importación utiliza una variedad de información sobre
cada módulo durante la importación, especialmente antes de la carga.
La mayor parte de la información es común a todos los módulos.  El
propósito de las especificaciones de un módulo es encapsular esta
información relacionada con la importación por módulo.

El uso de una especificación durante la importación permite transferir
el estado entre los componentes del sistema de importación, por
ejemplo, entre el buscador que crea la especificación del módulo y el
cargador que la ejecuta.  Lo más importante es que permite a la
maquinaria de importación realizar las operaciones de caldera de
carga, mientras que sin una especificación de módulo el cargador tenía
esa responsabilidad.

The module's spec is exposed as "module.__spec__". Setting "__spec__"
appropriately applies equally to modules initialized during
interpreter startup. The one exception is "__main__", where "__spec__"
is set to None in some cases.

See "ModuleSpec" for details on the contents of the module spec.

Added in version 3.4.


5.4.4. __path__ attributes on modules
-------------------------------------

The "__path__" attribute should be a (possibly empty) *sequence* of
strings enumerating the locations where the package's submodules will
be found. By definition, if a module has a "__path__" attribute, it is
a *package*.

A package's "__path__" attribute is used during imports of its
subpackages. Within the import machinery, it functions much the same
as "sys.path", i.e. providing a list of locations to search for
modules during import. However, "__path__" is typically much more
constrained than "sys.path".

The same rules used for "sys.path" also apply to a package's
"__path__". "sys.path_hooks" (described below) are consulted when
traversing a package's "__path__".

A package's "__init__.py" file may set or alter the package's
"__path__" attribute, and this was typically the way namespace
packages were implemented prior to **PEP 420**.  With the adoption of
**PEP 420**, namespace packages no longer need to supply "__init__.py"
files containing only "__path__" manipulation code; the import
machinery automatically sets "__path__" correctly for the namespace
package.


5.4.5. Representación (*Reprs*) de módulos
------------------------------------------

De forma predeterminada, todos los módulos tienen un repr utilizable,
sin embargo, dependiendo de los atributos establecidos anteriormente,
y en las especificaciones del módulo, puede controlar más
explícitamente el repr de los objetos de módulo.

Si el módulo tiene una especificación ("__spec__"), la maquinaria de
importación intentará generar un repr a partir de él.  Si eso falla o
no hay ninguna especificación, el sistema de importación creará un
repr predeterminado usando cualquier información disponible en el
módulo.  Intentará utilizar el "module.__name__", "module.__file__" y
"module.__loader__" como entrada en el repr, con valores
predeterminados para cualquier información que falte.

Aquí están las reglas exactas utilizadas:

* Si el módulo tiene un atributo "__spec__", la información de la
  especificación se utiliza para generar el repr.  Se consultan los
  atributos "name", "loader", "origin" y "has_location".

* Si el módulo tiene un atributo "__file__", se utiliza como parte del
  repr del módulo.

* Si el módulo no tiene "__file__" pero tiene un "__loader__" que no
  es "None", entonces el repr del cargador se utiliza como parte del
  repr del módulo.

* De lo contrario, sólo tiene que utilizar el "__name__" del módulo en
  el repr.

Distinto en la versión 3.12: El uso de "module_repr()", al ser
obsoleto desde Python 3.4, fue eliminado en Python 3.12 y no es
llamado durante la resolución de la representación (repr) de un
módulo.


5.4.6. Invalidación del código de bytes en caché
------------------------------------------------

Antes de que Python cargue el código de bytes en caché de un archivo
".pyc", verifica si el caché está actualizado con el archivo ".py" de
origen. De forma predeterminada, Python hace esto almacenando la marca
de tiempo y el tamaño de la última modificación de la fuente en el
archivo de caché al escribirlo. En tiempo de ejecución, el sistema de
importación valida el archivo de caché comprobando los metadatos
almacenados en el archivo de caché con los metadatos de la fuente.

Python también admite archivos de caché "basados en hash", que
almacenan un hash del contenido del archivo de origen en lugar de sus
metadatos. Hay dos variantes de archivos ".pyc" basados en hash:
marcados y desmarcados. Para los archivos ".pyc" marcados basados en
hash, Python valida el archivo de caché mediante el hash del archivo
de origen y la comparación del hash resultante con el hash en el
archivo de caché. Si se encuentra que un archivo de caché basado en
hash comprobado no es válido, Python lo regenera y escribe un nuevo
archivo de caché basado en hash comprobado. Para los archivos ".pyc"
sin marcar en hash, Python simplemente asume que el archivo de caché
es válido si existe. El comportamiento de validación de archivos
basado en hash ".pyc" se puede invalidar con el indicador "--check-
hash-based-pycs".

Distinto en la versión 3.7: Se han añadido archivos ".pyc" basados en
hash. Anteriormente, Python solo admitía la invalidación basada en la
marca de tiempo de la caché del código de bytes.


5.5. El buscador basado en rutas
================================

Como se mencionó anteriormente, Python viene con varios buscadores de
meta rutas predeterminados. Uno de ellos, llamado el buscador *path
based finder* ("PathFinder"), busca una *import path*, que contiene
una lista de *entradas de ruta*. Cada entrada de ruta de acceso nombra
una ubicación para buscar módulos.

El buscador basado en rutas en sí no sabe cómo importar nada. En su
lugar, atraviesa las entradas de ruta individuales, asociando cada una
de ellas con un buscador de entrada de ruta que sabe cómo manejar ese
tipo particular de ruta de acceso.

El conjunto predeterminado de buscadores de entradas de ruta
implementa toda la semántica para encontrar módulos en el sistema de
archivos, controlando tipos de archivos especiales como el código
fuente de Python (archivos "`.py"), el código de bytes de Python
(archivos ".pyc") y las bibliotecas compartidas (por ejemplo, archivos
".so`"). Cuando es compatible con el módulo "zipimport" en la
biblioteca estándar, los buscadores de entradas de ruta de acceso
predeterminados también controlan la carga de todos estos tipos de
archivo (excepto las bibliotecas compartidas) desde zipfiles.

Las entradas de ruta de acceso no deben limitarse a las ubicaciones
del sistema de archivos.  Pueden hacer referencia a direcciones URL,
consultas de base de datos o cualquier otra ubicación que se pueda
especificar como una cadena.

El buscador basado en rutas proporciona enlaces y protocolos
adicionales para que pueda ampliar y personalizar los tipos de
entradas de ruta de acceso que se pueden buscar.  Por ejemplo, si
desea admitir entradas de ruta de acceso como direcciones URL de red,
podría escribir un enlace que implemente la semántica HTTP para buscar
módulos en la web.  Este gancho (un al que se puede llamar) retornaría
un *path entry finder* compatible con el protocolo descrito a
continuación, que luego se utilizó para obtener un cargador para el
módulo de la web.

Una palabra de advertencia: esta sección y la anterior utilizan el
término *finder*, distinguiendo entre ellos utilizando los términos
*meta path finder* y *path entry finder*.  Estos dos tipos de
buscadores son muy similares, admiten protocolos similares y funcionan
de maneras similares durante el proceso de importación, pero es
importante tener en cuenta que son sutilmente diferentes. En
particular, los buscadores de meta path operan al principio del
proceso de importación, como se indica en el recorrido
"sys.meta_path".

Por el contrario, los buscadores de entradas de ruta son en cierto
sentido un detalle de implementación del buscador basado en rutas y,
de hecho, si el buscador basado en rutas se eliminara de
"sys.meta_path", no se invocaría ninguna semántica del buscador de
entradas de ruta.


5.5.1. Buscadores de entradas de ruta
-------------------------------------

El *path based finder* es responsable de encontrar y cargar módulos y
paquetes de Python cuya ubicación se especifica con una cadena *path
entry*.  La mayoría de las ubicaciones de nombres de entradas de ruta
de acceso en el sistema de archivos, pero no es necesario limitarlas a
esto.

Como buscador de meta rutas, el buscador *path based finder*
implementa el protocolo "find_spec()" descrito anteriormente, sin
embargo, expone enlaces adicionales que se pueden usar para
personalizar cómo se encuentran y cargan los módulos desde la ruta
*import path*.

Tres variables son usadas por *path based finder*, "sys.path",
"sys.path_hooks" y "sys.path_importer_cache".  También se utilizan los
atributos "__path__" en los objetos de paquete.  Estos proporcionan
formas adicionales de personalizar la maquinaria de importación.

"sys.path" contains a list of strings providing search locations for
modules and packages.  It is initialized from the "PYTHONPATH"
environment variable and various other installation- and
implementation-specific defaults.  Entries in "sys.path" can name
directories on the file system, zip files, and potentially other
"locations" (see the "site" module) that should be searched for
modules, such as URLs, or database queries.  Only strings should be
present on "sys.path"; all other data types are ignored.

El buscador *path based finder* es un *meta path finder*, por lo que
la maquinaria de importación comienza la búsqueda *import path*
llamando al método "find_spec()" basado en la ruta de acceso, tal como
se describió anteriormente.  Cuando se proporciona el argumento "path"
a "find_spec()", será una lista de rutas de acceso de cadena para
recorrer - normalmente el atributo "__path__" de un paquete para una
importación dentro de ese paquete.  Si el argumento "path" es "None",
esto indica una importación de nivel superior y se utiliza "sys.path".

The path based finder iterates over every entry in the search path,
and for each of these, looks for an appropriate *path entry finder*
("PathEntryFinder") for the path entry.  Because this can be an
expensive operation (e.g. there may be "stat()" call overheads for
this search), the path based finder maintains a cache mapping path
entries to path entry finders.  This cache is maintained in
"sys.path_importer_cache" (despite the name, this cache actually
stores finder objects rather than being limited to *importer*
objects). In this way, the expensive search for a particular *path
entry* location's *path entry finder* need only be done once.  User
code is free to remove cache entries from "sys.path_importer_cache"
forcing the path based finder to perform the path entry search again.

Si la entrada de ruta de acceso no está presente en la memoria caché,
el buscador basado en rutas de acceso recorre en iteración cada
llamada que se puede llamar en "sys.path_hooks".  Cada uno de los
enlaces de *ganchos de rutas de entrada* en esta lista se llama con un
solo argumento, la entrada de ruta de acceso que se va a buscar.  Esta
invocable puede retornar un *path entry finder* que puede controlar la
entrada de ruta de acceso, o puede generar "ImportError".  Un
"ImportError" es utilizado por el buscador basado en ruta para indicar
que el gancho no puede encontrar un *path entry finder* para eso
*entrada de ruta*.  Se omite la excepción y la iteración *import path*
continúa.  El enlace debe esperar un objeto de rutas o bytes; la
codificación de objetos bytes está hasta el enlace (por ejemplo, puede
ser una codificación del sistema de archivos, UTF-8, o algo más), y si
el gancho no puede decodificar el argumento, debe generar
"ImportError".

Si la iteración "sys.path_hooks" termina sin que se retorne ningún
valor *path entry finder*, a continuación, el método de búsqueda
basado en la ruta de acceso "find_spec()" almacenará "None" en
"sys.path_importer_cache" (para indicar que no hay ningún buscador
para esta entrada de ruta) y retornará "None", lo que indica que este
*meta path finder* no pudo encontrar el módulo.

Si un *path entry finder* *is* retornado por uno de los *path entry
hook* invocables en "sys.path_hooks", entonces el siguiente protocolo
se utiliza para pedir al buscador una especificación de módulo, que
luego se utiliza al cargar el módulo.

El directorio de trabajo actual, denotado por una cadena vacía, se
controla de forma ligeramente diferente de otras entradas de
"sys.path". En primer lugar, si se encuentra que el directorio de
trabajo actual no existe, no se almacena ningún valor en
"sys.path_importer_cache". En segundo lugar, el valor del directorio
de trabajo actual se busca actualizado para cada búsqueda de módulo.
En tercer lugar, la ruta de acceso utilizada para
"sys.path_importer_cache" y retornada por
"importlib.machinery.PathFinder.find_spec()" será el directorio de
trabajo actual real y no la cadena vacía.


5.5.2. Buscadores de entradas de ruta
-------------------------------------

Para admitir las importaciones de módulos y paquetes inicializados y
también para contribuir con partes a paquetes de espacio de nombres,
los buscadores de entradas de ruta de acceso deben implementar el
método "importlib.abc.PathEntryFinder.find_spec()".

"importlib.abc.PathEntryFinder.find_spec`()" toma dos argumentos: el
nombre completo del módulo que se va a importar y el módulo de destino
(opcional).  "find_spec()" retorna una especificación completamente
poblada para el módulo. Esta especificación siempre tendrá "cargador"
establecido (con una excepción).

To indicate to the import machinery that the spec represents a
namespace *portion*, the path entry finder sets
"submodule_search_locations" to a list containing the portion.

Distinto en la versión 3.4: "find_spec()" replaced "find_loader()" and
"find_module()", both of which are now deprecated, but will be used if
"find_spec()" is not defined.Los buscadores de entradas de ruta más
antiguos pueden implementar uno de estos dos métodos en desuso en
lugar de "find_spec()".  Los métodos todavía se respetan en aras de la
compatibilidad con versiones anteriores.  Sin embargo, si
"find_spec()" se implementa en el buscador de entrada de ruta, se
omiten los métodos heredados."find_loader()" takes one argument, the
fully qualified name of the module being imported.  "find_loader()"
returns a 2-tuple where the first item is the loader and the second
item is a namespace *portion*.Para la compatibilidad con versiones
anteriores con otras implementaciones del protocolo de importación,
muchos buscadores de entradas de ruta de acceso también admiten el
mismo método tradicional "find_module()" que admiten los buscadores de
rutas de acceso meta. Sin embargo, nunca se llama a los métodos del
buscador de entradas de ruta "find_module()" con un argumento "path"
(se espera que registren la información de ruta adecuada desde la
llamada inicial al enlace de ruta).El método "find_module()" en los
buscadores de entrada de ruta está en desuso, ya que no permite que el
buscador de entradas de ruta de acceso aporte partes a paquetes de
espacio de nombres.  Si existen tanto "find_loader()" como
"find_module()" en un buscador de entrada de ruta, el sistema de
importación siempre llamará a "find_loader()" en lugar de
"find_module()".

Distinto en la versión 3.10: Calls to "find_module()" and
"find_loader()" by the import system will raise "ImportWarning".

Distinto en la versión 3.12: Los métodos "find_module()" y
"find_loader()" fueron eliminados.


5.6. Reemplazando el sistema de importación estándar
====================================================

El mecanismo más confiable para reemplazar todo el sistema de
importación es eliminar el contenido predeterminado de
"sys.meta_path", sustituyéndolos por completo por un enlace de meta
path personalizado.

Si es aceptable alterar únicamente el comportamiento de las
declaraciones de importación sin afectar a otras API que acceden al
sistema de importación, puede ser suficiente reemplazar la función
incorporada "__import__()". Esta técnica también puede emplearse a
nivel de módulo para alterar únicamente el comportamiento de las
declaraciones de importación dentro de ese módulo.

Para evitar selectivamente la importación de algunos módulos de un
enlace al principio de la meta path (en lugar de deshabilitar
completamente el sistema de importación estándar), es suficiente
elevar "ModuleNotFoundError" directamente desde "find_spec()" en lugar
de retornar "None". Este último indica que la búsqueda de meta path
debe continuar, mientras que la generación de una excepción termina
inmediatamente.


5.7. Paquete Importaciones relativas
====================================

Las importaciones relativas utilizan puntos iniciales. Un único punto
inicial indica una importación relativa, empezando por el paquete
actual. Dos o más puntos iniciales indican una importación relativa a
los elementos primarios del paquete actual, un nivel por punto después
del primero. Por ejemplo, dado el siguiente diseño de paquete:

   package/
       __init__.py
       subpackage1/
           __init__.py
           moduleX.py
           moduleY.py
       subpackage2/
           __init__.py
           moduleZ.py
       moduleA.py

En "subpackage1/moduleX.py" o "subpackage1/__init__.py", las
siguientes son importaciones relativas válidas:

   from .moduleY import spam
   from .moduleY import spam as ham
   from . import moduleY
   from ..subpackage1 import moduleY
   from ..subpackage2.moduleZ import eggs
   from ..moduleA import foo

Las importaciones absolutas pueden utilizar la sintaxis "import <>" o
"from <> import <>", pero las importaciones relativas solo pueden usar
el segundo formulario; la razón de esto es que:

   import XXX.YYY.ZZZ

debe exponer "XXX. Yyy. ZZZ" como una expresión utilizable, pero
.moduleY no es una expresión válida.


5.8. Consideraciones especiales para __main__
=============================================

El módulo "__main__" es un caso especial relativo al sistema de
importación de Python. Como se señaló elsewhere, el módulo "__main__"
se inicializa directamente al inicio del intérprete, al igual que
"sys" y "builtins". Sin embargo, a diferencia de esos dos, no califica
estrictamente como un módulo integrado. Esto se debe a que la forma en
que se inicializa "__main__" depende de las marcas y otras opciones
con las que se invoca el intérprete.


5.8.1. __main__.__spec__
------------------------

Dependiendo de cómo se inicializa "__main__", "__main__.__spec__" se
establece correctamente o en "None".

Cuando Python se inicia con la opción "-m", "__spec__" se establece en
la especificación de módulo del módulo o paquete correspondiente.
"__spec__" también se rellena cuando el módulo "__main__" se carga
como parte de la ejecución de un directorio, zipfile u otro "sys.path"
entrada.

En los casos restantes "__main__.__spec__" se establece en "None", ya
que el código utilizado para rellenar el "__main__" no se corresponde
directamente con un módulo importable:

* mensaje interactivo

* opción "-c"

* ejecutando desde stdin

* que se ejecuta directamente desde un archivo de código fuente o de
  código de bytes

Tenga en cuenta que "__main__.__spec__" siempre es "None" en el último
caso, *incluso si* el archivo técnicamente podría importarse
directamente como un módulo en su lugar. Utilice el modificador "-m"
si se desean metadatos de módulo válidos en "__main__".

Tenga en cuenta también que incluso cuando "__main__" corresponde a un
módulo importable y "__main__.__spec__" se establece en consecuencia,
todavía se consideran módulos *distinct*. Esto se debe al hecho de que
los bloques protegidos por las comprobaciones "if __name__ ==
"__main__":" solo se ejecutan cuando el módulo se utiliza para
rellenar el espacio de nombres "__main__", y no durante la importación
normal.


5.9. Referencias
================

La maquinaria de importación ha evolucionado considerablemente desde
los primeros días de Python.  La especificación original para paquetes
todavía está disponible para leer, aunque algunos detalles han
cambiado desde la escritura de ese documento.

La especificación original de "sys.meta_path" era **PEP 302**, con
posterior extensión en **PEP 420**.

**PEP 420** introduced *namespace packages* for Python 3.3.  **PEP
420** also introduced the "find_loader()" protocol as an alternative
to "find_module()".

**PEP 366** describe la adición del atributo "__package__" para las
importaciones relativas explícitas en los módulos principales.

**PEP 328** introdujo importaciones relativas absolutas y explícitas e
inicialmente propuestas "__name__" para la semántica **PEP 366**
eventualmente especificaría para "__package__".

**PEP 338** define la ejecución de módulos como scripts.

**PEP 451** agrega la encapsulación del estado de importación por
módulo en los objetos de especificación. También descargara la mayoría
de las responsabilidades de los cargadores en la maquinaria de
importación. Estos cambios permiten el desuso de varias API en el
sistema de importación y también la adición de nuevos métodos a los
buscadores y cargadores.

-[ Notas al Pie de Pagina ]-

[1] Véase "types. ModuleType".

[2] La implementación de importlib evita usar el valor retornado
    directamente. En su lugar, obtiene el objeto module buscando el
    nombre del módulo en "sys.modules".  El efecto indirecto de esto
    es que un módulo importado puede sustituirse a sí mismo en
    "sys.modules".  Este es un comportamiento específico de la
    implementación que no se garantiza que funcione en otras
    implementaciones de Python.
