關於導入python文件時的問題的信息

本文目錄一覽：

• 1、python的文檔導入和屬性問題
• 2、python 導入模塊問題
• 3、python在導入nupmy和matplotlib時遇到問題
• 4、python導入py文件報錯怎麼辦
• 5、Python導入模塊問題

python的文檔導入和屬性問題

1. 為什麼函數的條件是if __name__==’__main__’;?

答：

運行一個.py文件時，這個文件本身的__name__的值就是__main__，即程序的入口，當你是在這個文件本身運行它時，那麼if內的代碼就會運行。那什麼時候不會運行呢？自然就是在別的文件運行時引用到它的時候，也就是這個文件作為模塊被其他文件引用時（此時，啟動文件時別的文件）

2. 怎麼把四個課程信息都導入進去啊？

答：

讀取的思路是沒錯的，但是，代碼寫錯了,具體代碼見最後代碼部分.

3. 不是一次只能定義一個課程信息嗎？ and 怎麼定義四次課程信息？

答：

因為你聲明的課程類是每一門課對應一條課程信息，所以，要將四條信息全部存下來，你需要實例化四個課程對象

4. 他們是怎麼同時存在的？and 像列表一樣有編號嗎？

答：

實例化後的對象是在內存中的，保存實例化的變數就保存了執行內存中的地址（當然這對於你來說是不可見的，也不需要你來直接操作內存）

5. 要對課程信息進行修改該如何進行大致外部操作？

答：

訪問這些信息只需要按照正常訪問屬性和方法就行了，例如course1.__course_name就是課程的名稱,course1.get_course_name()也能得到課程的名稱

正確代碼示例:

class Course:

    “””課程”””

    def __init__(self, course_name, course_id, credit, instructor_name, address, description):

        self.__course_name = course_name

        self.__course_id = course_id

        self.__credit = credit

        self.__instructor_name = instructor_name

        self.__address = address

        self.__description = description

    def get_course_name(self):

        return self.__course_name

    def __str__(self):

        string = ‘Course_name:’ + self.__course_name + ‘\n’

        string += ‘Course_id:’ + self.__course_id + ‘\n’

        string += ‘Credit:’ + self.__credit + ‘\n’

        string += ‘Instructor_name:’ + self.__instructor_name + ‘\n’

        string += ‘Address:’ + self.__address + ‘\n’

        string += ‘Description:’ + self.__description + ‘\n’

        return string

if __name__ == ‘__main__’:

    fi = open(‘course.txt’, ‘r’)

    course_list = []  # 課程對象列表

    while True:

        line1 = fi.readline().strip()  # 讀取1行

        if line1 == ”:

            break

        line2 = fi.readline().strip()  # 讀取1行

        tem_list = line1.split(sep=”,”)

        course_list.append(

            Course(tem_list[0], tem_list[1], tem_list[2], tem_list[3], tem_list[4], line2))  # 將實例化的課程對象添加到課程對象列表中

    fi.close()

    # 列印保存的課程對象數組

    for course in course_list:

        print(course)

輸出(數據只測試兩條)

Course_name:Academic English I

Course_id:31060101

Credit:3

Instructor_name:Liang ZHU-GE

Address:8-101

Description:Two hours each week-day.

Course_name:Advanced Mathematics l1

Course_id:31060102

Credit:4.5

Instructor_name:ChongZhi ZU

Address:8=101

Description:Two lectures in a week

程序使用的course.txt文件

Academic English I,31060101,3,Liang ZHU-GE,8-101

Two hours each week-day.

Advanced Mathematics l1,31060102,4.5,ChongZhi ZU,8=101

Two lectures in a week

以上代碼已上傳github，歡迎下載,star網頁鏈接

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

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

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

import math

File “/Users/michael/Desktop/math.py”, line 6, in

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在導入nupmy和matplotlib時遇到問題

1.最開始，在裝完nltk，numpy和scipy以及matplotlib後，我直接在python互動式命令行中導入matplotlib模塊，結果提示缺少模塊six，如下圖所示：

