python導入模塊中的類

⑴ python導入模塊的方法有哪些

方法一
import modname
模塊是指一個可以交互使用，或者從另一Python 程序訪問的代碼段。只要導入了一個模塊，就可以引用它的任何公共的函數、類或屬性。模塊可以通過這種方法來使用其它模塊的功能。
用import語句導入模塊，就在當前的名稱空間(namespace)建立了一個到該模塊的引用.這種引用必須使用全稱，也就是說，當使用在被導入模塊中定義的函數時，必須包含模塊的名字。所以不能只使用 funcname，而應該使用 modname.funcname

方法二
from modname import funcname
from modname import fa, fb, fc
或者
from modname import *
與第1種方法的區別：funcname 被直接導入到本地名字空間去了，所以它可以直接使用，而不需要加上模塊名的限定* 表示，該模塊的所有公共對象(public objects)都被導入到 當前的名稱空間，也就是任何只要不是以」_」開始的東西都會被導入。
modname沒有被定義，所以modname.funcname這種方式不起作用。並且，如果funcname如果已經被定義，它會被新版本（該導入模塊中的版本）所替代。如果funcname被改成指向其他對象，modname不能不會覺察到。
建議:
1)如果你要經常訪問模塊的屬性和方法，且不想一遍又一遍地敲入模塊名，使用 from mole import
2)如果你想要有選擇地導入某些屬性和方法，而不想要其它的，使用 from mole import
3)如果模塊包含的屬性和方法與你的某個模塊同名，你必須使用import mole來避免名字沖突
4)盡量少用 from mole import * ，因為判定一個特殊的函數或屬性是從哪來的有些困難，並且會造成調試和重構都更困難。

方法三
內建函數__import__()
除了前面兩種使用import關鍵字的方法以外，我們還可以使用內建函數 __import__() 來導入 mole。兩者的區別是，import 後面跟的必須是一個類型(type)，而__import__() 的參數是一個字元串，這個字元串可能來自配置文件，也可能是某個表達式計算結果。例如：
mymole = __import__ (』mole_name』)
附註:
1)模塊的內容都放在一個模塊文件中，如 mymole 的內容應該放在PYTHONPATH 目錄下的一個mymole.py中，C實現的除外
2)包可以將幾個模塊名稱空間組織起來, 如A.b 就表示在包A中的一個子模塊b
可以單獨導入某一個子模塊，如Python文檔中給出的例子
import sound.effects.echo
這樣必須使用全稱對裡面的對象進行引用，如
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
還可以使用下面的語句來載入echo子模塊
from Sound.Effects import echo
它在沒有包前綴的情況下也可以使用， 所以它可以如下方式調用：
echo.echofilter(input, output, delay=0.7, atten=4)
不主張從一個包或模塊中用import * 導入所有模塊，因為這樣的通常會導致可讀性很差。
from Package import specific_submole的用法並沒有錯，實際上這還是推薦的用法，除非導入的模塊需要使用其它包中的同名子模塊(the importing mole needs to use submoles with the same name from different packages).
綜上所述，一般情況應該使用import , 但有幾個例外
1)mole文檔告訴你要用from-import的
2)導入一個包組件。需要一個包裡面的某個子模塊，一般用from A.b import c比import A.b.c 更方便 且不會冒混淆的危險.

⑵ python導入模塊，運行模塊里的函數時，模塊中的類去哪找

寫了一個a.py，在a.py中定義了一個函數A，一個類B，之後A的內部使用了B的實例。我在b.py導入from a import A,之後在b.py中調用A

啥事也沒有。

⑶ python怎麼給導入模塊的類重寫其中部分類方法啊

要重寫ca.py中Test類的test方法，可以這樣做：
from ca import *
def t(self,mu):self.b=mu
Test.test=t

當然也可以重寫__init__方法：
from ca import *
def __init__(self):self.a,self.b=0,0
Test.__init__=__init__

⑷ python 類和繼承，包及模塊導入 求解答

一 .mole

通常模塊為一個文件，直接使用import來導入就好了。可以作為mole的文件類型有".py"、".pyo"、".pyc"、".pyd"、".so"、".dll"。

二. package

通常包總是一個目錄，可以使用import導入包，或者from + import來導入包中的部分模塊。包目錄下為首的一個文件便是 __init__.py。然後是一些模塊文件和子目錄，假如子目錄中也有 __init__.py 那麼它就是這個包的子包了。

一.模塊你可以使用import語句將一個源代碼文件作為模塊導入.例如:

[python]view plain

• #file:spam.py

• a=37#一個變數

• deffoo:#一個函數

• print"I'mfoo"

• classbar:#一個類

• defgrok(self):

• print"I'mbar.grok"

• b=bar()#創建一個實例

使用import spam 語句就可以將這個文件作為模塊導入。系統在導入模塊時，要做以下三件事：

