python - करन - हिंदी में निर्यात आयात किताब




पूर्ण पथ दिए गए मॉड्यूल को कैसे आयात करें? (14)

Sys.path (imp का उपयोग करने पर) को पथ जोड़ने का लाभ यह है कि यह एक पैकेज से एक से अधिक मॉड्यूल आयात करते समय चीजों को सरल बनाता है। उदाहरण के लिए:

import sys
# the mock-0.3.1 dir contains testcase.py, testutils.py & mock.py
sys.path.append('/foo/bar/mock-0.3.1')

from testcase import TestCase
from testutils import RunTests
from mock import Mock, sentinel, patch

मैं पाइथन मॉड्यूल को अपना पूरा पथ कैसे दे सकता हूं? ध्यान दें कि फ़ाइल फाइल सिस्टम में कहीं भी हो सकती है, क्योंकि यह एक कॉन्फ़िगरेशन विकल्प है।


आप इस तरह कुछ भी कर सकते हैं और निर्देशिका को जोड़ सकते हैं कि कॉन्फ़िगरेशन फ़ाइल पाइथन लोड पथ में बैठी है, और उसके बाद आप सामान्य रूप से फ़ाइल का नाम जानते हैं, इस मामले में "config"।

गन्दा, लेकिन यह काम करता है।

configfile = '~/config.py'

import os
import sys

sys.path.append(os.path.dirname(os.path.expanduser(configfile)))

import config

इसे उत्तर की सूची में जोड़ना क्योंकि मुझे कुछ भी नहीं मिला जो काम करता था। यह 3.4 में संकलित (पीईडी) पायथन मॉड्यूल के आयात की अनुमति देगा:

import sys
import importlib.machinery

def load_module(name, filename):
    # If the Loader finds the module name in this list it will use
    # module_name.__file__ instead so we need to delete it here
    if name in sys.modules:
        del sys.modules[name]
    loader = importlib.machinery.ExtensionFileLoader(name, filename)
    module = loader.load_module()
    locals()[name] = module
    globals()[name] = module

load_module('something', r'C:\Path\To\something.pyd')
something.do_something()

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

from runpy import run_path
settings = run_path("/path/to/file.py")

वह इंटरफ़ेस पायथन 2.7 और पायथन 3.2+ में उपलब्ध है


किसी दिए गए फ़ाइल नाम से मॉड्यूल आयात करने के लिए, आप अस्थायी रूप से पथ का विस्तार कर सकते हैं, और अंत में ब्लॉक reference: में सिस्टम पथ को पुनर्स्थापित कर सकते हैं reference:

filename = "directory/module.py"

directory, module_name = os.path.split(filename)
module_name = os.path.splitext(module_name)[0]

path = list(sys.path)
sys.path.insert(0, directory)
try:
    module = __import__(module_name)
finally:
    sys.path[:] = path # restore

क्या आपका मतलब भार या आयात है?

आप sys.path सूची में हेरफेर कर सकते हैं अपने मॉड्यूल के पथ निर्दिष्ट करें, फिर अपना मॉड्यूल आयात करें। उदाहरण के लिए, यहां एक मॉड्यूल दिया गया है:

/foo/bar.py

तुम यह कर सकते थे:

import sys
sys.path[0:0] = '/foo' # puts the /foo directory at the start of your path
import bar

पाइथन 3.5+ के लिए उपयोग करें:

import importlib.util
spec = importlib.util.spec_from_file_location("module.name", "/path/to/file.py")
foo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(foo)
foo.MyClass()

पायथन 3.3 और 3.4 के लिए उपयोग करें:

from importlib.machinery import SourceFileLoader

foo = SourceFileLoader("module.name", "/path/to/file.py").load_module()
foo.MyClass()

(हालांकि इसे पायथन 3.4 में बहिष्कृत कर दिया गया है।)

पायथन 2 उपयोग:

import imp

foo = imp.load_source('module.name', '/path/to/file.py')
foo.MyClass()

संकलित पायथन फाइलों और डीएलएल के लिए समकक्ष सुविधा कार्य हैं।

यह भी देखें। http://bugs.python.org/issue21436


मेरा मानना ​​है कि आप निर्दिष्ट मॉड्यूल को लोड करने के लिए imp.find_module() और imp.load_module() का उपयोग कर सकते हैं। आपको पथ के मॉड्यूल नाम को विभाजित करने की आवश्यकता होगी, यानी यदि आप /home/mypath/mymodule.py को लोड करना चाहते हैं तो आपको यह करना होगा:

imp.find_module('mymodule', '/home/mypath/')

... लेकिन यह काम पूरा करना चाहिए।


मैं यह नहीं कह रहा हूं कि यह बेहतर है, लेकिन पूर्णता के लिए, मैं exec समारोह का सुझाव देना चाहता था, जो कि पाइथन 2 और 3 दोनों में उपलब्ध है। exec आपको वैश्विक दायरे में या आंतरिक में मनमाने ढंग से कोड निष्पादित करने की अनुमति देता है एक शब्दकोश के रूप में प्रदान किया गया गुंजाइश।

