python - কিভাবে একটি সম্পূর্ণ মডিউল মডিউল আমদানি করতে?




configuration python-import (18)

কিভাবে আমি একটি সম্পূর্ণ পাইথন মডিউল লোড করা যাবে তার সম্পূর্ণ পথ? উল্লেখ্য যে ফাইলটি ফাইল সিস্টেমে যে কোনও জায়গায় থাকতে পারে, এটি একটি কনফিগারেশন বিকল্প।


Sys.path (আইপি ব্যবহার করে) এর একটি পথ যোগ করার সুবিধা হল এটি একটি প্যাকেজ থেকে একাধিক মডিউল আমদানি করার সময় এটি সহজ করে। উদাহরণ স্বরূপ:

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

আপনার মডিউল আমদানি করতে, আপনি তার ডিরেক্টরি পরিবেশগত পরিবর্তনশীল, অস্থায়ী বা স্থায়ীভাবে যোগ করতে হবে।

অস্থায়ীভাবে

import sys
sys.path.append("/path/to/my/modules/")
import my_module

স্থায়িভাবে

নিম্নলিখিত লাইনটি আপনার .bashrc ফাইলে যোগ করুন (linux এ) এবং টার্মিনালে source ~/.bashrc বর্জন করুন:

export PYTHONPATH="${PYTHONPATH}:/path/to/my/modules/"

ক্রেডিট / উত্স: saarrrr , অন্য saarrrr প্রশ্ন


আপনি ব্যবহার করতে পারেন

load_source(module_name, path_to_file) 

আইপি মডিউল থেকে পদ্ধতি।


আপনি লোড বা আমদানি মানে?

আপনি sys.path তালিকাটি আপনার মডিউলের পথ নির্দিষ্ট করতে পারেন এবং তারপর আপনার মডিউল আমদানি করতে পারেন। উদাহরণস্বরূপ, একটি মডিউল দেওয়া:

/foo/bar.py

আপনি করতে পারেন:

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

আমি আপনার জন্য 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 এবং 3 উভয় ক্ষেত্রেই পাওয়া যায়। exec আপনাকে বৈশ্বিক সুযোগ বা অভ্যন্তরীণভাবে নির্বিচারে কোড চালাতে দেয়। সুযোগ, একটি অভিধান হিসাবে প্রদান।

উদাহরণস্বরূপ, যদি ফাংশন foo() দ্বারা "/path/to/module " "/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)

উত্তরগুলির তালিকায় এটি যোগ করা যেহেতু আমি কাজ করে এমন কিছু খুঁজে পাইনি। এটি 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()

এই উত্তরটি সেবাস্তিয়ান রিটউর উত্তরটির প্রতিক্রিয়াটির একটি পরিপূরক: "কিন্তু যদি আপনার মডিউল নাম না থাকে?" এটি সম্ভবত একটি __init__.py মডিউল নামটি একটি ফাইলের নাম দেওয়ার একটি দ্রুত এবং নোংরা উপায় - এটি __init__.py ফাইল ছাড়াই কোনও ডিরেক্টরি খুঁজে না পাওয়া পর্যন্ত এটি কেবল গাছটি উপরে যায় এবং তারপরে এটি একটি __init__.py ফিরিয়ে নেয়। পাইথন 3.4+ (পাথলিব ব্যবহার করে), যা পিএইচ 2 ব্যক্তিরা "আইপি" বা আপেক্ষিক আমদানির অন্য উপায়গুলি ব্যবহার করতে পারে বলে ধারনা দেয়:

import pathlib

def likely_python_module(filename):
    '''
    Given a filename or Path, return the "likely" python module name.  That is, iterate
    the parent directories until it doesn't contain an __init__.py file.

    :rtype: str
    '''
    p = pathlib.Path(filename).resolve()
    paths = []
    if p.name != '__init__.py':
        paths.append(p.stem)
    while True:
        p = p.parent
        if not p:
            break
        if not p.is_dir():
            break

        inits = [f for f in p.iterdir() if f.name == '__init__.py']
        if not inits:
            break

        paths.append(p.stem)

    return '.'.join(reversed(paths))

উন্নতির জন্য অবশ্যই সম্ভাবনার সম্ভাবনা আছে এবং ঐচ্ছিক __init__.py ফাইলগুলি অন্যান্য পরিবর্তনগুলির প্রয়োজন হতে পারে, কিন্তু যদি আপনার কাছে __init__.py সাধারণভাবে থাকে তবে এটি কৌশলটি করে।


এখানে কিছু কোড যা সমস্ত পাইথন সংস্করণগুলিতে কাজ করে, 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())

