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

Posted 2023-02-23

【中文标题】不使用 reversed() 或 [::-1] 反转字符串？

【英文标题】：Reverse a string without using reversed() or [::-1]?

【发布时间】：2013-09-12 06:29:54

【问题描述】：

我遇到了一个奇怪的 Codecademy 练习，该练习需要一个将字符串作为输入并以相反顺序返回的函数。唯一的问题是您无法在 *** 上使用反向方法或常见答案，[::-1]。

显然，在现实的编程世界中，很可能会使用extended slice 方法，甚至使用reversed 函数，但也许在某些情况下这不起作用？

我在下面以问答形式提出一个解决方案，以防将来对人们有所帮助。

【参考方案1】：

试试这个简单而优雅的代码。

my_string= "sentence"
new_str = ""
for i in my_string:
    new_str = i + new_str
print(new_str)

【讨论】：

不要将str 用于变量，因为它已经是 Python 关键字列表的一部分。尝试使用new_string

【参考方案2】：

我从 thecrazyprogrammer.com 获得了一个在 python 中反转字符串的示例：

string1 =  "IkNoWwHeReYoUlIvE"
string2 = ""

i = len(string1)-1

while(i>=0):
  string2 = string2 + string1[i]
  i = i-1

print("original = " + string1)
print("reverse  = " + string2)

【参考方案3】：

只需运行它，但它会将每个字符打印在单独的行中，第二个版本将其打印在一行中。

def rev(str):
        for i in range(0,len(str)):
            print(list(str)[len(str)-i-1])

一行打印：

def rev(str):
    rev = list()
    for i in range(0,len(str)):
        rev.append((list(str)[len(str)-i-1]))
    print(''.join(rev))

【参考方案4】：

简单的方法，

>>> a = "hi hello"
>>> ''.join([a[len(a)-i-1] for i,j in enumerate(a)])
'olleh ih'
>>> 

【参考方案5】：

您可以按照建议简单地使用 pop。 这是一种衬里

chaine = 'qwertyuiop'
''.join([chaine[-(x + 1)] for x in range(len(chaine))])
'poiuytrewq'
gg = list(chaine)
''.join([gg.pop() for _ in range(len(gg))])
'poiuytrewq'

【参考方案6】：

我更喜欢这是使用 for 循环反转字符串的最佳方式。

def reverse_a_string(str): 

    result=" "
    for i in range(len(str),1,-1):
        result= result+ str[i-1]
    return result

print reverse_a_string(input())

【参考方案7】：

这是一个使用列表作为堆栈的例子：

def reverse(s):
  rev = [_t for _t in s]
  t = ''
  while len(rev) != 0:
    t+=rev.pop()
  return t

【参考方案8】：

我们可以先将字符串转换为列表，然后将字符串反转，然后使用“.join”方法再次将列表转换为单个字符串。

text="Youknowwhoiam"
lst=list(text)
lst.reverse()
print("".join(lst))

它将首先将“youknowwhoiam”转换为['Y', 'o', 'u', 'k', 'n', 'o', 'w', 'w', 'h', 'o ', 'i', 'a', 'm']

之后它将列表反转为 ['m', 'a', 'i', 'o', 'h', 'w', 'w', 'o', 'n', 'k' , 'u', 'o', 'Y']

最后它将列表转换为单个单词“maiohwwonkuoY "

要获得更多简要说明，只需运行以下代码：-

text="Youknowwhoiam"
lst=list(text)
print (lst)
lst.reverse()
print(lst)
print("".join(lst))

【参考方案9】：

__author__ = 'Sreedhar'
#find reverse of the string with out using index or reverse function?

def reverse(text):
    revs = ""
    for i in text:
        revs = i + revs
    return revs

strig = raw_input("enter anything:")

print reverse(strig)

#index method
print strig[::-1]

【参考方案10】：

enterString=input("Enter a string to be reversed:")
string_List=list(enterString)
revedString=[]

for i in range(len(string_List)):
    revedString.append(string_List.pop())
#Pop last element and append it to the empty list
print "reversed string is:",''.join(revedString)
#as the out come is in list convert it into string using .join

Sample Output:
>>>Enter a string to be reversed :sampleReverse1  
>>>reversed string is:1esreveRelpmas 

【参考方案11】：

反转字符串的最简单方法：

    backwards = input("Enter string to reverse: ")
    print(backwards[::-1])

【讨论】：

问题说“没有使用reverse或[::-1]”。

我最初的查询是如何反转一个字符串，这就是我被引导的地方。

【参考方案12】：

m = input("Enter string::")
def rev(s):
    z = -1
    x = len(s)
    while x != 0:
        print(s[z], end='')
        z = z-1
        x = x-1
rev(m)

【参考方案13】：

你可以这样做

def rev(str):
   rev = ""
   for i in range(0,len(str)):
   rev = rev + str[(len(str)-1)-i]
   return rev

【参考方案14】：

Blender 的回答很可爱，但是对于很长的字符串，它会产生惊人的RuntimeError: maximum recursion depth exceeded。可以将相同的代码重构为一个 while 循环，就像 Python 中的递归经常必须做的那样。由于时间和内存的问题，显然仍然很糟糕，但至少不会出错。

def reverse(text):
    answer = ""
    while text:
        answer = text[0] + answer
        text = text[1:]
    return answer

【参考方案15】：

这是python 2.7语法中最简单的方法

def reverse(text):

      rev = ""
      final = ""

      for a in range(0,len(text)):
            rev = text[len(text)-a-1]
            final = final + rev
return final

【参考方案16】：

reduce(lambda x, y : y + x, "hello world")

【参考方案17】：

def reverse(s):
    return "".join(s[i] for i in range(len(s)-1, -1, -1))

【参考方案18】：

这是我的贡献：

