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

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

网友回答：

@Paolo是最快的;一种较慢的方法（也许更具可读性，但这是有争议的）是。s[::-1]''.join(reversed(s))

网友回答：

使用切片：

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

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

网友回答：

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

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

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

或更易读（但由于方法名称查找以及给定迭代器时连接形成列表的事实而变慢），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 对象中没有内置的反向函数。

以下是你应该知道的关于Python字符串的几件事：

1. 在 Python 中，字符串是不可变的。更改字符串不会修改字符串。它会创建一个新的。
2. 字符串是可切片的。对字符串进行切片会为您提供一个新字符串，从字符串中的一个点向后或向前到另一个点，按给定的增量。它们采用切片表示法或下标中的切片对象：

   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

这在理论上是不好的，因为请记住，字符串是不可变的——所以每次看起来像是将一个字符附加到你的 ，理论上每次都会创建一个新字符串！但是，CPython知道如何在某些情况下对其进行优化，这个微不足道的案例就是其中之一。new_string

最佳实践

理论上更好的方法是将子字符串收集在一个列表中，稍后再连接它们：

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 优化了字符串连接，而其他实现可能不会：

…不要依赖CPython对形式为a += b或a = a + b的语句进行就地字符串串联的有效实现。即使在 CPython 中，这种优化也很脆弱（它仅适用于某些类型），并且在不使用 refcount 的实现中根本不存在。在库的性能敏感部分，应改用“.join（）”形式。这将确保串联在各种实现中以线性时间发生。