python導入模塊路徑

『壹』 怎麼從python引入自己的模塊

1.如果導入的模塊和主程序在同個目錄下，直接import就行了
2.如果導入的模塊是在主程序所在目錄的子目錄下，可以在子目錄中增加一個空白的__init__.py文件，該文件使得python解釋器將子目錄整個也當成一個模塊，然後直接通過「import 子目錄.模塊」導入即可。
3.如果導入的模塊是在主程序所在目錄的父目錄下，則要通過修改path來解決，有兩種方法：
(1)通過」import sys，sys.path.append('父目錄的路徑')「來改變，這種方法屬於一次性的，只對當前的python解釋器進程有效，關掉python重啟後就失效了。
(2)直接修改環境變數：在windows中是 「 set 變數=『路徑』 」 例如：set PYTHONPATH=『C:\test\...』 查看是否設置成功用echo %PYTHONPATH%,而且進到python解釋器中查看sys.path,會發現已經有了新增加的路徑了。這種方式是永久的，一次設置以後一直都有效。在linux中是 "export 變數=『路徑』 「，查看是" echo $變數 "
通過修改path是通用的方法，因為python解釋器就是通過sys.path去一個地方一個地方的尋找模塊的。

『貳』 Python找不到自定義的模塊

Python導入模塊時實際上是在 sys.path 中進行查找的。
一般會包括標准庫、第三方庫、當前文件目錄。
6. 模塊 — Python 3.10.5 文檔

有時候我們定義的模塊不在這裡面，可以手動 append 到 sys.path 。

相對路徑：在Python中可以用 . 表示當前目錄， .. 表示當前文件的上一級目錄。這個相對路徑實際上是相對 執行python xx.py命令時候 所在的目錄。

『叄』 如何在linux環境下添加python模塊路徑

本人python菜鳥一枚，在學習python過程中，經常要按照教程編寫一些模塊和函數練手，剛開始只是在python shell中編寫，但是如果出錯就會非常悲劇，又要從頭開始編，而且重啟python後也要重新編寫模塊。所以希望能像bash編程那樣將腳本路徑添加到環境變數中，這樣修改起來也方便。以下內容均來源於網路及本菜鳥。

摘要：本文敘述了如何在linux環境下添加python模塊的路徑，第1部分介紹了如何查看python環境變數，第2部分介紹了如何將腳本放入python自帶的環境變數目錄中，第3部分介紹了如何將目錄放入python的環境變數中重啟python失效，第4部分介紹了如何為python添加永久環境變數目錄。這些方法可以使模塊的修改和重復使用更加方便，不用重復輸入。

​

​1、首先，可以用python中的內建模塊sys來查看python的環境變數。

​這些目錄都是python的環境變數。

2.接下來本菜鳥嘗試一下如果將提前寫好的python腳本放入這些目錄中，能不能在python中使用。別問為什麼跑題，本菜就想試一試^ -^。

選擇/usr/local/lib/python2.7/dist-packages/pip-7.1.2-py2.7.egg這個目錄，腳本名為my_mole.py，裡面只有一個名為c_to_f的函數，用來計算從攝氏溫度轉換為華氏溫度。

​可以看到，腳本已經位於剛開始選定的的目錄下了。

我們現在來看看，在python中導入這個模塊。並按照「模塊.函數」的格式使用函數。

​可以看到，導入模塊成功，其中的c_to_f函數也正確使用，10攝氏度=50華氏度。或者你在確定函數名不重名的前提下，可以from my_mole import c_to_f，這樣就可以直接使用函數c_to_f，而不需要模塊名作為前綴。

​

實驗成功，將腳本導入python自帶的環境變數目錄中是有效的​，如果之前運行了python，再導入後並不用重啟python就可以導入模塊。

3.接下來​我們回歸正題，如何自定義python環境變數目錄。最直接的想法是把目錄加到剛才的python環境變數中。可以使用sys.path.append('/.../....')。

