reversePython'un strnesnesi için yerleşik bir işlev yoktur . Bu yöntemi uygulamanın en iyi yolu nedir?

Çok özlü bir cevap sağlıyorsanız, lütfen verimliliğini detaylandırın. Örneğin, strnesnenin farklı bir nesneye dönüştürülüp dönüştürülmediği vb.

Nasıl olur:

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

Bu, genişletilmiş dilim sözdizimidir. Yaparak çalışır [begin:end:step]- başlangıç ​​ve bitiş bırakarak ve -1 adımını belirterek, bir dizeyi tersine çevirir.

@ Paolo en s[::-1]hızlı; daha yavaş bir yaklaşım (belki daha okunabilir, ama bu tartışmalıdır) ''.join(reversed(s)).

Dizeler için bir ters işlev uygulamanın en iyi yolu nedir?

Bu soru ile ilgili kendi deneyimim akademik. Ancak, hızlı cevabı arayan bir profesyonelseniz, aşağıdaki adımları izleyen bir dilim kullanın -1:

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

ya da daha fazla okunabilmektedir (ancak nedeniyle daha yavaş bir yineleyici verildiğinde formları listesi katılmak yöntem adı aramaları ve aslında) str.join:

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

veya okunabilirlik ve tekrar kullanılabilirlik için dilimi bir işleve yerleştirin

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

ve sonra:

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

Daha uzun açıklama

Akademik sergiyle ilgileniyorsanız, lütfen okumaya devam edin.

Python'un str nesnesinde yerleşik ters fonksiyon yoktur.

İşte bilmeniz gereken Python dizeleri hakkında birkaç şey:

1. Python'da, dizeler değişmezdir . Bir dizeyi değiştirmek dizeyi değiştirmez. Yeni bir tane yaratır.

2. Dizeler dilimlenebilir. Bir dizeyi dilimlemek, dizede bir noktadan ileri veya geri, verilen artışlarla başka bir noktaya kadar yeni bir dize verir. Bir alt simge içinde dilim gösterimi veya bir dilim nesnesi alırlar:

   string[subscript]

Alt simge, parantez içine iki nokta üst üste koyarak bir dilim oluşturur:

    string[start:stop:step]

Diş telleri dışında bir dilim oluşturmak için bir dilim nesnesi oluşturmanız gerekir:

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

Okunabilir bir yaklaşım:

''.join(reversed('foo'))Okunabilir olsa da, str.joinnispeten yavaş olabilen başka bir işlevde bir dize yönteminin çağrılmasını gerektirir . Bunu bir fonksiyona koyalım - ona geri döneceğiz:

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

En başarılı yaklaşım:

Çok daha hızlı bir ters dilim kullanıyor:

'foo'[::-1]

Ancak bunu, dilimleri veya orijinal yazarın amacını daha az tanıyan birine nasıl daha okunabilir ve anlaşılır hale getirebiliriz? Altyazı gösteriminin dışında bir dilim nesnesi oluşturalım, açıklayıcı bir ad verelim ve altyazı gösterimine geçirelim.

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

İşlev Olarak Uygulama

Aslında bu bir işlev olarak uygulamak için, sadece açıklayıcı bir ad kullanmak için anlamsal olarak açık olduğunu düşünüyorum:

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

Ve kullanımı basitçe:

reversed_string('foo')

Öğretmeninizin muhtemelen istediği:

Eğitmeniniz varsa, muhtemelen boş bir dize ile başlamanızı ve eskisinden yeni bir dize oluşturmanızı istiyorlar. Bir while döngüsü kullanarak saf sözdizimi ve değişmez değerler ile bunu yapabilirsiniz:

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

Bu teorik olarak kötüdür, çünkü hatırlayın, dizeler değişmezdir - bu yüzden new_string, üzerine bir karakter eklediğiniz gibi göründüğünde , teorik olarak her seferinde yeni bir dize oluşturur! Bununla birlikte, CPython, bu önemsiz durumun bir olduğu belirli durumlarda bunun nasıl optimize edileceğini bilir.

En iyi pratik

Teorik olarak daha iyi, alt dizelerinizi bir listede toplamak ve daha sonra bunlara katılmaktır:

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)