def rev(test):  
    test = list(test)
    i = len(test)-1
    result = []

    print test
    while i >= 0:
        result.append(test.pop(i))
        i -= 1
    return "".join(result)

【参考方案19】：

这是我使用 for i in range 循环的解决方案：

def reverse(string):
    tmp = ""
    for i in range(1,len(string)+1):
        tmp += string[len(string)-i]            
    return tmp

这很容易理解。我从 1 开始以避免索引超出范围。

【参考方案20】：

def reverseThatString(theString):
    reversedString = ""
    lenOfString = len(theString)
    for i,j in enumerate(theString):
        lenOfString -= 1
        reversedString += theString[lenOfString]
    return reversedString

【参考方案21】：

我的解决方案：

s = raw_input("输入字符串") 打印 def 反向（文本）：

st = ""  
rev = ""  
count = len(text)  
print "Lenght of text: ", len(text)  
print  
for c in range(len(text)):  
    count = count - 1  
    st = st + "".join(text[c])  
    rev = rev + "".join(text[count])  
    print "count:       ", count  
    print "print c:     ", c  
    print "text[c]:     ", text[c]  
    print  
print "Original:    ", st  
print "Reversed:    ", rev  
return rev  

反向

结果屏幕

输入字符串 joca

文字长度：4

计数：3 打印 c: 0 文本[c]: j

计数：2 打印 c: 1 文本[c]: o

计数：1 打印 c: 2 文本[c]: c

计数：0 打印 c: 3 文本[c]：一个

原文：joca 反转：acoj 无

【参考方案22】：

不使用任何内置函数我能想到的方式：

a = 'word'
count = 0
for letter in a:
    count += 1

b = ''
for letter in a:
    b += a[count-1]
    count -= 1

如果你打印 b:

print b
drow

【参考方案23】：

您收到了很多替代答案，但只是添加另一个简单的解决方案——首先想到的是这样的：

def reverse(text):
    reversed_text = ""   

    for n in range(len(text)):
        reversed_text += text[-1 - n]

    return reversed_text

它没有人们提到的其他一些选项（或内置方法）那么快，但很容易理解，因为我们只是使用 text 字符串的长度通过切片一次连接一个字符从末端到前面。

【讨论】：

+1 甚至不知道你可以做到这一点，或者我曾经做过，我只是在 4 或 5 个月内没有使用 Python。不管怎样，干得好

【参考方案24】：

我用过这个：

def reverse(text):
s=""
l=len(text)
for i in range(l):
    s+=text[l-1-i]
return s

【讨论】：

最简单也是最快的之一！

【参考方案25】：

无积分：

from functools import partial
from operator import add

flip = lambda f: lambda x, y: f(y, x)
rev = partial(reduce, flip(add))

测试：

>>> rev('hello')
'olleh'

【参考方案26】：

只用了几天的 Python 代码，但我觉得这是一个相当干净的解决方案。创建一个空列表，遍历字符串中的每个字母并将其附加到列表的前面，将连接的列表作为字符串返回。

def reverse(text):
backwardstext = []
for letter in text:
    backwardstext.insert(0, letter)
return ''.join(backwardstext)

【参考方案27】：

您可以简单地从最后一个字符开始反向迭代您的字符串。使用python，您可以使用列表推导以相反的顺序构造字符列表，然后将它们连接起来以单行方式获取反转的字符串：

def reverse(s):
  return "".join([s[-i-1] for i in xrange(len(s))])

如果您甚至不允许使用负索引，则应将 s[-i-1] 替换为 s[len(s)-i-1]

【参考方案28】：

你也可以用递归来做：

def reverse(text):
    if len(text) <= 1:
        return text

    return reverse(text[1:]) + text[0]

还有一个字符串hello的简单示例：

   reverse(hello)
 = reverse(ello) + h           # The recursive step
 = reverse(llo) + e + h
 = reverse(lo) + l + e + h
 = reverse(o) + l + l + e + h  # Base case
 = o + l + l + e + h
 = olleh

【讨论】：

迄今为止最好的答案。如果不使用其有用的结构，Python 不适合这种低级编程，但如果必须的话，这是迄今为止最好的方法。

我认为这个解决方案需要 O(n^2) 内存......这对于长字符串来说可能非常糟糕。

@EmanuelePaolini：[::-1] 是您唯一应该使用的东西。所有这些答案只是反转字符串的不同方式，没有速度保证。

@ChrisPurrone：递归函数并没有真正“循环”字符串（在 CPython 中）。每次调用函数时，都会创建一个堆栈帧（其中包含局部变量和函数的返回值）。您的函数是递归的，因此每次 return 都会创建一个新的堆栈框架，但由于返回值取决于另一个函数的返回值，旧的堆栈框架仍然需要保留。这就是为什么我写了+ h 的长链。它们直到最后才真正连接起来，也就是最后一个函数调用返回一个字符串的时候。

@ChrisPurrone：CPython 根本不做任何递归优化（据我所知）。事实上，CPython 甚至没有优化尾递归函数，它可以很容易地转化为等效的迭代函数。

【参考方案29】：

不是很聪明，但很棘手

def reverse(t):
    for j in range(len(t) // 2):
        t = t[:j] + t[- j - 1] + t[j + 1:- j - 1] + t[j] + t[len(t) - j:]
    return t

【讨论】：

如果您可以在这样的答案上添加更多信息，对 OP 来说会更好。其他关注这一点的人都将受益。

同意@deepend 我也喜欢这个答案，它类似于 K&R 的 C 编程语言书中的做法

【参考方案30】：

我为实现反向字符串所做的只是在 for 循环中使用 xrange 函数和字符串的长度，然后按照以下步骤后退：

myString = "ABC"

for index in xrange(len(myString),-1):
    print index

我的输出是“CBA”