【问题标题】：Reverse a string in Python在 Python 中反转字符串
【发布时间】：2010-10-30 04:29:37
【问题描述】：

Python 的 str 对象没有内置的 reverse 函数。实现此方法的最佳方式是什么？

如果提供非常简洁的答案，请详细说明其效率。比如str对象是否转换为不同的对象等。

【问题讨论】：

【解决方案1】：

怎么样：

>>> 'hello world'[::-1]
'dlrow olleh'

这是extended slice 语法。它的工作原理是 [begin:end:step] - 离开 begin 和 end 并指定一个 -1 的步长，它会反转一个字符串。

【讨论】：

但这不适用于 utf8 .. 我也需要这样做 b = a.decode('utf8')[::-1].encode('utf8') 但感谢正确的方向！
@RickyLevi 如果需要.decode('utf8')，则表示a 不包含任何字符串对象，而是字节。
此解决方案（以及大多数其他答案）不适用于所有 unicode，即使应用于 Python unicode 字符串也是如此。例如，"??"[::-1] 产生 "??"。正确的解决方案是reversed_string = "".join(list(grapheme.graphemes(input_string))[::-1])。请参阅下面马丁的回答。
快速说明：s[::-1] 等价于 s[len(s):0:-1]。如果一个类型 s[0:len(s):-1] (for s[begin:end:-1]) 你得到空字符串''。

【解决方案2】：

@Paolo 的s[::-1] 最快； ''.join(reversed(s)) 是一种较慢的方法（可能更具可读性，但值得商榷）。

【讨论】：

这大约慢了 3 倍。
快速评论说明它的作用比使用这个较慢的版本更好地解释它！
它比较慢，因为join 必须构建列表才能获得大小。 ''.join(list(reversed(s))) 可能会稍微快一点。
你知道为什么 [::-1] 是最快的吗？我想深入研究。
@Tanner [::-1] 最快，因为它不调用任何外部函数，而是使用在 python 中高度优化的切片。 ''.join(list(reversed(s))) 进行 3 次函数调用。

【解决方案3】：

为字符串实现反向函数的最佳方法是什么？

我自己对这个问题的经验是学术性的。但是，如果您是寻求快速答案的专业人士，请使用按-1 步进的切片：

>>> 'a string'[::-1]
'gnirts a'

或者更易读（但由于方法名称查找以及在给定迭代器时 join 形成列表这一事实，速度较慢），str.join：

>>> ''.join(reversed('a string'))
'gnirts a'

或者为了可读性和可重用性，将切片放入函数中

def reversed_string(a_string):
    return a_string[::-1]

然后：

>>> reversed_string('a_string')
'gnirts_a'

更长的解释

如果您对学术博览会感兴趣，请继续阅读。

Python 的 str 对象中没有内置的 reverse 函数。

以下是您应该了解的有关 Python 字符串的几件事：

在 Python 中，字符串是不可变的。更改字符串不会修改字符串。它会创建一个新的。
字符串是可切片的。切片字符串会给你一个新的字符串，从字符串中的一个点向后或向前，到另一个点，按给定的增量。它们采用切片符号或下标中的切片对象：
```
string[subscript]
```

下标通过在大括号中包含冒号来创建切片：

    string[start:stop:step]

要在大括号之外创建切片，您需要创建切片对象：

    slice_obj = slice(start, stop, step)
    string[slice_obj]

一种可读的方法：

虽然''.join(reversed('foo')) 是可读的，但它需要在另一个被调用函数上调用字符串方法str.join，这可能会相对较慢。让我们把它放在一个函数中 - 我们会回到它：

def reverse_string_readable_answer(string):
    return ''.join(reversed(string))

最高效的方法：

使用反向切片要快得多：

'foo'[::-1]

但是，对于不太熟悉 slice 或原作者意图的人来说，我们如何才能使其更具可读性和可理解性呢？让我们在下标符号之外创建一个切片对象，给它一个描述性的名称，然后将它传递给下标符号。

start = stop = None
step = -1
reverse_slice = slice(start, stop, step)
'foo'[reverse_slice]

作为函数实现

要真正将其实现为一个函数，我认为只需使用描述性名称就足以在语义上清晰：

def reversed_string(a_string):
    return a_string[::-1]