• 1.為源代碼文件中定義的對象創建一個名字空間，通過這個名字空間可以訪問到模塊中定義的函數及變數。


• 2.在新創建的名字空間里執行源代碼文件.


• 3.創建一個名為源代碼文件的對象，該對象引用模塊的名字空間，這樣就可以通過這個對象訪問模塊中的函數及變數，如：



[python]view plain

• importspam#導入並運行模塊spam

• printspam.a#訪問模塊spam的屬性

• spam.foo()

• c=spam.bar()

用逗號分割模塊名稱就可以同時導入多個模塊:

[python]view plain

• importsocket,os,regex

• 模塊導入時可以使用 as 關鍵字來改變模塊的引用對象名字:

[python]view plain

• importosassystem

• importsocketasnet,threadasthreads

• system.chdir("..")

• net.gethostname()

• 使用from語句可以將模塊中的對象直接導入到當前的名字空間. from語句不創建一個到模塊名字空間的引用對象，而是把被導入模塊的一個或多個對象直接放入當前的名字空間:



[python]view plain

• fromsocketimportgethostname#將gethostname放如當前名字空間

• printgethostname()#直接調用

• socket.gethostname()#引發異常NameError:socket

from語句支持逗號分割的對象，也可以使用星號(*)代表模塊中除下劃線開頭的所有對象:

[python]view plain

• fromsocketimportgethostname,socket

• fromsocketimport*#載入所有對象到當前名字空間

• 不過，如果一個模塊如果定義有列表__all__，則from mole import * 語句只能導入__all__列表中存在的對象。



[python]view plain

• #mole:foo.py

• __all__=['bar','spam']#定義使用`*`可以導入的對象

另外, as 也可以和 from 聯合使用:

[python]view plain

• h=hostname()

import 語句可以在程序的任何位置使用，你可以在程序中多次導入同一個模塊，但模塊中的代碼*僅僅*在該模塊被首次導入時執行。後面的import語句只是簡單的創建一個到模塊名字空間的引用而已。sys.moles字典中保存著所有被導入模塊的模塊名到模塊對象的映射。這個字典用來決定是否需要使用import語句來導入一個模塊的最新拷貝.

• from mole import * 語句只能用於一個模塊的最頂層.*特別注意*：由於存在作用域沖突，不允許在函數中使用from 語句。


• 每個模塊都擁有 __name__ 屬性，它是一個內容為模塊名字的字元串。最頂層的模塊名稱是 __main__ .命令行或是交互模式下程序都運行在__main__ 模塊內部. 利用__name__屬性，我們可以讓同一個程序在不同的場合（單獨執行或被導入)具有不同的行為，象下面這樣做：



[python]view plain

• #檢查是單獨執行還是被導入

• if__name__=='__main__':

• #Yes

• statements

• else:

• #No(可能被作為模塊導入)

• statements



• 模塊搜索路徑


• 導入模塊時,解釋器會搜索sys.path列表,這個列表中保存著一系列目錄。一個典型的sys.path 列表的值：


• Linux:


• ['', '/usr/local/lib/python2.0',


• '/usr/local/lib/python2.0/plat-sunos5',


• '/usr/local/lib/python2.0/lib-tk',


• '/usr/local/lib/python2.0/lib-dynload',


• '/usr/local/lib/python2.0/site-packages']


• Windows:


• ['', 'C:\WINDOWS\system32\python24.zip', 'C:\Documents and Settings\weizhong', 'C:\Python24\DLLs', 'C:\Python24\lib', 'C:\Python24\lib\plat-win', 'C:\Python24\lib\lib-tk', 'C:\Python24\Lib\site-packages\pythonwin', 'C:\Python24', 'C:\Python24\lib\site-packages', 'C:\Python24\lib\site-packages\win32', 'C:\Python24\lib\site-packages\win32\lib', 'C:\Python24\lib\site-packages\wx-2.6-msw-unicode']


• 空字元串 代表當前目錄. 要加入新的搜索路徑,只需要將這個路徑加入到這個列表.




• 模塊導入和匯編


• 到現在為止，本章介紹的模塊都是包含Python源代碼的文本文件. 不過模塊不限於此，可以被 import 語句導入的模塊共有以下四類:


• •使用Python寫的程序( .py文件)


• •C或C++擴展(已編譯為共享庫或DLL文件)


• •包(包含多個模塊)


• •內建模塊(使用C編寫並已鏈接到Python解釋器內)


• 當查詢模塊 foo 時,解釋器按照 sys.path 列表中目錄順序來查找以下文件(目錄也是文件的一種):


• 1.定義為一個包的目錄 foo


• 2.foo.so, foomole.so, foomole.sl,或 foomole.dll (已編譯擴展)


