Không có reversechức năng tích hợp nào cho strđối tượng Python . Cách tốt nhất để thực hiện phương pháp này là gì?

Nếu cung cấp một câu trả lời rất súc tích, xin vui lòng giải thích về hiệu quả của nó. Ví dụ: liệu strđối tượng có được chuyển đổi thành một đối tượng khác không, v.v.

Làm thế nào về:

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

Đây là cú pháp lát mở rộng . Nó hoạt động bằng cách thực hiện [begin:end:step]- bằng cách để lại bắt đầu và kết thúc và chỉ định một bước -1, nó đảo ngược một chuỗi.

@ Paolo s[::-1]là nhanh nhất; một cách tiếp cận chậm hơn (có thể dễ đọc hơn, nhưng điều đó gây tranh cãi) là ''.join(reversed(s)).

Cách tốt nhất để thực hiện một chức năng đảo ngược cho chuỗi là gì?

Kinh nghiệm của riêng tôi với câu hỏi này là học tập. Tuy nhiên, nếu bạn là người chuyên nghiệp đang tìm kiếm câu trả lời nhanh, hãy sử dụng một lát cắt theo bước -1:

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

hoặc dễ đọc hơn (nhưng chậm hơn do tra cứu tên phương thức và thực tế là tham gia tạo thành một danh sách khi được đưa ra một trình vòng lặp) , str.join:

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

hoặc để dễ đọc và tái sử dụng, hãy đặt lát cắt vào một hàm

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

và sau đó:

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

Giải thích dài hơn

Nếu bạn quan tâm đến giải trình học thuật, xin vui lòng tiếp tục đọc.

Không có chức năng đảo ngược tích hợp trong đối tượng str của Python.

Đây là một vài điều về chuỗi của Python mà bạn nên biết:

1. Trong Python, chuỗi là bất biến . Thay đổi một chuỗi không sửa đổi chuỗi. Nó tạo ra một cái mới.

2. Dây có thể cắt được. Cắt một chuỗi cung cấp cho bạn một chuỗi mới từ một điểm trong chuỗi, ngược hoặc xuôi, đến một điểm khác, theo gia số đã cho. Họ lấy ký hiệu lát hoặc một đối tượng lát trong một chỉ mục:

   string[subscript]

Các chỉ mục tạo ra một lát bằng cách bao gồm một dấu hai chấm trong dấu ngoặc nhọn:

    string[start:stop:step]

Để tạo một lát cắt bên ngoài dấu ngoặc nhọn, bạn sẽ cần tạo một đối tượng lát:

    slice_obj = slice(start, stop, step)
    string[slice_obj]

Một cách tiếp cận dễ đọc:

Trong khi ''.join(reversed('foo'))có thể đọc được, nó yêu cầu gọi một phương thức chuỗi str.join, trên một hàm được gọi khác, có thể khá chậm. Chúng ta hãy đặt chức năng này - chúng ta sẽ quay lại với nó:

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

Cách tiếp cận hiệu quả nhất:

Nhanh hơn nhiều là sử dụng một lát đảo ngược:

'foo'[::-1]

Nhưng làm thế nào chúng ta có thể làm cho điều này trở nên dễ đọc và dễ hiểu hơn đối với một người ít quen thuộc hơn với các lát cắt hoặc ý định của tác giả ban đầu? Chúng ta hãy tạo một đối tượng lát bên ngoài ký hiệu chỉ mục, đặt cho nó một tên mô tả và chuyển nó vào ký hiệu đăng ký.

start = stop = None
step = -1
reverse_slice = slice(start, stop, step)
'foo'[reverse_slice]

Thực hiện như chức năng

Để thực sự thực hiện điều này như là một chức năng, tôi nghĩ rằng nó đủ rõ ràng về mặt ngữ nghĩa để chỉ cần sử dụng một tên mô tả:

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

Và cách sử dụng chỉ đơn giản là:

reversed_string('foo')

Giáo viên của bạn có thể muốn gì:

Nếu bạn có một người hướng dẫn, họ có thể muốn bạn bắt đầu với một chuỗi trống và xây dựng một chuỗi mới từ chuỗi cũ. Bạn có thể làm điều này với cú pháp thuần túy và bằng chữ bằng cách sử dụng vòng lặp while:

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

Điều này về mặt lý thuyết là xấu bởi vì, hãy nhớ rằng, các chuỗi là bất biến - vì vậy mỗi khi có vẻ như bạn đang gắn thêm một ký tự vào new_string, về mặt lý thuyết, nó tạo ra một chuỗi mới mỗi lần! Tuy nhiên, CPython biết cách tối ưu hóa điều này trong một số trường hợp nhất định, trong đó trường hợp tầm thường này là một.

Thực hành tốt nhất

Về mặt lý thuyết tốt hơn là thu thập các chuỗi con của bạn trong một danh sách và tham gia chúng sau:

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)

