¿Cómo cargar todos los módulos en una carpeta?

¿Podría alguien proporcionarme una buena manera de importar un directorio completo de módulos?
Tengo una estructura como esta:

/Foo
    bar.py
    spam.py
    eggs.py

Traté de convertirlo en un paquete agregando __init__.pyy haciendo, from Foo import *pero no funcionó de la manera que esperaba.

Enumere todos los .pyarchivos python ( ) en la carpeta actual y colóquelos como __all__variables en__init__.py

from os.path import dirname, basename, isfile, join
import glob
modules = glob.glob(join(dirname(__file__), "*.py"))
__all__ = [ basename(f)[:-3] for f in modules if isfile(f) and not f.endswith('__init__.py')]

Agregue la __all__variable a __init__.pycontener:

__all__ = ["bar", "spam", "eggs"]

Ver también http://docs.python.org/tutorial/modules.html

Actualización en 2017: probablemente quieras usar importliben su lugar.

Haga que el directorio de Foo sea un paquete agregando un __init__.py. En ese __init__.pycomplemento:

import bar
import eggs
import spam

Como lo desea dinámico (que puede o no ser una buena idea), enumere todos los archivos py con directorio dir e impórtelos con algo como esto:

import os
for module in os.listdir(os.path.dirname(__file__)):
    if module == '__init__.py' or module[-3:] != '.py':
        continue
    __import__(module[:-3], locals(), globals())
del module

Luego, desde su código, haga esto:

import Foo

Ahora puede acceder a los módulos con

Foo.bar
Foo.eggs
Foo.spam

etc. from Foo import *no es una buena idea por varias razones, incluidos los conflictos de nombres y la dificultad de analizar el código.

Ampliando la respuesta de Mihail, creo que la forma no hack (como no manejar las rutas de archivo directamente) es la siguiente:

1. crear un __init__.pyarchivo vacío debajoFoo/
2. Ejecutar

import pkgutil
import sys


def load_all_modules_from_dir(dirname):
    for importer, package_name, _ in pkgutil.iter_modules([dirname]):
        full_package_name = '%s.%s' % (dirname, package_name)
        if full_package_name not in sys.modules:
            module = importer.find_module(package_name
                        ).load_module(full_package_name)
            print module


load_all_modules_from_dir('Foo')

Obtendrás:

<module 'Foo.bar' from '/home/.../Foo/bar.pyc'>
<module 'Foo.spam' from '/home/.../Foo/spam.pyc'>

Python, incluye todos los archivos en un directorio:

Para los novatos que simplemente no pueden hacer que funcione, que necesitan que lo agarren de la mano.

1. Cree una carpeta / home / el / foo y cree un archivo main.pyen / home / el / foo. Coloque este código allí:

   from hellokitty import *
   spam.spamfunc()
   ham.hamfunc()
   

2. Hacer un directorio /home/el/foo/hellokitty

3. Haga un archivo __init__.pydebajo /home/el/foo/hellokittyy ponga este código allí:

   __all__ = ["spam", "ham"]

4. Hacer dos archivos de python: spam.pyy ham.pydebajo/home/el/foo/hellokitty

5. Defina una función dentro de spam.py:

   def spamfunc():
     print("Spammity spam")
   

6. Defina una función dentro de ham.py:

   def hamfunc():
     print("Upgrade from baloney")
   

7. Ejecutarlo:

   el@apollo:/home/el/foo$ python main.py 
   spammity spam
   Upgrade from baloney
   

Me cansé de este problema yo mismo, así que escribí un paquete llamado automodinit para solucionarlo. Puede obtenerlo en http://pypi.python.org/pypi/automodinit/ .

El uso es así:

1. Incluya el automodinitpaquete en sus setup.pydependencias.
2. Reemplace todos los archivos __init__.py como este:

__all__ = ["Me volverán a escribir"]
# ¡No modifique la línea de arriba, o esta línea!
importar automodinit
automodinit.automodinit (__ name__, __file__, globals ())
del automodinit
# Cualquier otra cosa que desee puede ir aquí, no se modificará.

¡Eso es! A partir de ahora, la importación de un módulo establecerá __todos__ en una lista de archivos .py [co] en el módulo y también importará cada uno de esos archivos como si hubiera escrito:

for x in __all__: import x

Por lo tanto, el efecto de "from M import *" coincide exactamente con "import M".

automodinit es feliz corriendo desde dentro de archivos ZIP y, por lo tanto, es seguro para ZIP.

Niall

Sé que estoy actualizando una publicación bastante antigua, e intenté usarla automodinit, pero descubrí que su proceso de configuración está roto para python3. Entonces, según la respuesta de Luca, se me ocurrió una respuesta más simple, que podría no funcionar con .zip, para este problema, así que pensé que debería compartirlo aquí:

dentro del __init__.pymódulo de yourpackage:

#!/usr/bin/env python
import os, pkgutil
__all__ = list(module for _, module, _ in pkgutil.iter_modules([os.path.dirname(__file__)]))

y dentro de otro paquete a continuación yourpackage:

from yourpackage import *

Luego tendrá todos los módulos que se colocan dentro del paquete cargado, y si escribe un nuevo módulo, también se importará automáticamente. Por supuesto, use ese tipo de cosas con cuidado, con grandes poderes conlleva grandes responsabilidades.

