0087-【Python系统】-python的导入语法2

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(),这也符合对象属性语法。

如果更改re.py的名为ree.py，则不能成功导入

$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