Tuy nhiên, như chúng ta sẽ thấy trong các định thời dưới đây cho CPython, việc này thực sự mất nhiều thời gian hơn, vì CPython có thể tối ưu hóa việc nối chuỗi.

Thời gian

Dưới đây là thời gian:

>>> 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 tối ưu hóa nối chuỗi, trong khi các triển khai khác có thể không :

... không dựa vào việc triển khai hiệu quả nối chuỗi tại chỗ của CPython cho các câu lệnh ở dạng a + = b hoặc a = a + b. Tối ưu hóa này rất dễ hỏng ngay cả trong CPython (nó chỉ hoạt động đối với một số loại) và hoàn toàn không có trong các triển khai không sử dụng tính năng đếm lại. Trong các phần nhạy cảm về hiệu năng của thư viện, nên sử dụng biểu mẫu '' .join (). Điều này sẽ đảm bảo rằng sự kết hợp xảy ra trong thời gian tuyến tính trên các triển khai khác nhau.

Trả lời nhanh (TL; DR)

Thí dụ

### example01 -------------------
mystring  =   'coup_ate_grouping'
backwards =   mystring[::-1]
print backwards

### ... or even ...
mystring  =   'coup_ate_grouping'[::-1]
print mystring

### result01 -------------------
'''
gnipuorg_eta_puoc
'''

Trả lời chi tiết

Lý lịch

Câu trả lời này được cung cấp để giải quyết mối quan tâm sau từ @odigity:

Ồ Lúc đầu, tôi đã rất kinh hoàng bởi giải pháp mà Paolo đề xuất, nhưng điều đó đã khiến người ta cảm thấy kinh hoàng khi đọc bình luận đầu tiên: "Điều đó rất trăn trở. Làm tốt lắm!" Tôi rất băn khoăn rằng một cộng đồng sáng giá như vậy nghĩ rằng sử dụng các phương pháp khó hiểu như vậy cho một cái gì đó rất cơ bản là một ý tưởng tốt. Tại sao nó không chỉ là s.reverse ()?

Vấn đề

• Bối cảnh
  • Python 2.x
  • Python 3.x
• Kịch bản:
  • Nhà phát triển muốn chuyển đổi một chuỗi
  • Biến đổi là để đảo ngược thứ tự của tất cả các nhân vật

Giải pháp

• example01 tạo ra kết quả mong muốn, sử dụng ký hiệu lát mở rộng .

Cạm bẫy

• Nhà phát triển có thể mong đợi một cái gì đó như string.reverse()
• Giải pháp thành ngữ gốc (còn gọi là " pythonic ") có thể không đọc được đối với các nhà phát triển mới hơn
• Nhà phát triển có thể được khuyến khích thực hiện phiên bản của riêng mình string.reverse()để tránh ký hiệu lát.
• Đầu ra của ký hiệu lát có thể phản trực giác trong một số trường hợp:
  • xem ví dụ, ví dụ02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • so với
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • so với
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • các kết quả khác nhau của việc lập chỉ mục [-1]có thể khiến một số nhà phát triển bỏ qua

Cơ sở lý luận

Python có một trường hợp đặc biệt cần lưu ý: một chuỗi là một kiểu lặp .

Một lý do để loại trừ một string.reverse()phương pháp là khuyến khích các nhà phát triển python tận dụng sức mạnh của tình huống đặc biệt này.

Nói một cách đơn giản, điều này đơn giản có nghĩa là mỗi ký tự riêng lẻ trong một chuỗi có thể được vận hành dễ dàng như là một phần của sự sắp xếp tuần tự các phần tử, giống như các mảng trong các ngôn ngữ lập trình khác.

Để hiểu cách thức này hoạt động, xem xét example02 có thể cung cấp một cái nhìn tổng quan tốt.

Ví dụ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'

Phần kết luận

Các tải nhận thức liên quan đến việc hiểu cách thức hoạt động ký hiệu slice trong python thực sự có thể là quá nhiều đối với một số chấp nhận và phát triển những người không muốn đầu tư nhiều thời gian trong việc học ngôn ngữ.

Tuy nhiên, một khi các nguyên tắc cơ bản được hiểu, sức mạnh của phương pháp này đối với các phương pháp thao tác chuỗi cố định có thể khá thuận lợi.

Đối với những người nghĩ khác, có các cách tiếp cận khác, chẳng hạn như các hàm lambda, các trình vòng lặp hoặc các khai báo hàm một lần đơn giản.

Nếu muốn, nhà phát triển có thể thực hiện phương thức string.reverse () của riêng mình, tuy nhiên, thật tốt khi hiểu lý do căn bản đằng sau khía cạnh này của python.

Xem thêm

• phương pháp đơn giản thay thế
• phương pháp đơn giản thay thế
• giải thích thay thế của ký hiệu lát

