【Python3之模塊及包的導入】

一、模塊導入

1.定義

Python 模塊(Module)，是一個 Python 文件，以 .py 結尾，包含了 Python 對象定義和Python語句。

模塊讓你能夠有邏輯地組織你的 Python 代碼段。

把相關的代碼分配到一個模塊里能讓你的代碼更好用，更易懂。 

模塊能定義函數，類和變量，模塊里也能包含可執行的代碼。

包括：內置模塊，自定義模塊，第三方模塊；

2.作用

最大的好處是大大提高了代碼的可維護性。其次，編寫代碼不必從零開始。當一個模塊編寫完畢，就可以被其他地方引用。我們在編寫程序的時候，也經常引用其他模塊，包括Python內置的模塊和來自第三方的模塊。

使用模塊還可以避免函數名和變量名沖突。相同名字的函數和變量完全可以分別存在不同的模塊中，因此，我們自己在編寫模塊時，不必考慮名字會與其他模塊沖突。但是也要注意，盡量不要與內置函數名字沖突。

 

3.import

模塊定義好后，我們可以使用 import 語句來引入模塊，語法如下：

import module1[, module2[,... moduleN]

例：

#spam.py
print('from the spam.py')

money=1000

def read1():
    print('spam->read1->money',money)

def read2():
    print('spam->read2 calling read')
    read1()

def change():
    global money
    money=0

導入模塊

import spam #只在第一次導入時才執行spam.py內代碼,此處的顯式效果是只打印一次'from the spam.py',當然其他的頂級代碼也都被執行了,只不過沒有顯示效果.

執行結果：
 from the spam.py

注：模塊可以包含可執行的語句和函數的定義，這些語句的目的是初始化模塊，它們只在模塊名第一次遇到導入import語句時才執行（import語句是可以在程序中的任意位置使用的,且針對同一個模塊很import多次,為了防止你重復導入，python的優化手段是：第一次導入后就將模塊名加載到內存了，后續的import語句僅是對已經加載大內存中的模塊對象增加了一次引用，不會重新執行模塊內的語句）

 

import導入模塊干的事：
1.產生新的名稱空間
2.以新建的名稱空間為全局名稱空間，執行文件的代碼
3.拿到一個模塊名spam，指向spam.py產生的名稱空間

 

• 測試一:money與spam.money不沖突

#測試一:money與spam.money不沖突
#test.py
import spam 
money=10
print(spam.money)

'''
執行結果：
from the spam.py
1000
'''

 

 

• 測試二：read1與spam.read1不沖突

#測試二：read1與spam.read1不沖突
#test.py
import spam
def read1():
    print('========')
spam.read1()

'''
執行結果:
from the spam.py
spam->read1->money 1000
'''

 

• 測試三：執行spam.change()操作的全局變量money仍然是spam中的money

#測試三：執行spam.change()操作的全局變量money仍然是spam中的
#test.py
import spam
money=1
spam.change()
print(money)

'''
執行結果：
from the spam.py
1
'''

 

• as，為模塊名起別名

 import spam as sm  #sm為spam的別名
 print(sm.money)

例：

為已經導入的模塊起別名的方式對編寫可擴展的代碼很有用，假設有兩個模塊xmlreader.py和csvreader.py，它們都定義了函數read_data(filename):用來從文件中讀取一些數據，但采用不同的輸入格式。可以編寫代碼來選擇性地挑選讀取模塊，例如

if file_format == 'xml':
     import xmlreader as reader
elif file_format == 'csv':
    import csvreader as reader
data=reader.read_date(filename)

 

• 在一行導入多個模塊

import sys,os,re

 

4.From…import

from modname import name1[, name2[, ... nameN]]

要導入模塊 fib 的 fibonacci 函數，使用如下語句：

from fib import fibonacci

這個聲明不會把整個 fib 模塊導入到當前的命名空間中，它只會將 fib 里的 fibonacci 單個引入到執行這個聲明的模塊的全局符號表。

 

from... import..導入模塊干的事：

1.產生新的名稱空間
2.以新建的名稱空間為全局名稱空間，執行文件的代碼
3.直接拿到就是spam.py產生的名稱空間中名字

 

#測試一：導入的函數read1，執行時仍然回到spam.py中尋找全局變量money
#test.py
from spam import read1
money=1000
read1()
'''
執行結果:
from the spam.py
spam->read1->money 1000
'''

#測試二:導入的函數read2，執行時需要調用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print('==========')
read2()

'''
執行結果:
from the spam.py
spam->read2 calling read
spam->read1->money 1000
'''

 

但如果當前有重名read1或者read2，那么會有覆蓋效果。

#測試三:導入的函數read1，被當前位置定義的read1覆蓋掉了
#test.py
from spam import read1
def read1():
    print('==========')
read1()
'''
執行結果:
from the spam.py
==========
'''

需要特別強調的一點是：python中的變量賦值不是一種存儲操作，而只是一種綁定關系，如下：

from spam import money,read1
money=100 #將當前位置的名字money綁定到了100
print(money) #打印當前的名字
read1() #讀取spam.py中的名字money,仍然為1000

'''
from the spam.py
100
spam->read1->money 1000
'''

 

from ... import ...
優點:方便，不用加前綴
缺點：容易跟當前文件的名稱空間沖突

 

• from ... import...也支持as和導入多模塊

from spam import read1 as read

from spam import (read1,
                  read2,
                  money)

 

• from spam import *

把spam中所有的不是以下划線(_)開頭的名字都導入到當前位置，大部分情況下我們的python程序不應該使用這種導入方式，因為*你不知道你導入什么名字，很有可能會覆蓋掉你之前已經定義的名字。而且可讀性極其的差，在交互式環境中導入時沒有問題。 

from spam import * #將模塊spam中所有的名字都導入到當前名稱空間
print(money)
print(read1)
print(read2)
print(change)

'''
執行結果:
from the spam.py
1000
<function read1 at 0x1012e8158>
<function read2 at 0x1012e81e0>
<function change at 0x1012e8268>
'''

 

• __all__來控制*（用來發布新版本）

在spam.py中新增一行

__all__=['money','read1'] #這樣在另外一個文件中用from spam import *就這能導入列表中規定的兩個名字

 

• __name__

spam.py當做腳本執行，__name__='__main__'
spam.py當做模塊導入，__name__=模塊名

作用：用來控制.py文件在不同的應用場景下執行不同的邏輯

#fib.py

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

執行

#python fib.py <arguments>
python fib.py 50 #在命令行

 

5.模塊的搜索路徑

模塊的查找順序是：內存中已經加載的模塊->內置模塊->sys.path路徑中包含的模塊

python解釋器在啟動時會自動加載一些模塊，可以使用sys.modules查看，在第一次導入某個模塊時（比如spam），會先檢查該模塊是否已經被加載到內存中（當前執行文件的名稱空間對應的內存），如果有則直接引用

如果沒有，解釋器則會查找同名的內建模塊，如果還沒有找到就從sys.path給出的目錄列表中依次尋找spam.py文件。

特別注意的是：自定義的模塊名不應該與系統內置模塊重名。

 

在初始化后，python程序可以修改sys.path,路徑放到前面的優先於標准庫被加載。

 

注意：搜索時按照sys.path中從左到右的順序查找，位於前的優先被查找，sys.path中還可能包含.zip歸檔文件和.egg文件，python會把.zip歸檔文件當成一個目錄去處理，

#首先制作歸檔文件：zip module.zip foo.py bar.py

import sys
sys.path.append('module.zip')
import foo,bar

#也可以使用zip中目錄結構的具體位置
sys.path.append('module.zip/lib/python')

 

注意：windows下的路徑不加r開頭，會語法錯誤

windows下的路徑不加r開頭，會語法錯誤
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a')

 

二、包的導入

1.定義

包是一種通過使用‘.模塊名’來組織python模塊名稱空間的方式。

無論是import形式還是from...import形式，凡是在導入語句中（而不是在使用時）遇到帶點的，都要第一時間提高警覺：這是關於包才有的導入語法。.的左邊必須是包；

包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的 Python 的應用環境。簡單來說，包就是文件夾，但該文件夾下必須存在 __init__.py 文件, 該文件的內容可以為空。__int__.py用於標識當前文件夾是一個包。

包是由一系列模塊組成的集合。模塊是處理某一類問題的函數和類的集合。

例：

glance/                   #Top-level package

├── __init__.py      #Initialize the glance package

├── api                  #Subpackage for api

│   ├── __init__.py

│   ├── policy.py

│   └── versions.py

├── cmd                #Subpackage for cmd

│   ├── __init__.py

│   └── manage.py

└── db                  #Subpackage for db

    ├── __init__.py

    └── models.py

文件內容

#文件內容

#policy.py
def get():
    print('from policy.py')

#versions.py
def create_resource(conf):
    print('from version.py: ',conf)

#manage.py
def main():
    print('from manage.py')

#models.py
def register_models(engine):
    print('from models.py: ',engine)

 

2.import

在使用一個模塊中的函數或類之前，首先要導入該模塊。模塊的導入使用import語句。

調用模塊的函數或類時，需要以模塊名作為前綴。

import導入文件時，產生名稱空間中的名字來源於文件，import 包，產生的名稱空間的名字同樣來源於文件，即包下的__init__.py，導入包本質就是在導入該文件

例
在與包glance同級別的文件中測試

import glance.db.models
glance.db.models.register_models('mysql') 

凡是在導入時帶點的，點的左邊都必須是一個包。

 

3.from ... import ...

如果不想在程序中使用前綴符，可以使用from…import…語句將模塊導入。

需要注意的是from后import導入的模塊，必須是明確的一個不能帶點，否則會有語法錯誤，如：from a import b.c是錯誤語法

例

在與包glance同級別的文件中測試 

from glance.db import models
models.register_models('mysql')

from glance.db.models import register_models
register_models('mysql')

 

執行的文件的當前路徑就是sys.path

import sys
print(sys.path)

 

注意：

1.關於包相關的導入語句也分為import和from ... import ...兩種，但是無論哪種，無論在什么位置，在導入時都必須遵循一個原則：凡是在導入時帶點的，點的左邊都必須是一個包，否則非法。可以帶有一連串的點，如item.subitem.subsubitem,但都必須遵循這個原則。

2.對於導入后，在使用時就沒有這種限制了，點的左邊可以是包,模塊，函數，類(它們都可以用點的方式調用自己的屬性)。

3.對比import item 和from item import name的應用場景：
如果我們想直接使用name那必須使用后者。

 

4.__init__.py文件

不管是哪種方式，只要是第一次導入包或者是包的任何其他部分，都會依次執行包下的__init__.py文件(我們可以在每個包的文件內都打印一行內容來驗證一下)，這個文件可以為空，但是也可以存放一些初始化包的代碼。

 

5.from glance.api import *

從包api中導入所有，實際上該語句只會導入包api下__init__.py文件中定義的名字，我們可以在這個文件中定義__all___:

#在__init__.py中定義
x=10

def func():
    print('from api.__init.py')

__all__=['x','func','policy']

此時我們在於glance同級的文件中執行from glance.api import *就導入__all__中的內容（versions仍然不能導入）。

 

6.絕對導入和相對導入

最頂級包glance是寫給別人用的，然后在glance包內部也會有彼此之間互相導入的需求，這時候就有絕對導入和相對導入兩種方式：

絕對導入：以glance作為起始

相對導入：用.或者..的方式最為起始（只能在一個包中使用，不能用於不同目錄內）

例：我們在glance/api/version.py中想要導入glance/cmd/manage.py

在glance/api/version.py

#絕對導入
from glance.cmd import manage
manage.main()

#相對導入
from ..cmd import manage
manage.main()

測試結果：注意一定要在於glance同級的文件中測試

from glance.api import versions 

 

注意：可以用import導入內置或者第三方模塊（已經在sys.path中），但是要絕對避免使用import來導入自定義包的子模塊(沒有在sys.path中)，應該使用from... import ...的絕對或者相對導入,且包的相對導入只能用from的形式。

 

7.單獨導入包

單獨導入包名稱時不會導入包中所有包含的所有子模塊，如

#在與glance同級的test.py中
import glance
glance.cmd.manage.main()

'''
執行結果：
AttributeError: module 'glance' has no attribute 'cmd'

'''

解決方法：

#glance/__init__.py
from . import cmd
 
#glance/cmd/__init__.py
from . import manage

執行：

#在於glance同級的test.py中
import glance
glance.cmd.manage.main()

千萬別問：__all__不能解決嗎，__all__是用於控制from...import *