python模塊沖突

❶ 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庫與模塊的區別是什麼

Python庫與模塊的區別是什麼

模塊、庫主要區別在於他們的定義與所指范圍不同。

模塊：包含並且有組織的代碼片段為模塊，sample.py 其中文件名smaple為模塊名字。

模塊是一種以.py為後綴的文件，在.py文件中定義了一些常量和函數。模塊的名稱是該.py文件的名稱。模塊的名稱作為一個全局變數__name__的取值可以被其他模塊獲取或導入。模塊的導入通過ipmort來實現。

庫：庫的概念是具有相關功能模塊的集合。這也是正是Python的一大特色之一，即具有強大的標准庫，還有第三方庫以及自定義模塊。

Python中的庫是借用其他編程語言的概念，沒有特別具體的定義，Python庫著重強調其功能性。在Python中，具有某些功能的模塊和包都可以被稱作庫。模塊有諸多函數組成，包由諸多模塊機構化組成，庫中也可以包含包、模塊和函數。

更多技術請關注Python視頻教程。

❸ python中，如果自己寫的模塊與系統模塊重名，該怎麼調用系統的模塊

sys.path是一個list，存放了當前所有import搜索的路徑。

絕大多數情況下，首個元素是""，即空串，也就是說，當你import re的時候，首先搜索的是"re"，這時候就會直接在當前目錄搜索到re。如下圖：

解決方法也有不止一個：

1，在當前目錄創建一個子文件夾，例如mine，在mine里放一個__init__.py，不用有代碼，空文件即可。使用的時候：import mine.re

2，在sys.path上做手腳，把第一個空串挪到最後面去：

import sys

sys.path = sys.path[1:]

sys.path.append("")

這樣當前目錄會跑到最後面去，從而達到最後搜索的目的。

不過這很可能有副作用，即你創建的模塊，不能和前面搜索路徑里的任何文件重名，否則會無法import你的模塊。

這也是為什麼默認把當前路徑放在最前搜索的原因，因為是用戶自己寫的，顯然優先順序最高。

盡管就你的問題作出分析和提出一些可能的解決辦法，但是嚴重不建議在實際工程起和系統模塊重名的文件名，這是自找麻煩。

當然，研究探討它的實現原理，始終是值得肯定的。

最後強調一下，當你在當前文件夾創建了一個sys.py時，方法2不好用！

❹ Python中的模塊和包的區別

1、模塊（Mole）就是包含代碼的文件，不一定是Python代碼，有四種代碼類型的模塊：

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

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

•包(包含多個模塊)

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

使用模塊可以提高代碼的可維護性和重復使用，還可以避免函數名和變數名沖突。相同名字的函數和變數完全可以分別存在不同的模塊中，所以編寫自己的模塊時，不必考慮名字會與其他模塊沖突，但要注意盡量不要與內置函數名字沖突。

2、包（Package）就是包含模塊文件的目錄，目錄名稱就是包名稱，目錄中可以包含目錄，子目錄也是包，但包名稱應該包含上一級目錄的名稱。Python引入了按目錄來組織模塊是為了避免模塊名沖突，不同包中的模塊名可以相同。

注意，每一個包目錄下面都會有一個__init__.py的文件，這個文件是必須存在的，否則，Python就把這個目錄當成普通目錄，而不是一個包。__init__.py可以是空文件，也可以有Python代碼，因為__init__.py本身就是一個模塊，而它的模塊名就是包名。

❺ python內置模塊無法調用，pycharm環境，怎麼辦

python內置模塊無法調用，pycharm環境是設置錯誤造成的，解決方法為：

1、點擊左上角的file菜單。

❻ python模塊安裝的時候出現這種情況怎麼辦

WINDOWS下安裝python模塊比較容易出問題
建議安裝編譯好的二進制文件 https://pypi.python.org/pypi/lxml/3.6.0

❼ python模塊以及導入出現ImportError: No mole named 'xxx'問題

驗證方式

如果不在，則將該模塊或包加入到sys.path中。加入的方式有：

python模塊以及導入出現ImportError: No mole named 'xxx'問題

❽ 從C#到Python——5模塊和包

本章是《從到Python》系列連載的最後一章 內容較簡單 主要介紹Python中模塊與包的使用方法 如果你對這部分內容已經比較熟悉 就不要再浪費時間看了 寫這一章只是為了整個系列完整而已 沒什麼新的東西（本章內容主要參考了《Python精要參考》的第八章《模塊和包》）