​然後再次查看path路徑，發現"/home/sh/python"目錄確實加入了。並且也可以使用。但是這種方法一旦退出python，剛才新加的目錄就消失了。

4.接下來介紹一種一勞永逸的方法，就是直接修改系統變數。

export PYTHONPATH=$PYTHONPATH:/..../..../​，對，沒錯，直接在shell中敲這一行，目錄是你自定義的目錄，然後打開python，import my_mole，你就愉快的可以使用自定義的模塊了。

http://blog.sina.com.cn/s/blog_959cf80d0102vx3j.html

『肆』 在python中如何導入兩個不同目錄下自定義的模塊呢

import sys
print sys.path

上面的代碼會給出所有可用的python路徑，你把.py文件放到這些路徑下面就可以在其他文件里導入它了。
另外一個特殊的路徑就是當前路徑，比如你在一個文件夾test下新建兩個.py文件，分別為123.py 和456.py ，那麼你可以在123.py寫：

import 456

就可以導入456.py了。

python的模塊都是.py文件，提示invaild syntax 是說語法錯誤。如果你用的是python3，那你的print就寫錯了。python2和3的print 區別如下。

print 'hello world' #python2
print('hello world') #python3

『伍』 Python導入模塊問題

Python是一種面向對象的編程語言，裡麵包含有豐富強大的庫，想要學習Python開發，首先需要學習如何導入模塊或包。下面就跟大家一起討論下Python導入模塊的幾種方法：
常規導入
最常用的導入方式，大概是這樣的：
import sys
只需要使用 import ，然後指定希望導入的模塊或包即可。用這種方法導入的好處是可以一次性導入多個包或模塊：
import os, sys, time
雖然這節省了空間，但是卻違背了Python風格指南。 Python風格指南建議將每個導入語句單獨成行 。
有時在導入模塊時，你想要重命名這個模塊。這個功能很容易實現：
import sys as system
print(system.platform)
上面的代碼將我們導入的 sys 模塊重命名為 system 。我們可以按照和以前一樣的方式調用模塊的方法，但是可以用一個新的模塊名。也有某些子模塊必須要使用點標記法才能導入。
import urllib.error
這個情況不常見，但是對此有所了解總是沒有壞處的。
使用from語句導入
有時我們只想要導入一個模塊或庫中的某個部分。那麼Python是如何實現這點：
from functools import lru_cache
上面這行代碼可以讓你直接調用 lru_cache 。如果按常規方式導入 functools ，那麼就必須像這樣調用 lru_cache ：
functools.lru_cache(*args)
根據實際的使用場景，上面的做法可能是更好的。在復雜的代碼庫中，能夠看出某個函數是從哪裡導入的這點很有用的。不過，如果你的代碼維護的很好，模塊化程度高，那麼只從某個模塊中導入一部分內容也是非常方便和簡潔的。
當然，你還可以使用from方法導入模塊的全部內容，就像這樣：
from os import *
這種做法在少數情況下是挺方便的，但是這樣也會打亂你的命名空間。問題在於，你可能定義了一個與導入模塊中名稱相同的變數或函數，這時如果你試圖使用
os 模塊中的同名變數或函數，實際使用的將是你自己定義的內容。因此，你最後可能會碰到一個相當讓人困惑的邏輯錯誤。
標准庫中我唯一推薦全盤導入的模塊只有Tkinter 。
如果你正好要寫自己的模塊或包，有人會建議你在 __init__.py 文件中導入所有內容，讓模塊或者包使用起來更方便。我個人更喜歡顯示地導入，而非隱式地導入。
你也可以採取折中方案，從一個包中導入多個項：
from os import path, walk, unlinkfrom os import uname, remove
在上述代碼中，我們從 os 模塊中導入了5個函數。你可能注意到了，我們是通過多次從同一個模塊中導入實現的。當然，如果你願意的話，你也可以使用圓括弧一次性導入多個項：
from os import (path, walk, unlink, uname,
remove, rename)
這是一個有用的技巧，不過你也可以換一種方式：
from os import path, walk, unlink, uname, \
remove, rename
上面的反斜杠是Python中的續行符，告訴解釋器這行代碼延續至下一行。
相對導入
PEP 328 介紹了引入相對導入的原因，以及選擇了哪種語法。具體來說，是使用句點來決定如何相對導入其他包或模塊。這么做的原因是為了避免偶然情況下導入標准庫中的模塊產生沖突。這里我們以PEP 328中給出的文件夾結構為例，看看相對導入是如何工作的：
my_package/
__init__.py
subpackage1/
__init__.py
mole_x.py
mole_y.py
subpackage2/
__init__.py
mole_z.py
mole_a.py
在本地磁碟上找個地方創建上述文件和文件夾。在頂層的 __init__.py 文件中，輸入以下代碼：
from . import subpackage1from . import subpackage2
接下來進入 subpackage1 文件夾，編輯其中的 __init__.py 文件，輸入以下代碼：
from . import mole_xfrom . import mole_y
現在編輯 mole_x.py 文件，輸入以下代碼：
from .mole_y import spam as ham
def main():
ham()
最後編輯 mole_y.py 文件，輸入以下代碼：
def spam():
print('spam ' * 3)
打開終端， cd 至 my_package 包所在的文件夾，但不要進入 my_package 。在這個文件夾下運行Python解釋器。我使用的是IPython，因為它的自動補全功能非常方便：
In [1]: import my_package
In [2]: my_package.subpackage1.mole_xOut[2]: <mole
'my_package.subpackage1.mole_x' from
'my_package/subpackage1/mole_x.py'>
In [3]: my_package.subpackage1.mole_x.main()spam spam spam
相對導入適用於你最終要放入包中的代碼。如果你編寫了很多相關性強的代碼，那麼應該採用這種導入方式。
你會發現PyPI上有很多流行的包也是採用了相對導入 。還要注意一點，如果你想要跨越多個文件層級進行導入，只需要使用多個句點即可。不過， PEP
328建議相對導入的層級不要超過兩層 。
還要注意一點，如果你往 mole_x.py 文件中添加了 if __name__ == 『__main__』 ，然後試圖運行這個文件，你會碰到一個很難理解的錯誤。編輯一下文件，試試看吧！
from . mole_y import spam as ham
def main():
ham()
if __name__ == '__main__':
# This won't work!
main()
現在從終端進入 subpackage1 文件夾，執行以下命令：
python mole_x.py
如果你使用的是Python 2，你應該會看到下面的錯誤信息：
Traceback (most recent call last):
File "mole_x.py", line 1, in <mole>
from . mole_y import spam as hamValueError: Attempted relative import in non-package
如果你使用的是Python 3，錯誤信息大概是這樣的：
Traceback (most recent call last):
File "mole_x.py", line 1, in <mole>
from . mole_y import spam as hamSystemError: Parent mole '' not loaded, cannot perform relative import
這指的是， mole_x.py 是某個包中的一個模塊，而你試圖以腳本模式執行，但是 這種模式不支持相對導入 。
如果你想在自己的代碼中使用這個模塊，那麼你必須將其添加至Python的導入檢索路徑（import search path）。最簡單的做法如下：
import syssys.path.append('/path/to/folder/containing/my_package')import my_package
注意，你需要添加的是 my_package 的上一層文件夾路徑，而不是 my_package 本身。原因是 my_package 就是我們想要使用的包，所以如果你添加它的路徑，那麼將無法使用這個包。
我們接下來談談可選導入。
可選導入（Optional imports）
如果你希望優先使用某個模塊或包，但是同時也想在沒有這個模塊或包的情況下有備選，你就可以使用可選導入這種方式。這樣做可以導入支持某個軟體的多種版本或者實現性能提升。以 github2包 中的代碼為例：
try:
# For Python 3
from http.client import responsesexcept ImportError: # For Python 2.5-2.7
try:
from httplib import responses # NOQA
except ImportError: # For Python 2.4
from BaseHTTPServer import BaseHTTPRequestHandler as _BHRH
responses = dict([(k, v[0]) for k, v in _BHRH.responses.items()])
lxml 包也有使用可選導入方式：
try:
from urlparse import urljoin
from urllib2 import urlopenexcept ImportError:
# Python 3
from urllib.parse import urljoin
from urllib.request import urlopen
正如以上示例所示， 可選導入的使用很常見，是一個值得掌握的技巧 。
局部導入
當你在局部作用域中導入模塊時，你執行的就是局部導入。如果你在Python腳本文件的頂部導入一個模塊，那麼你就是在將該模塊導入至全局作用域，這意味著之後的任何函數或方法都可能訪問該模塊。例如：
import sys # global scope
def square_root(a):
# This import is into the square_root functions local scope
import math
return math.sqrt(a)
def my_pow(base_num, power):
return math.pow(base_num, power)
if __name__ == '__main__':
print(square_root(49))
print(my_pow(2, 3))
這里，我們將 sys 模塊導入至全局作用域，但我們並沒有使用這個模塊。然後，在 square_root 函數中，我們將 math
模塊導入至該函數的局部作用域，這意味著 math 模塊只能在 square_root 函數內部使用。如果我們試圖在 my_pow 函數中使用
math ，會引發 NameError 。試著執行這個腳本，看看會發生什麼。
使用局部作用域的好處之一，是你使用的模塊可能需要很長時間才能導入，如果是這樣的話，將其放在某個不經常調用的函數中或許更加合理，而不是直接在全局作
用域中導入。老實說，我幾乎從沒有使用過局部導入，主要是因為如果模塊內部到處都有導入語句，會很難分辨出這樣做的原因和用途。
根據約定，所有的導入語句都應該位於模塊的頂部 。
導入注意事項
在導入模塊方面，有幾個程序員常犯的錯誤。這里我們介紹兩個。
循環導入（circular imports）
覆蓋導入（Shadowed imports，暫時翻譯為覆蓋導入）
先來看看循環導入。
循環導入
如果你創建兩個模塊，二者相互導入對方，那麼就會出現循環導入。例如：
# a.pyimport b
def a_test():
print("in a_test")
b.b_test()
a_test()
然後在同個文件夾中創建另一個模塊，將其命名為 b.py 。
import a
def b_test():
print('In test_b"')
a.a_test()
b_test()
如果你運行任意一個模塊，都會引發 AttributeError 。這是因為這兩個模塊都在試圖導入對方。簡單來說，模塊 a 想要導入模塊 b
，但是因為模塊 b 也在試圖導入模塊 a （這時正在執行），模塊 a 將無法完成模塊 b
的導入。我看過一些解決這個問題的破解方法（hack），但是 一般來說，你應該做的是重構代碼，避免發生這種情況 。
覆蓋導入
當你創建的模塊與標准庫中的模塊同名時，如果你導入這個模塊，就會出現覆蓋導入。舉個例子，創建一個名叫 math.py 的文件，在其中寫入如下代碼：
import math
def square_root(number):
return math.sqrt(number)
square_root(72)
現在打開終端，試著運行這個文件，你會得到以下回溯信息（traceback）：
Traceback (most recent call last):
File "math.py", line 1, in <mole>
import math
File "/Users/michael/Desktop/math.py", line 6, in <mole>
square_root(72)
File "/Users/michael/Desktop/math.py", line 4, in square_root
return math.sqrt(number)AttributeError: mole 'math' has no attribute 'sqrt'
這到底是怎麼回事？其實，你運行這個文件的時候，Python解釋器首先在當前運行腳本所處的的文件夾中查找名叫 math
的模塊。在這個例子中，解釋器找到了我們正在執行的模塊，試圖導入它。但是我們的模塊中並沒有叫 sqrt 的函數或屬性，所以就拋出了
AttributeError 。