Bununla birlikte, CPython için aşağıdaki zamanlamalarda göreceğimiz gibi, bu aslında daha uzun sürer, çünkü CPython dize birleştirmesini optimize edebilir.

zamanlamalar

İşte zamanlamalar:

>>> 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, dize birleştirmeyi optimize ederken diğer uygulamalar şunları yapamayabilir :

... CPython'un a + = b veya a = a + b biçimindeki ifadeler için yerinde dize birleştirmesinin etkili bir şekilde uygulanmasına güvenmeyin. Bu optimizasyon CPython'da bile kırılgandır (yalnızca bazı türler için çalışır) ve yeniden sayım kullanmayan uygulamalarda hiç mevcut değildir. Kütüphanenin performansa duyarlı bölümlerinde, bunun yerine '' .join () formu kullanılmalıdır. Bu, birleştirme işleminin çeşitli uygulamalarda doğrusal zamanda gerçekleşmesini sağlayacaktır.

Hızlı Yanıt (TL; DR)

Misal

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

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

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

Detaylı cevap

Arka fon

Bu cevap @odigity'den aşağıdaki endişeleri gidermek için verilmiştir:

Vay. İlk başta Paolo'nun önerdiği çözümden dehşete düştüm, ama bu ilk yorumu okuduktan sonra hissettiğim dehşete arka koltuk aldı: "Bu çok pitonik. İyi iş çıkardın!" Böylesine parlak bir topluluğun bu kadar şifreli yöntemleri bu kadar temel bir şey için kullanmayı düşündüğü için çok rahatsız oldum iyi bir fikir. Neden sadece s.reverse () değil?

Sorun

• bağlam
  • Python 2.x
  • Python 3.x
• Senaryo:
  • Geliştirici bir dizeyi dönüştürmek istiyor
  • Dönüşüm tüm karakterlerin sırasını tersine çevirmektir

Çözüm

• example01, genişletilmiş dilim gösterimi kullanarak istenen sonucu üretir .

tuzaklar

• Geliştirici, string.reverse()
• Doğal deyimsel (diğer adıyla " pitonik ") çözüm yeni geliştiriciler tarafından okunamayabilir
• Geliştirici, string.reverse()dilim gösterimini önlemek için kendi sürümünü kullanmaya cazip gelebilir .
• Dilim gösteriminin çıktısı bazı durumlarda karşı sezgisel olabilir:
  • bakınız örneğin, example02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • nazaran
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • nazaran
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • endekslemenin farklı sonuçları [-1]bazı geliştiricileri ortadan kaldırabilir

gerekçe

Python'un farkında olmak için özel bir durumu vardır: bir dize yinelenebilir bir türdür .

Bir string.reverse()yöntemi dışlamak için bir gerekçe, python geliştiricilerine bu özel durumun gücünden yararlanmaya teşvik etmektir.

Basitleştirilmiş terimlerle, bu, bir dizedeki her bir karakterin, tıpkı diğer programlama dillerindeki diziler gibi, sıralı bir eleman düzenlemesinin bir parçası olarak kolayca çalıştırılabileceği anlamına gelir.

Bunun nasıl çalıştığını anlamak için, örnek02'yi gözden geçirmek iyi bir genel bakış sağlayabilir.

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'

Sonuç

Bilişsel yük Python dilim notasyonu eserler gerçekten de dil öğrenmek çok zaman yatırım yapmak istemeyen bazı benimseyen ve geliştiriciler için çok fazla olabilir nasıl anlamak ile ilişkili.

Bununla birlikte, temel prensipler anlaşıldıktan sonra, bu yaklaşımın sabit dizi manipülasyon yöntemleri üzerindeki gücü oldukça uygun olabilir.

Aksini düşünenler için lambda işlevleri, yineleyiciler veya basit bir defalık işlev bildirimleri gibi alternatif yaklaşımlar vardır.

İstenirse, bir geliştirici kendi string.reverse () yöntemini uygulayabilir, ancak python'un bu yönünün arkasındaki mantığı anlamak iyidir.

Ayrıca bakınız

• alternatif basit yaklaşım
• alternatif basit yaklaşım
• dilim gösteriminin alternatif açıklaması

Mevcut cevaplar yalnızca Unicode Değiştiricileri / grafik kümeleri yoksayılırsa doğrudur. Bununla daha sonra ilgileneceğim, ancak önce bazı ters algoritmaların hızına bir göz atın:

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

