ไม่มีreverseฟังก์ชันในตัวสำหรับstrวัตถุของ Python วิธีที่ดีที่สุดในการใช้วิธีนี้คืออะไร?

หากคำตอบที่กระชับมากโปรดอธิบายเกี่ยวกับประสิทธิภาพ ตัวอย่างเช่นไม่ว่าstrวัตถุจะถูกแปลงเป็นวัตถุอื่นหรือไม่ก็ตาม

เกี่ยวกับ:

>>> 'hello world'[::-1]
'dlrow olleh'

นี่คือไวยากรณ์ส่วนเพิ่มเติม มันทำงานโดยการทำ[begin:end:step]- โดยปล่อยให้เริ่มต้นและสิ้นสุดและระบุขั้นตอนที่ -1 มันกลับสตริง

@ Paolo's s[::-1]เร็วที่สุด; วิธีการช้าลง (อาจจะอ่านได้มากขึ้น แต่ที่เป็นที่ถกเถียงกันของ) ''.join(reversed(s))เป็น

วิธีที่ดีที่สุดในการใช้ฟังก์ชันย้อนกลับสำหรับสตริงคืออะไร?

ประสบการณ์ของฉันกับคำถามนี้คือนักวิชาการ อย่างไรก็ตามหากคุณเป็นมืออาชีพที่กำลังมองหาคำตอบอย่างรวดเร็วให้ใช้ส่วนที่ทำตาม-1:

>>> 'a string'[::-1]
'gnirts a'

หรือมากกว่าอ่านได้ง่ายขึ้น (แต่ช้าลงเนื่องจากการค้นหาชื่อวิธีและความจริงที่เข้าร่วมในรูปแบบรายการเมื่อได้รับ iterator) str.join:

>>> ''.join(reversed('a string'))
'gnirts a'

หรือสำหรับความสามารถในการอ่านและการนำกลับมาใช้ใหม่ให้ใส่ชิ้นในฟังก์ชั่น

def reversed_string(a_string):
    return a_string[::-1]

แล้ว:

>>> reversed_string('a_string')
'gnirts_a'

คำอธิบายอีกต่อไป

หากคุณสนใจงานนิทรรศการทางวิชาการโปรดอ่านต่อไป

ไม่มีฟังก์ชั่นย้อนกลับในตัวในวัตถุ str ของ Python

นี่คือบางสิ่งเกี่ยวกับสตริงของ Python ที่คุณควรรู้:

1. ในหลาม, สตริงจะไม่เปลี่ยนรูป การเปลี่ยนสตริงไม่ได้แก้ไขสตริง มันสร้างขึ้นมาใหม่

2. สายอักขระจะเชือด การแบ่งสตริงจะช่วยให้คุณมีสตริงใหม่จากจุดหนึ่งในสตริงไปข้างหลังหรือส่งต่อไปยังจุดอื่นโดยการเพิ่มทีละ พวกเขาใช้สัญกรณ์ชิ้นหรือวัตถุชิ้นในตัวห้อย:

   string[subscript]

ตัวห้อยสร้างชิ้นโดยรวมเครื่องหมายโคลอนไว้ในวงเล็บปีกกา:

    string[start:stop:step]

ในการสร้างชิ้นนอกวงเล็บปีกกาคุณจะต้องสร้างวัตถุชิ้น:

    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]

แต่เราจะทำให้คนอ่านได้เข้าใจและเข้าใจได้ง่ายขึ้นด้วยการแบ่งส่วนหรือเจตนาของผู้แต่ง ลองสร้างวัตถุชิ้นนอกสัญกรณ์ตัวห้อยให้ชื่อที่เป็นคำอธิบายและส่งไปยังรูปแบบตัวห้อย

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

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 สำหรับข้อความสั่งในรูปแบบ + = b หรือ a = a + b การเพิ่มประสิทธิภาพนี้มีความเปราะบางแม้จะอยู่ใน CPython (ใช้ได้กับบางประเภทเท่านั้น) และจะไม่ปรากฏเลยในการใช้งานที่ไม่ได้ใช้การนับใหม่ ในส่วนที่อ่อนไหวด้านประสิทธิภาพของไลบรารีควรใช้ฟอร์ม '' .join () แทน สิ่งนี้จะทำให้มั่นใจได้ว่าการต่อข้อมูลจะเกิดขึ้นในเวลาเชิงเส้นในการนำไปใช้งานต่าง ๆ