『陸』 python 導入模塊問題

導入模塊是會執行一遍的
如果不想在導入模塊時執行某部分代碼，
需要將那部分代碼到
if __name__=='__main__': 裡面，
那部分代碼只會在當他是作為主文件運行時才會跑

『柒』 python 中庫怎麼導入

讓包內導入更加顯式，這個功能的一部分設計初衷是，為了幫助腳本解決同名文件出現在模塊搜索路徑上多個不同位置時的二義性。考慮包目錄，這定義了一個名為mypkg 的包，其中含有名為mypkg.main和mypkg.string 的模塊。現在，假設模塊main試圖導入名為string的模塊。在 Python 2.X和更早版本中，Python會先尋找mypkg目錄以執行相對導入。這會找到並導入位於該處的string.py文件，將其賦值給mypkg.main模塊命名空間內的名稱string。不過，這一導入的本意可能是要導入Python標准庫的string模塊。可惜的是，在這些Python版本中，無法直接忽略mypkg.string 去尋找位於模塊搜索路徑更右側的標准庫中的string模塊。此外，我們無法使用完整包導入路徑來解決這個問題，因為我們無法依賴在每台機器上的標准鏈接庫路徑。換句話說，包中的簡單導入可能具有二義性而且容易出錯。在包內，我們無法確定imports pam語句指的是包內的模塊還是包外的模塊。一種可能的後果是，一個局部的模塊或包會在不經意間隱藏了sys.path 上的另一個模塊。
在實踐中，Python使用者可以避免為他們自己的模塊重復使用標准庫模塊的名稱（如果需要標准string庫，就不要把新的模塊命名為string)。但是，一個包還是有可能意外地隱藏標准庫模塊。再者，Python 以後可能新增標准庫模塊，而其名稱可能剛好就和自己的一個模塊同名。而依賴於沒有點號開頭相對導入的程序代碼同樣也不容易理解，因為讀者可能對希望使用哪個模塊而感到困惑。所以我們最好能在代碼中顯式地指出導入的解析過程。