Liste anlama zamanının ( reversed = string[::-1]) her durumda (yazım hatalarını düzelttikten sonra bile) çok düşük olduğunu görebilirsiniz.

Dize Ters Çevirme

Eğer gerçekten bir anlamda bir dizgeyi tersine çevirmek istiyorsanız, WAY daha karmaşıktır. Örneğin, aşağıdaki dizeyi alın ( kahverengi parmak sola , sarı parmak yukarı dönük ). Bunlar iki grafiktir, ancak 3 adet unicode kod noktasıdır. Ek olarak bir cilt değiştirici .

example = "👈🏾👆"

Ancak verilen yöntemlerden herhangi biriyle ters çevirirseniz, kahverengi parmak yukarı , sarı parmak sola bakacaksınız . Bunun nedeni, "kahverengi" renk değiştiricinin hala ortada olması ve önündeki her şeye uygulanmasıdır. Böylece sahibiz

• U: parmak yukarı dönük
• M: kahverengi değiştirici
• L: parmak sola dönük

ve

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

Unicode Grapheme Kümeleri , yalnızca değiştirici kod noktalarından biraz daha karmaşıktır. Neyse ki, grafik haritalarını işlemek için bir kütüphane var :

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

ve dolayısıyla doğru cevap

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

bu da açık ara en yavaş olanı:

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

Kod

#!/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. dilim gösterimi kullanarak

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

2. ters () işlevini kullanarak

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

3. özyineleme kullanma

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

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

Ona bakmak için daha az şaşırtıcı bir yol olurdu:

string = 'happy'
print(string)

'mutlu'

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

'Yppah'

İngilizce [-1 :: - 1] şu şekilde okunur:

"-1'den başlayarak, -1'e kadar adım atın"

Reversed () veya [:: - 1] kullanmadan python'da bir dizeyi ters çevirme

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

Bu da ilginç bir yol:

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

veya benzeri:

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

.Reverse () işlevini destekleyen byterarray kullanarak daha 'egzotik' bir yol

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

üretecek:

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

Bu, bir dizede döngü yaparak ve değerlerini ters sırada başka bir dizeye atayarak çalışır.

İşte süslü bir tane yok:

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

İşte [::-1]veya olmayan reversed(öğrenme amaçlı):

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

+=dizeleri birleştirmek için kullanabilirsiniz ancak join()daha hızlıdır.

Özyinelemeli yöntem:

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

misal:

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

Yukarıdaki çözümlerin hepsi mükemmeldir, ancak python'da for döngüsü kullanarak bir dizeyi tersine çevirmeye çalışıyorsak, biraz zorlaşacaktır, bu yüzden burada for için kullanarak bir dizeyi tersine çevirebiliriz

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

Umarım bu birisi için yararlı olur.

Bu benim yolum:

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

Bir dizeyi tersine çevirmenin birçok yolu var ama aynı zamanda sadece eğlence için başka bir tane oluşturdum. Bence bu yaklaşım o kadar da kötü değil.

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

Bu sınıf, bir dizeyi tersine çevirmek için python magic işlevlerini kullanır:

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)  

Çıktı

dlrow olleh

Referans

Python 3 ile dizeyi yerinde ters çevirebilirsiniz, yani başka bir değişkene atanmayacaktır. Önce dizeyi bir listeye dönüştürmeniz ve sonra reverse()işlevi kullanmanız gerekir .

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

Bu basit ve anlamlı ters fonksiyon, anlaşılması ve kodlanması kolay

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

İşte basitçe:

"loremipsum" yazdır [- 1 :: - 1]

ve bazıları mantıklı olarak:

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

çıktı:

muspimerol

Python büyüsü olmayan bir dizeyi tersine çevirin.

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

Elbette, Python'da çok süslü 1 satırlık şeyler yapabilirsiniz. :)
İşte herhangi bir programlama dilinde çalışabilecek basit, çok yönlü bir çözüm.

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

ÇIKTI :

o l l e h

Tersine çevrilmiş işlevi kapsamlı bir liste ile kullanabilirsiniz. Ama python 3'te bu yöntemin neden ortadan kaldırıldığını anlamıyorum, gereksizdi.

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