目录
一、简单模块化
可以把函数、类、常量拆分到不同的文件，把它们放在同一个文件夹，然后使用 from your_file import function_name,class_name 的方式调用，之后，这些函数可以在文件内直接使用。
# utils.py
def get_sum(a, b):
return a + b
# class_utils.py
class Encoder(object):
def encode(self, s):
return s[::-1]
class Decoder(object):
def decode(self, s):
return ''.join(reversed(list(s)))
# class_utils.py
class Encoder(object):
def encode(self, s):
return s[::-1]
class Decoder(object):
def decode(self, s):
return ''.join(reversed(list(s)))
以上代码，get_sum()函数定义在utils.py,Encoder和Decoder类则在class_utils.py可以直接在main函数直接调用from import,就可以将我们需要的东西import过来。
文件结构如下：
.
├── utils
│ ├── utils.py
│ └── class_utils.py
├── src
│ └── sub_main.py
└── main.py
很容易可以看出，main.py调用目录的模块时，只需要使用.代替/来表示子目录，utils.utils表示utils子文件理的utils.py模块。
除了一些特殊的情况，import必须位于最前端。
我们还需要在模块所在的文件夹新建一个__init__.py，内容可以为空，也可以用来表述包对外暴露的模块接口，不过，事实上，这是python2的规范。python3中,__init__.py并不是必须的。
二、项目模块化
在Linux中，以/开头，来表示从根目录到叶子节点的路径，eg:/home/ubuntn/Desktop/my_project/test.py这种方法叫做绝对路径。
另外，对于任意二个文件，我们都有一条通路可以从一个文件到另一个文件。eg:/home/ubuntu/Downloads/example.json。如果从test.py访问，需要写成../../Downloads/example.json，表示上一层目录，这种方法表示相对路径。
通常一个python文件在运行时，都会有一个位置，最开始为这个文件所在的文件夹，当然，这个路径可以被改变。运行sys.path.append("..")则可以改变当前python解释器的位置。相对路径不是一种好的选择，因为如果代码迁移，相对位置会使得重构，也会出错。对于一个独立的项目，所有的模块的追寻方式，最好从项目的根目录开始，这叫绝对路径。
绝对路径的优点：
(1)简化依赖管理
(2)版本统一，不存在使用一个新模块，却导致一系列函数崩溃的情况，并且所有的升级都需要通过单元测试才可以继续。
(3)代码追溯，可以容易的追溯，一个API是从哪里被调用的，它的历史版本是怎么迭代开发的，产生变化的。
做项目时，不可能把全世界的代码都放在一个文件下，但是类似模块化的思想还是要有的，那就是以项目作为最基本的目录，所有的模块调用，都要通过根目录一层层向下索引的方式来import.
可以使用pycharm来创建一个项目，项目结构为：
.
├── proto
│ ├── mat.py
├── utils
│ └── mat_mul.py
└── src
└── main.py
# utils/mat_mul.py
from proto.mat import Matrix
def mat_mul(matrix_1: Matrix, matrix_2: Matrix):
assert matrix_1.m == matrix_2.n
n, m, s = matrix_1.n, matrix_1.m, matrix_2.m
result = [[0 for _ in range(n)] for _ in range(s)]
for i in range(n):
for j in range(s):
for k in range(m):
result[i][k] += matrix_1.data[i][j] * matrix_2.data[j][k]
return Matrix(result)
# src/main.py
from proto.mat import Matrix
from utils.mat_mul import mat_mul
a = Matrix([[1, 2], [3, 4]])
b = Matrix([[5, 6], [7, 8]])
print(mat_mul(a, b).data)
########## 输出 ##########
[[19, 22], [43, 50]]
这个例子和上面的像，但注意utils/mat_mul.py，会发现，它import Matrix的方式是from proto.mat这种做法，直接从项目目录中导入，并依次向下导入模块mat.py中和Matrix，而不是使用..导入上一级文件夹。
接下来和项目都是使用pycharm来构建。把不同模块放在不同文件里，跨模块调用是从顶层直接索引，一步到位，非常方便。
实际上，python解释器遇到到import时，它会在一个特定的列表中寻找模块，，这个特定的列表，可以在下面方式得到：
import sys
print(sys.path)
########## 输出 ##########
['', '/usr/lib/python36.zip', '/usr/lib/python3.6', '/usr/lib/python3.6/lib-dynload', '/usr/local/lib/python3.6/dist-packages', '/usr/lib/python3/dist-packages']
第一项为空，是因为将第一项高为根目录的绝对地址。这样，每次运行main.py，import函数在执行时，都会去项目根目录中找相应的包。
使一般的python环境楞也能做到，两种方法
import sys
sys.path[0] = '/home/ubuntu/workspace/your_projects'
三、神奇的if__name__=='__main__'
python也可以直接写代码，if __name__ == '__main__'。
项目结构如下:
.
├── utils.py
├── utils_with_main.py
├── main.py
└── main_2.py
# utils.py
def get_sum(a, b):
return a + b
print('testing')
print('{} + {} = {}'.format(1, 2, get_sum(1, 2)))
# utils_with_main.py
def get_sum(a, b):
return a + b
if __name__ == '__main__':
print('testing')
print('{} + {} = {}'.format(1, 2, get_sum(1, 2)))
# main.py
from utils import get_sum
print('get_sum: ', get_sum(1, 2))
########## 输出 ##########
testing
1 + 2 = 3
get_sum: 3
# main_2.py
from utils_with_main import get_sum
print('get_sum: ', get_sum(1, 2))
########## 输出 ##########
get_sum_2: 3
import 在导入文件时，会自动把所有暴露在外面的代码全都执行一遍，如果你要把一个东西封装成模块，又想让它可以执行，必做将执行代码放在if __name__=='__main__'下面。
其实，__name__作为python的魔术内置参数，本质上是模块对象的珍上属性，使用import语句时，__name__就会赋值为该模块的名字，自然不等于__main__了。
四、总结
1.通过绝对路径和相对路径，我们可以import模块。
2.在大型工程中模块化非常重要，模块的索引通过绝路径来做，而绝对路径从程序的根目录开始
3.记着巧用if __name__ == ‘__main__’来避开import时执行。
五、思考题
from module_name import *和import module_name有什么区别？
from module_name import *是导入module_name内所有内容，可以直接调用内部方法；import module_name，则是导入module_name在代码中必须写成module_name.function的形式。