import pkgutil
__path__ = pkgutil.extend_path(__path__, __name__)
for imp, module, ispackage in pkgutil.walk_packages(path=__path__, prefix=__name__+'.'):
  __import__(module)

También me encontré con este problema y esta fue mi solución:

import os

def loadImports(path):
    files = os.listdir(path)
    imps = []

    for i in range(len(files)):
        name = files[i].split('.')
        if len(name) > 1:
            if name[1] == 'py' and name[0] != '__init__':
               name = name[0]
               imps.append(name)

    file = open(path+'__init__.py','w')

    toWrite = '__all__ = '+str(imps)

    file.write(toWrite)
    file.close()

Esta función crea un archivo (en la carpeta proporcionada) llamado __init__.py, que contiene una __all__variable que contiene cada módulo en la carpeta.

Por ejemplo, tengo una carpeta llamada Test que contiene:

Foo.py
Bar.py

Entonces, en el script que quiero que se importen los módulos, escribiré:

loadImports('Test/')
from Test import *

Esto importará todo Testy el __init__.pyarchivo Testahora contendrá:

__all__ = ['Foo','Bar']

El ejemplo de Anurag con un par de correcciones:

import os, glob

modules = glob.glob(os.path.join(os.path.dirname(__file__), "*.py"))
__all__ = [os.path.basename(f)[:-3] for f in modules if not f.endswith("__init__.py")]

¡Respuesta de Anurag Uniyal con mejoras sugeridas!

#!/usr/bin/python
# -*- encoding: utf-8 -*-

import os
import glob

all_list = list()
for f in glob.glob(os.path.dirname(__file__)+"/*.py"):
    if os.path.isfile(f) and not os.path.basename(f).startswith('_'):
        all_list.append(os.path.basename(f)[:-3])

__all__ = all_list  

Ver que tu __init__.pydefine __all__. Los módulos - paquetes doc dice

Los __init__.pyarchivos son necesarios para hacer que Python trate los directorios como paquetes que contienen; Esto se hace para evitar que los directorios con un nombre común, como cadena, oculten involuntariamente módulos válidos que se producen más adelante en la ruta de búsqueda del módulo. En el caso más simple, __init__.pypuede ser un archivo vacío, pero también puede ejecutar el código de inicialización del paquete o establecer la __all__variable, que se describe más adelante.

...

La única solución es que el autor del paquete proporcione un índice explícito del paquete. La declaración de importación utiliza la siguiente convención: si el __init__.pycódigo de un paquete define una lista nombrada __all__, se considera que es la lista de nombres de módulos que deben importarse cuando se encuentra desde la importación del paquete *. Depende del autor del paquete mantener esta lista actualizada cuando se lance una nueva versión del paquete. Los autores de paquetes también pueden decidir no admitirlo, si no ven un uso para importar * desde su paquete. Por ejemplo, el archivo sounds/effects/__init__.pypodría contener el siguiente código:

__all__ = ["echo", "surround", "reverse"]

Esto significaría que from sound.effects import *importaría los tres submódulos nombrados del paquete de sonido.

Esta es la mejor manera que he encontrado hasta ahora:

from os.path import dirname, join, isdir, abspath, basename
from glob import glob
pwd = dirname(__file__)
for x in glob(join(pwd, '*.py')):
    if not x.startswith('__'):
        __import__(basename(x)[:-3], globals(), locals())

Usar importliblo único que tienes que agregar es

from importlib import import_module
from pathlib import Path

__all__ = [
    import_module(f".{f.stem}", __package__)
    for f in Path(__file__).parent.glob("*.py")
    if "__" not in f.stem
]
del import_module, Path

Mire el módulo pkgutil de la biblioteca estándar. Le permitirá hacer exactamente lo que quiera siempre que tenga un __init__.pyarchivo en el directorio. El __init__.pyarchivo puede estar vacío.

He creado un módulo para eso, que no se basa en __init__.py(ni en ningún otro archivo auxiliar) y me hace escribir solo las siguientes dos líneas:

import importdir
importdir.do("Foo", globals())

Siéntase libre de reutilizar o contribuir: http://gitlab.com/aurelien-lourot/importdir

Simplemente impórtelos por importlib y agréguelos a __all__(la addacción es opcional) en forma recurrente en el __init__.pypaquete.

/Foo
    bar.py
    spam.py
    eggs.py
    __init__.py

# __init__.py
import os
import importlib
pyfile_extes = ['py', ]
__all__ = [importlib.import_module('.%s' % filename, __package__) for filename in [os.path.splitext(i)[0] for i in os.listdir(os.path.dirname(__file__)) if os.path.splitext(i)[1] in pyfile_extes] if not filename.startswith('__')]
del os, importlib, pyfile_extes

Cuando from . import *no es lo suficientemente bueno, esta es una mejora sobre la respuesta de ted . Específicamente, el uso de __all__no es necesario con este enfoque.

"""Import all modules that exist in the current directory."""
# Ref https://stackoverflow.com/a/60861023/
from importlib import import_module
from pathlib import Path

for f in Path(__file__).parent.glob("*.py"):
    module_name = f.stem
    if (not module_name.startswith("_")) and (module_name not in globals()):
        import_module(f".{module_name}", __package__)
    del f, module_name
del import_module, Path

Tenga en cuenta que module_name not in globals()está destinado a evitar volver a importar el módulo si ya está importado, ya que esto puede arriesgar las importaciones cíclicas.