• 3.foo.pyo (只在使用 -O 或 -OO 選項時)


• 4.foo.pyc


• 5.foo.py




• 對於.py文件,當一個模塊第一次被導入時,它就被匯編為位元組代碼,並將位元組碼寫入一個同名的 .pyc文件.後來的導入操作會直接讀取.pyc文件而不是.py文件.(除非.py文件的修改日期更新,這種情況會重新生成.pyc文件) 在解釋器使用 -O 選項時，擴展名為.pyo的同名文件被使用. pyo文件的內容雖去掉行號,斷言,及其他調試信息的位元組碼，體積更小,運行速度更快.如果使用-OO選項代替-O,則文檔字元串也會在創建.pyo文件時也被忽略.


• 如果在sys.path提供的所有路徑均查找失敗,解釋器會繼續在內建模塊中尋找,如果再次失敗，則引發 ImportError 異常.


• .pyc和.pyo文件的匯編,當且僅當import 語句執行時進行.


• 當 import 語句搜索文件時,文件名是大小寫敏感的。即使在文件系統大小寫不敏感的系統上也是如此(Windows等). 這樣, import foo 只會導入文件foo.py而不會是FOO.PY.




• 重新導入模塊


• 如果更新了一個已經用import語句導入的模塊，內建函數reload()可以重新導入並運行更新後的模塊代碼.它需要一個模塊對象做為參數.例如:


• import foo


• ... some code ...


• reload(foo) # 重新導入 foo


• 在reload()運行之後的針對模塊的操作都會使用新導入代碼，不過reload()並不會更新使用舊模塊創建的對象，因此有可能出現新舊版本對象共存的情況。 *注意* 使用C或C++編譯的模塊不能通過 reload() 函數來重新導入。記住一個原則，除非是在調試和開發過程中，否則不要使用reload()函數.

⑸ 如何導入python中的模塊

定義模塊，只要使用文本編輯器，把一些python代碼輸入到文本中，然後以.py為後綴名進行保存，任何此類文件都會被認為是python模塊。
比如說，下面的代碼輸入到一個文件中，就可以看作是一個模塊：
def printme(var): print varif __name__ == '__main__': printme(1)

假設說輸入到a.py中，那麼import a就可以把這個模塊導入。
然後可執行a.printme(3)，屏幕即可列印出3：
>>> a.printme(3)3>>>

一個模塊頂層定義的變數，會自動變成模塊的屬性。例如：
data=[1,2,3]def printme(var): print varif __name__ == '__main__': printme(1)

data變數就是模塊的一個屬性。其實printme也是一個屬性，只不過是一個函數罷了。
引入模塊示例如下：（假定此時data=[1,2,3]未定義）

>>> import a>>> a.data Traceback (most recent call last): File "<pyshell#1>", line 1, in <mole> a.dataAttributeError: 'mole' object has no attribute 'data'>>> reload(a)<mole 'a' from 'C:/py\a.pyc'>>>> a.data Traceback (most recent call last): File "<pyshell#3>", line 1, in <mole> a.dataAttributeError: 'mole' object has no attribute 'data'>>>

從上述提示可以看出data屬性未定義，此時再在a.py文件中定義data=[1,2,3]，重新載入a模塊，並輸出data屬性：
>>> reload(a)<mole 'a' from 'C:/py\a.py'>>>> a.data[1, 2, 3]>>>

這里的reload函數可以重新載入一個模塊。如果在模塊代碼中更改了，那麼需要重新載入。
上面a.data，就是訪問模塊中的屬性。
上面的例子是導入一個文件作為一個模塊。
其實python的模塊導入還有更豐富的內容。
除了模塊名之外，python也可以導入指定目錄路徑。python代碼的目錄就稱為包。因此，這類導入就稱為包導入。事實上，包導入是把計算機上的目錄變成python的一個命名空間。而屬性就是目錄中包含的子目錄或者是模塊文件。
看下面例子：
在我的桌面上有一個aa文件夾，裡面有bb文件夾，bb裡面有a.py這個文件。
那麼在aa和bb文件夾中分別放置一個__init__.py，之後，在命令行中import aa.bb.a，就可以導入模塊a了。

⑹ 如何導入Python模塊中的類

正確的方法就是像你圖中這樣導入的。

只是你的init方法定義錯了，應該是__init__，前後各有兩個_，而你的只有一個。

⑺ 詳解Python中import方法引入模塊