『捌』 python怎麼導入同一包的模塊

一、何為模塊

1.一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴。

2.模塊目的和函數，對象等一樣，是為了代碼的復用性而存在的。即一個py程序寫了很多功能，也可以被其他py程序調用。被調用後被作為模塊，此時會產生一個pyc的文件即為這個模塊的緩存文件，相當於編譯了模塊文件使該py模塊被調用的速度變快。一個大的項目一個人肯定是不行的，所以模塊也為程序員相互間的合作提供了便利。

二、模塊妙用

1.import

只需要在py程序開頭加上import 文件名（不能有.py後綴）。例如，模塊的文件名是span.py，那麼只需在自己的py程序加import span。

2. import可以在程序的任意位置調用，但一次調用後會駐留內存，下次再調用會直接調用內存中的模塊（python的優化）。

3.個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當做全局名稱空間，這樣我們在編寫自己的模塊時，就不用擔心我們定義在自己模塊中全局變數會在被導入時，與使用者的全局變數沖突。

print('from the spam.py')

money=1000def read1(): print('spam->read1->money',1000)def read2(): print('spam->read2 calling read')
read1()def change(): global money
money=0

支持tab自動補全

『玖』 python 怎樣添加模塊載入路徑

這里主要介紹第二種方法：通過.ph文件進行設置，好處是可以將路徑設為永久路徑

在Python的安裝目錄下，找到Libsite-packages文件夾，在該文件夾下新建一個以.pth為後綴名的文件，編輯文件，內容為要添加的庫路徑。（我的文件名命名為setpath.pth）。添加路徑示例：文件內容寫入要引用的庫路徑

步驟1：建立文件，可以首先建立一個文本文檔，寫下路徑如D:\Python\mulib。我這里新建的文件路徑的文件夾命名為「mulib」

步驟3：將保存好的文件放在Python的site-packages文件夾中就完成了。