而且用法很简单：

reversed_string('foo')

你的老师可能想要什么：

如果您有讲师，他们可能希望您从一个空字符串开始，然后从旧字符串构建一个新字符串。您可以使用 while 循环使用纯语法和文字来做到这一点：

def reverse_a_string_slowly(a_string):
    new_string = ''
    index = len(a_string)
    while index:
        index -= 1                    # index = index - 1
        new_string += a_string[index] # new_string = new_string + character
    return new_string

这在理论上很糟糕，因为，请记住，字符串是不可变的 - 所以每次看起来你在new_string 上附加一个字符时，理论上每次都会创建一个新字符串！但是，CPython 知道如何在某些情况下对此进行优化，这个简单的情况就是其中之一。

最佳实践

理论上更好的做法是把你的子字符串收集到一个列表中，然后再加入它们：

def reverse_a_string_more_slowly(a_string):
    new_strings = []
    index = len(a_string)
    while index:
        index -= 1                       
        new_strings.append(a_string[index])
    return ''.join(new_strings)

但是，正如我们将在下面的 CPython 时序中看到的那样，这实际上需要更长的时间，因为 CPython 可以优化字符串连接。

时间

以下是时间安排：

>>> a_string = 'amanaplanacanalpanama' * 10
>>> min(timeit.repeat(lambda: reverse_string_readable_answer(a_string)))
10.38789987564087
>>> min(timeit.repeat(lambda: reversed_string(a_string)))
0.6622700691223145
>>> min(timeit.repeat(lambda: reverse_a_string_slowly(a_string)))
25.756799936294556
>>> min(timeit.repeat(lambda: reverse_a_string_more_slowly(a_string)))
38.73570013046265

CPython 优化字符串连接，而其他实现 may not:

... 对于 a += b 或 a = a + b 形式的语句，不要依赖 CPython 对就地字符串连接的有效实现。即使在 CPython 中，这种优化也是脆弱的（它只适用于某些类型），并且在不使用引用计数的实现中根本不存在。在库的性能敏感部分，应该使用 ''.join() 形式。这将确保连接在各种实现中以线性时间发生。

【讨论】：

我喜欢这个答案，关于优化的解释，可读性与优化，关于老师想要什么的提示。我不确定while 和递减索引的最佳实践部分，尽管这可能不太可读：for i in range(len(a_string)-1, -1, -1): 。最重要的是，我喜欢您选择的示例字符串是您永远不需要反转它的一种情况，并且无法判断您是否有:)

【解决方案4】：

快速解答 (TL;DR)

示例

### example01 -------------------
mystring  =   'coup_ate_grouping'
backwards =   mystring[::-1]
print(backwards)

### ... or even ...
mystring  =   'coup_ate_grouping'[::-1]
print(mystring)

### result01 -------------------
'''
gnipuorg_eta_puoc
'''

详细解答

背景

提供此答案是为了解决@odigity 提出的以下问题：

哇。起初我对 Paolo 提出的解决方案感到震惊，但让我在阅读第一部时感到的恐惧退居二线评论：“这非常pythonic。干得好！”我很不安这样一个聪明的社区认为使用这种神秘的方法来做某事基本是个好主意。为什么不只是 s.reverse()？

问题

上下文
- Python 2.x
- Python 3.x
场景：
- 开发者想要转换一个字符串
- 转换是反转所有字符的顺序

解决方案

example01 使用extended slice notation 产生所需的结果。

陷阱

开发人员可能会期望类似string.reverse()
新开发人员可能无法阅读本机惯用（又名“pythonic”）解决方案
开发人员可能很想实现他或她自己的string.reverse() 版本以避免切片符号。
在某些情况下，切片符号的输出可能违反直觉：
- 参见例如 example02
  - print 'coup_ate_grouping'[-4:] ## => 'ping'
  - 相比
  - print 'coup_ate_grouping'[-4:-1] ## => 'pin'
  - 相比
  - print 'coup_ate_grouping'[-1] ## => 'g'
- 在 [-1] 上建立索引的不同结果可能会让一些开发人员望而却步

基本原理

Python 有一个特殊情况需要注意：字符串是iterable 类型。

排除string.reverse() 方法的一个理由是为了激励python 开发人员利用这种特殊情况的力量。

