Tidak ada reversefungsi bawaan untuk Pythonstr objek . Apa cara terbaik untuk menerapkan metode ini?

Jika memberikan jawaban yang sangat ringkas, mohon jelaskan efisiensinya. Misalnya, apakah strobjek tersebut dikonversi ke objek lain, dll.

Bagaimana tentang:

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

Ini adalah sintaks slice yang diperpanjang . Ia bekerja dengan melakukan [begin:end:step]- dengan meninggalkan mulai dan berakhir dan menentukan langkah -1, itu membalikkan string.

@ Paolo's s[::-1]adalah yang tercepat; pendekatan yang lebih lambat (mungkin lebih mudah dibaca, tapi itu bisa diperdebatkan) ''.join(reversed(s)).

Apa cara terbaik menerapkan fungsi terbalik untuk string?

Pengalaman saya sendiri dengan pertanyaan ini bersifat akademis. Namun, jika Anda seorang pro mencari jawaban cepat, gunakan irisan yang langkah oleh -1:

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

atau lebih readably (tapi lebih lambat karena pencarian nama metode dan fakta bahwa bergabung bentuk daftar ketika diberi iterator), str.join:

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

atau agar mudah dibaca dan digunakan kembali, letakkan slice dalam suatu fungsi

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

lalu:

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

Penjelasan yang lebih panjang

Jika Anda tertarik pada eksposisi akademik, silakan terus membaca.

Tidak ada fungsi terbalik bawaan dalam objek str Python.

Berikut adalah beberapa hal tentang string Python yang harus Anda ketahui:

1. Dalam Python, string tidak dapat diubah . Mengubah string tidak mengubah string. Itu menciptakan yang baru.

2. String dapat diiris. Mengiris string memberi Anda string baru dari satu titik di string, mundur atau maju, ke titik lain, dengan penambahan yang diberikan. Mereka mengambil notasi irisan atau objek irisan dalam subskrip:

   string[subscript]

Subskrip membuat irisan dengan memasukkan titik dua di dalam kurung:

    string[start:stop:step]

Untuk membuat irisan di luar kawat gigi, Anda harus membuat objek irisan:

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

Pendekatan yang mudah dibaca:

Meskipun ''.join(reversed('foo'))dapat dibaca, ia membutuhkan pemanggilan metode string str.join, pada fungsi lain yang dipanggil, yang bisa agak lambat. Mari kita letakkan ini di fungsi - kita akan kembali ke sana:

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

Kebanyakan pendekatan berkinerja:

Jauh lebih cepat menggunakan slice terbalik:

'foo'[::-1]

Tetapi bagaimana kita bisa membuat ini lebih mudah dibaca dan dimengerti oleh seseorang yang kurang akrab dengan irisan atau maksud dari penulis asli? Mari kita membuat objek irisan di luar notasi subskrip, berikan nama deskriptif, dan berikan ke notifikasi subskrip.

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

Diimplementasikan sebagai Fungsi

Untuk benar-benar mengimplementasikan ini sebagai fungsi, saya pikir secara semantik cukup jelas untuk hanya menggunakan nama deskriptif:

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

Dan penggunaannya adalah:

reversed_string('foo')

Apa yang mungkin diinginkan oleh guru Anda:

Jika Anda memiliki instruktur, mereka mungkin ingin Anda memulai dengan string kosong, dan membangun string baru dari yang lama. Anda bisa melakukan ini dengan sintaks dan literal murni menggunakan loop sementara:

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

Ini secara teori buruk karena, ingat, string tidak dapat diubah - jadi setiap kali sepertinya Anda menambahkan karakter ke karakter Andanew_string , string secara teoritis membuat string baru setiap saat! Namun, CPython tahu cara mengoptimalkan ini dalam kasus-kasus tertentu, salah satunya adalah sepele.

Praktek terbaik

Secara teoritis lebih baik adalah mengumpulkan substring Anda dalam daftar, dan bergabunglah nanti:

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)

Namun, seperti yang akan kita lihat pada timing di bawah untuk CPython, ini sebenarnya memakan waktu lebih lama, karena CPython dapat mengoptimalkan penggabungan string.

