19.4. dis — 反汇编 python 字节码 | 语言工具 |《python 3 标准库实例教程》| python 技术论坛-大发黄金版app下载
目的：将代码对象转换为字节码的人类可读表示形式以供分析。
dis 模块包括用于反编译 python 字节码将其拆解为更易于阅读的形式的函数。 查看解释器正在执行的字节码是手动调整紧密循环和执行其他类型优化的好方法。 它对于在多线程应用程序中查找竞争条件也很有用，因为它可用于估计代码中线程控制可能切换的点。
警告
字节码的使用是 cpython 解释器的特定版本的实现细节。 请参阅源代码中的
include/opcode.h，了解用于当前查找字节码规范列表的解释器版本。
基本反编译
函数 dis() 打印 python 代码源（模块、类、方法、函数或代码对象）的反汇编形式。 可以通过从命令行运行 dis 来反汇编诸如 dis_simple.py 之类的模块。
dis_simple.py
#!/usr/bin/env python3
# encoding: utf-8
my_dict = {'a': 1}
输出被组织成列，包含原始源行号，代码对象中的指令地址、操作码名称以及传递给操作码的任何参数。
$ python3 -m dis dis_simple.py
4 0 load_const 0 ('a')
2 load_const 1 (1)
4 build_map 1
6 store_name 0 (my_dict)
8 load_const 2 (none)
10 return_value
在这个例子中，源转换为四种不同的操作来创建和填充字典，然后将结果保存到局部变量。 由于 python 解释器是基于堆栈的，因此第一步是使用 load_const 以正确的顺序将常量放入堆栈，然后使用 build_map 弹出新的键和值以添加到字典中。 生成的 dict 对象绑定到变量名 my_dict 并带有 store_name 。
函数反编译
不幸的是，反编译整个模块并不会自动递归到函数中。
dis_function.py
#!/usr/bin/env python3
# encoding: utf-8
def f(*args):
nargs = len(args)
print(nargs, args)
if __name__ == '__main__':
import dis
dis.dis(f)
反编译 dis_function.py 的结果显示了将函数的代码对象加载到堆栈然后将其转换为函数（ load_const ， make_function ）的操作，但不是函数的主体。
$ python3 -m dis dis_function.py
5 0 load_const 0 ()
2 load_const 1 ('f')
4 make_function 0
6 store_name 0 (f)
10 8 load_name 1 (__name__)
10 load_const 2 ('__main__')
12 compare_op 2 (==)
14 pop_jump_if_false 34
11 16 load_const 3 (0)
18 load_const 4 (none)
20 import_name 2 (dis)
22 store_name 2 (dis)
12 24 load_name 2 (dis)
26 load_attr 2 (dis)
28 load_name 0 (f)
30 call_function 1
32 pop_top
>> 34 load_const 4 (none)
36 return_value
要查看函数内部，函数本身必须传递给 dis() 。
$ python3 dis_function.py
6 0 load_global 0 (len)
2 load_fast 0 (args)
4 call_function 1
6 store_fast 1 (nargs)
7 8 load_global 1 (print)
10 load_fast 1 (nargs)
12 load_fast 0 (args)
14 call_function 2
16 pop_top
18 load_const 0 (none)
20 return_value
要打印函数的摘要，包括有关它使用的参数和名称的信息，请调用 show_code() ，将函数作为第一个参数传递。
#!/usr/bin/env python3
# encoding: utf-8
def f(*args):
nargs = len(args)
print(nargs, args)
if __name__ == '__main__':
import dis
dis.show_code(f)
show_code() 的参数传递给 code_info() ，它返回一个格式正确的函数、方法、代码字符串或其他代码对象的摘要，准备好打印。
$ python3 dis_show_code.py
name: f
filename: dis_show_code.py
argument count: 0
kw-only arguments: 0
number of locals: 2
stack size: 3
flags: optimized, newlocals, varargs, nofree
constants:
0: none
names:
0: len
1: print
variable names:
0: args
1: nargs
类
类可以传递给 dis() ，在这种情况下，所有的方法都会被反编译。
dis_class.py
#!/usr/bin/env python3
# encoding: utf-8
import dis
class myobject:
"""example for dis."""
class_attribute = 'some value'
def __str__(self):
return 'myobject({})'.format(self.name)
def __init__(self, name):
self.name = name
dis.dis(myobject)
这些方法按字母顺序列出，而不是它们在文件中出现的顺序。
$ python3 dis_class.py
disassembly of __init__:
16 0 load_fast 1 (name)
2 load_fast 0 (self)
4 store_attr 0 (name)
6 load_const 0 (none)
8 return_value
disassembly of __str__:
13 0 load_const 1 ('myobject({})')
2 load_attr 0 (format)
4 load_fast 0 (self)
6 load_attr 1 (name)
8 call_function 1
10 return_value
源代码
使用程序的源代码通常比使用代码对象本身更方便。 dis 中的函数接受包含源代码的字符串参数，并在生成反编译或其他输出之前将它们转换为代码对象。
dis_string.py
import dis
code = """
my_dict = {'a': 1}
"""
print('disassembly:\n')
dis.dis(code)
print('\ncode details:\n')
dis.show_code(code)
传递字符串可以保存编译代码的步骤并自己保存对结果的引用，这在检查函数外部的语句时更为方便。
$ python3 dis_string.py
disassembly:
2 0 load_const 0 ('a')
2 load_const 1 (1)
4 build_map 1
6 store_name 0 (my_dict)
8 load_const 2 (none)
10 return_value
code details:
name:
filename:
argument count: 0
kw-only arguments: 0
number of locals: 0
stack size: 2
flags: nofree
constants:
0: 'a'
1: 1
2: none
names:
0: my_dict
使用反编译调试
有时在调试异常时，查看哪个字节码导致问题会很有用。 有几种方法可以围绕错误反编译代码。 第一种是通过在交互式解释器中使用 dis() 来报告最后一个异常。 如果没有参数传递给 dis() ，那么它会查找异常并显示导致错误的堆栈顶部的反编译。
$ python3
python 3.5.1 (v3.5.1:37a07cee5969, dec 5 2015, 21:12:44)
[gcc 4.2.1 (apple inc. build 5666) (dot 3)] on darwin
type "help", "大发黄金版app下载 copyright", "credits" or "license" for more information.
>>> import dis
>>> j = 4
>>> i = i 4
traceback (most recent call last):
file "", line 1, in
nameerror: name 'i' is not defined
>>> dis.dis()
1 --> 0 load_name 0 (i)
3 load_const 0 (4)
6 binary_add
7 store_name 0 (i)
10 load_const 1 (none)
13 return_value
>>>
行号后面的 --> 表示导致错误的操作码。 没有定义 i 变量，因此与名称关联的值无法加载到堆栈中。
程序还可以直接将其传递给 distb() 来打印有关活动回溯的信息。 在这个例子中，有一个 dividebyzero 异常，但由于公式有两个分区，因此可能不清楚哪个部分为零。
dis_traceback.py
#!/usr/bin/env python3
# encoding: utf-8
i = 1
j = 0
k = 3
try:
result = k * (i / j) (i / k)
except exception:
import dis
import sys
exc_type, exc_value, exc_tb = sys.exc_info()
dis.distb(exc_tb)
在反编译版本中将错误加载到堆栈中时，很容易发现该错误。 使用 --> 突出显示错误操作，其中前一行将 j 的值压入堆栈。
$ python3 dis_traceback.py
4 0 load_const 0 (1)
2 store_name 0 (i)
5 4 load_const 1 (0)
6 store_name 1 (j)
6 8 load_const 2 (3)
10 store_name 2 (k)
8 12 setup_except 24 (to 38)
9 14 load_name 2 (k)
16 load_name 0 (i)
18 load_name 1 (j)
--> 20 binary_true_divide
22 binary_multiply
24 load_name 0 (i)
26 load_name 2 (k)
28 binary_true_divide
30 binary_add
32 store_name 3 (result)
...trimmed...
循环性能分析
除了调试错误，dis 还可以帮助识别性能问题。 检查反编译代码对于紧密循环特别有用，其中的 python 指令数量很少但它们被转换为低效的字节码集。 通过检查类的一些不同实现，可以看到反编译的有用性， dictionary 读取单词列表并按照第一个字母对它们进行分组。
dis_test_loop.py
import dis
import sys
import textwrap
import timeit
module_name = sys.argv[1]
module = __import__(module_name)
dictionary = module.dictionary
dis.dis(dictionary.load_data)
print()
t = timeit.timer(
'd = dictionary(words)',
textwrap.dedent("""
from {module_name} import dictionary
words = [
l.strip()
for l in open('/usr/share/dict/words', 'rt')
]
""").format(module_name=module_name)
)
iterations = 10
print('time: {:0.4f}'.format(t.timeit(iterations) / iterations))
测试驱动程序应用程序 dis_test_loop.py 可用于运行 dictionary 类的每个实体，从一个简单但缓慢的实现开始。
dis_slow_loop.py
#!/usr/bin/env python3
# encoding: utf-8
class dictionary:
def __init__(self, words):
self.by_letter = {}
self.load_data(words)
def load_data(self, words):
for word in words:
try:
self.by_letter[word[0]].append(word)
except keyerror:
self.by_letter[word[0]] = [word]
使用此版本运行测试程序会显示反编译的程序以及运行所需的时间。
$ python3 dis_test_loop.py dis_slow_loop
12 0 setup_loop 83 (to 86)
3 load_fast 1 (words)
6 get_iter
>> 7 for_iter 75 (to 85)
10 store_fast 2 (word)
13 13 setup_except 28 (to 44)
14 16 load_fast 0 (self)
19 load_attr 0 (by_letter)
22 load_fast 2 (word)
25 load_const 1 (0)
28 binary_subscr
29 binary_subscr
30 load_attr 1 (append)
33 load_fast 2 (word)
36 call_function 1 (1 positional, 0
keyword pair)
39 pop_top
40 pop_block
41 jump_absolute 7
15 >> 44 dup_top
45 load_global 2 (keyerror)
48 compare_op 10 (exception match)
51 pop_jump_if_false 81
54 pop_top
55 pop_top
56 pop_top
16 57 load_fast 2 (word)
60 build_list 1
63 load_fast 0 (self)
66 load_attr 0 (by_letter)
69 load_fast 2 (word)
72 load_const 1 (0)
75 binary_subscr
76 store_subscr
77 pop_except
78 jump_absolute 7
>> 81 end_finally
82 jump_absolute 7
>> 85 pop_block
>> 86 load_const 0 (none)
89 return_value
time: 0.0568
上一个输出显示 dis_slow_loop.py 需要0.0568秒才能在 os x 上的/usr/share/dict/words 副本中加载 235886 个单词。这不是太糟糕，但随附的反编译表明循环在做更多它不需要的工作。 当它进入操作码 13 中的循环时，它会建立一个异常上下文（ setup_except ）。 然后，在将 word 附加到列表之前，需要六个操作码才能找到 self.by_letter[word[0]] 。 如果因为 word[0] 不在字典中而有异常，则异常处理程序执行所有相同的工作以确定 word [0] （三个操作码）并设置 self.by_letter[word[0]] 到包含该单词的新列表。
消除异常设置的一种技术是预先填充 self.by_letter ，其中每个字母的字母都有一个列表。 这意味着应始终能找到新单词的列表，并且可以在查找后保存该值。
dis_faster_loop.py
#!/usr/bin/env python3
# encoding: utf-8
import string
class dictionary:
def __init__(self, words):
self.by_letter = {
letter: []
for letter in string.ascii_letters
}
self.load_data(words)
def load_data(self, words):
for word in words:
self.by_letter[word[0]].append(word)
此更改将操作码数量减少了一半，但只将时间减少到 0.0567 秒。 显然，异常处理有一些开销，但不是很大。
$ python3 dis_test_loop.py dis_faster_loop
17 0 setup_loop 38 (to 41)
3 load_fast 1 (words)
6 get_iter
>> 7 for_iter 30 (to 40)
10 store_fast 2 (word)
18 13 load_fast 0 (self)
16 load_attr 0 (by_letter)
19 load_fast 2 (word)
22 load_const 1 (0)
25 binary_subscr
26 binary_subscr
27 load_attr 1 (append)
30 load_fast 2 (word)
33 call_function 1 (1 positional, 0
keyword pair)
36 pop_top
37 jump_absolute 7
>> 40 pop_block
>> 41 load_const 0 (none)
44 return_value
time: 0.0567
通过在循环之外移动 self.by_letter 的查找，可以进一步提高性能（毕竟值不会改变）。
dis_fastest_loop.py
#!/usr/bin/env python3
# encoding: utf-8
import collections
class dictionary:
def __init__(self, words):
self.by_letter = collections.defaultdict(list)
self.load_data(words)
def load_data(self, words):
by_letter = self.by_letter
for word in words:
by_letter[word[0]].append(word)
操作码 0-6 现在找到 self.by_letter 的值并将其保存为局部变量 by_letter 。 使用局部变量只需要一个操作码，而不是两个操作码（语句 22 使用 load_fast 将字典放入堆栈中）。此更改后，运行时间将减少到0.0473秒。
$ python3 dis_test_loop.py dis_fastest_loop
14 0 load_fast 0 (self)
3 load_attr 0 (by_letter)
6 store_fast 2 (by_letter)
15 9 setup_loop 35 (to 47)
12 load_fast 1 (words)
15 get_iter
>> 16 for_iter 27 (to 46)
19 store_fast 3 (word)
16 22 load_fast 2 (by_letter)
25 load_fast 3 (word)
28 load_const 1 (0)
31 binary_subscr
32 binary_subscr
33 load_attr 1 (append)
36 load_fast 3 (word)
39 call_function 1 (1 positional, 0
keyword pair)
42 pop_top
43 jump_absolute 16
>> 46 pop_block
>> 47 load_const 0 (none)
50 return_value
time: 0.0473
brandon rhodes 建议的进一步优化是完全消除 for 循环的 python 版本。 如果 itertools.groupby() 用于排列输入，则迭代将移至 c 中。这是安全的，因为已知输入已排序。 如果不是这样，程序将需要先对它们进行排序。
dis_eliminate_loop.py
#!/usr/bin/env python3
# encoding: utf-8
import operator
import itertools
class dictionary:
def __init__(self, words):
self.by_letter = {}
self.load_data(words)
def load_data(self, words):
# 按字母表排列
grouped = itertools.groupby(
words,
key=operator.itemgetter(0),
)
# 保存已排序的单词集
self.by_letter = {
group[0][0]: group
for group in grouped
}
itertools 版本只需要0.0332秒运行，大约是原始运行时间的60％。
$ python3 dis_test_loop.py dis_eliminate_loop
16 0 load_global 0 (itertools)
3 load_attr 1 (groupby)
17 6 load_fast 1 (words)
9 load_const 1 ('key')
18 12 load_global 2 (operator)
15 load_attr 3 (itemgetter)
18 load_const 2 (0)
21 call_function 1 (1 positional, 0
keyword pair)
24 call_function 257 (1 positional, 1
keyword pair)
27 store_fast 2 (grouped)
21 30 load_const 3 ( at 0x101517930, file ".../dis_eliminate_loop.py",
line 21>)
33 load_const 4
('dictionary.load_data..')
36 make_function 0
23 39 load_fast 2 (grouped)
42 get_iter
43 call_function 1 (1 positional, 0
keyword pair)
46 load_fast 0 (self)
49 store_attr 4 (by_letter)
52 load_const 0 (none)
55 return_value
time: 0.0332
编译器优化
反编译编译源还会暴露编译器所做的一些优化。 例如，在可能的情况下，在编译期间折叠文字表达式。
dis_constant_folding.py
#!/usr/bin/env python3
# encoding: utf-8
# folded
i = 1 2
f = 3.4 * 5.6
s = 'hello,' ' world!'
# not folded
i = i * 3 * 4
f = f / 2 / 3
s = s '\n' 'fantastic!'
第 5-7 行的表达式中的值都不能改变执行操作的方式，因此表达式的结果可以在编译时计算并折叠成单个 load_const 指令。 第 10-12 行不是这样。 因为变量涉及这些表达式，并且变量可能引用了重载所涉及的运算符的对象，所以执行必须延迟到运行时。
$ python3 -m dis dis_constant_folding.py
5 0 load_const 11 (3)
2 store_name 0 (i)
6 4 load_const 12 (19.04)
6 store_name 1 (f)
7 8 load_const 13 ('hello, world!')
10 store_name 2 (s)
10 12 load_name 0 (i)
14 load_const 6 (3)
16 binary_multiply
18 load_const 7 (4)
20 binary_multiply
22 store_name 3 (i)
11 24 load_name 1 (f)
26 load_const 1 (2)
28 binary_true_divide
30 load_const 6 (3)
32 binary_true_divide
34 store_name 4 (f)
12 36 load_name 2 (s)
38 load_const 8 ('\n')
40 binary_add
42 load_const 9 ('fantastic!')
44 binary_add
46 store_name 5 (s)
48 load_const 10 (none)
50 return_value
另请参阅
- -- 包括 的列表。
include/opcode.h -- cpython 解释器的源代码定义了 opcode.h 中的字节代码。- python essential reference, 第四版, david m. beazley --
- -- 简要讨论在 python 2.5 和2.6 之间存储字典中值的区别。
- -- stackoverflow 上关于通过反汇编的字节码比较 2 个循环示例的讨论。
- -- raymond hettinger 和 skip montanaro 的 python cookbook 参考，说明了一个函数装饰器，它重写函数的字节码以插入全局常量，以避免运行时名称查找。
本译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 cc 协议，如果我们的工作有侵犯到您的权益，请及时联系大发黄金版app下载。
