在 Python 中反转字符串

使用 slicing：

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

切片表示法采用 [start:stop:step] 形式。在这种情况下，我们省略了 start 和 stop 位置，因为我们想要整个字符串。我们还使用 step = -1，意思是“从右到左重复步进 1 个字符”。

---

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

---

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

我自己对这个问题的经验是学术性的。但是，如果您是寻求快速答案的专业人士，请使用按 -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]

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

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：

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

---

快速回答 (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

Python 2.x

Python 3.x

场景：开发人员想要转换一个字符串转换是反转所有字符的顺序

开发人员想要转换一个字符串

转换是反转所有字符的顺序

解决方案

example01 使用扩展切片表示法产生所需的结果。

陷阱

开发人员可能期望类似 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] 上建立索引的不同结果可能会让一些开发人员失望

参见 example02 print 'coup_ate_grouping'[-4:] ## => 'ping' 与 print 'coup_ate_grouping'[-4:-1] ## => 'pin' 与 print 'coup_ate_grouping'[-1] 相比## => 'g'

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 可以提供一个很好的概述。

Example02

### 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'

结论

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

然而，一旦理解了基本原理，这种方法相对于固定字符串操作方法的强大功能可能会非常有利。

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

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

也可以看看

替代简单方法

替代简单方法

切片符号的替代解释

---

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

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

https://i.stack.imgur.com/JiAue.png

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

https://i.stack.imgur.com/ZxVY0.png

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. 使用切片符号

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])

---

一个不那么令人困惑的看待它的方式是：

string = 'happy'
print(string)

'快乐的'

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

'yppah'

在英语中 [-1::-1] 读作：

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

---

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

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

---

这也是一个有趣的方式：

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'

---

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

---

这是一个不花哨的：

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!")

---

original = "string"

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

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

---

以编程方式解决这个问题进行面试

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

---

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)

---

递归方法：

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

---

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"

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

---

 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 ||

---

以下是我们如何使用 for 循环反转字符串：

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

---

这是没有 [::-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() 更快。

---

有很多方法可以反转字符串，但我也创建了另一种只是为了好玩。我认为这种方法并没有那么糟糕。

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"))

---

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

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

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

---

我不喜欢 .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])

---

my_str = "hello

快速选项：my_str[::-1]

慢速选项："".join(reversed(my_str))

---

当然，在 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)

---

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

---

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

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

---