एक स्ट्रिंग

Question

से फ़ाइल में गतिशील रूप से एक विधि आयात करें मेरे पास एक स्ट्रिंग है, कहें: abc.def.ghi.jkl.myfile.mymethod। मैं गतिशील रूप से mymethod आयात कैसे करूं?

यहाँ कैसे मैं इसके बारे में चला गया है:

def get_method_from_file(full_path): 
    if len(full_path) == 1: 
     return map(__import__,[full_path[0]])[0] 
    return getattr(get_method_from_file(full_path[:-1]),full_path[-1]) 


if __name__=='__main__': 
    print get_method_from_file('abc.def.ghi.jkl.myfile.mymethod'.split('.')) 

मैं अगर आयात करने व्यक्तिगत मॉड्यूल बिल्कुल आवश्यक है सोच रहा हूँ।

संपादित करें: मैं पाइथन संस्करण 2.6.5 का उपयोग कर रहा हूं।

Answer 1

importlib (2.7+ केवल) का उपयोग करें।

Answer 2

अजगर < 2.7 निर्मित विधि __ import__ इस्तेमाल किया जा सकता के लिए:

__import__('abc.def.ghi.jkl.myfile.mymethod', fromlist=['']) 

अजगर> = 2.7 या 3.1 सुविधाजनक तरीका importlib.import_module जोड़ दिया गया है के लिए। बस इस तरह अपने मॉड्यूल आयात:

importlib.import_module('abc.def.ghi.jkl.myfile.mymethod') 

अद्यतन: टिप्पणियां (मैं मानता हूं कि मैं स्ट्रिंग पढ़ने नहीं था अंत तक आयात करने के लिए के अनुसार अद्यतन संस्करण और मैं इस तथ्य को याद है कि की एक विधि एक मॉड्यूल आयातित किया जाना चाहिए और नहीं एक मॉड्यूल में ही):

अजगर < 2.7:

mymethod = getattr(__import__("abc.def.ghi.jkl.myfile", fromlist=["mymethod"])) 

अजगर> = 2.7:

mymethod = getattr(importlib.import_module("abc.def.ghi.jkl.myfile"), "mymethod") 

Answer 3

आप अलग-अलग मॉड्यूल आयात करने की आवश्यकता नहीं है। यह मॉड्यूल आप से एक नाम आयात करना चाहते हैं आयात और fromlist तर्क प्रदान करने के लिए पर्याप्त है:

def import_from(module, name): 
    module = __import__(module, fromlist=[name]) 
    return getattr(module, name) 

अपने उदाहरण abc.def.ghi.jkl.myfile.mymethod के लिए,

import_from("abc.def.ghi.jkl.myfile", "mymethod") 

के रूप में इस फ़ंक्शन को कॉल करें (ध्यान दें कि मॉड्यूल स्तर के कार्यों पाइथन में फ़ंक्शन कहा जाता है, विधियों नहीं।)

इस तरह के एक साधारण कार्य के लिए, importlib मॉड्यूल का उपयोग करने में कोई फायदा नहीं है।

Answer 4

पायथन 2.7 से आप importlib.import_module() फ़ंक्शन का उपयोग कर सकते हैं। आप एक मॉड्यूल आयात और निम्न कोड के साथ एक वस्तु के भीतर परिभाषित पहुंच सकता है: जिस तरह से मैं यह करने के लिए करते हैं (और साथ ही इस तरह के तोरणों और पेस्ट के रूप में अन्य पुस्तकालयों, के एक नंबर,

from importlib import import_module 

p, m = name.rsplit('.', 1) 

mod = import_module(p) 
met = getattr(mod, m) 

met() 

Answer 5

मेरी स्मृति अगर मुझे सही ढंग से सेवा करता है) मॉड्यूल नाम को उनके बीच ':' का उपयोग करके फ़ंक्शन/विशेषता नाम से अलग करना है। निम्नलिखित उदाहरण देखें:

'abc.def.ghi.jkl.myfile:mymethod'

यह उपयोग में आसान एक छोटे से नीचे import_from(path) समारोह में आता है।

def import_from(path): 
    """ 
    Import an attribute, function or class from a module. 
    :attr path: A path descriptor in the form of 'pkg.module.submodule:attribute' 
    :type path: str 
    """ 
    path_parts = path.split(':') 
    if len(path_parts) < 2: 
     raise ImportError("path must be in the form of pkg.module.submodule:attribute") 
    module = __import__(path_parts[0], fromlist=path_parts[1]) 
    return getattr(module, path_parts[1]) 


if __name__=='__main__': 
    func = import_from('a.b.c.d.myfile:mymethod') 
    func() 

Answer 6

यह स्पष्ट नहीं है कि आप अपने स्थानीय नामस्थान में क्या करने का प्रयास कर रहे हैं। मुझे लगता है कि आप my_method स्थानीय के रूप में output = my_method() टाइप करना चाहते हैं?

# This is equivalent to "from a.b.myfile import my_method" 
the_module = importlib.import_module("a.b.myfile") 
same_module = __import__("a.b.myfile") 
# import_module() and __input__() only return modules 
my_method = getattr(the_module, "my_method") 

# or, more concisely, 
my_method = getattr(__import__("a.b.myfile"), "my_method") 
output = my_method() 

आप केवल स्थानीय नाम स्थान के लिए my_method जोड़ने के दौरान, आप मॉड्यूल की श्रृंखला लोड है। आप आयात से पहले और बाद में sys.modules की चाबियाँ देखकर परिवर्तन देख सकते हैं। मुझे उम्मीद है कि यह आपके अन्य उत्तरों की तुलना में स्पष्ट और अधिक सटीक है।

पूर्णता के लिए, इस तरह आप पूरी श्रृंखला जोड़ते हैं।

# This is equivalent to "import a.b.myfile" 
a = __import__("a.b.myfile") 
also_a = importlib.import_module("a.b.myfile") 
output = a.b.myfile.my_method() 

# This is equivalent to "from a.b import myfile" 
myfile = __import__("a.b.myfile", fromlist="a.b") 
also_myfile = importlib.import_module("a.b.myfile", "a.b") 
output = myfile.my_method() 

और अंत में, यदि आप __import__() का उपयोग कर रहे हैं और आप पथ खोज के बाद कार्यक्रम शुरू कर दिया संशोधित किया है, तो आप __import__(normal args, globals=globals(), locals=locals()) उपयोग करने की आवश्यकता हो सकती है। एक जटिल चर्चा क्यों है।

Answer 7

इस वेबसाइट पर एक अच्छा समाधान है: load_class। मैं इसे इस तरह का उपयोग करें:

foo = load_class(package.subpackage.FooClass)() 
type(foo) # returns FooClass 

Answer 8

from importlib import import_module 


name = "file.py".strip('.py') 
# if Path like : "path/python/file.py" 
# use name.replaces("/",".") 

imp = import_module(name) 

# get Class From File.py 
model = getattr(imp, "naemClassImportFromFile") 

NClass = model() # Class From file