659 lines
19 KiB
Markdown
659 lines
19 KiB
Markdown
---
|
||
front: https://nie.res.netease.com/r/pic/20210728/2dc2a94f-71f6-4cc5-8700-3c3696f79a0c.jpg
|
||
hard: 进阶
|
||
time: 30分钟
|
||
---
|
||
|
||
# 代码优化
|
||
|
||
## 前言
|
||
|
||
本文介绍了基于Python 2的一些常用技巧，能够优化代码，提升程序运行效率。
|
||
|
||
## 使用缓存(内存换CPU)
|
||
|
||
对象的重复创建与销毁会有一定性能消耗，对于需要频繁使用的数据，建议保存起来，下次从内存取出来直接使用，是一种常用的空间换时间(内存换CPU)的优化手段，对于减少游戏卡顿有较好效果。
|
||
|
||
### 避免在tick函数内使用import
|
||
|
||
import模块的消耗并没有小到可以忽略的地步，建议挪到文件的顶部进行import。如果这样会导致循环引用，则可以将模块缓存为类的成员变量
|
||
|
||
- 错误写法:
|
||
|
||
```python
|
||
class DemoClientSystem(ClientSystem):
|
||
def Update(self):
|
||
# 在每帧执行的逻辑内import模块
|
||
import mod.client.extraClientApi as clientApi
|
||
clientApi.xxx
|
||
```
|
||
|
||
- 正确写法:
|
||
|
||
```python
|
||
# 在文件顶部import模块
|
||
import mod.client.extraClientApi as clientApi
|
||
class DemoClientSystem(ClientSystem):
|
||
def Update(self):
|
||
clientApi.xxx
|
||
```
|
||
|
||
如果两个模块需要相互引用，那么同时在文件顶部import对方，会导致循环引用报错，则可以用下面的方法处理：
|
||
|
||
```python
|
||
class DemoClientSystem(ClientSystem):
|
||
def __init__(self, namespace, systemName):
|
||
ClientSystem.__init__(self, namespace, systemName)
|
||
# 假设当前模块与另一个otherModule模块需要相互引用
|
||
import demoScripts.client.otherModule as otherModule
|
||
self.otherModule = otherModule
|
||
|
||
def Update(self):
|
||
self.otherModule.xxx
|
||
```
|
||
|
||
### 避免多次初始化常量
|
||
|
||
- 错误写法:
|
||
|
||
在频繁调用的函数中进行声明，例如每次Update的时候
|
||
|
||
```python
|
||
class DemoClientSystem(ClientSystem):
|
||
def Update(self):
|
||
# 常量，每帧创建，实际中可能这里会是比较多的数据
|
||
bigDict = {
|
||
(-1, -1): 1,
|
||
(-1, 0): 2,
|
||
(-1, 1): 3,
|
||
(0, -1): 4,
|
||
(0, 0): 5,
|
||
(0, 1): 6,
|
||
(1, -1): 7,
|
||
(1, 0): 8,
|
||
(1, 1): 9,
|
||
}
|
||
# 读取常量做一些逻辑
|
||
do_something(bigDict)
|
||
```
|
||
|
||
- 正确写法:
|
||
|
||
包含数据比较多的一些常量，特别是List或者Dict类型的，可以放到类的__init__函数当中
|
||
|
||
```python
|
||
class DemoClientSystem(ClientSystem):
|
||
# 构造函数
|
||
def __init__(self, namespace, systemName):
|
||
ClientSystem.__init__(self, namespace, systemName)
|
||
# 在初始化时创建
|
||
self.bigDict = {
|
||
(-1, -1): 1,
|
||
(-1, 0): 2,
|
||
(-1, 1): 3,
|
||
(0, -1): 4,
|
||
(0, 0): 5,
|
||
(0, 1): 6,
|
||
(1, -1): 7,
|
||
(1, 0): 8,
|
||
(1, 1): 9,
|
||
}
|
||
|
||
def Update(self):
|
||
do_something(self.bigDict)
|
||
```
|
||
|
||
### 缓存多次用到的中间数据
|
||
|
||
一些方法多次调用的返回值是一样，可以使用临时变量缓存，不需要重复调用
|
||
|
||
- 错误写法:
|
||
```python
|
||
class DemoServerSystem(ServerSystem):
|
||
# 监听的ServerItemUseOnEvent事件回调
|
||
def ServerItemUseOnEvent(self, args):
|
||
# 设置多个方块
|
||
self.SetBlock(args['dimensionId'], (args['x']-1, args['y'], args['z']), 'minecraft:air')
|
||
self.SetBlock(args['dimensionId'], (args['x']-1, args['y'], args['z']), 'minecraft:air')
|
||
self.SetBlock(args['dimensionId'], (args['x'], args['y'], args['z']), 'minecraft:air')
|
||
self.SetBlock(args['dimensionId'], (args['x'], args['y'], args['z']-1), 'minecraft:air')
|
||
self.SetBlock(args['dimensionId'], (args['x'], args['y'], args['z']+1), 'minecraft:air')
|
||
|
||
def SetBlock(self, dimensionId, pos, blockName):
|
||
serverApi.GetEngineCompFactory().CreateBlockInfo(levelId).SetBlockNew(pos, {'name': blockName}, 0, dimensionId)
|
||
```
|
||
|
||
- 正确写法:
|
||
|
||
```python
|
||
# compFactory使用缓存
|
||
serverCompFactory = serverApi.GetEngineCompFactory()
|
||
class DemoServerSystem(ServerSystem):
|
||
# 监听的ServerItemUseOnEvent事件回调
|
||
def ServerItemUseOnEvent(self, args):
|
||
# 对字典内的值做缓存
|
||
dimensionId = args['dimensionId']
|
||
x = args['x']
|
||
y = args['y']
|
||
z = args['z']
|
||
self.SetBlock(dimensionId, (x-1, y, z), 'minecraft:air')
|
||
self.SetBlock(dimensionId, (x-1, y, z), 'minecraft:air')
|
||
self.SetBlock(dimensionId, (x, y, z), 'minecraft:air')
|
||
self.SetBlock(dimensionId, (x, y, z-1), 'minecraft:air')
|
||
self.SetBlock(dimensionId, (x, y, z+1), 'minecraft:air')
|
||
|
||
def SetBlock(self, dimensionId, pos, blockName):
|
||
serverCompFactory.CreateBlockInfo(levelId).SetBlockNew(pos, {'name': blockName}, 0, dimensionId)
|
||
```
|
||
|
||
### 使用dict代替多个else if
|
||
|
||
当条件判断的分支很多时，dict跳转的性能会比一连串的else高很多。如果一定要用if，推荐把命中概率较高的判断放前面。
|
||
|
||
- 错误写法:
|
||
|
||
```python
|
||
serverCompFactory = serverApi.GetEngineCompFactory()
|
||
class DemoServerSystem(ServerSystem):
|
||
def HandleBlocks(self, pos, dimensionId):
|
||
# 获取方块信息
|
||
blockIdentifier = serverCompFactory.CreateBlockInfo(levelId).GetBlockNew(pos, dimensionId)[0]
|
||
# 根据方块类型做出不同的处理
|
||
if blockIdentifier == "minecraft:iron_ore":
|
||
self.handleIronBlock()
|
||
elif blockIdentifier == "minecraft:gold_ore":
|
||
self.handleGoldBlock()
|
||
elif blockIdentifier == "minecraft:diamond_ore":
|
||
self.handleDiamondBlock()
|
||
...
|
||
```
|
||
|
||
- 正确写法:
|
||
|
||
```python
|
||
serverCompFactory = serverApi.GetEngineCompFactory()
|
||
class DemoServerSystem(ServerSystem):
|
||
def __init__(self):
|
||
# 注册处理函数
|
||
self.blockHandlers = {
|
||
"minecraft:iron_ore": self.handleIronBlock,
|
||
"minecraft:gold_ore": self.handleGoldBlock,
|
||
"minecraft:diamond_ore": self.handleDiamondBlock,
|
||
}
|
||
|
||
def HandleBlocks(self, data):
|
||
blockIdentifier = serverCompFactory.CreateBlockInfo(levelId).GetBlockNew(pos, dimensionId)[0]
|
||
# 从dict中选取处理函数
|
||
handler = self.blockHandlers.get(blockIdentifier)
|
||
if handler:
|
||
handler()
|
||
```
|
||
|
||
## 使用分帧（实时性换CPU）
|
||
|
||
同一时刻内处理大量的逻辑，容易造成卡顿。这时候需要把逻辑执行的时间错开到多帧去执行，让每一帧的任务量不要太重。
|
||
|
||
### 大批量修改数据分多帧处理
|
||
|
||
这里以方块为例：
|
||
|
||
- 错误写法: (同一时刻全部处理，需要处理 100 * 100 * 100 即一百万个方块，必然会卡)
|
||
|
||
```python
|
||
# 修改某个区域 100 * 100 * 100范围内的方块为空气
|
||
def SetBlocksToAir(self, fromPos):
|
||
blockcomp = serverApi.CreateComponent(id, "Minecraft", "blockInfo")
|
||
for x in range(1, 100):
|
||
for y in range(1, 100):
|
||
for z in range(1, 100):
|
||
blockcomp.SetBlockNew((fromPos[0] + x, fromPos[1] + y, fromPos[2] + z), {'name':'minecraft:air'})
|
||
```
|
||
|
||
- 正确写法: (分开每帧只处理5个)
|
||
|
||
```python
|
||
# 修改某个区域 100 * 100 * 100范围内的方块为空气
|
||
def SetBlocksToAir(self, fromPos):
|
||
# 命令队列
|
||
self.posList = []
|
||
self.posIndex = 0
|
||
|
||
for x in range(1, 100):
|
||
for y in range(1, 100):
|
||
for z in range(1, 100):
|
||
self.posList.append((fromPos[0] + x, fromPos[1] + y, fromPos[2] + z))
|
||
|
||
# 被引擎直接执行的父类的重写函数，引擎会执行该Update回调，1秒钟30帧
|
||
def Update(self):
|
||
if self.posList:
|
||
posListLen = len(self.posList)
|
||
blockcomp = serverApi.CreateComponent(id, "Minecraft", "blockInfo")
|
||
#每帧处理5个
|
||
handleNum = 5
|
||
while(handleNum > 0 and self.posIndex < posListLen):
|
||
blockcomp.SetBlockNew(self.posList[self.posIndex], {'name':'minecraft:air'})
|
||
self.posIndex = self.posIndex + 1
|
||
handleNum = handleNum - 1
|
||
|
||
# 全部处理完成
|
||
if self.posIndex >= posListLen:
|
||
self.posList = None
|
||
```
|
||
|
||
### 非重要逻辑降帧处理
|
||
|
||
不要每帧执行所有逻辑更新，不同的逻辑实际中根据实时性要求进行间隔更新
|
||
|
||
- 错误写法:
|
||
(每帧执行所有更新逻辑)
|
||
```python
|
||
def Update(self):
|
||
self.do_something1()
|
||
self.do_something2()
|
||
self.do_something3()
|
||
```
|
||
|
||
- 正确写法:
|
||
(分开每帧只处理5个)
|
||
```python
|
||
class DemoClientSystem(ClientSystem):
|
||
# 构造函数
|
||
def __init__(self, namespace, systemName):
|
||
ClientSystem.__init__(self, namespace, systemName)
|
||
self.tick = 0
|
||
|
||
def Update(self):
|
||
self.tick = self.tick + 1
|
||
# 重要逻辑每帧执行
|
||
self.do_something1()
|
||
|
||
if self.tick % 5 == 0:
|
||
# 次要逻辑降帧执行
|
||
self.do_something2()
|
||
|
||
if self.tick % 10 == 0:
|
||
# 更次要的逻辑，使用更低的帧率执行
|
||
self.do_something3()
|
||
```
|
||
|
||
### 少用轮询逻辑
|
||
|
||
使用事件或一些适用的接口来代替每帧尝试的操作。
|
||
|
||
假想有一个需求：我想删除一个实体，但是当前这个实体没有被加载
|
||
|
||
- 错误写法：
|
||
|
||
每帧尝试删除该实体，直到成功为止
|
||
|
||
- 推荐写法：
|
||
|
||
1. 监听AddEntityServerEvent，在该实体的回调中删除。
|
||
2. 如果该实体是手动创建的，可以使用SetPersistence接口将其设置为不存盘，那就不再需要处理该实体被卸载而无法删除的情况。
|
||
|
||
## 优化字节码
|
||
|
||
Python 是解释型语言，代码在运行时会先编译为字节码（Bytecode），再由解释器逐行执行字节码，优化字节码可以直接提升执行效率。
|
||
|
||
### 使用推导式
|
||
|
||
如果要对容器进行操作，使用推导式是最快的办法。在可以使用列表/字典/集合推导式时，尽量使用推导式，而不是使用for循环。
|
||
|
||
**列表添加元素：**
|
||
|
||
```python
|
||
a = []
|
||
for i in xrange(1000):
|
||
if i % 2 == 0:
|
||
a.append(i*i)
|
||
```
|
||
|
||
**缓存append方法：**
|
||
|
||
```python
|
||
a = []
|
||
l = a.append
|
||
for i in xrange(1000):
|
||
if i % 2 == 0:
|
||
l(i*i)
|
||
```
|
||
|
||
**列表推导式：**
|
||
|
||
```python
|
||
a = [i*i for i in xrange(1000) if i % 2 == 0]
|
||
```
|
||
|
||
**测试样例：**
|
||
|
||
```python
|
||
from timeit import timeit
|
||
print "loop + append:", timeit("for i in xrange(1000):\n if i % 2 == 0:\n a.append(i*i)", "a=[]", number=10000)
|
||
print "loop + append(cache):", timeit("for i in xrange(1000):\n if i % 2 == 0:\n l(i*i)", "a=[];l=a.append", number=10000)
|
||
print "list comprehenshion:", timeit("a = [i*i for i in xrange(1000) if i % 2 == 0]", number=10000)
|
||
```
|
||
|
||
**测试结果：**
|
||
|
||
```python
|
||
loop + append: 0.6161811
|
||
loop + append(cache): 0.5132234
|
||
list comprehenshion: 0.4063318
|
||
```
|
||
|
||
**结论：**
|
||
|
||
列表推导式，能获得明显的性能提升，元素越多差距越明显。
|
||
|
||
还有**字典推导式：**
|
||
|
||
```python
|
||
g = (('a',1),('b',2),('c',3),('d',4),('e',5),('f',6))
|
||
d = {k:v for k, v in g if v % 2 == 0}
|
||
```
|
||
|
||
**集合推导式：**
|
||
|
||
```python
|
||
g = (1,2,3,4,5,6)
|
||
s = {v for v in g if v % 2 == 0}
|
||
```
|
||
|
||
### 字符串拼接
|
||
|
||
我们有很多办法拼接字符串，比如直接相加、使用format、使用%、使用join，那么到底哪种办法最快呢？
|
||
|
||
**常见写法：**
|
||
|
||
```python
|
||
s = s1 + s2 + s3
|
||
|
||
s = s1; s += s2; s += s3
|
||
|
||
s = '%s%s%s' % (s1,s2,s3)
|
||
|
||
s = ''.join((s1,s2,s3))
|
||
```
|
||
|
||
**测试样例1：**
|
||
|
||
```python
|
||
from timeit import timeit
|
||
N = 10000000
|
||
setup = 's1="hello"*35; s2="world"*25; s3="!"*30; s4=s3*2; s5=s3*2'
|
||
print(timeit("s = s1 + s2 + s3", setup, number=N))
|
||
print(timeit("s = s1; s+=s2; s+=s3", setup, number=N))
|
||
print(timeit("s = '%s%s%s' % (s1,s2,s3)", setup, number=N))
|
||
print(timeit("s = '{}{}{}'.format(s1,s2,s3)", setup, number=N))
|
||
print(timeit("s = ''.join((s1,s2,s3))", setup, number=N))
|
||
```
|
||
|
||
**测试结果1：**
|
||
|
||
```python
|
||
0.7396258
|
||
0.8553558
|
||
1.5691264
|
||
3.8130296
|
||
1.0085892
|
||
```
|
||
|
||
**测试样例2：**
|
||
|
||
```python
|
||
from timeit import timeit
|
||
N = 10000000
|
||
setup = 's1="hello"*35; s2="world"*25; s3="!"*30; s4=s3*2; s5=s3*2'
|
||
print(timeit("s = s1 + s2 + s3 + s4 + s5", setup, number=N))
|
||
print(timeit("s = s1; s+=s2; s+= s3; s+= s4; s+= s5", setup, number=N))
|
||
print(timeit("s = '%s%s%s%s%s' % (s1,s2,s3,s4,s5)", setup, number=N))
|
||
print(timeit("s = '{}{}{}{}{}'.format(s1,s2,s3,s4,s5)", setup, number=N))
|
||
print(timeit("s = ''.join((s1,s2,s3,s4,s5))", setup, number=N))
|
||
```
|
||
|
||
**测试结果2：**
|
||
|
||
```python
|
||
1.4091635
|
||
1.6201083
|
||
3.4721674
|
||
4.6679361
|
||
1.2252783
|
||
```
|
||
|
||
**结论：**
|
||
|
||
- 要拼接的子串数量较少时（如不多于3个），直接相加是最快的
|
||
- 当拼接的子串数量较多时，`join`方法是最快的
|
||
- 如果只是想纯粹拼接一下字符串，不要使用格式化方法
|
||
|
||
### 变量访问
|
||
|
||
局部变量访问速度最快，其次是全局变量。如果要访问对象的属性，比如self.client.aaa.bbb中出现了三个点，而每一个点代表一次访问，就会多消耗一次性能。建议在频繁使用时缓存为局部变量。
|
||
|
||
```python
|
||
# 缓存为全局变量CF，减少了一次访问
|
||
CF = serverApi.GetEngineCompFactory()
|
||
def OnCustomCommandTrigger(self, args):
|
||
# 在循环前，将api方法缓存为局部变量
|
||
createExplosion = CF.CreateExplosion(levelId).CreateExplosion
|
||
for _ in xrange(1000):
|
||
createExplosion(...)# 直接调用
|
||
|
||
# 将自己的方法/属性缓存为局部变量
|
||
func = self.xxxsystem.aaa.bbb
|
||
for _ in xrange(1000):
|
||
func(...)
|
||
```
|
||
|
||
### 字典查询
|
||
|
||
字典的查询属于属性访问中的一个特例。取字典中特定key的值，如取不到返回None，可有下列写法：
|
||
|
||
```python
|
||
def get1(d, key):
|
||
if key in d:
|
||
return d[key]
|
||
return None
|
||
|
||
def get2(d, key):
|
||
if d.has_key(key):
|
||
return d[key]
|
||
return None
|
||
|
||
def get3(d, key):
|
||
return d.get(key)
|
||
|
||
def get4(d, key):
|
||
return d.get(key, None)
|
||
|
||
def get5(d, key):
|
||
try:
|
||
return d[key]
|
||
except KeyError:
|
||
pass
|
||
```
|
||
|
||
**测试样例：**
|
||
|
||
```python
|
||
g_d = {"a": 23, "b": 11, "c": 88, "d": 2, "e": 3, "f": 4, "g": 11, "h": 25, "i": 46}
|
||
from timeit import timeit
|
||
print(timeit('get1(g_d, "b")', 'from __main__ import get1, g_d', number=100000))
|
||
print(timeit('get2(g_d, "b")', 'from __main__ import get2, g_d', number=100000))
|
||
print(timeit('get3(g_d, "b")', 'from __main__ import get3, g_d', number=100000))
|
||
print(timeit('get4(g_d, "b")', 'from __main__ import get4, g_d', number=100000))
|
||
print(timeit('get5(g_d, "b")', 'from __main__ import get5, g_d', number=100000))
|
||
|
||
print(timeit('get1(g_d, "z")', 'from __main__ import get1, g_d', number=100000))
|
||
print(timeit('get2(g_d, "z")', 'from __main__ import get2, g_d', number=100000))
|
||
print(timeit('get3(g_d, "z")', 'from __main__ import get3, g_d', number=100000))
|
||
print(timeit('get4(g_d, "z")', 'from __main__ import get4, g_d', number=100000))
|
||
print(timeit('get5(g_d, "z")', 'from __main__ import get5, g_d', number=100000))
|
||
```
|
||
|
||
结果分命中、不命中两种情况汇总：
|
||
|
||
| 单位：ms/1w次 | 命中 | 不命中 |
|
||
| --------- | -------- | -------- |
|
||
| get1 | 1.17 | **1.05** |
|
||
| get2 | 1.59 | 1.43 |
|
||
| get3 | 1.62 | 1.59 |
|
||
| get4 | **1.75** | 1.80 |
|
||
| get5 | **1.04** | **9.01** |
|
||
|
||
从这个表可以看到，get1用in来判断，平均表现是最好的，是否命中，都是1ms多一点。而最后这个try except，命中的时候是最佳的，不命中的时候性能就大幅恶化。
|
||
|
||
**结论：**
|
||
|
||
- 对于key是否存在，直接用in来做判断即可，has_key接口比in慢。当然in方法不止可以对字典用，也可以对任何iterable的对象用，python是动态语言，要清楚你in的对象到底是什么。
|
||
- get的default参数不必填None，因为它本来就是None，填进去反而更慢。
|
||
|
||
### 函数调用
|
||
|
||
函数调用是有额外开销的，效率敏感场合不容忽略。
|
||
|
||
**测试样例：**
|
||
|
||
```python
|
||
log = lambda msg: None
|
||
|
||
def foo(msg):
|
||
log(msg)
|
||
|
||
from timeit import timeit
|
||
print(timeit('foo("hello")', 'from __main__ import foo', number=100000))
|
||
print(timeit('log("hello")', 'from __main__ import log', number=100000))
|
||
```
|
||
|
||
**测试结果：**
|
||
|
||
```python
|
||
0.0104322
|
||
0.0051873
|
||
```
|
||
|
||
**结论：**
|
||
|
||
python里1万次的函数调用的消耗，约1毫秒的量级。在效率敏感场合，尽量省去不必要的几行代码的函数包装，减少调用层级，以及减少默认参数个数。
|
||
|
||
### 方法调用
|
||
|
||
类与实例方法的调用和函数调用类似，封装太多也会有明显的效率下降，而且情况可能更严重。
|
||
|
||
**测试样例：**
|
||
|
||
```python
|
||
# -*- coding: gbk -*-
|
||
import time
|
||
# 定义时间测量装饰器
|
||
def time_it(func):
|
||
def wrapper(*args, **kwargs):
|
||
start_time = time.time()
|
||
result = func(*args, **kwargs)
|
||
end_time = time.time()
|
||
print "函数 {} 耗时: {:.0f} 毫秒".format(func.__name__, (end_time - start_time) * 1000)
|
||
return result
|
||
return wrapper
|
||
def show_warn(message):
|
||
pass
|
||
HP_TH = 10
|
||
class Player(object):
|
||
def __init__(self):
|
||
self.hp = 0
|
||
self.hp_th = HP_TH
|
||
def tick(self):
|
||
if self.hp < self.hp_th:
|
||
self.perform_warn()
|
||
def perform_warn(self):
|
||
show_warn("warn")
|
||
class Player2(object):
|
||
def __init__(self):
|
||
self.hp = 0
|
||
self.hp_th = HP_TH
|
||
def tick(self):
|
||
if self.hp < self.hp_th:
|
||
show_warn("warn")
|
||
# 性能测试
|
||
if __name__ == "__main__":
|
||
N = 10000
|
||
# 测试 Player 类
|
||
players = []
|
||
for _ in xrange(N):
|
||
players.append(Player())
|
||
@time_it
|
||
def run(n):
|
||
for _ in xrange(n):
|
||
for p in players:
|
||
p.tick()
|
||
run(100)
|
||
# 测试 Player2 类
|
||
players = []
|
||
for _ in xrange(N):
|
||
players.append(Player2())
|
||
@time_it
|
||
def run2(n):
|
||
for _ in xrange(n):
|
||
for p in players:
|
||
p.tick()
|
||
run2(100)
|
||
```
|
||
|
||
**测试结果：**
|
||
|
||
```python
|
||
函数 run 耗时: 274 毫秒
|
||
函数 run2 耗时: 168 毫秒
|
||
```
|
||
|
||
可见，减少一层方法调用后，耗时274ms能降到168ms。
|
||
|
||
**结论：**
|
||
|
||
为了效率的话，请尽量避免过多的类方法封装；同一实例方法的频繁调用，请先缓存下来（如第一个例子中的l=a.append）
|
||
|
||
### 模块导入
|
||
|
||
关于import写在什么地方，我们都知道，写在模块开头，有这么一些弊端：
|
||
|
||
- 首次加载卡顿
|
||
- 内存过多
|
||
- 带来冗余
|
||
- 循环引用
|
||
|
||
但写在函数内就一定是最好的办法吗？
|
||
|
||
**测试样例：**
|
||
|
||
```python
|
||
def tick():
|
||
from packageA.subpackageA import math
|
||
math.fabs(100)
|
||
|
||
from packageA.subpackageA import math
|
||
def tick2():
|
||
math.fabs(100)
|
||
|
||
from timeit import timeit
|
||
print timeit("tick()", "from __main__ import tick", number=100000)
|
||
print timeit("tick2()", "from __main__ import tick2", number=100000)
|
||
|
||
# 假设把tick函数移到另一个package下（packageB/test.py）：
|
||
print timeit("tick()", "from packageB.test import tick", number=100000)
|
||
```
|
||
|
||
**测试结果：**
|
||
|
||
```python
|
||
0.1006268
|
||
0.0177434
|
||
0.1125192
|
||
```
|
||
|
||
可见，函数内import明显要慢很多，尤其是在另外一个package里面import。
|
||
|
||
**结论：**
|
||
|
||
基础性/通用性模块的导入，import写在模块头，当然前提是这些基础模块要做好规划，不要过于臃肿，不要互相耦合严重。
|
||
|
||
对于频繁调用的函数，函数开头不适宜有太多import，package结构也不宜搞得过于复杂。 |