Python 颠倒顺序

我是python新手，不太擅长递归，所以如果有人能帮我解决这个问题，我将不胜感激。 所以我基本上是想颠倒字符串的顺序。例如，如果字符串为“It's me”，则应返回“me It's”。虽然，我得到了一个完全相反的字符串，并且在大多数情况下，我得到了一个错误，表示第二个函数没有定义

def reverse_phrase(str):
    reverse_phrase_recursive(str.split())

def reverse_phrase_recursive(str):
    if len(str)==0:
        return str
    else:
        return reverse_phrase(str[1:]) + str[0]
        
print(reverse_phrase("DO I CHOOSE YOU PIKACHU"))

---

您需要调用

reverse\u phrase\u recursive

作为递归调用，否则列表将被传递到

reverse\u phrase

，然后它将尝试调用列表上的.split（），这将抛出AttributeError

另外，实际上，从reverse_短语返回值，并将该值合并到递归调用列表中，因为您不能直接将str合并到列表中

def reverse_phrase(str):
    return " ".join(reverse_phrase_recursive(str.split()))

def reverse_phrase_recursive(str):
    if len(str)==0:
        return str
    else:
        return reverse_phrase_recursive(str[1:]) + [str[0]]
        
print(reverse_phrase("DO I CHOOSE YOU PIKACHU"))

---

旁注：不要将变量命名为“str”，它会覆盖内置的

str

以下是一个反转的解决方案：

def reverse(s): 
    return ' '.join(s.split()[::-1])

s = "DO I CHOOSE YOU PIKACHU" 
reverse(s)

#Output: 

'PIKACHU YOU CHOOSE I DO'

---

下面是一个不必执行整个拆分/连接过程的递归。正如我在评论中提到的，从性能角度来看，它是昂贵的

def reverse_phrase(str, reversedStr=""):
    if (len(reversedStr) == len(str)):
      return reversedStr;

    reversedStrLength = len(reversedStr);  
    index = len(str) - reversedStrLength - 1;
    reversedStr += str[index];

    return reverse_phrase(str, reversedStr);
   
        
print(reverse_phrase("DO I CHOOSE YOU PIKACHU"));

---

这里有另一种不使用join的方法。您的reverse_phrase（）函数使用单词列表调用递归函数。递归函数的基本情况是当列表的长度为2时，在这种情况下它交换两个单词。否则，它会将列表的最后一个单词与所有首字母单词的递归输出交换

def reverse_phrase(str):
    return reverse_phrase_recursive(str.split())

def reverse_phrase_recursive(l):
    if len(l) == 2:
        return l[1] + " " + l[0]
    return l[-1] + " " + reverse_phrase_recursive(l[:-1])

print(reverse_phrase('this is a great recursive function'))
#function recursive great a is this

---

还有一种方法不依赖内置函数

。split

-

def reverse_phrase(s):
  def loop(s, word, phrase):
    if not s:
      return word + " " + phrase                #1
    elif s[0] == " ":
      return loop(s[1:], "", word + " " + phrase) #2
    else:
      return loop(s[1:], word + s[0], phrase)       #3
  return loop(s, "", "")

print(reverse_phrase("DO I CHOOSE YOU PIKACHU"))

评估为-

loop（“我是否选择你皮卡丘”，“皮卡丘”，“皮卡丘”）#3
循环（“我选择你，皮卡丘”，“D”，“D”）#3
循环（“我选择你皮卡丘”，“做”，“做”）2
循环（“我选择你皮卡丘”，“做”）#3
循环（“选择你皮卡丘”、“我”、“做”）#2
循环（“选择你皮卡丘”，“我愿意”）#3
循环（“HOOSE YOU PIKACHU”，“C”，“I DO”）#3
循环（“OOSE YOU PIKACHU”，“CH”，“I DO”）#3
循环（“OSE YOU PIKACHU”、“CHO”、“I DO”）#3
循环（“SE YOU PIKACHU”、“CHOO”、“I DO”）#3
循环（“E YOU PIKACHU”、“CHOOS”、“I DO”）#3
循环（“你皮卡丘”，“选择”，“我愿意”）#2
循环（“你比卡丘”，“选择我做”）#3
循环（“OU PIKACHU”、“Y”、“选择我做”）#3
循环（“U PIKACHU”，“YO”，“选择我做什么”）#3
循环（“皮卡丘”、“你”、“选择我做”）#2
循环（“皮卡丘”，“你选择我做”）#3
循环（“IKACHU”，“P”，“你选择我做”）#3
循环（“卡丘”、“皮”、“你选择我做”）#3
循环（“阿丘”、“皮克”、“你选择我做”）#3
循环（“楚”、“皮卡”、“你选择我做”）#3
循环（“胡”、“皮卡克”、“你选择我做”）#3
循环（“U”、“皮卡奇”、“你选择我做”）#3
循环（“，”皮卡丘“，”你选择我做“）#1
“皮卡丘你选择我做”