模塊

Python的腳本都是用擴展名為py的文本文件保存的 一個腳本可以單獨運行 也可以導入另一個腳本中運行 當腳本被導入運行時 我們將其稱為模塊（mole） 模塊是Python組織代碼的基本方式

模塊名與腳本的文件名相同 例如我們編寫了一個名為Items py的腳本 則可在另外一個腳本中用import Items語句來導入它 在導入時 Python解釋器會先在腳本當前目錄下查找 如果沒有則在sys path包含的路徑中查找

在導入模塊時 Python會做以下三件事

( ) 為模塊文件中定義的對象創建一個名字空間 通過這個名字空間可以訪問到模塊中定義的函數及變數

( ) 在新創建的名字空間里執行模塊文件

( ) 創建一個名為模塊文件的對象 該對象引用模塊的名字空間 這樣就可以通過這個對象訪問模塊中的函數及變數 如

importsys printsys path

如果要同時導入多個模塊 可以用逗號分隔 如 import sys os

可以使用as關鍵字來改變模塊的引用對象名 如 import os as system

也可以用from語句將模塊中的對象直接導入到當前的名字空間（不創建模塊名字空間的引用對象） 如 from socket import gethostname

from語句支持逗號分割的對象 也可以使用星號(*)代表模塊中除下劃線開頭的所有對象 如 from socket import * 這是個懶省事的方法 我是經常用 不過用之前最好先搞清楚會不會覆蓋當前名字空間中的函數名等 總之不是個好習慣:)

