Python 在不使用reversed（）或[：-1]的情况下反转字符串？

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

[：：-1]

显然，在编程的现实世界中，人们很可能会使用该方法，甚至使用

reversed

函数，但也许在某些情况下这不起作用

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

编辑

最近关于这个问题的活动使我回顾过去，并将我的解决方案更改为使用生成器的快速单行程序：

rev = ''.join([text[len(text) - count] for count in xrange(1,len(text)+1)])

虽然这里显然有一些更好的答案，比如range或xrange函数中的负阶跃。以下是我最初的解决方案：

---

这是我的解决方案，我会一步一步地解释

def reverse(text):

    lst = []
    count = 1

    for i in range(0,len(text)):

        lst.append(text[len(text)-count])
        count += 1

    lst = ''.join(lst)
    return lst

print reverse('hello')

首先，我们必须向函数传递一个参数，在本例中为

text

接下来，我设置了一个名为

lst

的空列表，供以后使用。（事实上，在进入

for

循环之前，我并不知道我需要这个列表，您马上就会明白为什么需要它。）

一旦进入

for

循环，

count

变量就有意义了

让我们来看看我们正在努力实现的基本版本：

将最后一个字符追加到列表中会以相反的顺序开始，这是有道理的。例如：

>>lst = []
>>word = 'foo'
>>lst.append(word[2])
>>print lst
['o']

但是为了继续颠倒顺序，我们需要先追加

word[1]

，然后再追加

word[0]

：

>>lst.append(word[2])
>>lst.append(word[1])
>>lst.append(word[0])
>>print lst
['o','o','f']

这很好，我们现在有了一个列表，它的原始单词顺序相反，可以使用

.join（）

将其转换回字符串。但是有个问题。这适用于单词foo，甚至适用于任何长度为3个字符的单词。但是一个有5个字符的单词呢？还是10个字符？现在不行了。如果有一种方法可以动态地更改我们附加的索引，以便以相反的顺序返回任何单词呢

输入循环

for i in range(0,len(text)):

    lst.append(text[len(text)-count])
    count += 1

首先，有必要在range（）中使用

，而不仅仅是在

中使用

，因为我们需要迭代单词中的字符，但我们还需要提取单词的索引值，以便更改顺序

for循环主体的第一部分看起来应该很熟悉。它与

>>lst.append(word[..index..])

事实上，它的基本概念完全相同：

>>lst.append(text[..index..])

P：中间的所有东西在做什么？
首先，我们需要将最后一个字母的索引附加到列表中，即单词的长度，
text
，-1。从现在起，我们称之为l（t）-1

仅此一项就可以得到单词的最后一个字母，并将其附加到
lst
，而不管单词的长度如何。但是现在我们有了最后一个字母，即l（t）-1，我们需要倒数第二个字母，即l（t）-2，依此类推，直到列表中没有更多的字符可附加。还记得我们上面的
count
变量吗？那会派上用场的。通过使用
for
循环，我们可以在每次迭代中将
count
的值增加1，这样我们减去的值就会增加，直到for循环遍历整个单词：

>>for i in range(0,len(text)):
..        
..      lst.append(text[len(text)-count])
..      count += 1

现在我们已经掌握了函数的核心，让我们看看到目前为止我们已经掌握了什么：

def reverse(text):

    lst = []
    count = 1

    for i in range(0,len(text)):

        lst.append(text[len(text)-count])
        count += 1

我们快完了！现在，如果我们用单词“hello”调用函数，我们将得到如下列表：

