反转Python中的字符串

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

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

#1楼

在python中反转字符串，而不使用reversed（）或[::-1]

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

#2楼

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

我对这个问题的经验是学术上的。但是，如果您是专业人士，正在寻找快速解答，请使用以-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对象中没有内置的反向函数。

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

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

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

    string[start:stop:step]

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

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

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

#3楼

这是一个没有幻想的：

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

#4楼

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

#5楼

快速解答（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提出的解决方案感到震惊，但这让我在读了第一条评论时感到恐惧，这让我感到恐惧：“那太好了。做得好！” 我感到非常不安，以至于如此聪明的社区认为将如此神秘的方法用于如此基本的东西是一个好主意。为什么不只是s.reverse（）？

问题

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

基本原理

Python有一种特殊的情况要注意：字符串是可迭代的类型。

排除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'

结论

对于理解切片表示法如何在python中工作的人来说，认知负担确实对于那些不愿意在学习该语言上花费大量时间的采用者和开发人员来说实在太大了。

但是，一旦理解了基本原理，此方法相对于固定字符串操作方法的功能可能会非常有利。

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

如果需要，开发人员可以实现自己的string.reverse（）方法，但是最好理解python这方面的原理。

也可以看看

来源：oschina

链接：https://my.oschina.net/u/3797416/blog/3139363

标签

cpython

python