扭转而不使用反转的字符串（）或[:: - 1]？扭转而不使用反转的字符串（）或[:: - 1

我碰到的是要求会采取一个字符串作为输入，并以相反的顺序返回它的函数一个奇怪的Codecademy网站的锻炼。 唯一的问题是你不能使用反向方法或常见的答案在这里计算器， [::-1]

显然，在编程的现实世界中，一个最有可能与去扩展切片法，甚至使用reversed功能，但也许有一些情况下这是行不通的？

我在Q＆A的风格呈现解决方案如下，如果它是人们对未来有帮助的。

Answer 1:

你也可以用递归做到这一点：

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

Answer 2:

只是另一种选择：

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

Answer 3:

使用了反转range ：

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

xrange或range为-1步骤将返回相反顺序的项目，所以我们需要遍历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'

Answer 4:

编辑

在这个问题上最近的活动使我回过头来，用发电机改变我解决一个快速班轮：

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

虽然明明有这里有一些更好的答案就像范围或功能的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循环，你就会明白为什么它在第二个是必要的。）

该count变数将非常有意义，一旦我进入for循环

因此，让我们来看看在我们试图完成一个基本的版本：

这是有道理的，追加的最后一个字符的名单将启动顺序相反。 例如：

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

首先，它是必要使用in range()而不是仅仅in ，因为我们需要通过在单词中的字符进行迭代，但我们也需要拉字的索引值，使我们改变顺序。

我们的身体循环的第一部分应该很熟悉。 它非常类似于

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

事实上，它的基础概念是完全一样的：

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

那么什么是在中间做所有的东西吗？

好了，我们需要的最后一个字母的指数第一附加到我们的名单，这是这个词的长度， text ，-1。 从现在开始，我们称其为L（T）-1

>>lst.append(text[len(text)-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

我们几乎完成了！ 现在，如果我们调用我们的功能字“你好”，我们会得到一个看起来像列表：

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

仅此而已。 如果我们呼吁反向（）字“你好”，我们会得到这样的：

>>print reverse('hello')
olleh

显然，这是方式更多的代码比在现实生活中的情况是必要的。 使用反向功能或扩展的片断将完成这一任务的最佳方法，但也许有一些实例时，它不会工作，你就需要这个。 无论哪种方式，我想我会分享它的人会是谁感兴趣。

如果你们有任何其他想法，我很想听听他们！

Answer 5:

只有被编码的​​Python了几天，但我觉得这是一个相当干净的解决方案。 通过串中的每个字母创建一个空的列表，循环和其追加到列表的前面，返回加入列表作为字符串。

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

Answer 6:

我用这个：

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

Answer 7:

由Jon的回答，这个怎么样的启发

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

Answer 8:

这是一个非常有趣的问题，我会想提供一个简单的衬垫的答案：

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

Answer 9:

我创建了不同版本的如何扭转Python中的字符串在我的回购： https://github.com/fedmich/Python-Codes/tree/master/Reverse%20a%20String

您可以通过使用列表理解或做拉姆达技术 ：

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

或通过执行一个向后for循环

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

Answer 10:

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

Answer 11:

甲golfed版本： r=lambda x:"".join(x[i] for i in range(len(x-1),-1,-1))

Answer 12:

我只是解决了这个代码学院和检查我的答案和整个这个名单跑。 所以与Python的了解非常有限，我只是做了这一点，它缝工作。

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

Answer 13:

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

Answer 14:

Blender的答案是可爱的，但对于一个很长的字符串，它会导致高达RuntimeError: maximum recursion depth exceeded 。 有人可能会重构相同的代码为while循环，作为一个经常必须在Python递归做。 显然仍然很糟糕，由于时间和内存的问题，但至少不会出错。

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

Answer 15:

今天有人问我，在笔和纸本同样的工作，所以我想出这个功能列表：

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

Answer 16:

这是一种while循环做到这一点：

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

Answer 17:

我也刚刚解决了上codeacademy的coresponding锻炼，想比较我的做法给他人。 我还没有找到我迄今为止所使用的解决方案，所以我想我在这里注册，并提供我的解决方案给他人。 也许我得到一个建议，或者对如何提高代码有帮助的评论。

好吧这里有云，我没有使用任何列表存储字符串，而不是我刚刚访问字符串索引。 我花了一点首先要处理的LEN（）和索引号，但最终它的工作:)。

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

我仍然想知道如果reversestring = ""可能是一个更优雅的方式来解决，或者如果它是“不良作风”，甚至，但我无法找到答案为止。

Answer 18:

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

我只是串联起来的文本指数最高（这使通过各1个循环递减）的字符串。

Answer 19:

我所做的一切，实现了反向串使用xrange函数的字符串的长度在for循环中，每个以下退一步：

myString = "ABC"

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

我的输出为“CBA”

Answer 20:

你可以简单地逆转迭代您的字符串从最后一个字符开始。 与Python，您可以使用列表中理解，构建以相反的顺序字符的列表，然后加入他们的行列，以获得一个班轮颠倒字符串：

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

如果你不能使用，甚至负分度应更换s[-i-1]与s[len(s)-i-1]

Answer 21:

你已经收到了很多的备选答案，但只是为了添加另一个简单的解决方案 - 来考虑这样的事的第一件事：

def reverse(text):
    reversed_text = ""   

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

    return reversed_text

这不是一样快，一些人提到（或内置的方法）的其他选项，但很容易因为我们只是使用的长度遵循text由朝结束切片串在一个时间来连接一个字符面前。

Answer 22:

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

Answer 23:

这是使用了我我的解决方案在范围内循环：

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

这是很容易理解的。 我从1开始，以避免指数超出界限。

Answer 24:

这里是我的贡献：

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)

Answer 25:

你可以简单地这样

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

Answer 26:

下面是一个使用列表作为堆栈：

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

Answer 27:

你已经有足够的答案。

想和大家分享的另一种方式。

你可以写反面的两个小的功能和作用与输出给定的字符串比较

是=“”

DEF反向（数据）：

for i in data:
    var = i + var
return var

如果不是VAR ==数据：

打印“没有回文”

其他：

打印“回文”

Answer 28:

不是很聪明，但棘手的解决方案

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

Answer 29:

Pointfree：

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'

Answer 30:

我能想到的，而无需使用任何内置函数的方法：

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

文章来源: Reverse a string without using reversed() or [::-1]?