這個模塊實在剛才裝完的SciPy包中，找到自己的Python的安裝目錄，然後把%PYTHON_ROOT%\Lib\site-packages\scipy\lib目下的six.py,six.pyc,six.pyo三個文件放到%PYTHON_ROOT%\Lib\site-packages目錄下即可解決這個問題，這裡%PYTHON_ROOT%是指你電腦上的python安裝的根目錄，如我是把python安裝在C盤根目錄的，所以在我電腦上這個%PYTHON_ROOT%表示的是C：\python27，這個根據你自己安裝Python的目錄不同而不同。

2.在解決上面的問題後，再次在python互動式命令行下，導入matplotlib模塊，結果仍然提示出錯，如下圖：

根據提示可以知道，matplotlib需要dateutil，所以我們需要安裝第6步中的dateutil，在我給的鏈接里，如今只能下到.whl格式的安裝文件，這個是python自己的包文件需要用到python的包管理軟體來安裝，python自帶的包管理軟體常見的有setuptools和pip兩種，我這裡使用的是pip來進行安裝。使用之前最好自己添加環境變數，免得在後面使用時，要輸入Pip程序的完整路勁比較麻煩。在系統變數Path的最後面添加如下的地址：%PYTHON_ROOT%\Scripts。其中，%PYTHON_ROOT%仍然是python的根目錄。安裝過程如下：將下載好的dateutil的安裝包，放到某個目錄下，如我把它放在D盤根目錄，然後打開windows的命令行窗口，請注意是Windows的命令行窗口，然後進入D盤根目錄，然後輸入如下命令，如下圖下半部分所示：

3.安裝完dateutil後，導入matplotlib仍然提示有錯，提示缺少pyparsing模塊，按照第二步方式，下載安裝文件，安裝完成後，便可正確導入matplotlib模塊，安裝的命令如上圖上半部分所示，這裡不再贅述。正確安裝後即可成功導入，如下圖所示：

安裝的正確過程：

1.先安裝python，我用的是32位python3.4.1（下載地址可以去：，當然也可以去官網，但nltk官網上給出了相應版本的nltk所需要的python版本）

2.安裝nltk（版本nltk-3.0.1.win32）,這是python下的一個自然語言工具，裡面集成了很多處理自然語言所需要的函數。（下載地址：同上）

3.安裝NumPy（版本numpy-1.8.1-win32-superpack-python3.4）（下載地址：）

4.安裝SciPy(版本scipy-0.15.1-win32-superpack-python3.4)（下載地址：同上）

5.安裝Matplotlib（版本matplotlib-1.4.1.win32-py3.4）（下載地址：）

6.安裝dateutil(版本python_dateutil-2.3-py2.py3-none-any)（下載地址：）

7.安裝Pyparsing(版本pyparsing-2.0.3-py3-none-any)（下載地址：同上）

其中，NumPy和SciPy中的一些模塊，是導入Matplotlib所需的，應該安裝。

python導入py文件報錯怎麼辦

其實這兩個錯誤的原因歸根結底是一樣的：在涉及到相對導入時，package所對應的文件夾必須正確的被python解釋器視作package，而不是普通文件夾。否則由於不被視作package，無法利用package之間的嵌套關係實現python中包的相對導入。

文件夾被python解釋器視作package需要滿足兩個條件：

1、文件夾中必須有__init__.py文件，該文件可以為空，但必須存在該文件。

2、不能作為頂層模塊來執行該文件夾中的py文件（即不能作為主函數的入口）。

補充：在”from YY import XX”這樣的代碼中，無論是XX還是YY，只要被python解釋器視作package，就會首先調用該package的__init__.py文件。如果都是package，則調用順序是YY，XX。

另外，練習中「from . import XXX」和「from .. import XXX」中的’.’和’..’，可以等同於linux里的shell中’.’和’..’的作用，表示當前工作目錄的package和上一級的package。

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 。