दिलचस्प पोस्ट
नेटवर्क्स जावास्क्रिप्ट का उपयोग करते हुए एक एचटीएमएल डोम ईवेंट पर जेएसएफ प्रबंधित बीन को कैसे खोलें? मैं एंड्रॉइड एम्यूलेटर में एक्सीलरोमीटर कैसे अनुकरण कर सकता हूं? Xcode 4 में परियोजनाओं का नामकरण एफसीएम (फायरबेज क्लाउड मेसेजिंग) एकाधिक डिवाइसों को भेजें कैसे XP / Vista और नए पर VB6 के लिए एक सरल स्थापना प्रणाली बनाने के लिए? जीआईटी में कमानों की एक श्रेणी को वापस लाएं आदिम डेटा प्रकारों के लिए अशक्त PHP में फैक्टरी डिजाइन पैटर्न क्या है? जावा में एक स्ट्रिंग रिवर्स Google ऐप स्क्रिप्ट टाइमआउट ~ 5 मिनट? पायथन में एक थ्रेड में कॉल किए जाने पर sys.exit () क्यों नहीं निकल जाता? पायथन में, सूची से डुप्लिकेट को निकालने के लिए सबसे तेज़ एल्गोरिथ्म है ताकि ऑर्डर * के संरक्षण के दौरान सभी तत्व अद्वितीय हों *? सी ++ में एक गतिशील सरणी कैसे प्रारंभ करें? JQuery.extend और jQuery.fn.extend के बीच अंतर? पायथन में XSLT का उपयोग करते हुए XML फ़ाइल को कैसे बदलना है?

पायथन में एक फ़ोल्डर में सभी मॉड्यूल लोड किए जा रहे हैं

क्या कोई मुझे मॉड्यूल की संपूर्ण निर्देशिका आयात करने का एक अच्छा तरीका प्रदान कर सकता है?
मेरे पास इस तरह की संरचना है:

/Foo bar.py spam.py eggs.py 

मैंने इसे __init__.py को जोड़कर और from Foo import * जोड़कर इसे पैकेज में परिवर्तित करने की कोशिश की, लेकिन यह जिस तरीके से मैंने आशा व्यक्त की थी, वह काम नहीं किया।

वेब के समाधान से एकत्रित समाधान "पायथन में एक फ़ोल्डर में सभी मॉड्यूल लोड किए जा रहे हैं"

__init__.py युक्त __all__ परिवर्तनीय जोड़ें:

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

http://docs.python.org/tutorial/modules.html भी देखें

वर्तमान फ़ोल्डर में सभी अजगर ( .py ) फ़ाइलों की सूची बनाएं और उन्हें __init__.py में __all__ चर में डाल दें

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

अद्यतन: आज आप शायद इसके बजाय importlib का उपयोग करना चाहते हैं।

एक __init__.py जोड़कर Foo निर्देशिका को एक पैकेज बनाइए। उस __init__.py जोड़ें:

 import bar import eggs import spam 

चूंकि आप चाहते हैं कि यह गतिशील (जो हो सकता है या अच्छा विचार न हो), सूची फाइल के साथ सभी फाइलों को सूचीबद्ध करें और उन्हें कुछ ऐसा आयात करें:

 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 

आदि फू आयात * से कई कारणों के लिए एक अच्छा विचार नहीं है, जिसमें नाम संघर्ष भी शामिल है और कोड का विश्लेषण करना मुश्किल है।

मिहिल के जवाब पर विस्तार, मेरा मानना ​​है कि गैर-हँसने वाला तरीका (जैसा कि, फ़ाइल पथों को सीधे संभाल नहीं रहा है) निम्नलिखित है:

  1. Foo/ अंतर्गत खाली __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'> 

पायथन, एक निर्देशिका के अंतर्गत सभी फाइलों को शामिल करें:

नए लोगों के लिए जो इसे काम करने के लिए नहीं मिल सकते हैं, जिनके हाथों की जरूरत होती है

  1. एक फ़ोल्डर / होम / एल / main.py बनाओ और / main.py / el / foo के तहत main.py फाइल main.py इस कोड को वहां रखो:

     from hellokitty import * spam.spamfunc() ham.hamfunc() 
  2. एक निर्देशिका /home/el/foo/hellokitty बनाएं

  3. /home/el/foo/hellokitty तहत एक फ़ाइल __init__.py बनाओ और वहां इस कोड को डाल दिया:

     __all__ = ["spam", "ham"] 
  4. दो अजगर फ़ाइलों को बनाएं: spam.py और ham.py /home/el/foo/hellokitty अंतर्गत

  5. स्पैमपैकेज के अंदर फ़ंक्शन परिभाषित करें:

     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. अपने setup.py निर्भरता में automodinit पैकेज शामिल करें
  2. सभी __init__.py फ़ाइलों को इस तरह बदलें:
 __all__ = ["मुझे फिर से लिखा जाएगा"]
 # ऊपर की रेखा को संशोधित न करें, या यह रेखा!
 आयात automodinit
 automodinit.automodinit (__ नाम__, __file__, ग्लोबल्स ())
 डेल ऑटोमोडाइनट
 # आप चाहते हैं कि कुछ भी यहाँ के बाद जा सकते हैं, इसे संशोधित नहीं किया जाएगा।

