python匯入

案例1 python的匯入包中的函式

目錄

├── package_runoob
│   ├── __init__.py
│   ├── __pycache__
│   │   ├── __init__.cpython-36.pyc
│   │   ├── runoob1.cpython-36.pyc
│   │   └── runoob2.cpython-36.pyc
│   ├── runoob1.py
│   └── runoob2.py
└── runtest.py

建立檔案

$cat package_runoob/runoob1.py
def runoob1():
    print("I'm in runoob1")

$cat package_runoob/runoob2.py
def runoob2():
    print("I'm in runoob2")

$cat package_runoob/__init__.py
if __name__ == '__main__':
    print("作為主程式執行")
else:
    print("package_runoob 初始化")

$cat runtest.py
from package_runoob.runoob1 import runoob1
from package_runoob.runoob2 import runoob2

runoob1()
runoob2()

 

執行命令

$python package_runoob/__init__.py
作為主程式執行

$python runtest.py
package_runoob 初始化
I'm in runoob1
I'm in runoob2

成功將包中的py指令碼的函式進行匯入

案例 2 模組的匯入方法

模組匯入的方式

import + 模組名 from + 模組名 + import + 物件名

第一步：

執行匯入語句時，Python會建立一個空的模組物件，從上到下、逐一執行該模組內的語句，並且把在模組內部全域性作用域（相對於模組自身來講）定義的物件都作為模組物件的屬性。

第二步：

1. "import module_name"的方式

此時Python會在全域性作用域（當前程式中）定義名字為module_name的變數名，並且讓變數名module_name指向模組物件，其實等同於賦值操作，即：將模組物件賦值給變數module_name；

$cat re.py
re = 521
print("匯入re前的變數re為:",re)

$cat run1.py
import re
print("匯入re後的變數re為",re)

執行

$python run1.py
匯入re前的變數re為: 521
匯入re後的變數re為 <module 're' from '/opt/script/ref/python/imp/test1/re.py'>
#匯入後變數re不再指向521,而是指向模組物件。
#匯入模組後，我們就可以使用模組物件的屬性和方法，比如re.match(),這也符合物件屬性語法。
 

$mv re.py ree.py
$python run1.py
匯入re後的變數re為 <module 're' from '/opt/conda/lib/python3.6/re.py'>

重新匯入模組的變數，只要模組不要與全域性變數中的名稱一致，則就不會衝突

$cat run1.py
import ree
print("匯入ree後的變數re為",ree.re)

$python run1.py
匯入re前的變數re為: 521
匯入ree後的變數re為 521

2. from module_name import a,b,c的方式

此時Python不會定義模組物件的名字，而只是從模組物件的屬性中把物件a,b,c取出來放到全域性作用域中，可以理解為在全域性作用域定義了變數名a,b,c 並且分別指向模組物件的屬性中的a,b,c所指向的物件。

我們來做個實驗，先建立一個py1.py檔案，檔案內容如下：

$cat m1.py
a = 123
b = [1,2,3]
print("匯入成功")

$cat run2.py
from m1 import a,b
print("a is ",a)
print("b is",b)

$python run2.py
匯入成功
a is  123
b is [1, 2, 3]

可以直接m1.py的作為模組，a,b作為物件。 主程式匯入後，會先執行匯入模組的。然後，再向物件進行列印。

從結果看出，只輸出了一次“匯入成功”，所以當執行import m1語句時Python並沒有再次匯入模組，因為匯入模組的操作在執行from語句時已經完成，但是全域性變數中多出來一個m1，所以import m1此時的作用只有一個：把模組物件賦值給m1，也就是說給模組物件命了個名字。

從python物件的屬性中取出變數的。

#首先我們用from匯入模組，並取得變數a

屬性匯入後，修改

$cat run3.py
from m1 import a
import m1
print("修改模組物件屬性之前的a",a)

a= 666
print("修改模組物件屬性之後的a",a)

print("m1.b前",m1.b)
m1.b[0]=777
print("m1.b後",m1.b)


$python run3.py
匯入成功
修改模組物件屬性之前的a 123
修改模組物件屬性之後的a 666
m1.b前 [1, 2, 3]
m1.b後 [777, 2, 3]

本文參考資料為：(美)MarkLutz. Python學習手冊（原書第4版）

新增匯入預設路徑

## 將m1放入多層路徑下
$mkdir -p path2/path3
$mv m1.py path2/path3/

使用sys進行確定路徑

$cat run4.py
import sys
sys.path.append("path2/path3/")
from m1 import a,b
print(a)
print(b)

$python run4.py
匯入成功
123
[1, 2, 3]

獲取當前指令碼的路徑，再採用絕對路徑，來匯入包

$cat run6.py
import os
import sys
print(os.path.realpath(__file__))
print(os.path.split(os.path.realpath(__file__)))
bin = os.path.split(os.path.realpath(__file__))[0]
print(bin)

sys.path.append("{bin}/path2/path3".format(bin=bin))
from m1 import a,b
print(a)
print(b)

$python run6.py
/opt/script/ref/python/imp/test1/run6.py
('/opt/script/ref/python/imp/test1', 'run6.py')
/opt/script/ref/python/imp/test1
匯入成功
123
[1, 2, 3]

指令碼的自動執行

ddd

指令碼末端加入以下語句
py1.py
if __name__ == '__main__':
    print '作為主程式執行'
else:
    print 'package_runoob 初始化'

python py1.py

例如

$cat run2.py
from m1 import a,b
print("a is ",a)
print("b is",b)

if __name__ == "__main__":
   print(" main run ")
else:
   print(" package init ")

$python run2.py
匯入成功
a is  123
b is [1, 2, 3]
main run