本文目錄一覽：
- 1、Python導入模塊或包需要注意哪些點
- 2、python中導入py文件為什麼是導入模塊
- 3、python導入模塊問題
- 4、python如何導入自定義模塊
- 5、python 類和繼承，包及模塊導入 求解答
- 6、問Python導入模塊的兩種方法import module 和 from module*的差異
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
module_x.py
module_y.py
subpackage2/
__init__.py
module_z.py
module_a.py
在本地磁碟上找個地方創建上述文件和文件夾。在頂層的 __init__.py 文件中，輸入以下代碼：
from . import subpackage1from . import subpackage2
接下來進入 subpackage1 文件夾，編輯其中的 __init__.py 文件，輸入以下代碼：
from . import module_xfrom . import module_y
現在編輯 module_x.py 文件，輸入以下代碼：
from .module_y import spam as ham
def main():
ham()
最後編輯 module_y.py 文件，輸入以下代碼：
def spam():
print(‘spam ‘ * 3)
打開終端， cd 至 my_package 包所在的文件夾，但不要進入 my_package 。在這個文件夾下運行Python解釋器。我使用的是IPython，因為它的自動補全功能非常方便：
In [1]: import my_package
In [2]: my_package.subpackage1.module_xOut[2]: module
‘my_package.subpackage1.module_x’ from
‘my_package/subpackage1/module_x.py’
In [3]: my_package.subpackage1.module_x.main()spam spam spam
相對導入適用於你最終要放入包中的代碼。如果你編寫了很多相關性強的代碼，那麼應該採用這種導入方式。
你會發現PyPI上有很多流行的包也是採用了相對導入 。還要注意一點，如果你想要跨越多個文件層級進行導入，只需要使用多個句點即可。不過， PEP
328建議相對導入的層級不要超過兩層 。
還要注意一點，如果你往 module_x.py 文件中添加了 if __name__ == 『__main__』 ，然後試圖運行這個文件，你會碰到一個很難理解的錯誤。編輯一下文件，試試看吧！
from . module_y import spam as ham
def main():
ham()
if __name__ == ‘__main__’:
# This won’t work!
main()
現在從終端進入 subpackage1 文件夾，執行以下命令：
python module_x.py
如果你使用的是Python 2，你應該會看到下面的錯誤信息：
Traceback (most recent call last):
File “module_x.py”, line 1, in module
from . module_y import spam as hamValueError: Attempted relative import in non-package
如果你使用的是Python 3，錯誤信息大概是這樣的：
Traceback (most recent call last):
File “module_x.py”, line 1, in module
from . module_y import spam as hamSystemError: Parent module ” not loaded, cannot perform relative import
這指的是， module_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 module
import math
File “/Users/michael/Desktop/math.py”, line 6, in module
square_root(72)
File “/Users/michael/Desktop/math.py”, line 4, in square_root
return math.sqrt(number)AttributeError: module ‘math’ has no attribute ‘sqrt’
這到底是怎麼回事？其實，你運行這個文件的時候，Python解釋器首先在當前運行腳本所處的的文件夾中查找名叫 math
的模塊。在這個例子中，解釋器找到了我們正在執行的模塊，試圖導入它。但是我們的模塊中並沒有叫 sqrt 的函數或屬性，所以就拋出了
AttributeError 。
python中導入py文件為什麼是導入模塊
項目中想使用以前的代碼，或者什麼樣的需求致使你需要導入外部的包
如果是web 下，比如說django ，那麼你新建一個app，把你需要導入的說用東東，都寫到這個app中，然後在setting中的app也配上基本就ok了
如果是本地代碼，可以有幾種方式，
1、這種最簡單，也可能最不實用，將你的外部文件放到跟需要調用外部文件的文件同一個包下，同一目錄
folder
——toinvoke.py
——tobeinvoded.py
這樣在toinvoke.py 中引入
import toveinvoked 或 from tobeinvoked import *
即可
2、你的其他文件不是單個文件，或者不能如上所說放到同一目錄下，而是在不同目錄中，子目錄
folder
——tobeinvodedA.py
——tobeinvodedB.py
——tobeinvodedC.py
toinvoke.py
這種情況，現在folder 下新建一個__init__.py 的空文件，此時的folder不再是一個普通的文件夾，而是一個包 package,現在像這樣
folder #文件夾 現在的性質為一個python包package
——__init__.py
——tobeinvoded.py
——tobeinvodedA.py
——tobeinvodedB.py
——tobeinvodedC.py
toinvoke.py
這樣在toinvoke.py 中引入
import folder.toveinvoked 或 from folder.tobeinvoked import *
即可
3、同理，如果是如下的情況,folderB中的模塊要調用folderA中的模塊，方法同上，有什麼改變，你已經知道了
folderA
——tobeinvoded.py
——tobeinvodedA.py
——tobeinvodedB.py
——tobeinvodedC.py
folderB
——–toinvoke.py
這樣在toinvoke.py 中引入
import folder.toveinvoked 或 from folder.tobeinvoked import *
即可
4、將要被調用的代碼拷貝到$PYTHONHOME$\Lib\site-packages 下面，這個就跟Eclipse插件安裝差不多
5、在$PYTHONHOME$\Lib\site-packages 下面新建一個.pth文件,比如說是MyPackage.pth,裡面的內容是你的包的絕對路徑比如：E:/PythonPrj
那麼，在E:/PythonPrj下的所有包都可以按照包所在的相對路徑引入，這個跟Eclipse插件安裝的link 方式差不多
6、跟上面的差不多，也可以加個環境變數，這個就不多說了
總結、看看Python的包搜索路徑
Python會在以下路徑中搜索它想要尋找的模塊：
1. 程序所在的文件夾
2. 標準庫的安裝路徑
3. 操作系統環境變數PYTHONPATH所包含的路徑
將自定義庫的路徑添加到Python的庫路徑中去，有如下兩種方法：
1. 動態的添加庫路徑。在程序運行過程中修改sys.path的值，添加自己的庫路徑
import sys
sys.path.append(r’your_path’)
2. 在Python安裝目錄下的\Lib\site-packages文件夾中建立一個.pth文件，內容為自己寫的庫路徑。示例如下
E:\\work\\Python\\http
E:\\work\\Python\\logging
python導入模塊問題
其實很簡單，這是命名空間的問題，每個模塊或者一個包就是一個命名空間，每個都相對獨立的，只有導入時才會有某種關係存在。
也就是說，如果你在connect.py文件里沒有導入time模塊，使用的話本來就會提示time沒有定義（因為你事先沒有導入嘛）。然後當程序運行時，會優先把模塊和定義的函數先走一遍存在緩存里（你可以理解為檢測一篇），然後再按照代碼順序由上而下運行。所以當程序優先運行模塊和定義的函數時，發現你的connect.py報錯，那麼後面與這個函數或者模塊相關的代碼都不會再繼續運行。
所以你在connect.py的文件里import time，而主py文件不需要導入time模塊就行。
python如何導入自定義模塊
這個問題涉及到包和模塊管理。包名和模塊名一般是小寫。你的文件是下面的結構，需要創建空文件 b/__init__.py，將b目錄變成package。
a/a.py
from b.c import index
index()
b/c.py
def index():
print(“hello”)
b/__init__.py
a/a.py 裡面有兩種引用方式，相對引用和絕對引用：
# 如果a.py是 library，兩種引用方式都可以
from ..b.c import index
# 如果a.py是 executable，必須使用絕對引用
from b.c import index
如果使用絕對引用，需要確保b所在目錄在PYTHONPATH (sys.path)裡面，比如可以這樣執行：
env PYTHONPATH=. python a/a.py
python 類和繼承，包及模塊導入 求解答
一 .module
通常模塊為一個文件，直接使用import來導入就好了。可以作為module的文件類型有”.py”、”.pyo”、”.pyc”、”.pyd”、”.so”、”.dll”。
二. package
通常包總是一個目錄，可以使用import導入包，或者from + import來導入包中的部分模塊。包目錄下為首的一個文件便是 __init__.py。然後是一些模塊文件和子目錄，假如子目錄中也有 __init__.py 那麼它就是這個包的子包了。
一.模塊你可以使用import語句將一個源代碼文件作為模塊導入.例如:
[python] view plain copy
# file : spam.py
a = 37 # 一個變數
def foo: # 一個函數
print “I’m foo”
class bar: # 一個類
def grok(self):
print “I’m bar.grok”
b = bar() # 創建一個實例
使用import spam 語句就可以將這個文件作為模塊導入。系統在導入模塊時，要做以下三件事：
1.為源代碼文件中定義的對象創建一個名字空間，通過這個名字空間可以訪問到模塊中定義的函數及變數。
2.在新創建的名字空間里執行源代碼文件.
3.創建一個名為源代碼文件的對象，該對象引用模塊的名字空間，這樣就可以通過這個對象訪問模塊中的函數及變數，如：
[python] view plain copy
import spam # 導入並運行模塊 spam
print spam.a # 訪問模塊 spam 的屬性
spam.foo()
c = spam.bar()
用逗號分割模塊名稱就可以同時導入多個模塊:
[python] view plain copy
import socket, os, regex
模塊導入時可以使用 as 關鍵字來改變模塊的引用對象名字:
[python] view plain copy
import os as system
import socket as net, thread as threads
system.chdir(“..”)
net.gethostname()
使用from語句可以將模塊中的對象直接導入到當前的名字空間. from語句不創建一個到模塊名字空間的引用對象，而是把被導入模塊的一個或多個對象直接放入當前的名字空間:
[python] view plain copy
from socket import gethostname # 將gethostname放如當前名字空間
print gethostname() # 直接調用
socket.gethostname() # 引發異常NameError: socket
from語句支持逗號分割的對象，也可以使用星號(*)代表模塊中除下劃線開頭的所有對象:
[python] view plain copy
from socket import gethostname, socket
from socket import * # 載入所有對象到當前名字空間
不過，如果一個模塊如果定義有列表__all__，則from module import * 語句只能導入__all__列表中存在的對象。
[python] view plain copy
# module: foo.py
__all__ = [ ‘bar’, ‘spam’ ] # 定義使用 `*` 可以導入的對象
另外, as 也可以和 from 聯合使用:
[python] view plain copy
from socket import gethostname as hostname
h = hostname()
import 語句可以在程序的任何位置使用，你可以在程序中多次導入同一個模塊，但模塊中的代碼*僅僅*在該模塊被首次導入時執行。後面的import語句只是簡單的創建一個到模塊名字空間的引用而已。sys.modules字典中保存著所有被導入模塊的模塊名到模塊對象的映射。這個字典用來決定是否需要使用import語句來導入一個模塊的最新拷貝.
from module import * 語句只能用於一個模塊的最頂層.*特別注意*：由於存在作用域衝突，不允許在函數中使用from 語句。
每個模塊都擁有 __name__ 屬性，它是一個內容為模塊名字的字元串。最頂層的模塊名稱是 __main__ .命令行或是交互模式下程序都運行在__main__ 模塊內部. 利用__name__屬性，我們可以讓同一個程序在不同的場合（單獨執行或被導入)具有不同的行為，象下面這樣做：
[python] view plain copy
# 檢查是單獨執行還是被導入
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, foomodule.so, foomodule.sl,或 foomodule.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導入模塊的兩種方法import module 和 from module*的差異
區別如下，以numpy模塊為例：
① import numpy，在代碼中調用numpy內的函數、方法、參數等時，需要如下寫代碼: numpy.mean()。 當然 也可寫為import numpy as np，這樣你在代碼中調用時就用np替代numpy。
② from numpy import *，在代碼中調用numpy內的函數、方法、參數等時則可直接如下寫代碼：mean()。
但是建議使用①中的方法導入模塊，因為不排除兩個模型中有相同名稱的函數、方法、參數等，如出現此情況會起衝突。如你使用②方法導入了模塊A、B，並且兩個模型中都有函數mean（），而你在後面的代碼中剛好需要調用mean()…請問計算機會怎麼辦？？？
打字不易，請採納！！！
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/276084.html
微信掃一掃 
支付寶掃一掃 