คำตอบด่วน (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:

ว้าว. ในตอนแรกฉันรู้สึกหวาดกลัวด้วยวิธีที่เปาโลเสนอ แต่นั่นก็ทำให้ฉันรู้สึกกลัวเมื่อได้อ่านความคิดเห็นแรก: "นั่นเป็นเพลงที่ไพเราะมากทำได้ดีมาก!" ฉันรำคาญมากที่ชุมชนที่สดใสเช่นนี้คิดว่าการใช้วิธีการเข้ารหัสลับเพื่อสิ่งพื้นฐานดังนั้นจึงเป็นความคิดที่ดี ทำไมมันไม่ใช่แค่ s.reverse ()?

ปัญหา

• บริบท
  • Python 2.x
  • Python 3.x
• สถานการณ์:
  • ผู้พัฒนาต้องการแปลงสตริง
  • การเปลี่ยนแปลงคือการย้อนกลับลำดับของตัวละครทั้งหมด

สารละลาย

• example01 ผลิตผลลัพธ์ที่ต้องการโดยใช้สัญกรณ์ชิ้นขยาย

ผิดพลาด

• นักพัฒนาอาจคาดหวังบางอย่างเช่น string.reverse()
• วิธีแก้ปัญหาดั้งเดิม (aka " 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 มีสถานการณ์พิเศษที่ต้องระวัง: สตริงเป็นชนิดที่สามารถวนซ้ำได้

เหตุผลหนึ่งที่ยกเว้นstring.reverse()วิธีคือการให้แรงจูงใจกับนักพัฒนาหลามเพื่อยกระดับพลังของสถานการณ์พิเศษนี้

ในคำศัพท์ที่เรียบง่ายนี่หมายถึงอักขระแต่ละตัวในสตริงสามารถดำเนินการได้อย่างง่ายดายโดยเป็นส่วนหนึ่งของการจัดเรียงตามลำดับขององค์ประกอบเช่นเดียวกับอาร์เรย์ในภาษาโปรแกรมอื่น ๆ

เพื่อให้เข้าใจถึงวิธีการทำงานการทบทวน example02 สามารถให้ภาพรวมที่ดี

Example02

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

ข้อสรุป

โหลดองค์ความรู้ที่เกี่ยวข้องกับการทำความเข้าใจวิธีสัญกรณ์ชิ้นทำงานในหลามแน่นอนอาจจะมากเกินไปสำหรับบาง adopters และนักพัฒนาที่ไม่ต้องการที่จะลงทุนเวลามากในการเรียนรู้ภาษา

อย่างไรก็ตามเมื่อเข้าใจหลักการพื้นฐานแล้วพลังของวิธีนี้ต่อวิธีการจัดการสตริงคงที่ก็ค่อนข้างดี

สำหรับผู้ที่คิดเป็นอย่างอื่นมีวิธีการอื่นเช่นฟังก์ชั่นแลมบ์ดาตัววนซ้ำหรือการประกาศฟังก์ชันหนึ่งครั้งง่าย

หากต้องการนักพัฒนาสามารถใช้วิธีการ string.reverse () ของเธอเองอย่างไรก็ตามมันเป็นสิ่งที่ดีที่จะเข้าใจเหตุผลเบื้องหลังของงูหลาม

ดูสิ่งนี้ด้วย

• วิธีการง่ายๆแบบอื่น
• วิธีการง่ายๆแบบอื่น
• คำอธิบายอื่นของสัญกรณ์ชิ้น

คำตอบที่มีอยู่นั้นถูกต้องก็ต่อเมื่อ Unicode Modifiers / clusters ถูกละเว้น ฉันจะจัดการกับมันในภายหลัง แต่ก่อนอื่นให้ดูที่ความเร็วของอัลกอริทึมการกลับรายการ:

list_comprehension  : min:   0.6μs, mean:   0.6μs, max:    2.2μs
reverse_func        : min:   1.9μs, mean:   2.0μs, max:    7.9μs
reverse_reduce      : min:   5.7μs, mean:   5.9μs, max:   10.2μs
reverse_loop        : min:   3.0μs, mean:   3.1μs, max:    6.8μs

list_comprehension  : min:   4.2μs, mean:   4.5μs, max:   31.7μs
reverse_func        : min:  75.4μs, mean:  76.6μs, max:  109.5μs
reverse_reduce      : min: 749.2μs, mean: 882.4μs, max: 2310.4μs
reverse_loop        : min: 469.7μs, mean: 577.2μs, max: 1227.6μs

คุณจะเห็นว่าเวลาสำหรับรายการความเข้าใจ ( reversed = string[::-1]) อยู่ในทุกกรณีโดยไกลที่สุด (แม้หลังจากแก้ไขการพิมพ์ผิดของฉัน)

การกลับรายการสตริง

หากคุณต้องการย้อนกลับสตริงในสามัญสำนึกมันเป็นวิธีที่ซับซ้อนมากขึ้น ตัวอย่างเช่นใช้สตริงต่อไปนี้ ( นิ้วสีน้ำตาลชี้ไปทางซ้ายและนิ้วสีเหลืองชี้ขึ้น ) นั่นคือสองรูปแบบ แต่มี 3 จุดรหัส unicode เพิ่มเติมคือสกินโมดิฟายเออร์

example = "👈🏾👆"

แต่ถ้าคุณย้อนกลับด้วยวิธีการใด ๆ ที่กำหนดคุณจะได้รับนิ้วชี้ขึ้นสีน้ำตาล , นิ้วชี้ซ้ายสีเหลือง สาเหตุของเรื่องนี้คือตัวปรับแต่งสี "น้ำตาล" ยังคงอยู่ตรงกลางและนำไปใช้กับสิ่งที่อยู่ตรงหน้า ดังนั้นเราจึงมี

• U: นิ้วชี้ขึ้น
• M: ตัวดัดแปลงสีน้ำตาล
• L: นิ้วชี้ไปทางซ้าย

และ

original: LMU
reversed: UML (above solutions)
reversed: ULM (correct reversal)

กลุ่ม Unicode Graphemeนั้นซับซ้อนกว่าบิตโค้ดตัวดัดแปลงเพียงเล็กน้อย โชคดีที่มีห้องสมุดสำหรับจัดการกับกราฟิก :

>>> import grapheme
>>> g = grapheme.graphemes("👈🏾👆")
>>> list(g)
['👈🏾', '👆']

และด้วยเหตุนี้คำตอบที่ถูกต้องจะเป็น

def reverse_graphemes(string):
    g = list(grapheme.graphemes(string))
    return ''.join(g[::-1])

ซึ่งยังช้าที่สุด:

list_comprehension  : min:    0.5μs, mean:    0.5μs, max:    2.1μs
reverse_func        : min:   68.9μs, mean:   70.3μs, max:  111.4μs
reverse_reduce      : min:  742.7μs, mean:  810.1μs, max: 1821.9μs
reverse_loop        : min:  513.7μs, mean:  552.6μs, max: 1125.8μs
reverse_graphemes   : min: 3882.4μs, mean: 4130.9μs, max: 6416.2μs

รหัส

#!/usr/bin/env python

import numpy as np
import random
import timeit
from functools import reduce
random.seed(0)


def main():
    longstring = ''.join(random.choices("ABCDEFGHIJKLM", k=2000))
    functions = [(list_comprehension, 'list_comprehension', longstring),
                 (reverse_func, 'reverse_func', longstring),
                 (reverse_reduce, 'reverse_reduce', longstring),
                 (reverse_loop, 'reverse_loop', longstring)
                 ]
    duration_list = {}
    for func, name, params in functions:
        durations = timeit.repeat(lambda: func(params), repeat=100, number=3)
        duration_list[name] = list(np.array(durations) * 1000)
        print('{func:<20}: '
              'min: {min:5.1f}μs, mean: {mean:5.1f}μs, max: {max:6.1f}μs'
              .format(func=name,
                      min=min(durations) * 10**6,
                      mean=np.mean(durations) * 10**6,
                      max=max(durations) * 10**6,
                      ))
        create_boxplot('Reversing a string of length {}'.format(len(longstring)),
                       duration_list)


def list_comprehension(string):
    return string[::-1]


def reverse_func(string):
    return ''.join(reversed(string))


def reverse_reduce(string):
    return reduce(lambda x, y: y + x, string)


def reverse_loop(string):
    reversed_str = ""
    for i in string:
        reversed_str = i + reversed_str
    return reversed_str


def create_boxplot(title, duration_list, showfliers=False):
    import seaborn as sns
    import matplotlib.pyplot as plt
    import operator
    plt.figure(num=None, figsize=(8, 4), dpi=300,
               facecolor='w', edgecolor='k')
    sns.set(style="whitegrid")
    sorted_keys, sorted_vals = zip(*sorted(duration_list.items(),
                                           key=operator.itemgetter(1)))
    flierprops = dict(markerfacecolor='0.75', markersize=1,
                      linestyle='none')
    ax = sns.boxplot(data=sorted_vals, width=.3, orient='h',
                     flierprops=flierprops,
                     showfliers=showfliers)
    ax.set(xlabel="Time in ms", ylabel="")
    plt.yticks(plt.yticks()[0], sorted_keys)
    ax.set_title(title)
    plt.tight_layout()
    plt.savefig("output-string.png")


if __name__ == '__main__':
    main()

1. ใช้สัญกรณ์ชิ้น

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

2. ใช้ฟังก์ชัน reversed ()

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

3. ใช้การเรียกซ้ำ

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"

ย้อนกลับสตริงในไพ ธ อนโดยไม่ใช้ reverse () หรือ [:: - 1]

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

นี่เป็นวิธีที่น่าสนใจ:

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'

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

original = "string"

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

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

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"

สิ่งนี้ทำงานโดยการวนลูปผ่านสตริงและกำหนดค่าของมันในลำดับย้อนกลับไปยังสตริงอื่น

ที่นี่ไม่มีใครแฟนซี:

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

นี่คือสิ่งที่ไม่มี[::-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(s): return s[0] if len(s)==1 else s[len(s)-1] + reverse(s[0:len(s)-1])

ตัวอย่าง:

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

คำตอบทั้งหมดข้างต้นนั้นสมบูรณ์แบบ แต่ถ้าเราพยายามที่จะย้อนกลับสตริงที่ใช้สำหรับลูปในไพ ธ อนจะกลายเป็นเรื่องยุ่งยากเล็กน้อยดังนั้นนี่คือวิธีที่เราสามารถย้อนกลับสตริงที่ใช้สำหรับลูป

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

ฉันหวังว่าอันนี้จะเป็นประโยชน์สำหรับใครบางคน

นั่นคือทางของฉัน:

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

มีหลายวิธีในการย้อนสตริง แต่ฉันสร้างอีกอันเพื่อความสนุก ฉันคิดว่าวิธีการนี้ไม่เลว

def reverse(_str):
    list_char = list(_str) # Create a hypothetical list. because string is immutable

    for i in range(len(list_char)/2): # just t(n/2) to reverse a big string
        list_char[i], list_char[-i - 1] = list_char[-i - 1], list_char[i]

    return ''.join(list_char)

print(reverse("Ehsan"))

ชั้นนี้ใช้ฟังก์ชั่นเวทหลามเพื่อย้อนกลับสตริง:

class Reverse(object):
    """ Builds a reverse method using magic methods """

    def __init__(self, data):
        self.data = data
        self.index = len(data)


    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration

        self.index = self.index - 1
        return self.data[self.index]


REV_INSTANCE = Reverse('hello world')

iter(REV_INSTANCE)

rev_str = ''
for char in REV_INSTANCE:
    rev_str += char

print(rev_str)  

เอาท์พุต

dlrow olleh

การอ้างอิง

ด้วย python 3 คุณสามารถย้อนกลับสตริงแบบ in-place ซึ่งหมายความว่ามันจะไม่ถูกกำหนดให้กับตัวแปรอื่น ก่อนอื่นคุณต้องแปลงสตริงเป็นรายการแล้วใช้ประโยชน์จากreverse()ฟังก์ชัน

https://docs.python.org/3/tutorial/datastructures.html

   def main():
        my_string = ["h","e","l","l","o"]
        print(reverseString(my_string))

    def reverseString(s):
      print(s)
      s.reverse()
      return s

    if __name__ == "__main__":
        main()

นี่คือฟังก์ชั่นย้อนกลับที่เรียบง่ายและมีความหมายง่ายต่อการเข้าใจและรหัส

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

เอาท์พุท:

muspimerol

ย้อนกลับสตริงโดยไม่ต้องใช้เวทมนตร์หลาม

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

แน่นอนว่าใน Python คุณสามารถทำสิ่งต่าง ๆ ได้ 1 บรรทัด :)
นี่เป็นวิธีการแก้ปัญหาที่ง่ายและกลมทั้งหมดซึ่งสามารถทำงานได้ในภาษาการเขียนโปรแกรมใด ๆ

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 = '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 3 โดยไม่จำเป็น

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