स्ट्रिंग से, फ़ाइल में डायनामिक तरीके से आयात करें

Question 1

मेरे पास एक तार है, कहते हैं 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 का उपयोग कर रहा हूं।

Question 2

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

from importlib import import_module

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

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

met()

Question 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मॉड्यूल का उपयोग करने में कोई फायदा नहीं है ।

Question 4

पायथन <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")

Question 5

यह स्पष्ट नहीं है कि आप अपने स्थानीय नामस्थान पर क्या करने की कोशिश कर रहे हैं। मुझे लगता है कि आप 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())। क्यों एक जटिल चर्चा है।

Question 6

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, "classNameImportFromFile")

NClass = model() # Class From file

Question 7

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

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

अनुरोध के अनुसार, यहाँ वेब लिंक से कोड है:

import importlib

def load_class(full_class_string):
    """
    dynamically load a class from a string
    """

    class_data = full_class_string.split(".")
    module_path = ".".join(class_data[:-1])
    class_str = class_data[-1]

    module = importlib.import_module(module_path)
    # Finally, we retrieve the Class
    return getattr(module, class_str)

Question 8

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

Question 9

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

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

Question 10

इस बारे में कैसा है :

def import_module(name):

    mod = __import__(name)
    for s in name.split('.')[1:]:
        mod = getattr(mod, s)
    return mod