बस! मॉड्यूल आयात करने से अब __all__ को मॉड्यूल में .pi [co] फाइलों की सूची में सेट कर दिया जाएगा और उन सभी फाइलों को भी आयात करेगा जैसे कि आपने टाइप किया था:

 for x in __all__: import x 

इसलिए "एम आयात से" का प्रभाव बिल्कुल "आयात एम" से मेल खाता है

automodinit ज़िप अभिलेखागार के अंदर से चल रहा है और इसलिए ज़िप सुरक्षित है।

नियाल

मुझे भी इस समस्या का सामना करना पड़ा है और यह मेरा समाधान था:

 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 से सब कुछ आयात करेगा और Test में __init__.py फ़ाइल में अब शामिल होंगे:

 __all__ = ['Foo','Bar'] 

सुझाए गए सुधारों के साथ अनुराग उन्ियाल का जवाब !

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

कुछ सुधारों के साथ अनुराग का उदाहरण:

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

देखें कि आपका __init__.py परिभाषित करता है __all__ मॉड्यूल – पैकेज डॉक्टर कहते हैं

पैकेट को डायरेक्ट्रीज़ को संकुल के रूप में रखने के लिए __init__.py फाइलों को आवश्यक है; यह एक साधारण नाम के साथ निर्देशिका को रोकने के लिए किया जाता है, जैसे कि स्ट्रिंग, अनजाने में मान्य मॉड्यूल को छुपाता है जो बाद में मॉड्यूल खोज पथ पर होता है। सरलतम मामले में, __init__.py सिर्फ एक खाली फ़ाइल हो सकता है, लेकिन यह पैकेज के लिए आरंभीकरण कोड भी निष्पादित कर सकता है या बाद में वर्णित __all__ चर, सेट कर __all__

संकुल के लेखक पैकेज के एक स्पष्ट सूचक प्रदान करने के लिए एकमात्र समाधान है। आयात स्टेटमेंट निम्नलिखित कन्वेंशन का उपयोग करता है: यदि किसी पैकेज का __init__.py कोड __all__ नामक सूची को परिभाषित करता है, तो इसे मॉड्यूल नामों की सूची में लिया जाता है, जिसे आयात किए जाने के समय पैकेज आयात * से मिलता है पैकेज सूची का एक नया संस्करण जारी होने पर यह सूची अप-टू-डेट रखने के लिए पैकेज लेखक पर निर्भर है पैकेज लेखक भी इसका समर्थन नहीं कर सकते, यदि वे अपने पैकेज से * आयात करने के लिए उपयोग नहीं देखते हैं। उदाहरण के लिए, फ़ाइल sounds/effects/__init__.py में निम्न कोड हो सकता है:

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

इसका मतलब यह होगा कि from sound.effects import * से ध्वनि पैकेज के तीन नामित from sound.effects import * जाएंगे।

यह मैंने अभी तक पाया सबसे अच्छा तरीका है:

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

मुझे पता है कि मैं एक पुरानी पोस्ट को अपडेट कर रहा हूं, और मैंने automodinit का उपयोग करने की कोशिश की, लेकिन पता चला कि यह सेटअप प्रक्रिया Python3 के लिए टूट गई है। तो, लुका के उत्तर के आधार पर, मैं एक सरल जवाब के साथ आया – जो शायद इस मुद्दे पर .zip – के साथ काम नहीं कर सकता, इसलिए मुझे लगा कि मुझे इसे यहां साझा करना चाहिए:

__init__.py yourpackage से __init__.py मॉड्यूल के भीतर:

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

और अपने पैकेज के नीचे एक और पैकेज के भीतर:

 from yourpackage import * 

उसके बाद आपके पास सभी मॉड्यूल लोड किए गए पैकेज के भीतर होंगे, और यदि आप एक नया मॉड्यूल लिखेंगे, तो इसे स्वचालित रूप से भी आयात किया जाएगा। बेशक, देखभाल के साथ उस तरह की चीजों का उपयोग करें, महान शक्तियों के साथ महान जिम्मेदारियां आती हैं

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

मानक पुस्तकालय से pkgutil मॉड्यूल को देखो। यह आपको ठीक से ऐसा करने देगा जो आप चाहते हैं जब तक आपके पास निर्देशिका में एक __init__.py फ़ाइल है। __init__.py फ़ाइल खाली हो सकती है।

मैंने इसके लिए एक मॉड्यूल बनाया है, जो __init__.py (या कोई अन्य सहायक फ़ाइल) पर भरोसा नहीं करता है और मुझे केवल निम्नलिखित दो पंक्तियां लिखता है:

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

पुन: उपयोग या योगदान करने के लिए स्वतंत्र महसूस करें: http://gitlab.com/aurelien-lourot/importdir