उदाहरण के लिए, यदि आपके पास फ़ंक्शन foo() साथ "/path/to/module " में संग्रहीत मॉड्यूल है, तो आप इसे निम्न करके चला सकते हैं:

module = dict()
with open("/path/to/module") as f:
    exec(f.read(), module)
module['foo']()

इससे यह थोड़ा और स्पष्ट हो जाता है कि आप गतिशील रूप से कोड लोड कर रहे हैं, और आपको कुछ अतिरिक्त शक्ति प्रदान करते हैं, जैसे कस्टम बिल्टिन प्रदान करने की क्षमता।

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

class MyModuleClass(dict):
    def __getattr__(self, name):
        return self.__getitem__(name)

मैंने एक पैकेज बनाया जो आपके लिए imp का उपयोग करता है। मैं इसे import_file कहते हैं और इस तरह इसका उपयोग किया जाता है:

>>>from import_file import import_file
>>>mylib = import_file('c:\\mylib.py')
>>>another = import_file('relative_subdir/another.py')

आप इसे यहां प्राप्त कर सकते हैं:

http://pypi.python.org/pypi/import_file

या कि

http://code.google.com/p/import-file/


यहां कुछ कोड है जो सभी पायथन संस्करणों में 2.7-3.5 और शायद अन्य लोगों में भी काम करता है।

config_file = "/tmp/config.py"
with open(config_file) as f:
    code = compile(f.read(), config_file, 'exec')
    exec(code, globals(), locals())

मैंने इसका परीक्षण किया। यह बदसूरत हो सकता है लेकिन अब तक केवल एक ही है जो सभी संस्करणों में काम करता है।


लिनक्स में, निर्देशिका में एक प्रतीकात्मक लिंक जोड़कर आपकी पायथन स्क्रिप्ट काम करता है।

अर्थात:

ln -s /absolute/path/to/module/module.py /absolute/path/to/script/module.py

पायथन /absolute/path/to/script/module.pyc और यदि आप /absolute/path/to/module/module.py की सामग्री बदलते हैं तो इसे अपडेट कर /absolute/path/to/module/module.py

फिर mypythonscript.py में निम्नलिखित शामिल करें

from module import *

सबसे अच्छा तरीका, मुझे लगता है, आधिकारिक दस्तावेज से है ( 2 9 .1। आईपी - आयात आंतरिक प्रवेश करें ):

import imp
import sys

def __import__(name, globals=None, locals=None, fromlist=None):
    # Fast path: see if the module has already been imported.
    try:
        return sys.modules[name]
    except KeyError:
        pass

    # If any of the following calls raises an exception,
    # there's a problem we can't handle -- let the caller handle it.

    fp, pathname, description = imp.find_module(name)

    try:
        return imp.load_module(name, fp, pathname, description)
    finally:
        # Since we may exit via an exception, close fp explicitly.
        if fp:
            fp.close()

रनटाइम पर पैकेज मॉड्यूल आयात करें (पायथन रेसिपी)

http://code.activestate.com/recipes/223972/

###################
##                #
## classloader.py #
##                #
###################

import sys, types

def _get_mod(modulePath):
    try:
        aMod = sys.modules[modulePath]
        if not isinstance(aMod, types.ModuleType):
            raise KeyError
    except KeyError:
        # The last [''] is very important!
        aMod = __import__(modulePath, globals(), locals(), [''])
        sys.modules[modulePath] = aMod
    return aMod

def _get_func(fullFuncName):
    """Retrieve a function object from a full dotted-package name."""

    # Parse out the path, module, and function
    lastDot = fullFuncName.rfind(u".")
    funcName = fullFuncName[lastDot + 1:]
    modPath = fullFuncName[:lastDot]

    aMod = _get_mod(modPath)
    aFunc = getattr(aMod, funcName)

    # Assert that the function is a *callable* attribute.
    assert callable(aFunc), u"%s is not callable." % fullFuncName

    # Return a reference to the function itself,
    # not the results of the function.
    return aFunc

def _get_class(fullClassName, parentClass=None):
    """Load a module and retrieve a class (NOT an instance).

    If the parentClass is supplied, className must be of parentClass
    or a subclass of parentClass (or None is returned).
    """
    aClass = _get_func(fullClassName)

    # Assert that the class is a subclass of parentClass.
    if parentClass is not None:
        if not issubclass(aClass, parentClass):
            raise TypeError(u"%s is not a subclass of %s" %
                            (fullClassName, parentClass))

    # Return a reference to the class itself, not an instantiated object.
    return aClass


######################
##       Usage      ##
######################

class StorageManager: pass
class StorageManagerMySQL(StorageManager): pass

def storage_object(aFullClassName, allOptions={}):
    aStoreClass = _get_class(aFullClassName, StorageManager)
    return aStoreClass(allOptions)




python-module