Pengaturan waktu

Berikut ini waktunya:

>>> 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 mengoptimalkan penggabungan string, sedangkan implementasi lainnya mungkin tidak :

... jangan bergantung pada implementasi efisien dari rangkaian string in-place CPython untuk pernyataan dalam bentuk a = = b atau a = a + b. Optimasi ini rapuh bahkan dalam CPython (hanya berfungsi untuk beberapa jenis) dan tidak ada sama sekali dalam implementasi yang tidak menggunakan penghitungan ulang. Di bagian peka kinerja yang sensitif, formulir '' .join () harus digunakan sebagai gantinya. Ini akan memastikan bahwa rangkaian terjadi dalam waktu linier di berbagai implementasi.

Jawaban Cepat (TL; DR)

Contoh

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

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

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

Jawaban terperinci

Latar Belakang

Jawaban ini diberikan untuk mengatasi masalah berikut dari @odigity:

Wow. Pada awalnya saya merasa ngeri dengan solusi yang diusulkan Paolo, tetapi itu membuat saya merasa ngeri ketika membaca komentar pertama: "Itu sangat pythonic. Kerja bagus!" Saya sangat terganggu bahwa komunitas yang begitu terang berpikir menggunakan metode samar untuk sesuatu yang begitu mendasar adalah ide yang bagus. Mengapa bukan hanya s.reverse ()?

Masalah

• Konteks
  • Python 2.x
  • Python 3.x
• Skenario:
  • Pengembang ingin mengubah string
  • Transformasi adalah membalik urutan semua karakter

Larutan

• example01 menghasilkan hasil yang diinginkan, menggunakan notasi irisan yang diperluas .

Perangkap

• Pengembang mungkin mengharapkan sesuatu seperti string.reverse()
• Solusi idiomatik asli (alias " pythonic ") mungkin tidak dapat dibaca oleh pengembang yang lebih baru
• Pengembang mungkin tergoda untuk mengimplementasikan versinya sendiri string.reverse() untuk menghindari notasi slice.
• Keluaran notasi irisan mungkin kontra-intuitif dalam beberapa kasus:
  • lihat misalnya, example02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • dibandingkan dengan
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • dibandingkan dengan
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • perbedaan hasil pengindeksan [-1]dapat membuat beberapa pengembang tidak aktif

Alasan

Python memiliki keadaan khusus yang harus diperhatikan: string adalah tipe yang dapat diubah .

Satu alasan untuk mengecualikan string.reverse()metode adalah untuk memberikan insentif pengembang python untuk memanfaatkan kekuatan keadaan khusus ini.

Dalam istilah yang disederhanakan, ini berarti setiap karakter individu dalam string dapat dengan mudah dioperasikan sebagai bagian dari susunan elemen berurutan, seperti halnya array dalam bahasa pemrograman lain.

Untuk memahami cara kerjanya, meninjau example02 dapat memberikan tinjauan yang baik.

Contoh02

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

Kesimpulan

Beban kognitif yang terkait dengan memahami bagaimana notasi slice bekerja dengan python memang mungkin terlalu banyak untuk beberapa pengguna dan pengembang yang tidak ingin menginvestasikan banyak waktu dalam mempelajari bahasa.

Namun demikian, begitu prinsip-prinsip dasar dipahami, kekuatan pendekatan ini atas metode manipulasi string tetap bisa sangat menguntungkan.

Bagi mereka yang berpikir sebaliknya, ada pendekatan alternatif, seperti fungsi lambda, iterator, atau deklarasi fungsi satu kali sederhana.

Jika diinginkan, pengembang dapat mengimplementasikan metode string.reverse () miliknya, namun ada baiknya memahami alasan di balik aspek python ini.

Lihat juga

• alternatif pendekatan sederhana
• alternatif pendekatan sederhana
• penjelasan alternatif notasi slice

Jawaban yang ada hanya benar jika Unicode Modifiers / cluster grapheme diabaikan. Saya akan membahasnya nanti, tetapi pertama-tama kita lihat kecepatan beberapa algoritma pembalikan:

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

