Как да заредя всички модули в папка?

Избройте всички python (.py) файлове в текущата папка и ги поставете като __all__ променлива в __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')]

Добавете променливата __all__ към __init__.py, съдържаща:

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

Вижте също http://docs.python.org/tutorial/modules.html

Актуализация през 2017 г.: вероятно искате да използвате importlib вместо това.

Направете директорията Foo пакет, като добавите __init__.py. В това __init__.py добавете:

import bar
import eggs
import spam

Тъй като искате да е динамичен (което може или не може да е добра идея), избройте всички py-файлове със списък dir и ги импортирайте с нещо подобно:

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

След това от вашия код направете следното:

import Foo

Вече имате достъп до модулите с

Foo.bar
Foo.eggs
Foo.spam

и т.н. from Foo import * не е добра идея поради няколко причини, включително сблъсъци на имена и затрудняване на анализа на кода.

Разширявайки отговора на Михаил, вярвам, че не-хакерският начин (както в, без директно обработване на файловите пътища) е следният:

1. създайте празен __init__.py файл под Foo/
2. Изпълни

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

Ще получите:

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

Python, включете всички файлове в директория:

За начинаещи, които просто не могат да го накарат да работи, които се нуждаят от държане за ръце.

1. Създайте папка /home/el/foo и направете файл main.py под /home/el/foo Поставете този код там:

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

2. Направете директория /home/el/foo/hellokitty

3. Направете файл __init__.py под /home/el/foo/hellokitty и поставете този код там:

   __all__ = ["spam", "ham"]
   

4. Направете два python файла: spam.py и ham.py под /home/el/foo/hellokitty

5. Дефинирайте функция в spam.py:

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

6. Дефинирайте функция в ham.py:

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

7. Стартирайте го:

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

Самият аз се уморих от този проблем, така че написах пакет, наречен automodinit, за да го поправя. Можете да го получите от http://pypi.python.org/pypi/automodinit/.

Използването е така:

1. Включете пакета automodinit във вашите setup.py зависимости.
2. Заменете всички __init__.py файлове по този начин:

__all__ = ["I will get rewritten"]
# Don't modify the line above, or this line!
import automodinit
automodinit.automodinit(__name__, __file__, globals())
del automodinit
# Anything else you want can go after here, it won't get modified.

Това е! Отсега нататък импортирането на модул ще зададе __all__ на списък от .py[co] файлове в модула и също ще импортира всеки от тези файлове, сякаш сте въвели:

for x in __all__: import x

Следователно ефектът на „от М импортиране *“ съвпада точно с „импортиране на М“.

automodinit работи успешно от вътрешните ZIP архиви и следователно е безопасен за ZIP.

Найл

Знам, че актуализирам доста стара публикация и се опитах да използвам automodinit, но разбрах, че процесът на настройка е повреден за python3. И така, въз основа на отговора на Лука, измислих по-прост отговор - който може да не работи с .zip - на този проблем, така че реших, че трябва да го споделя тук:

в рамките на модула __init__.py от yourpackage:

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

и в друг пакет под yourpackage:

from yourpackage import *

След това ще имате заредени всички модули, които са поставени в пакета, и ако напишете нов модул, той също ще бъде автоматично импортиран. Разбира се, използвайте този вид неща внимателно, с големите правомощия идват и големи отговорности.

Аз също се сблъсках с този проблем и това беше моето решение:

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

Тази функция създава файл (в предоставената папка) с име __init__.py, който съдържа променлива __all__, която съдържа всеки модул в папката.

Например, имам папка с име Test, която съдържа:

Foo.py
Bar.py

Така че в скрипта, в който искам модулите да бъдат импортирани, ще напиша:

loadImports('Test/')
from Test import *

Това ще импортира всичко от Test и файлът __init__.py в Test вече ще съдържа:

__all__ = ['Foo','Bar']

Това е най-добрият начин, който съм открил досега:

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

Примерът на Anurag с няколко корекции:

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

Отговорът на Anurag Uniyal с предложени подобрения!

#!/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  

Използвайки importlib единственото нещо, което трябва да добавите е

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

Вижте, че вашият __init__.py дефинира __all__. В документа модули - пакети се казва

Файловете __init__.py са необходими, за да може Python да третира директориите като съдържащи пакети; това се прави, за да се предотврати неволно скриване на валидни модули от директории с общо име, като например низ, които се появяват по-късно в пътя за търсене на модула. В най-простия случай __init__.py може да бъде просто празен файл, но може също така да изпълни код за инициализация за пакета или да зададе променливата __all__, описана по-късно.

...

Единственото решение е авторът на пакета да предостави изричен индекс на пакета. Изявлението за импортиране използва следната конвенция: ако __init__.py кодът на пакет дефинира списък с име __all__, той се приема за списък с имена на модули, които трябва да бъдат импортирани, когато се срещне от import * на пакет. От автора на пакета зависи да поддържа този списък актуален, когато бъде пусната нова версия на пакета. Авторите на пакети може също да решат да не го поддържат, ако не виждат употреба за импортиране на * от техния пакет. Например файлът sounds/effects/__init__.py може да съдържа следния код:

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

Това би означавало, че from sound.effects import * ще импортира трите именувани подмодула на звуковия пакет.

Създадох модул за това, който не разчита на __init__.py (или друг спомагателен файл) и ме кара да въвеждам само следните два реда:

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

Чувствайте се свободни да използвате повторно или да допринесете: http://gitlab.com/aurelien-lourot/importdir

Вижте модула pkgutil от стандартната библиотека. Ще ви позволи да правите точно това, което искате, стига да имате __init__.py файл в директорията. Файлът __init__.py може да е празен.

Когато from . import * не е достатъчно добър, това е подобрение спрямо отговора от ted. По-конкретно, използването на __all__ не е необходимо при този подход.

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

Имайте предвид, че module_name not in globals() има за цел да избегне повторно импортиране на модула, ако той вече е импортиран, тъй като това може да застраши циклично импортиране.

Бих искал да добавя към отговора на Anurag Uniyal. Можете да го направите още по-просто и да се отървете от много импортирания. Съдържание на файла __init__.py:

from os import listdir
from os.path import dirname
__all__ = [i[:-3] for i in listdir(dirname(__file__)) if not i.startswith('__') and i.endswith('.py')]

Просто ги импортирайте от importlib и ги добавете към __all__ (add действието не е задължително) при рекурсия в __init__.py на пакета.

/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

Имах структура на вложена директория, т.е. имах множество директории в основната директория, която съдържаше модулите на Python.

Добавих следния скрипт към моя __init__.py файл, за да импортирам всички модули

import glob, re, os 

module_parent_directory = "path/to/the/directory/containing/__init__.py/file"

owd = os.getcwd()
if not owd.endswith(module_parent_directory): os.chdir(module_parent_directory)

module_paths = glob.glob("**/*.py", recursive = True)

for module_path in module_paths:
    if not re.match( ".*__init__.py$", module_path):
        import_path = module_path[:-3]
        import_path = import_path.replace("/", ".")
        exec(f"from .{import_path} import *")

os.chdir(owd)

Вероятно не е най-добрият начин да постигна това, но не можах да накарам нищо друго да работи за мен.