[o'、'l'、'l'、'e'、'h']

我们不想要列表，我们想要字符串。我们可以使用
.join
来实现：

def reverse(text):

    lst = []
    count = 1

    for i in range(0,len(text)):

        lst.append(text[len(text)-count])
        count += 1

    lst = ''.join(lst) # join the letters together without a space
    return lst

就这样。如果我们在reverse（）上调用单词“hello”，我们将得到以下结果：

>>print reverse('hello')
olleh

显然，这是一种比现实生活中需要的更多的代码。使用反向函数或扩展切片将是完成此任务的最佳方式，但可能在某些情况下它不起作用，您需要这样做。不管怎样，我想我会把它分享给任何有兴趣的人

如果你们还有其他想法，我很想听听
 您也可以使用递归来实现：

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

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

使用反向
范围
：

def reverse(strs):
    for i in xrange(len(strs)-1, -1, -1):
        yield strs[i]
...         
>>> ''.join(reverse('hello'))
'olleh'

xrange
或带有-1步骤的
range
将以相反的顺序返回项目，因此我们需要从
len（string）-1
迭代到
-1
（独占），并从字符串中逐个提取项目

>>> list(xrange(len(strs) -1, -1 , -1))
[4, 3, 2, 1, 0]  #iterate over these indexes and fetch the items from the string

一艘班轮：

def reverse(strs):
    return ''.join([strs[i] for i in xrange(len(strs)-1, -1, -1)])
... 
>>> reverse('hello')
'olleh'

golfed版本：
r=lambda x:：。加入（x[i]表示范围内的i（len（x-1），-1，-1））
只是另一个选项：

from collections import deque
def reverse(iterable):
    d = deque()
    d.extendleft(iterable)
    return ''.join(d)

受乔恩回答的启发，这个怎么样

word = 'hello'
q = deque(word)
''.join(q.pop() for _ in range(len(word)))

这是一个非常有趣的问题，我想提出一个简单的问题
线性回答：

>>> S='abcdefg'
>>> ''.join(item[1] for item in sorted(enumerate(S), reverse=True))
'gfedcba'

简要说明：

enumerate（）
返回
[（0，'a'）、（1，'b'）、（2，'c'）、（3，'d'）、（4，'e'）、（5，'f'）、（6，'g'）]
。指数和数值。
要反转这些值，只需按
sorted（）
对其进行反向排序即可。
最后，把它放回一个
str
今天我被要求在纸笔上做同样的练习，所以我为列表提供了这个函数：

def rev(s):
  l = len(s)
  for i,j in zip(range(l-1, 0, -1), range(l//2)):
    s[i], s[j] = s[j], s[i]
  return s

它可以与带“
”的字符串一起使用。join（rev（list（“hello”））
您已经得到了足够的答案

只是想以另一种方式分享

您可以编写一个用于反转的两个小函数，并将函数输出与给定字符串进行比较

var=''

def倒档（数据）：

如果不是var==数据：

打印“无回文”

其他：

打印“回文”
我刚在代码学院解决了这个问题，正在检查我的答案，然后浏览了这个列表。因此，在对python的理解非常有限的情况下，我只做了这件事，它成功了

def reverse(s):
    i = len(s) - 1
    sNew = ''
    while  i >= 0:
        sNew = sNew + str(s[i])
        i = i -1
    return sNew

这是一种使用while循环的方法：

def reverse(s):
    t = -1
    s2 = ''
    while abs(t) < len(s) + 1: 
        s2 = s2 + s[t]
        t  = t - 1
    return s2

def倒档：
t=-1
s2=“”
而abs（t）for i in data:
    var = i + var
return var

def reverse(s):
    i = len(s) - 1
    sNew = ''
    while  i >= 0:
        sNew = sNew + str(s[i])
        i = i -1
    return sNew

def reverse(s):
    t = -1
    s2 = ''
    while abs(t) < len(s) + 1: 
        s2 = s2 + s[t]
        t  = t - 1
    return s2

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

def reverse(text):
    a=""
    l=len(text)
    while(l>=1):
        a+=text[l-1]
        l-=1
    return a

# Reverse a string without using reverse() function
s = 'Federico';
li = list( s )  #convert string to list

ret = [ li[i-1] for i in xrange(len(li),0,-1)  ]    #1 liner lambda
print ( "".join( ret ) )

# Reverse a string without using reverse() function
s = 'Federico';
r = []

length = len(s)
for i in xrange(length,0,-1):
    r.append( s[ i - 1] )

print ( "".join(r) )

myString = "ABC"

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

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

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

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

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'

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

def reverse(text):
    reversed_text = ""   

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

    return reversed_text

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

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

print b
drow

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

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

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

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)

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

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

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

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