除了Python腳本（不僅限於py 還包括pyc和pyo） import語句還可以導入C或擴展（已編譯為共享庫或DLL文件） 包（包含多個模塊 一會介紹)和內建模塊（使用C編寫並已鏈接到Python解釋器內） 不過除了包 另外兩個我也沒用過:(

Python解釋器在第一次import一個py文件的時候 會嘗試將其編譯為位元組碼文件 這個文件的擴展名通常為 pyc 它是已經完成語法檢查並轉譯為虛擬機指令的代碼 後邊的導入操作會直接讀取 pyc文件而不是 py文件 一般而言速度會更快

包

Python的模塊可以按目錄組織為包（package） 一般來說 我們將多個關系密切的模塊組織成一個包 以便於維護和使用 同時可有效避免名字空間沖突 創建一個包的步驟是 建立一個名字為包名字的文件夾 並在該文件夾下創建一個__init__ py文件 你可以根據需要在該文件夾下存放腳本文件 已編譯擴展及子包

一個典型的包可能有以下結構:

package / __init__ py subPack / __init__ py mole_ py mole_ py mole_ py subPack / __init__ py mole_ py mole_ py ……

只要目錄下存在__init__ py 就表明此目錄應被作為一個package處理 在最簡單的例子中 __init__ py 是一個空文件 不過一般我們都要在__init__ py中做一些包的初始化動作 或是設定一些變數

最常用的變數是__all__ 當使用包的人在用from pack import * 語句導入的時候 系統會查找目錄pack下的__init__ py文件中的__all__這個變數 __all__是一個list 包含了所有應該被導入的模塊名稱 例如 __all__ = [ m m m ] 表示當from pack import * 時會import 這三個mole

如果沒有定義__all__ from pack import * 不會保證所有的子模塊被導入 所以要麼通過__init py__ 要麼顯式地import 以保證子模塊被導入 如 import pack m pack m pack m

本章小結

本章介紹了Python中模塊與包的使用方法 要點如下

( ) 模塊是一個可以導入的Python腳本文件

( ) 包是一堆按目錄組織的模塊和子包 目錄下的__init__ py文件存放了包的信息

( ) 可以用import import as form import 等語句導入模塊和包

總之 模塊與包是在物理上組織Python代碼復用的一種有效方式 它有點類似於中的程序集（Assembly） 初學Python不一定要會自己建立模塊和包 但一定要學會使用各種包 這正是Python的強大之處 Python帶著各種各樣的battery 當你想完成一項功能時 最好先去搜索是不是有相關的包能夠復用（多數情況下是這樣的 因為在各種領域都有太多的人在為Python作著貢獻） 而且 絕大多數Python包都是開源的 研讀優秀的代碼也是提高編程能力的一種有效途徑

進一步閱讀的參考

《從C#到Python》系列連載到今天就全部寫完了 非常感謝各位的支持 鼓勵以及批評 使我能夠不斷完善和提高 讀完這個連載 在Python的語法上應該夠應付一陣了 當然結合具體的應用領域 還是有很多東西需要不斷學習 在此向大家推薦一些有用的讀物

[ ] 科學計算方面 這個是我的應用Python的主陣地 推薦HYRY Studio的《用Python做科學計算》（見） 我個人認為非常優秀的一本原創著作（這么好的書不知為何不正式出版 欽佩作者的rp ！）

[ ] GUI開發方面 如果你用wxPython 那麼肯定要看《wxPython in Action》（中文版見） 而我個人主要用PyQt 這方面值得推薦的讀物是柴樹杉翻譯的《PyQt 編程簡介》（見） 如果英文好 還是推薦看《Rapid GUI Programming with Python and Qt》（英文pdf版地址 Oct pdf）

[ ] 開發方面 這個我還沒有涉及 Django的資料網上也是大把了 其它的Python Web開發框架也是多如牛毛 自己找找吧 ）

❾ 那些Python中的模塊

Python的解釋環境是很好用，但是如果我們需要編寫一個大型的程序的時候，解釋環境就完全不夠用了。這個時候我們需要將python程序保存在一個文件里。通常這個文件是以.py結尾的。

對於大型的應用程序來說，一個文件可能是不夠的，這個時候我們需要在文件中引用其他的文件，這樣文件就叫做模塊。

模塊是一個包含Python定義和語句的文件。文件名就是模塊名後跟文件後綴 .py 。在模塊內部，模塊名可以通過全局變數 __name__ 獲得。

還是之前的斐波拉赫數列的例子，我們在fibo.py文件中存放了函數的實現：

編寫完畢之後，我們可以在Python的解釋環境中導入它：

然後直接使用即可：

常用的函數，我們可以將其賦值給一個變數：

或者，我們在導入的時候，直接給這個模塊起個名字：

或者導入模塊中的函數：

每個模塊都有它自己的私有符號表，該表用作模塊中定義的所有函數的全局符號表。因此，模塊的作者可以在模塊內使用全局變數，而不必擔心與用戶的全局變數發生意外沖突。

前面我們提到了可以使用import來導入一個模塊，並且 __name__ 中保存的是模塊的名字。

和java中的main方法一樣，如果我們想要在模塊中進行一些測試工作，有沒有類似java中main方法的寫法呢？

先看一個例子：

在模塊中，我們需要進行一個判斷 __name__ 是不是被賦值為 "__main__"。

我們這樣來執行這個模塊：

以腳本執行的情況下，模塊的 __name__ 屬性會被賦值為 __main__ , 這也是例子中為什麼要這樣寫的原因。

看下執行效果：

如果是以模塊導入的話，那麼將不會被執行：

使用import導入模塊的時候，解釋器首先會去找該名字的內置模塊，如果沒找到的話，解釋器會從 sys.path變數給出的目錄列表裡尋找。

sys.path的初始目錄包括：

要想查看模塊中定義的內容，可以使用dir函數。

上面的例子列出了當前模塊中定義的內容，包括變數，模塊，函數等。

我們可以給dir加上參數，來獲取特定模塊的內容：

java中有package的概念，用來隔離程序代碼。同樣的在Python中也有包。

我們看一個Python中包的例子：

上面我們定義了4個包，分別是sound,sound.formats, sound.effects, sound.filters。

__init__.py 可以是一個空文件，也可以執行包的初始化代碼或設置 __all__ 變數。

當導入的時候， python就會在 sys.path 路徑中搜索該包。

包的導入有很多種方式，我們可以導入單個模塊：

但是這樣導入之後，使用的時候必須載入全名：

如果不想載入全名，可以這樣導入：

那麼就可以這樣使用了：

還可以直接導入模塊中的方法：

然後這樣使用：

如果一個包裡面的子包比較多，我們可能會希望使用 * 來一次性導入：

那麼如何去控制到底會導入effects的哪一個子包呢？

我們可以在 __init__.py 中定義一個名叫 __all__ 的列表，在這個列表中列出將要導出的子包名，如下所示：

這樣from sound.effects import * 將導入 sound 包的三個命名子模塊。

如果沒有定義 __all__，from sound.effects import * 語句 不會 從包 sound.effects 中導入所有子模塊到當前命名空間；它只會導入包 sound.effects。

Import 可以指定相對路徑，我們使用 . 來表示當前包， 使用 .. 來表示父包。

如下所示：

❿ python 導入模塊問題

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