Python bool compare vs string compare，哪个更快？

Question

我需要处理一个非常大的 CSV 文件。

在此过程中，第一行需要特别注意。

因此，显而易见的代码是检查 csv 行中的值。 但这意味着对每一行（大约 200.000）进行字符串比较

另一种选择是设置一个布尔值并让布尔比较在“或”表达式中排在第一位。

两个选项如下：

import csv

def do_extra_processing():
    pass


def do_normal_processing():
    pass


if __name__ == "__main__":

    with open('file.csv', newline='') as csvfile:
        lines = csv.reader(csvfile, delimiter=';')

        line_checked: bool = False

        for line in lines:
            # Check the first line: Option 1
            if line[1] == "SomeValue":
                # Every line of the 200000 lines does the string-compare
                do_extra_processing()
            do_normal_processing()

            # Check the first line: Option 2
            if (line_checked) or (line[1] == "SomeValue"):
                # Every line of the 200000 lines does the boolean-compare first and does not evaluate the string compare
                do_extra_processing()
                line_checked = True
            do_normal_processing()

我已经检查过，在“或”表达式中，当第一部分为 True 时，不会计算第二部分。

布尔值在 for 循环上方初始化，并在 extra_processing 完成时在 if 语句中设置。

问题是：使用 bool-compare 的第二个选项明显更快吗？

（无需转换为 ，与37615264 的问题不同）

Answer 1

（编辑/注意：这适用于我认为 OP 的代码打算做的事情，而不是它实际做的事情。我 asked 是否像我怀疑的那样是一个错误。）

原始版本的作用：

1. 加载line。
2. 加载1。
3. 加载line[1]。
4. 加载字符串常量。
5. 进行字符串比较，得到一个布尔值。
6. 检查布尔值的真实性。

布尔优化版本的作用：

1. 加载line_checked。
2. 检查布尔值的真实性。

哪个更快？猜一下 ：-）。但更好的衡量标准是，您可能会发现两者都不重要，即两者都比每行剩余的实际处理速度要快得多。

无论如何，这里有两个想法需要不需要为第一行之后的行做额外的工作：

1. 单独的代码：

    with open('file.csv', newline='') as csvfile:
        lines = csv.reader(csvfile, delimiter=';')

        for line in lines:
            if line[1] == "SomeValue":
                do_extra_processing()
            do_normal_processing()
            break

        for line in lines:
            do_normal_processing()

1. 在第一行之后切换处理函数：

    with open('file.csv', newline='') as csvfile:
        lines = csv.reader(csvfile, delimiter=';')

        def process():
            if line[1] == "SomeValue":
                do_extra_processing()
            do_normal_processing()
            nonlocal process
            process = do_normal_processing
            
        for line in lines:
            process()

未测试。如果您将该代码块保留在全局空间中，后一种解决方案可能需要global 而不是nonlocal。不过，将其放入函数中可能是个好主意。

一个小基准：如果您有我怀疑的错误，并且 bool 旨在避免除第一行之外的所有字符串比较和额外处理，那么我会得到这样的时间：

11.5 ms  11.6 ms  11.6 ms  if is_first_line and line[1] == "Somevalue": doesnt_happen_in_other_lines
45.1 ms  45.3 ms  45.3 ms  if line[1] == "Somevalue": doesnt_happen_in_other_lines

代码（Try it online!）：

from timeit import repeat

setup = '''
is_first_line = False
line = [None, "Othervalue"]
'''

statements = [
    'if is_first_line and line[1] == "Somevalue": doesnt_happen_in_other_lines',
    'if line[1] == "Somevalue": doesnt_happen_in_other_lines',
]

for _ in range(3):
    for stmt in statements:
        ts = sorted(repeat(stmt, setup))[:3]
        print(*('%4.1f ms ' % (t * 1e3) for t in ts), stmt)
    print()

Answer 2

在进一步测试之前，我建议使用第二个版本，因为我们都知道测试布尔值比测试字符串相等性更简单。

然后我做了我建议@AidenEllis 做的事情（Windows 上的 Python 3.10），有点惊讶：

timeit('x = "foo" if a == b else "bar"', '''a=True
b=False
''')
0.031938999999511
timeit('x = "foo" if a == b else "bar"', '''a=True
b=True
''')
0.032499900000402704
timeit('x = "foo" if a == b else "bar"', '''a="Somevalue"
b="Somevalue1"
''')
0.03237569999964762

没什么大不了的……

然后我尝试了：

timeit('x = "foo" if a else "bar"', 'a=True')
0.022047000000384287
timeit('x = "foo" if a else "bar"', 'a=False')
0.020898400000078254

快了近 30%，看起来不错……

最后

timeit('x = "foo" if (a or (b == c)) else "bar"', '''a=True
b="Somevalue"
c="Somevalue1"
''')
0.022851300000183983

仍然很重要，但这意味着测试布尔值比比较两个值更快，无论值的类型如何，即使它们是布尔值。和我预期的不太一样……

我的结论是，我们正在研究实现细节（我给出 Python 版本的原因），唯一明智的答案是 这并不重要：如果有的话，收益应该可以忽略不计与实际处理时间相比。

Answer 3

可能不是您正在寻找的快速答案，但您为什么不比较两者的处理时间，分别进行两种方式，然后检查哪个完成得更快。

如果您只想快速比较两组不同的代码，请使用它：

import time

start = time.perf_counter()

# do your processes here

finish = time.perf_counter()
total = finish - start
print(f"Process Time: {round(total * 1000, 2)}ms")

好吧，回到它XD