在python用import或者from...import或者from...import...as...來導入相應的模塊，作用和使用方法與C語言的include頭文件類似。其實就是引入某些成熟的函數庫和成熟的方法，避免重復造輪子，提高開發速度。
python的import方法可以引入系統的模塊，也可以引入我們自己寫好的共用模塊，這點和php非常相似，但是它們的具體細節還不是很一樣。因為php是在引入的時候指明引入文件的具體路徑，而python中不能夠寫文件路徑進行引入。
下面總結一下import的幾種情況：
python包含子目錄中的模塊方法比較簡單，關鍵是能夠在sys.path裡面找到通向模塊文件的路徑。
下面將具體介紹幾種常用情況:
（1）主程序與模塊程序在同一目錄下:
如下面程序結構:
`-- src
|-- mod1.py
`-- test1.py
若在程序test1.py中導入模塊mod1, 則直接使用import mod1或from mod1 import *;
（2）主程序所在目錄是模塊所在目錄的父(或祖輩)目錄
如下面程序結構:
`-- src
|-- mod1.py
|-- mod2
| `-- mod2.py
`-- test1.py
若在程序test1.py中導入模塊mod2, 需要在mod2文件夾中建立空文件__init__.py文件(也可以在該文件中自定義輸出模塊介面); 然後使用 from mod2.mod2 import * 或import mod2.mod2.
（3）主程序導入上層目錄中模塊或其他目錄(平級)下的模塊
如下面程序結構:
`-- src
|-- mod1.py
|-- mod2
| `-- mod2.py
|-- sub
| `-- test2.py
`-- test1.py
若在程序test2.py中導入模塊mod1和mod2。首先需要在mod2下建立__init__.py文件(同(2))，src下不必建立該文件。然後調用方式如下:
下面程序執行方式均在程序文件所在目錄下執行，如test2.py是在cd sub;之後執行python test2.py
而test1.py是在cd src;之後執行python test1.py; 不保證在src目錄下執行python sub/test2.py成功。
import sys
sys.path.append("..")
import mod1
import mod2.mod2

⑻ 在python中,哪個關鍵字可以導入模塊

有兩種：
①import +模塊名
②from +模塊名 import +模塊下的方法/類/值名
①示例：import math
之後可以使用math.log(40)等函數了，它會返回3.6888794541139363。
還有一種類似於import math as m，它就是表示你只要輸入m就代表math了，可以方便寫。這樣的話就寫m.log(40)
②示例：from math import log
之後可以直接使用log(40)，但是不能使用math.（因為被跳過了），結果同上。
還有一種，就是類似於from math import *
這樣之後，你就會把所有的math里的直接的方法/類/值調用出來，直接使用。

⑼ Python中怎樣將一個類引入到另一個模塊中

如果要引入的類在同一個文件中，直接使用即可，如果不在一個py文件中，則先import
這個類所在的py文件，然後直接使用
如，類a在moleA.py文件中，則先import
moleA
使用方式為moleA.a

⑽ python導入模塊的「最佳實踐」是什麼

通常，不要使用from molename import *。這樣做會使導入器的命名空間變得混亂，並且使得連接器更難以檢測未定義的名稱。

在文件的頂部導入模塊。這樣做可以清楚地了解代碼所需的其他模塊，並避免了模塊名稱是否在范圍內的問題。每行導入一個模塊可以輕松添加和刪除導入的模塊，但每行導入多個模塊會佔用更少的屏幕空間。

如果按以下順序導入模塊，這是一種很好的做法：

1.標准庫模塊 -- 例如：sys,os,getopt,re

2.第三方庫模塊（安裝在Python的site-packages目錄中的任何內容） -- 例如mx.DateTime，ZODB，PIL.Image等

3.本地開發的模塊

有時需要將模塊導入語句移動到函數或類裡面，以避免循環導入問題。Gordon McMillan 說：

當兩個模塊都使用 "import <mole>" 的導入形式時，循環導入就可以了。但是當第 2 個模塊想從第 1 個模塊中獲取一個名稱 ("from mole import name") 並且導入位於頂層時，就會出錯。 這是因為第 1 個模塊中的名稱還不可用，因為第 1 個模塊正在忙著導入第 2 個模塊。

在這種情況下，如果第二個模塊僅用於一個函數，則可以輕松地將模塊導入語句移動到該函數中。調用導入時，第一個模塊將完成初始化，第二個模塊可以進行導入。

如果某些模塊是特定於平台的，則可能還需要將模塊導入語句移出頂級代碼。在這種情況下，甚至可能無法導入文件頂部的所有模塊。在這種情況下，在相應的特定於平台的代碼中導入正確的模塊是一個很好的選擇。

只有當需要解決諸如避免循環導入或試圖減少模塊初始化時間的問題時，才可以將導入移動到本地范圍，例如在函數定義中。如果根據程序的執行方式，許多導入是不必要的，這種技術尤其有用。如果僅在某個函數中使用模塊，您還可能希望將導入移到該函數中。請注意，第一次載入模塊可能會因為模塊的一次初始化而代價高昂，但多次載入模塊實際上是免費的，只需進行幾次字典查找。即使模塊名稱超出了作用域，模塊也可能在 sys.moles 中可用。