我认为重要的是不要只以一种方式思考这个问题。试着用不同的方法做-

def版本，位置=0:
如果位置>=长度：
返回s#1
elif s[pos]==“”：
返回版本（s[pos+1:]）+“”+s[0:pos]#2
其他：
返回版本（s，位置+1）#3
打印（修订版（“我选择你皮卡丘吗”））

评估为-

rev（“我选择你皮卡丘吗”，0）#3
rev（“我选择你皮卡丘吗”，1）#3
牧师（“我选择你皮卡丘吗”，2）#2
rev（“我选择你皮卡丘”，0）+“做”#3
rev（“我选择你皮卡丘”，1）+“做”#2
rev（“选择你皮卡丘”，0）+“我”+“做”#3
rev（“选择你皮卡丘”，1）+“我愿意”#3
rev（“选择你皮卡丘”，2）+“我愿意”#3
rev（“选择你皮卡丘”，3）+“我愿意”#3
rev（“选择你皮卡丘”，4）+“我愿意”#3
rev（“选择你皮卡丘”，5）+“我愿意”#3
rev（“选择你皮卡丘”，6）+“我愿意”#2
rev（“YOU PIKACHU”，0）+“选择”+“我愿意”#3
rev（“YOU PIKACHU”，1）+“选择我做”#3
rev（“YOU PIKACHU”，2）+“选择我做”#3
rev（“皮卡丘”，0）+“你”+“选择我做什么”#2
rev（“皮卡丘”，1）+“你选择我做”#3
rev（“皮卡丘”，2）+“你选择我做”#3
rev（“皮卡丘”，3）+“你选择我做”#3
rev（“皮卡丘”，4）+“你选择我做”#3
rev（“皮卡丘”，5）+“你选择我做”#3
rev（“皮卡丘”，6）+“你选择我做”#3
rev（“皮卡丘”，7）+“你选择我做”#1
“皮卡丘”+“你选择我做”
“皮卡丘你选择我做”

有无限的方式来表达一个程序-

def find（s、char、ifmatch、nomatch）：
def回路（位置）：
如果位置>=长度：
返回nomatch（）
elif s[pos]==字符：
返回ifmatch（pos）
其他：
回路（位置+1）
返回循环（0）
def切割（s、char、ifmatch、nomatch）：
返回查找\
（s）
烧焦
，lambda pos:ifmatch（s[0:pos]，s[pos+1:]）
，lambda:nomatch（s）
)
def版本：
回程\
（s）
, " "
，lambda左，右：rev（右）+“”+左
，lambda last:last
)
打印（修订版（“我选择你皮卡丘吗”））

评估为-

cut\
（“我选你皮卡丘的？”
, " "
，lambda左，右：rev（右）+“”+左
，lambda last:last
)
发现\
（“我选你皮卡丘吗？”
, " "
，lambda pos:（lambda left，right:rev（right）+“left”（“我选择你皮卡丘吗”[0:pos]，“我选择你皮卡丘吗”[pos+1:]））
lambda:（lambda last:last）（“我选你皮卡丘吗”）
)
循环（0）
环路（1）
环路（2）
（lambda左、右：转（右）+“”+左）\
（“我选择你皮卡丘吗”[0:2]，“我选择你皮卡丘吗”[2+1:]）
rev（“我选择你皮卡丘”）+“做”
# ...

“皮卡丘你选择我做”

你有堆栈跟踪吗？我得到一个供参考的错误：

AttributeError:'list'对象没有属性'split'def reverse_phrase(s):
  def loop(s, word, phrase):
    if not s:
      return word + " " + phrase                #1
    elif s[0] == " ":
      return loop(s[1:], "", word + " " + phrase) #2
    else:
      return loop(s[1:], word + s[0], phrase)       #3
  return loop(s, "", "")

print(reverse_phrase("DO I CHOOSE YOU PIKACHU"))