简而言之，这意味着字符串中的每个单独字符都可以作为元素顺序排列的一部分轻松操作，就像其他编程语言中的数组一样。

要了解其工作原理，查看 example02 可以提供一个很好的概述。

示例02

### example02 -------------------
## start (with positive integers)
print 'coup_ate_grouping'[0]  ## => 'c'
print 'coup_ate_grouping'[1]  ## => 'o' 
print 'coup_ate_grouping'[2]  ## => 'u' 

## start (with negative integers)
print 'coup_ate_grouping'[-1]  ## => 'g'
print 'coup_ate_grouping'[-2]  ## => 'n' 
print 'coup_ate_grouping'[-3]  ## => 'i' 

## start:end 
print 'coup_ate_grouping'[0:4]    ## => 'coup'    
print 'coup_ate_grouping'[4:8]    ## => '_ate'    
print 'coup_ate_grouping'[8:12]   ## => '_gro'    

## start:end 
print 'coup_ate_grouping'[-4:]    ## => 'ping' (counter-intuitive)
print 'coup_ate_grouping'[-4:-1]  ## => 'pin'
print 'coup_ate_grouping'[-4:-2]  ## => 'pi'
print 'coup_ate_grouping'[-4:-3]  ## => 'p'
print 'coup_ate_grouping'[-4:-4]  ## => ''
print 'coup_ate_grouping'[0:-1]   ## => 'coup_ate_groupin'
print 'coup_ate_grouping'[0:]     ## => 'coup_ate_grouping' (counter-intuitive)

## start:end:step (or start:end:stride)
print 'coup_ate_grouping'[-1::1]  ## => 'g'   
print 'coup_ate_grouping'[-1::-1] ## => 'gnipuorg_eta_puoc'

## combinations
print 'coup_ate_grouping'[-1::-1][-4:] ## => 'puoc'

结论

cognitive load 与了解切片符号在 python 中的工作原理相关联，对于一些不想花太多时间学习该语言的采用者和开发人员来说，确实可能太多了。

不过，一旦理解了基本原理，这种方法相对于固定的字符串操作方法的威力可能会非常有利。

对于那些不这样认为的人，还有其他方法，例如 lambda 函数、迭代器或简单的一次性函数声明。

如果需要，开发人员可以实现自己的 string.reverse() 方法，但是最好了解 python 这方面背后的基本原理。

另见

【讨论】：

【解决方案5】：

这个答案有点长，包含 3 个部分：现有解决方案的基准，为什么这里的大多数解决方案都是错误的，我的解决方案。

仅当忽略 Unicode 修饰符/字素簇时，现有答案才是正确的。我稍后会处理这个问题，但首先看看一些反转算法的速度：

list_comprehension  : min:   0.6μs, mean:   0.6μs, max:    2.2μs
reverse_func        : min:   1.9μs, mean:   2.0μs, max:    7.9μs
reverse_reduce      : min:   5.7μs, mean:   5.9μs, max:   10.2μs
reverse_loop        : min:   3.0μs, mean:   3.1μs, max:    6.8μs

list_comprehension  : min:   4.2μs, mean:   4.5μs, max:   31.7μs
reverse_func        : min:  75.4μs, mean:  76.6μs, max:  109.5μs
reverse_reduce      : min: 749.2μs, mean: 882.4μs, max: 2310.4μs
reverse_loop        : min: 469.7μs, mean: 577.2μs, max: 1227.6μs

您可以看到，列表理解 (reversed = string[::-1]) 的时间在所有情况下都是迄今为止最低的（即使在修正了我的错字之后）。

字符串反转

如果你真的想在常识中反转一个字符串，那就更复杂了。例如，采用以下字符串（brown finger pointing left、yellow finger pointing up）。那是两个字素，但是 3 个 unicode 代码点。另一个是skin modifier。

example = "???"

但是如果你用任何给定的方法来反转它，你会得到brown finger pointing up，yellow finger pointing left。这样做的原因是“棕色”颜色修饰符仍在中间，并应用于它之前的任何内容。所以我们有

U：手指向上
M：棕色修饰符
L：手指向左

和

original: LMU                    ???
reversed: UML (above solutions)  ☝??
reversed: ULM (correct reversal) ???

