(0) 你问“为什么 win32com 比 xlrd 慢这么多？” ......这个问题有点像“你停止打你的妻子了吗？” --- 它基于一个可能不正确的假设；win32com 是由一位才华横溢的程序员用 C 编写的，而 xlrd 是由普通程序员用纯 Python 编写的。真正的区别是win32com必须调用COM，这涉及到进程间通信并且是由你知道的人编写的，而xlrd是直接读取Excel文件。此外，场景中还有第四方：你。请继续阅读。
(1) 您没有向我们展示find_last_col()您在 COM 代码中重复使用的函数的来源。在 xlrd 代码中，您很乐意一直使用相同的值 (ws.ncols)。因此，在 COM 代码中，您应该调用find_last_col(ws)ONCE，然后使用返回的结果。更新请参阅关于如何从 COM获取等效 xlrd 的单独问题的答案。Sheet.ncols
(2) 访问每个单元格值 TWICE 会减慢两个代码的速度。代替
if ws.cell_value(6, cnum):
wsHeaders[str(ws.cell_value(6, cnum))] = (cnum, ws.ncols)
尝试
value = ws.cell_value(6, cnum)
if value:
wsHeaders[str(value)] = (cnum, ws.ncols)
注意：每个代码片段中都有 2 种情况。
(3) 嵌套循环的目的是什么并不明显，但似乎确实存在一些冗余计算，涉及从 COM 的冗余提取。如果您愿意通过示例告诉我们您要实现的目标，我们可以帮助您使其运行得更快。至少，从 COM 中提取值一次，然后在 Python 的嵌套循环中处理它们应该更快。有多少列？
更新 2与此同时，小精灵们用直肠镜查看了您的代码，并提出了以下脚本：
tests= [
"A/B/C/D",
"A//C//",
"A//C//E",
"A///D",
"///D",
]
for test in tests:
print "\nTest:", test
row = test.split("/")
ncols = len(row)
# modelling the OP's code
# (using xlrd-style 0-relative column indexes)
d = {}
for cnum in xrange(ncols):
if row[cnum]:
k = row[cnum]
v = (cnum, ncols) #### BUG; should be ncols - 1 ("inclusive")
print "outer", cnum, k, '=>', v
d[k] = v
for cend in xrange(cnum + 1, ncols):
if row[cend]:
k = row[cnum]
v = (cnum, cend - 1)
print "inner", cnum, cend, k, '=>', v
d[k] = v
break
print d
# modelling a slightly better algorithm
d = {}
prev = None
for cnum in xrange(ncols):
key = row[cnum]
if key:
d[key] = [cnum, cnum]
prev = key
elif prev:
d[prev][1] = cnum
print d
# if tuples are really needed (can't imagine why)
for k in d:
d[k] = tuple(d[k])
print d
输出这个：
Test: A/B/C/D
outer 0 A => (0, 4)
inner 0 1 A => (0, 0)
outer 1 B => (1, 4)
inner 1 2 B => (1, 1)
outer 2 C => (2, 4)
inner 2 3 C => (2, 2)
outer 3 D => (3, 4)
{'A': (0, 0), 'C': (2, 2), 'B': (1, 1), 'D': (3, 4)}
{'A': [0, 0], 'C': [2, 2], 'B': [1, 1], 'D': [3, 3]}
{'A': (0, 0), 'C': (2, 2), 'B': (1, 1), 'D': (3, 3)}
Test: A//C//
outer 0 A => (0, 5)
inner 0 2 A => (0, 1)
outer 2 C => (2, 5)
{'A': (0, 1), 'C': (2, 5)}
{'A': [0, 1], 'C': [2, 4]}
{'A': (0, 1), 'C': (2, 4)}
Test: A//C//E
outer 0 A => (0, 5)
inner 0 2 A => (0, 1)
outer 2 C => (2, 5)
inner 2 4 C => (2, 3)
outer 4 E => (4, 5)
{'A': (0, 1), 'C': (2, 3), 'E': (4, 5)}
{'A': [0, 1], 'C': [2, 3], 'E': [4, 4]}
{'A': (0, 1), 'C': (2, 3), 'E': (4, 4)}
Test: A///D
outer 0 A => (0, 4)
inner 0 3 A => (0, 2)
outer 3 D => (3, 4)
{'A': (0, 2), 'D': (3, 4)}
{'A': [0, 2], 'D': [3, 3]}
{'A': (0, 2), 'D': (3, 3)}
Test: ///D
outer 3 D => (3, 4)
{'D': (3, 4)}
{'D': [3, 3]}
{'D': (3, 3)}