Anda dapat melihat bahwa waktu untuk pemahaman daftar (reversed = string[::-1] ) dalam semua kasus adalah yang terendah (bahkan setelah memperbaiki kesalahan ketik saya).

String Reversal

Jika Anda benar-benar ingin membalik string dalam akal sehat, itu WAY lebih rumit. Misalnya, ambil string berikut ( jari coklat menunjuk ke kiri , jari kuning menunjuk ke atas ). Itu adalah dua grapheme, tetapi 3 poin kode unicode. Yang tambahan adalah pengubah kulit .

example = "👈🏾👆"

Tetapi jika Anda membalikkannya dengan salah satu metode yang diberikan, Anda mendapatkan jari cokelat mengarah ke atas , jari kuning menunjuk ke kiri . Alasan untuk ini adalah bahwa pengubah warna "coklat" masih di tengah dan diterapkan pada apa pun yang ada sebelum itu. Jadi kita punya

• U: jari menunjuk ke atas
• M: pengubah cokelat
• L: jari menunjuk ke kiri

dan

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

Unicode Grapheme Clusters sedikit lebih rumit dari sekedar titik kode pengubah. Untungnya, ada perpustakaan untuk menangani grafik :

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

dan karenanya jawaban yang benar adalah

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

yang juga paling lambat:

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

Kode

#!/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. menggunakan notasi slice

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

2. menggunakan fungsi terbalik ()

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

3. menggunakan rekursi

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

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

Cara yang membingungkan untuk melihatnya adalah:

string = 'happy'
print(string)

'senang'

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

'yppah'

Dalam bahasa Inggris [-1 :: - 1] dibaca sebagai:

"Mulai dari -1, lanjutkan, mengambil langkah -1"

Membalikkan string dalam python tanpa menggunakan terbalik () atau [:: - 1]

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

Ini juga cara yang menarik:

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

atau serupa:

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

Cara lain yang lebih 'eksotis' menggunakan byterarray yang mendukung .reverse ()

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

akan menghasilkan:

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

Ini bekerja dengan mengulang melalui string dan menetapkan nilainya dalam urutan terbalik ke string lain.

Inilah yang tidak mewah:

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

Ini satu tanpa [::-1]atau reversed(untuk tujuan belajar):

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

Anda dapat menggunakan +=untuk menggabungkan string tetapi join()lebih cepat.

Metode rekursif:

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

contoh:

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

Semua solusi di atas adalah sempurna tetapi jika kita mencoba untuk membalik sebuah string menggunakan untuk loop dengan python akan menjadi sedikit rumit jadi di sini adalah bagaimana kita dapat membalikkan string menggunakan untuk loop

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

Saya harap yang ini akan membantu seseorang.

Itulah cara saya:

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

Ada banyak cara untuk membalik string tetapi saya juga membuat yang lain hanya untuk bersenang-senang. Saya pikir pendekatan ini tidak seburuk itu.

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

Kelas ini menggunakan fungsi sulap python untuk membalikkan string:

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)  

Keluaran

dlrow olleh

Referensi

Dengan python 3 Anda dapat membalikkan string di tempat yang berarti tidak akan ditugaskan ke variabel lain. Pertama, Anda harus mengubah string menjadi daftar dan kemudian memanfaatkan reverse()fungsi.

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

Ini adalah fungsi terbalik yang sederhana dan bermakna, mudah dimengerti dan kode

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

Ini sederhananya:

cetak "loremipsum" [- 1 :: - 1]

dan beberapa secara logis:

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

keluaran:

muspimerol

Membalikkan string tanpa sihir python.

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

Tentu, dengan Python Anda dapat melakukan hal-hal 1-baris yang sangat mewah. :)
Inilah solusi sederhana, serba bisa yang bisa digunakan dalam bahasa pemrograman apa pun.

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

OUTPUT:

o l l e h

Anda dapat menggunakan fungsi terbalik dengan daftar komprehensif. Tapi saya tidak mengerti mengapa metode ini dihilangkan dengan python 3, tidak perlu.

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