আমি এটা পরীক্ষা করেছিলাম। এটি কুৎসিত হতে পারে তবে এ পর্যন্ত একমাত্র যা সমস্ত সংস্করণে কাজ করে।


পাইথন 3.4 এর এই এলাকাটি বোঝার জন্য অত্যন্ত যন্ত্রণাদায়ক মনে হচ্ছে! তবে শুরুতে ক্রিস ক্যালোয়েয়ের কোডটি ব্যবহার করে হ্যাকিংয়ের একটি বিট দিয়ে আমি কিছু কাজ করতে পেরেছি। এখানে মৌলিক ফাংশন।

def import_module_from_file(full_path_to_module):
    """
    Import a module given the full path/filename of the .py file

    Python 3.4

    """

    module = None

    try:

        # Get module name and path from full path
        module_dir, module_file = os.path.split(full_path_to_module)
        module_name, module_ext = os.path.splitext(module_file)

        # Get module "spec" from filename
        spec = importlib.util.spec_from_file_location(module_name,full_path_to_module)

        module = spec.loader.load_module()

    except Exception as ec:
        # Simple error printing
        # Insert "sophisticated" stuff here
        print(ec)

    finally:
        return module

এটি পাইথন 3.4 থেকে অপ্রচলিত মডিউলগুলি ব্যবহার করতে বলে মনে হচ্ছে। কেন আমি বুঝতে পারছি না কেন, কিন্তু এটি একটি প্রোগ্রাম থেকে কাজ করে বলে মনে হচ্ছে। আমি ক্রিস সমাধান সমাধান কমান্ড লাইন কাজ কিন্তু একটি প্রোগ্রাম ভিতরে থেকে পাওয়া যায় নি।


পাইথন মডিউল test.py তৈরি করুন

import sys
sys.path.append("<project-path>/lib/")
from tes1 import Client1
from tes2 import Client2
import tes3

পাইথন মডিউল test_check.py তৈরি করুন

from test import Client1
from test import Client2
from test import test3

আমরা মডিউল থেকে আমদানি মডিউল আমদানি করতে পারেন।


প্রদত্ত ফাইলের নাম থেকে একটি মডিউল আমদানি করতে, আপনি সাময়িকভাবে পথটি প্রসারিত করতে এবং অবশেষে ব্লক 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

বেশ সহজ উপায়: ধরুন আপনি আপেক্ষিক পথ দিয়ে ফাইল আমদানি করতে চান ../../MyLibs/pyfunc.py


libPath = '../../MyLibs'
import sys
if not libPath in sys.path: sys.path.append(libPath)
import pyfunc as pf

কিন্তু আপনি যদি কোন গার্ড ছাড়াই এটি তৈরি করেন তবে অবশেষে আপনি খুব দীর্ঘ পথ পেতে পারেন


মনে হচ্ছে আপনি বিশেষভাবে কনফিগারেশন ফাইলটি আমদানি করতে চান না (যার সাথে অনেকগুলি পার্শ্ব প্রতিক্রিয়া এবং জড়িত অতিরিক্ত জটিলতা রয়েছে), আপনি কেবল এটি চালাতে চান এবং ফলে নামস্থান অ্যাক্সেস করতে সক্ষম হবেন। স্ট্যান্ডার্ড লাইব্রেরিটি বিশেষভাবে runpy.run_path রূপে একটি API runpy.run_path :

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

যে ইন্টারফেস Python 2.7 এবং পাইথন 3.2+ পাওয়া যায়


লিনাক্সে, আপনার পাইথন স্ক্রিপ্টটি কাজ করে এমন ডিরেক্টরিতে একটি প্রতীকী লিঙ্ক যোগ করে।

অর্থাৎ,

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 এর সামগ্রী পরিবর্তন করেন

তারপর mypythonscript.py এ নিম্নলিখিত অন্তর্ভুক্ত করুন

from module import *

সবচেয়ে ভাল উপায়, আমি মনে করি, অফিসিয়াল ডকুমেন্টেশন থেকে ( 29.1। Imp - আমদানি অভ্যন্তরীণ অ্যাক্সেস ):

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)

def import_file(full_path_to_module):
    try:
        import os
        module_dir, module_file = os.path.split(full_path_to_module)
        module_name, module_ext = os.path.splitext(module_file)
        save_cwd = os.getcwd()
        os.chdir(module_dir)
        module_obj = __import__(module_name)
        module_obj.__file__ = full_path_to_module
        globals()[module_name] = module_obj
        os.chdir(save_cwd)
    except:
        raise ImportError

import_file('/home/somebody/somemodule.py')




python-module