python - 与从具有多个循环的 string.split() 创建的列表迭代相比，具有单个循环的字符串迭代是否更慢？

Question

我正在处理一个简单的代码问题，我需要编写一个函数，该函数将字符串作为输入并以 3 种格式打印反转字符串，如下所示。

reverse_str("Hello Folks Lets Code")  --> output as below

edoC steL skloF olleH

Code Lets Folks Hello

olleH skloF steL edoC

我在下面编写了带有单个 while 循环的函数，该循环仅遍历字符串一次并给出上述输出。这工作得很好。

def reverse_str(inp_str: str):
    original_word=''
    reversed_word=''
    order_word_rvrsd=''
    order_rvrsd=''
    word_rvrsd=''
    indx=0
    while True:
        try:
            c=inp_str[indx]
            if c!=' ':
                original_word+=c
                reversed_word=c+reversed_word

            else :
                order_word_rvrsd=reversed_word+c+order_word_rvrsd
                order_rvrsd=original_word+c+order_rvrsd
                word_rvrsd=word_rvrsd+reversed_word+c
                original_word=''
                reversed_word=''
            indx+=1
        except IndexError:
            c=' '
            order_word_rvrsd=reversed_word+c+order_word_rvrsd
            order_rvrsd=original_word+c+order_rvrsd
            word_rvrsd=word_rvrsd+reversed_word
            break
    print(order_word_rvrsd,order_rvrsd,word_rvrsd,sep='\n')

但我发现下面有人做同样的事情，但将输入字符串拆分为单词列表并多次迭代它:

def reverseStr(s: str):
  splitted_s = s.split(" ")
  l = len(splitted_s)
  out1 = ""
  out2 = ""
  out3 = ""
  for i in range(1, l+1):
    out1 += splitted_s[-i][::-1] + " "
  for i in range(1, l+1):
    out2 += splitted_s[-i] + " "
  for i in range(l):
    out3 += splitted_s[i][::-1] + " "
  print(out1,out2,out3,sep='\n')

根据时间复杂度分析，我的单循环方法应该是 O(n) 复杂度，因为它只遍历字符串字符一次。而第二个函数会多次执行。但令人惊讶的是，对于更大的字符串，第二个函数比我的第一个函数运行得更快。

这是因为与使用多循环从 string.split() 创建的单词列表的迭代相比，使用单循环的字符串迭代更慢吗？

非常感谢任何帮助理解

Answer 1

我做了一些粗略的计算。

inp_str = ' '.join([''.join(random.choices(string.ascii_uppercase + string.digits, k = 4)) for indx in range(10000)])

inp_str字符串的长度为 10000 * 5 = 50000字符和空格每隔 4字符(10000 单词)。

reverse_str 中的循环功能:

indx = 0

while True:
    try:
        # ...
        indx += 1
    except IndexError:
        # ...
        break

被执行50000次。这意味着输入 10000空格字符和 40000字母/数字。

• 对于每个非空格字符都有2作业和 2串联

  original_word += c
  reversed_word = c + reversed_word
  

• 对于空格字符，至少有 3作业和 6串联

  order_word_rvrsd = reversed_word + c + order_word_rvrsd
  order_rvrsd = original_word + c + order_rvrsd
  word_rvrsd = word_rvrsd + reversed_word + c
  

总数是:40000 * 2 + 10000 *3 = 110000作业和 40000 * 2 + 10000 * 6 = 140000串联。

---

reverseStr函数有三个循环，每个循环都在(或多或少)10000 上工作话。

• 执行第一个循环(for i in range(1, l+1):)10000次(1 分配和 2 连接)；
• 第二个循环(for i in range(1, l+1):)被执行10000次(1 分配和 2 连接)；
• 执行最后一个循环10000次(1 分配和 2 连接)；

所以总数是:30000作业和 60000串联。

差异足以补偿初始分词(它可能大致需要 10000 分配)。

---

性能差异随着输入字符串中单词的平均长度的增加而增加。