Göreli yoldan bir modülü içe aktarma

Göreli yolu verilen bir Python modülünü nasıl alabilirim?

Örneğin, dirFooiçerdiği Foo.pyve dirBarve dirBariçerdiği Bar.py, nasıl aktarırım Bar.pyiçine Foo.py?

İşte görsel bir sunum:

dirFoo\
    Foo.py
    dirBar\
        Bar.py

Fooeklemek istiyor Bar, ancak klasör hiyerarşisini yeniden yapılandırmak bir seçenek değil.

Her iki dizininizin de gerçek Python paketleri olduğunu varsayarsak ( __init__.pyiçinde dosya var), modüllerin komut dosyasının konumuna nispeten dahil edilmesi için güvenli bir çözüm.

Bunu yapmak istediğinizi varsayıyorum, çünkü senaryonuza bir dizi modül eklemeniz gerekiyor. Bunu çeşitli ürünlerde üretimde kullanıyorum ve başka bir dizinden çağrılan veya yeni bir yorumlayıcı açmak yerine python ile yürütülen komut dosyaları gibi birçok özel senaryoda çalışıyor.

 import os, sys, inspect
 # realpath() will make your script run, even if you symlink it :)
 cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
 if cmd_folder not in sys.path:
     sys.path.insert(0, cmd_folder)

 # Use this if you want to include modules from a subfolder
 cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"subfolder")))
 if cmd_subfolder not in sys.path:
     sys.path.insert(0, cmd_subfolder)

 # Info:
 # cmd_folder = os.path.dirname(os.path.abspath(__file__)) # DO NOT USE __file__ !!!
 # __file__ fails if the script is called in different ways on Windows.
 # __file__ fails if someone does os.chdir() before.
 # sys.argv[0] also fails, because it doesn't not always contains the path.

Bonus olarak, bu yaklaşım Python'u sisteminizde yüklü olanlar yerine modülünüzü kullanmaya zorlamanıza izin verir.

Uyarı! Mevcut modül bir eggdosyanın içindeyken ne olduğunu gerçekten bilmiyorum . Muhtemelen de başarısız oluyor.

DirBar'ın dosyaya sahip olduğundan emin olun __init__.py- bu, bir dizini Python paketine dönüştürür.

Ayrıca, alt dizini Python yolunuza ekleyerek normal bir komut dosyası olarak içe aktarabilirsiniz.

import sys
sys.path.insert(0, <path to dirFoo>)
import Bar

import os
import sys
lib_path = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'lib'))
sys.path.append(lib_path)

import mymodule

Farklı bir klasörden .py dosyasını almak için basit şeyler yapın.

Diyelim ki aşağıdaki gibi bir dizininiz var:

lib/abc.py

Sonra boş bir dosyayı adlandırılmış şekilde lib klasöründe tutun

__init__.py

Ve sonra kullan

from lib.abc import <Your Module name>

__init__.pyDosyayı, içe aktarma modülünün hiyerarşisinin her klasöründe tutun .

Projenizi bu şekilde yapılandırırsanız:

src\
  __init__.py
  main.py
  dirFoo\
    __init__.py
    Foo.py
  dirBar\
    __init__.py
    Bar.py

Sonra Foo.py'den şunları yapabilmelisiniz:

import dirFoo.Foo

Veya:

from dirFoo.Foo import FooObject

Tom'un yorumuna göre, bu, srcklasöre ya site_packagesda arama yolunuzdan erişilebilir olmasını gerektirir . Ayrıca, bahsettiği gibi, __init__.pyo paket / dizine bir modülü ilk kez içe aktardığınızda dolaylı olarak içe aktarılır. Genellikle __init__.pyboş bir dosyadır.

En kolay yöntem sys.path.append () yöntemini kullanmaktır.

Ancak, imp modülüyle de ilgilenebilirsiniz . Dahili içe aktarma işlevlerine erişim sağlar.

# mod_name is the filename without the .py/.pyc extention
py_mod = imp.load_source(mod_name,filename_path) # Loads .py file
py_mod = imp.load_compiled(mod_name,filename_path) # Loads .pyc file 

Bu, bir modülün adını bilmediğinizde modülleri dinamik olarak yüklemek için kullanılabilir.

Geçmişte, kullanıcının uygulamaya özgü işlevleri olan bir komut dosyası yazacağı ve yalnızca komut dosyasını belirli bir dizine bırakacağı bir uygulamaya bir eklenti türü arabirimi oluşturmak için bunu kullandım.

Ayrıca, bu işlevler yararlı olabilir:

imp.find_module(name[, path])
imp.load_module(name, file, pathname, description)

İlgili PEP:

http://www.python.org/dev/peps/pep-0328/

Özellikle, dirFoo dirBar bir dizin ...

DirFoo \ Foo.py içinde:

from ..dirBar import Bar

Betiğinizde herhangi bir değişiklik yapmadan en kolay yol PYTHONPATH ortam değişkenini ayarlamaktır. Sys.path bu konumlardan başlatıldığından:

1. Giriş komut dosyasını (veya geçerli dizini) içeren dizin.
2. PYTHONPATH (kabuk değişkeni PATH ile aynı sözdizimine sahip dizin adlarının listesi).
3. Yüklemeye bağlı varsayılan.

Sadece koş:

export PYTHONPATH=/absolute/path/to/your/module

Sys.path, aşağıda gösterildiği gibi yukarıdaki yolu içerecektir:

print sys.path

['', '/absolute/path/to/your/module', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7', '/usr/lib/python2.7/dist-packages/ubuntu-sso-client', '/usr/lib/python2.7/dist-packages/ubuntuone-client', '/usr/lib/python2.7/dist-packages/ubuntuone-control-panel', '/usr/lib/python2.7/dist-packages/ubuntuone-couch', '/usr/lib/python2.7/dist-packages/ubuntuone-installer', '/usr/lib/python2.7/dist-packages/ubuntuone-storage-protocol']

Bence en iyi seçim __ init __.py'yi klasöre koymak ve dosyayı

from dirBar.Bar import *

Mevcut python paketiyle aynı dosya adını kullanırsanız bir şeyler ters gidebileceğinden, sys.path.append () yönteminin kullanılması önerilmez. Bunu test etmedim ama bu belirsiz olacak.

Linux kullanıcıları için hızlı ve kirli yol

Sadece uğraşıyorsanız ve dağıtım sorunlarını umursamıyorsanız, modülü veya paketi istekte bulunan modülün klasöründe doğrudan görünür hale getirmek için sembolik bir bağlantı kullanabilirsiniz (dosya sisteminizin desteklediğini varsayarak).

ln -s (path)/module_name.py

veya

ln -s (path)/package_name

Not: "Modül", .py uzantılı herhangi bir dosyadır ve "paket", dosyayı içeren __init__.py(boş bir dosya olabilir) herhangi bir klasördür . Kullanım açısından bakıldığında, modüller ve paketler aynıdır - her ikisi de importkomut aracılığıyla istendiği gibi içerdikleri "tanımları ve ifadeleri" ortaya koyar.

Bkz. Http://docs.python.org/2/tutorial/modules.html

from .dirBar import Bar

onun yerine:

from dirBar import Bar

başka bir dirBar kurulu olması ve foo.py okuyucunun karıştırılması durumunda.

Bu durumda Bar.py'yi Foo.py'ye aktarmak için, önce bu klasörleri şu şekilde Python paketlerine dönüştürürüm:

dirFoo\
    __init__.py
    Foo.py
    dirBar\
        __init__.py
        Bar.py

Sonra Foo.py böyle yapardı:

from .dirBar import Bar

İsim aralığının Bar gibi görünmesini isteseydim. her neyse , ya da

from . import dirBar

Eğer isimlendirmek dirBar.Bar isteseydim. her neyse . Bu ikinci durum, dirBar paketi altında daha fazla modülünüz varsa kullanışlıdır.

__İnit__.py dosyası ekleyin :

dirFoo\
    Foo.py
    dirBar\
        __init__.py
        Bar.py

Sonra bu kodu Foo.py'nin başına ekleyin:

import sys
sys.path.append('dirBar')
import Bar

Göreli sys.path örneği:

# /lib/my_module.py
# /src/test.py


if __name__ == '__main__' and __package__ is None:
    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../lib')))
import my_module

Bu cevaba dayanarak .

Bahsettiğiniz gibi, genellikle ana komut dosyanızın çalıştığı yere göre modüllerinizle bir klasöre erişmek istersiniz, bu yüzden onları içe aktarırsınız.

Çözüm:

Ben komut dosyası D:/Books/MyBooks.pyve bazı modüller (oldies.py gibi) var. Alt dizinden almak gerekir D:/Books/includes:

import sys,site
site.addsitedir(sys.path[0] + '\\includes')
print (sys.path)  # Just verify it is there
import oldies

Her şeyin yolunda gittiğini doğrulamak için bir print('done')yer yerleştirin oldies.py. Bu yol her zaman çalışır çünkü sys.pathprogram başlangıcında başlatılan Python tanımıyla , bu listenin ilk öğesi olan path[0]Python yorumlayıcısını çağırmak için kullanılan komut dosyasını içeren dizindir.

Kod dizini mevcut değilse (örneğin, yorumlayıcı etkileşimli olarak çağrılırsa veya kod standart girdiden okunursa), path[0]Python'u önce geçerli dizindeki modülleri aramaya yönlendiren boş dizedir. Komut dosyası dizininin bir sonucu olarak eklenen girdilerden önce eklendiğine dikkat edin PYTHONPATH.

Basitçe kullanabilirsiniz: from Desktop.filename import something

Misal:

dosyanın test.pydizindeki ad olduğu Users/user/Desktopve her şeyi içe aktaracağı göz önüne alındığında .

kod:

from Desktop.test import *

Ancak __init__.pybu dizinde " " adında boş bir dosya yaptığınızdan emin olun

Başka bir çözüm py-requir paketi kurmak ve daha sonra aşağıdakileri kullanmak olacaktır:Foo.py

import require
Bar = require('./dirBar/Bar')

Göreli yolu kullanarak bir düzeyden bir dosyayı içe aktarmanın bir yolu.

Temel olarak, çalışma dizinini bir düzey (veya herhangi bir göreli konum) yukarı taşıyın, bunu yolunuza ekleyin, ardından çalışma dizinini başladığı yere geri taşıyın.

#to import from one level above:
cwd = os.getcwd()
os.chdir("..")
below_path =  os.getcwd()
sys.path.append(below_path)
os.chdir(cwd)

Python hakkında tecrübeli değilim, bu yüzden kelimelerimde herhangi bir yanlışlık varsa, söyle. Dosya hiyerarşiniz şu şekilde düzenlenmişse:

project\
    module_1.py 
    module_2.py

module_1.pyadında bir işlevi tanımlar func_1(), module_2.py :

from module_1 import func_1

def func_2():
    func_1()

if __name__ == '__main__':
    func_2()

ve python module_2.pycmd'de koşarsanız, func_1()tanımlayanı yapar. Genellikle aynı hiyerarşi dosyalarını bu şekilde içe aktarırız. Eğer yazarken Ama from .module_1 import func_1içinde module_2.py, piton tercüman diyecekler No module named '__main__.module_1'; '__main__' is not a package. Bunu düzeltmek için, sadece yaptığımız değişikliği koruyoruz ve her iki modülü de bir pakete taşıyoruz ve çalışacak arayan olarak üçüncü bir modül yapıyoruz module_2.py.

project\
    package_1\
        module_1.py
        module_2.py
    main.py

main.py :

from package_1.module_2 import func_2

def func_3():
    func_2()

if __name__ == '__main__':
    func_3()

Ama biz eklemek nedeni .önce module_1de module_2.pybiz bu ve koşmak yapmazsak yani main.py, piton tercüman diyecekler No module named 'module_1', biraz zor olduğunu, module_1.pysağ yanında module_2.py. Şimdi izin func_1()de module_1.pydo şey:

def func_1():
    print(__name__)

Bu __name__kayıtlar kim func_1 çağırır. Şimdi tutmak .önce module_1, koşmak main.py, bu yazdırır package_1.module_1değil module_1. O çağıran bir işaret func_1()ile aynı hiyerarşi olan main.py, .ima module_1ile aynı hiyerarşi olan module_2.pykendisi. Bir nokta yoksa, Yani main.pytanıyacak module_1kendisiyle aynı hiyerarşi de, bu tanıyabilir package_1, fakat ne "altında".

Şimdi biraz karmaşıklaştıralım. A config.inive modülünüz 'main.py' ile aynı hiyerarşide okumak için bir işlev tanımlar.

project\
    package_1\
        module_1.py
        module_2.py
    config.py
    config.ini
    main.py

Ve kaçınılmaz bir nedenden ötürü, onu aramak zorundasınız module_2.py, bu yüzden üst hiyerarşiden içe aktarmak zorunda. module_2.py :

 import ..config
 pass

İki nokta, üst hiyerarşiden içe aktarma anlamına gelir (üç nokta, üstten üste erişim vb.). Şimdi koşmak main.py, tercüman diyecekler: ValueError:attempted relative import beyond top-level package. Buradaki "üst düzey paket" dir main.py. Bunun config.pyyanında main.py, aynı hiyerarşide oldukları, config.py"altında" main.pyolmadığı veya "önderlik etmediği" main.pyiçin, ötesi de öyledir main.py. Bunu düzeltmek için en basit yol:

project\
    package_1\
        module_1.py
        module_2.py
    config.py
    config.ini
main.py

Bunun proje dosyası hiyerarşisini düzenleme ilkesine uyduğunu düşünüyorum, farklı klasörlerde farklı işlevlere sahip modüller ayarlamanız ve dışarıda en çok arayanı bırakmanız ve istediğiniz kadar içe aktarabilmeniz gerekir.

Bu aynı zamanda çalışır ve sysmodülle her şeyden çok daha basittir :

with open("C:/yourpath/foobar.py") as f:
    eval(f.read())

Bana aşırı temkinli diyorum, ama benimkini daha taşınabilir hale getirmeyi seviyorum çünkü dosyaların her bilgisayarda aynı yerde olacağını varsaymak güvensiz. Şahsen ben kod ilk dosya yolu aramak var. Linux kullanıyorum böylece benimki şöyle görünecek:

import os, sys
from subprocess import Popen, PIPE
try:
    path = Popen("find / -name 'file' -type f", shell=True, stdout=PIPE).stdout.read().splitlines()[0]
    if not sys.path.__contains__(path):
        sys.path.append(path)
except IndexError:
    raise RuntimeError("You must have FILE to run this program!")

Bunları birlikte paketlemeyi düşünmüyorsanız elbette. Ancak bu durumda, zaten iki ayrı dosyaya ihtiyacınız yoktur.