Unicode Grapheme Clusters 比修饰符代码点要复杂一些。幸运的是，有一个库可以处理graphemes：

>>> import grapheme
>>> g = grapheme.graphemes("???")
>>> list(g)
['??', '?']

因此正确答案是

def reverse_graphemes(string):
    g = list(grapheme.graphemes(string))
    return ''.join(g[::-1])

这也是迄今为止最慢的：

list_comprehension  : min:    0.5μs, mean:    0.5μs, max:    2.1μs
reverse_func        : min:   68.9μs, mean:   70.3μs, max:  111.4μs
reverse_reduce      : min:  742.7μs, mean:  810.1μs, max: 1821.9μs
reverse_loop        : min:  513.7μs, mean:  552.6μs, max: 1125.8μs
reverse_graphemes   : min: 3882.4μs, mean: 4130.9μs, max: 6416.2μs

代码

#!/usr/bin/env python

import numpy as np
import random
import timeit
from functools import reduce
random.seed(0)


def main():
    longstring = ''.join(random.choices("ABCDEFGHIJKLM", k=2000))
    functions = [(list_comprehension, 'list_comprehension', longstring),
                 (reverse_func, 'reverse_func', longstring),
                 (reverse_reduce, 'reverse_reduce', longstring),
                 (reverse_loop, 'reverse_loop', longstring)
                 ]
    duration_list = {}
    for func, name, params in functions:
        durations = timeit.repeat(lambda: func(params), repeat=100, number=3)
        duration_list[name] = list(np.array(durations) * 1000)
        print('{func:<20}: '
              'min: {min:5.1f}μs, mean: {mean:5.1f}μs, max: {max:6.1f}μs'
              .format(func=name,
                      min=min(durations) * 10**6,
                      mean=np.mean(durations) * 10**6,
                      max=max(durations) * 10**6,
                      ))
        create_boxplot('Reversing a string of length {}'.format(len(longstring)),
                       duration_list)


def list_comprehension(string):
    return string[::-1]


def reverse_func(string):
    return ''.join(reversed(string))


def reverse_reduce(string):
    return reduce(lambda x, y: y + x, string)


def reverse_loop(string):
    reversed_str = ""
    for i in string:
        reversed_str = i + reversed_str
    return reversed_str


def create_boxplot(title, duration_list, showfliers=False):
    import seaborn as sns
    import matplotlib.pyplot as plt
    import operator
    plt.figure(num=None, figsize=(8, 4), dpi=300,
               facecolor='w', edgecolor='k')
    sns.set(style="whitegrid")
    sorted_keys, sorted_vals = zip(*sorted(duration_list.items(),
                                           key=operator.itemgetter(1)))
    flierprops = dict(markerfacecolor='0.75', markersize=1,
                      linestyle='none')
    ax = sns.boxplot(data=sorted_vals, width=.3, orient='h',
                     flierprops=flierprops,
                     showfliers=showfliers)
    ax.set(xlabel="Time in ms", ylabel="")
    plt.yticks(plt.yticks()[0], sorted_keys)
    ax.set_title(title)
    plt.tight_layout()
    plt.savefig("output-string.png")


if __name__ == '__main__':
    main()

【讨论】：

感谢您展示正确的字形感知字符串反转。对于几乎任何现实目的，这里的所有其他答案都是错误的。不过，很遗憾，您在最受欢迎的答案中获得的选票不到 1%。
不幸的是，您的解决方案在许多基准测试的中间是半隐藏的。我会更早更突出地提出它，并且可能会明确展示其他人给出的简单解决方案是如何出错的（你描述它但不展示它）。标记表情符号也是很好的例子。

【解决方案6】：

1。使用切片表示法

def rev_string(s): 
    return s[::-1]

2。使用 reversed() 函数

def rev_string(s): 
    return ''.join(reversed(s))

3。使用递归

def rev_string(s): 
    if len(s) == 1:
        return s

    return s[-1] + rev_string(s[:-1])

【讨论】：

必须注意递归解决方案，如果字符串长度合适，您将遇到RecursionError: maximum recursion depth exceeded while calling a Python object。例如：rev_string("abcdef"*1000)

【解决方案7】：