Các câu trả lời hiện tại chỉ đúng nếu cụm điều chỉnh / biểu đồ Unicode bị bỏ qua. Tôi sẽ giải quyết vấn đề đó sau, nhưng trước tiên hãy xem tốc độ của một số thuật toán đảo ngược:

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

Bạn có thể thấy rằng thời gian để hiểu danh sách ( reversed = string[::-1]) trong mọi trường hợp là thấp nhất (ngay cả sau khi sửa lỗi đánh máy của tôi).

Chuỗi đảo ngược

Nếu bạn thực sự muốn đảo ngược một chuỗi theo nghĩa thông thường, thì đó là CÁCH phức tạp hơn. Ví dụ: lấy chuỗi sau ( ngón tay nâu chỉ trái , ngón tay vàng hướng lên ). Đó là hai biểu đồ, nhưng 3 điểm mã unicode. Một bổ sung là một sửa đổi da .

example = "👈🏾👆"

Nhưng nếu bạn đảo ngược nó với bất kỳ phương pháp nào, bạn sẽ thấy ngón tay nâu chỉ lên , ngón tay vàng chỉ sang trái . Lý do cho điều này là công cụ sửa đổi màu "nâu" vẫn ở giữa và được áp dụng cho bất cứ điều gì trước nó. Vì vậy chúng tôi có

• U: ngón tay chỉ lên
• M: sửa đổi màu nâu
• L: ngón tay trỏ trái

và

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

Các cụm đồ thị Unicode phức tạp hơn một chút so với chỉ các điểm mã sửa đổi. May mắn thay, có một thư viện để xử lý đồ thị :

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

và do đó câu trả lời đúng sẽ là

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

đó cũng là chậm nhất:

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

Mật mã

#!/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. sử dụng ký hiệu lát

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

2. sử dụng hàm Reverse ()

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

3. sử dụng đệ quy

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

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

Một cách khó hiểu hơn để xem xét nó sẽ là:

string = 'happy'
print(string)

'vui mừng'

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

'yppah'

Trong tiếng Anh [-1 :: - 1] đọc là:

"Bắt đầu từ -1, đi hết con đường, thực hiện các bước của -1"

Đảo ngược một chuỗi trong python mà không sử dụng đảo ngược () hoặc [:: - 1]

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

Đây cũng là một cách thú vị:

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

hoặc tương tự:

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

Một cách khác 'kỳ lạ' hơn bằng cách sử dụng byterarray hỗ trợ .reverse ()

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

sẽ sản xuất:

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

Điều này hoạt động bằng cách lặp qua một chuỗi và gán các giá trị của nó theo thứ tự ngược lại cho một chuỗi khác.

Đây là một không ưa thích:

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

Đây là một cái không có [::-1]hoặc reversed(cho mục đích học tập):

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

bạn có thể sử dụng +=để nối chuỗi nhưng join()nhanh hơn.

Phương pháp đệ quy:

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

thí dụ:

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

Tất cả các giải pháp trên đều hoàn hảo nhưng nếu chúng ta cố gắng đảo ngược chuỗi sử dụng vòng lặp for trong python sẽ trở nên khó khăn một chút, vì vậy đây là cách chúng ta có thể đảo ngược chuỗi bằng vòng lặp for

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

Tôi hy vọng điều này sẽ hữu ích cho một ai đó.

Đó là cách làm của tôi:

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

Có rất nhiều cách để đảo ngược một chuỗi nhưng tôi cũng tạo ra một cách khác chỉ để cho vui. Tôi nghĩ rằng cách tiếp cận này không phải là xấu.

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

Lớp này sử dụng các hàm ma thuật python để đảo ngược một chuỗi:

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)  

Đầu ra

dlrow olleh

Tài liệu tham khảo

Với python 3, bạn có thể đảo ngược chuỗi tại chỗ, nghĩa là nó sẽ không được gán cho biến khác. Đầu tiên bạn phải chuyển đổi chuỗi thành một danh sách và sau đó tận dụng reverse()hàm.

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

Đây là chức năng đảo ngược đơn giản và có ý nghĩa, dễ hiểu và mã

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

Đây chỉ đơn giản là:

in "loremipsum" [- 1 :: - 1]

và một số logic:

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

đầu ra:

muspimerol

Đảo ngược một chuỗi mà không có ma thuật trăn.

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

Chắc chắn, trong Python bạn có thể làm những thứ 1 dòng rất lạ mắt. :)
Đây là một giải pháp đơn giản, hoàn hảo hơn có thể hoạt động trong mọi ngôn ngữ lập trình.

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

ĐẦU RA:

o l l e h

Bạn có thể sử dụng chức năng đảo ngược với một danh sách đầy đủ. Nhưng tôi không hiểu tại sao phương pháp này đã bị loại bỏ trong python 3, là không cần thiết.

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