在python3中如何将单词向后翻转?在这种情况下[副本]

您可以将reversed函数与list comprehesive一起使用。但我不明白为什么这个方法在python 3中被删除,是不必要的。

string = [ char for char in reversed(string)]

s = 'hello'
ln = len(s)
i = 1
while True:
    rev = s[ln-i]
    print rev,
    i = i + 1
    if i == ln + 1 :
        break

输出:

o l l e h

当然,在python中,你可以做一些非常花哨的单行代码。:)
这里有一个简单,全面的解决方案,可以在任何编程语言工作。

def reverse_string(phrase):
    reversed = ""
    length = len(phrase)
    for i in range(length):
        reversed += phrase[length-1-i]
    return reversed

phrase = raw_input("Provide a string: ")
print reverse_string(phrase)

S='你好世界'

S:(::- 1)

在上面的示例中,标签s或变量s保存包含hello world字符串的字符串,在第二步中,我以-1的相反步骤从所有内容开始到所有内容,打印hello world字符串的相反部分。

这是一个简单而有意义的反向函数,易于理解和编码

def reverse_sentence(text):
    words = text.split(" ")
    reverse =""
    for word in reversed(words):
        reverse += word+ " "
    return reverse

这里简单地说:

打印“loremipsum”[-1::-1]

一些逻辑上:

def str_reverse_fun():
    empty_list = []
    new_str = 'loremipsum'
    index = len(new_str)
    while index:
        index = index - 1
        empty_list.append(new_str[index])
    return ''.join(empty_list)
print str_reverse_fun()

输出:

麝香草酚

在没有python魔法的情况下反转字符串。

>>> def reversest(st):
    a=len(st)-1
    for i in st:
        print(st[a],end="")
        a=a-1

def reverse_string(string):
    length = len(string)
    temp = ''
    for i in range(length):
        temp += string[length - i - 1]
    return temp

print(reverse_string('foo')) #prints "oof"

这是通过循环遍历一个字符串并将其值以相反的顺序分配给另一个字符串来实现的。

这里有一个没有 [::-1] 或 reversed (用于学习目的):

def reverse(text):
    new_string = []
    n = len(text)
    while (n > 0):
        new_string.append(text[n-1])
        n -= 1
    return ''.join(new_string)
print reverse("abcd")

你可以使用 += 连接字符串,但是 join() 更快。

这是我的方式:

def reverse_string(string):
    character_list = []
    for char in string:
        character_list.append(char)
    reversed_string = ""
    for char in reversed(character_list):
        reversed_string += char
    return reversed_string

以上所有的解决方案都是完美的,但是如果我们试图在python中使用for循环来反转字符串,那么会变得有点棘手,下面是如何使用for循环来反转字符串

string ="hello,world"
for i in range(-1,-len(string)-1,-1):
    print (string[i],end=(" ")) 

我希望这个对某人有帮助。

递归方法:

def reverse(s): return s[0] if len(s)==1 else s[len(s)-1] + reverse(s[0:len(s)-1])

例子:

print(reverse("Hello!"))    #!olleH

这里有一个不喜欢的人:

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

original = "string"

rev_index = original[::-1]
rev_func = list(reversed(list(original))) #nsfw

print(original)
print(rev_index)
print(''.join(rev_func))

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

这也是一个有趣的方式:

def reverse_words_1(s):
    rev = ''
    for i in range(len(s)):
        j = ~i  # equivalent to j = -(i + 1)
        rev += s[j]
    return rev

或类似的:

def reverse_words_2(s):
    rev = ''
    for i in reversed(range(len(s)):
        rev += s[i]
    return rev

使用byterarray的另一种更“奇特”的方式,它支持.reverse()

b = bytearray('Reverse this!', 'UTF-8')
b.reverse()
b.decode('UTF-8')

将产生:

'!siht esreveR'

在python中反转字符串,而不使用reversed()或[::-1]

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

1。使用切片表示法

def rev_string(s): 
    return s[::-1]

2。使用reversed()函数

def rev_string(s): 
    return ''.join(reversed(s))

三。使用递归

def rev_string(s): 
    if len(s) == 1:
        return s

    return s[-1] + rev_string(s[:-1])

一个不那么令人费解的方法是:

string = 'happy'
print(string)

“快乐”

string_reversed = string[-1::-1]
print(string_reversed)

“碧波”

英语中[-1::-1]读作:

“从-1开始,一直走,采取-1的步骤”

快速回答(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
'''

详细答案

背景

提供此答案是为了解决@odigty提出的以下问题:

真的。起初我对保罗提出的解决方案感到震惊,但是 坐在后座上看第一本书时我感到很害怕 点评:“那是非常蟒蛇。干得好!”我很不安 一个聪明的群体认为用这种神秘的方法 基本的是个好主意。为什么不只是s.reverse()?

问题

• 语境
  • Python 2 x
  • Python 3 x
• 脚本:
  • 开发人员希望转换字符串
  • 转换是将所有字符的顺序颠倒

解决方案

• 示例01使用 extended slice notation .

陷阱

• 开发人员可能希望 string.reverse()
• 土生土长的成语 pythonic )解决方案可能对新开发人员不可读
• 开发人员可能会尝试实现自己的版本 string.reverse() 以避免切片符号。
• 在某些情况下,切片表示法的输出可能与直觉相反:
  • 参见示例02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • 相比于
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • 相比于
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • 索引的不同结果 [-1] 可能会让一些开发人员失望

理论基础

python有一个特殊的情况需要注意:字符串是 iterable 类型。

排除 string.reverse() 方法是让python开发人员有动力利用这种特殊情况的能力。

简而言之,这仅仅意味着字符串中的每个字符都可以作为元素顺序排列的一部分轻松操作,就像其他编程语言中的数组一样。

为了理解这是如何工作的,回顾example2可以提供一个很好的概述。

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

结论

这个 cognitive load 对于一些不想花太多时间学习这种语言的采用者和开发人员来说,理解切片表示法在python中的工作原理可能确实是太多了。

然而,一旦理解了基本原理,这种方法相对于固定字符串操作方法的威力就相当大了。

对于那些不这么认为的人,有其他方法,比如lambda函数、迭代器或简单的一次性函数声明。

如果需要的话,开发人员可以实现自己的string.reverse()方法,但是理解python这方面背后的原理是很好的。

也见

• alternate simple approach
• alternate simple approach
• alternate explanation of slice notation