一种不那么令人困惑的方式是：

string = 'happy'
print(string)

'快乐'

string_reversed = string[-1::-1]
print(string_reversed)

'yppah'

英文 [-1::-1] 读作：

“从-1开始，一路走，走-1”

【讨论】：

不过，-1 仍然不需要。
@EricDuminil 如果您想了解我认为需要它

【解决方案8】：

不使用 reversed() 或 [::-1] 在 python 中反转字符串

def reverse(test):
    n = len(test)
    x=""
    for i in range(n-1,-1,-1):
        x += test[i]
    return x

【讨论】：

你不应该使用 xrange 因为你不需要列表，在 python 2 中？

【解决方案9】：

这也是一种有趣的方式：

def reverse_words_1(s):
    rev = ''
    for i in range(len(s)):
        j = ~i  # equivalent to j = -(i + 1)
        rev += s[j]
    return rev

或类似的：

def reverse_words_2(s):
    rev = ''
    for i in reversed(range(len(s)):
        rev += s[i]
    return rev

使用支持 .reverse() 的 bytearray 的另一种更“异国情调”的方式

b = bytearray('Reverse this!', 'UTF-8')
b.reverse()
b.decode('UTF-8')`

将产生：

'!siht esreveR'

【讨论】：

【解决方案10】：

def reverse(input):
    return reduce(lambda x,y : y+x, input)

【讨论】：

我点击了投票，因为我喜欢这个 lambda 表达式。不幸的是，这是上面列出的所有解决方案中效率最低的（测试：Gist palindrome.py）
这是一个糟糕的解决方案，不必要的低效

【解决方案11】：

这是一个不花哨的：

def reverse(text):
    r_text = ''
    index = len(text) - 1

    while index >= 0:
        r_text += text[index] #string canbe concatenated
        index -= 1

    return r_text

print reverse("hello, world!")

【讨论】：

【解决方案12】：

def reverse_string(string):
    length = len(string)
    temp = ''
    for i in range(length):
        temp += string[length - i - 1]
    return temp

print(reverse_string('foo')) #prints "oof"

这通过遍历一个字符串并将其值以相反的顺序分配给另一个字符串来工作。

【讨论】：

【解决方案13】：

original = "string"

rev_index = original[::-1]
rev_func = list(reversed(list(original))) #nsfw

print(original)
print(rev_index)
print(''.join(rev_func))

【讨论】：

虽然这段代码可以回答问题，但最好解释一下如何解决问题，并提供代码作为示例或参考。仅代码的答案可能会令人困惑且缺乏上下文。

【解决方案14】：

以编程方式解决这个问题

def reverse_a_string(string: str) -> str:
    """
    This method is used to reverse a string.
    Args:
        string: a string to reverse

    Returns: a reversed string
    """
    if type(string) != str:
        raise TypeError("{0} This not a string, Please provide a string!".format(type(string)))
    string_place_holder = ""
    start = 0
    end = len(string) - 1
    if end >= 1:
        while start <= end:
            string_place_holder = string_place_holder + string[end]
            end -= 1
        return string_place_holder
    else:
        return string


a = "hello world"
rev = reverse_a_string(a)
print(rev)

输出：

dlrow olleh

【讨论】：

【解决方案15】：

 a=input()
 print(a[::-1])

上面的代码接收来自用户的输入，并通过添加 [::-1] 打印一个与输入相反的输出。

输出：

>>> Happy 
>>> yppaH

但是说到句子的大小写，查看下面的代码输出：

>>> Have a happy day
>>> yad yppah a evaH

但如果你只想反转字符串的字符而不是字符串的序列，试试这个：

a=input().split() #Splits the input on the basis of space (" ")
for b in a: #declares that var (b) is any value in the list (a)
    print(b[::-1], end=" ") #End declares to print the character in its quotes (" ") without a new line.

在上面第 2 行的代码中，我说 ** 变量 b 是列表中的任何值 (a)** 我说 var a 是一个列表，因为当您在输入中使用 split 时，输入的变量变成一个列表。 还要记住在int(input())的情况下不能使用split

输出：

>>> Have a happy day
>>> evaH a yppah yad

如果我们不在上面的代码中添加end(" ")，那么它会打印如下：

>>> Have a happy day
>>> evaH
>>> a
>>> yppah
>>> yad

下面是一个理解end()的例子：

代码：

for i in range(1,6):
     print(i) #Without end()

输出：

>>> 1
>>> 2
>>> 3
>>> 4
>>> 5

现在用 end() 编码：

for i in range(1,6):
    print(i, end=" || ")

输出：

>>> 1 || 2 || 3 || 4 || 5 ||

【讨论】：

【解决方案16】：

在 Python 中有多种反转字符串的方法

切片方法

string = "python"
rev_string = string[::-1]
print(rev_string)

使用反转函数

string = "python"
rev= reversed(string) 
rev_string = "".join(rev) 
print(rev_string)

使用递归

string = "python"
def reverse(string):
  if len(string)==0:
    return string
  else:
    return reverse(string[1:])+string[0]
print(reverse(string))

使用 for 循环

string = "python"
rev_string =""
for s in string:
  rev_string = s+ rev_string
print(rev_string)

使用while循环

string = "python"
rev_str =""
length = len(string)-1
while length >=0:
  rev_str += string[length]
  length -= 1
print(rev_str)

【讨论】：

【解决方案17】：

这是一个没有[::-1]或reversed的（用于学习目的）：

def reverse(text):
    new_string = []
    n = len(text)
    while (n > 0):
        new_string.append(text[n-1])
        n -= 1
    return ''.join(new_string)
print reverse("abcd")

您可以使用+= 连接字符串，但join() 更快。

【讨论】：

【解决方案18】：

递归方法：

def reverse(s): return s[0] if len(s)==1 else s[len(s)-1] + reverse(s[0:len(s)-1])

示例：

print(reverse("Hello!"))    #!olleH

【讨论】：

【解决方案19】：

上述所有解决方案都很完美，但是如果我们试图在 python 中使用 for 循环来反转字符串会变得有点棘手，所以这里是我们如何使用 for 循环来反转字符串

string ="hello,world"
for i in range(-1,-len(string)-1,-1):
    print (string[i],end=(" "))

我希望这篇文章对某人有所帮助。

【讨论】：

【解决方案20】：

有很多方法可以反转字符串，但我也创建了另一种只是为了好玩。我认为这种方法还不错。

def reverse(_str):
    list_char = list(_str) # Create a hypothetical list. because string is immutable

    for i in range(len(list_char)/2): # just t(n/2) to reverse a big string
        list_char[i], list_char[-i - 1] = list_char[-i - 1], list_char[i]

    return ''.join(list_char)

print(reverse("Ehsan"))

【讨论】：

【解决方案21】：

或者你可以做类似的事情？

>>> a = 'hello world'
>>> ''.join(a[len(a) - i - 1] for i in range(len(a)))
'dlrow olleh'
>>>

使用生成器表达式和字符串索引。

【讨论】：

【解决方案22】：

我不喜欢.join() 技术。面试官不喜欢[::-1] 技术，所以我想出了这个。

_list = [12, 34, 5, 6, 7, 8, 98, 44, 25]

for count, x in enumerate(_list, start=1):
    print(_list[len(_list) - count])

【讨论】：

【解决方案23】：

当然，在 Python 中你可以做非常花哨的单行代码。 :)
这是一个简单、全面的解决方案，适用于任何编程语言。

def reverse_string(phrase):
    reversed = ""
    length = len(phrase)
    for i in range(length):
        reversed += phrase[length-1-i]
    return reversed

phrase = raw_input("Provide a string: ")
print reverse_string(phrase)

【讨论】：

对于这样一个微不足道的任务有这么长的代码不是一个好的解决方案。

【解决方案24】：

s = 'hello'
ln = len(s)
i = 1
while True:
    rev = s[ln-i]
    print rev,
    i = i + 1
    if i == ln + 1 :
        break

输出：

o l l e h

【讨论】：

【解决方案25】：

您可以将反向函数与列表综合使用。但我不明白为什么这个方法在 python 3 中被淘汰了，是不必要的。

string = [ char for char in reversed(string)]

【讨论】：

问题要求反转一个字符串，而你却给出一个列表？？
您需要 .join 或其他东西才能使其成为有效答案
顺便说一句，[c for c in string] 等同于list(string)。