Es gibt keine eingebaute reverseFunktion für Pythons strObjekt. Was ist der beste Weg, um diese Methode zu implementieren?

Wenn Sie eine sehr präzise Antwort geben, erläutern Sie bitte deren Effizienz. Zum Beispiel, ob das strObjekt in ein anderes Objekt konvertiert wird usw.

Wie wäre es mit:

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

Dies ist eine erweiterte Slice- Syntax. Es funktioniert so: Wenn Sie [begin:end:step]Anfang und Ende verlassen und einen Schritt von -1 angeben, wird eine Zeichenfolge umgekehrt.

@ Paolo s[::-1]ist am schnellsten; Ein langsamerer Ansatz (vielleicht besser lesbar, aber das ist umstritten) ist ''.join(reversed(s)).

Was ist der beste Weg, um eine Umkehrfunktion für Strings zu implementieren?

Meine eigene Erfahrung mit dieser Frage ist akademisch. Wenn Sie jedoch ein Profi sind, der nach einer schnellen Antwort sucht, verwenden Sie ein Slice, das folgende Schritte umfasst -1:

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

oder besser lesbar (aber langsamer aufgrund der Suche nach Methodennamen und der Tatsache, dass Join eine Liste bildet, wenn ein Iterator angegeben wird) , str.join:

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

oder setzen Sie das Slice zur besseren Lesbarkeit und Wiederverwendbarkeit in eine Funktion ein

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

und dann:

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

Längere Erklärung

Wenn Sie an der akademischen Ausstellung interessiert sind, lesen Sie bitte weiter.

In Pythons str-Objekt ist keine Umkehrfunktion integriert.

Hier sind einige Dinge über Pythons Zeichenfolgen, die Sie wissen sollten:

1. In Python sind Zeichenfolgen unveränderlich . Durch Ändern einer Zeichenfolge wird die Zeichenfolge nicht geändert. Es schafft eine neue.

2. Saiten sind in Scheiben geschnitten. Wenn Sie eine Zeichenfolge in Scheiben schneiden, erhalten Sie eine neue Zeichenfolge von einem Punkt in der Zeichenfolge vorwärts oder rückwärts zu einem anderen Punkt in bestimmten Schritten. Sie nehmen die Slice-Notation oder ein Slice-Objekt in einem Index an:

   string[subscript]

Der Index erstellt ein Slice, indem ein Doppelpunkt in die geschweiften Klammern eingefügt wird:

    string[start:stop:step]

Um ein Slice außerhalb der geschweiften Klammern zu erstellen, müssen Sie ein Slice-Objekt erstellen:

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

Ein lesbarer Ansatz:

Während ''.join(reversed('foo'))es lesbar ist, muss eine String-Methode str.joinfür eine andere aufgerufene Funktion aufgerufen werden, die relativ langsam sein kann. Lassen Sie uns dies in eine Funktion einfügen - wir werden darauf zurückkommen:

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

Performantester Ansatz:

Viel schneller ist die Verwendung eines umgekehrten Slice:

'foo'[::-1]

Aber wie können wir dies für jemanden lesbarer und verständlicher machen, der mit Slices oder der Absicht des ursprünglichen Autors weniger vertraut ist? Erstellen wir ein Slice-Objekt außerhalb der Indexnotation, geben Sie ihm einen beschreibenden Namen und übergeben Sie es an die Indexnotation.

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

Als Funktion implementieren

Um dies tatsächlich als Funktion zu implementieren, denke ich, dass es semantisch klar genug ist, einfach einen beschreibenden Namen zu verwenden:

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

Und die Nutzung ist einfach:

reversed_string('foo')

Was Ihr Lehrer wahrscheinlich will:

Wenn Sie einen Lehrer haben, möchten diese wahrscheinlich, dass Sie mit einer leeren Zeichenfolge beginnen und eine neue Zeichenfolge aus der alten erstellen. Sie können dies mit reiner Syntax und Literalen mithilfe einer while-Schleife tun:

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

Dies ist theoretisch schlecht, da Zeichenfolgen unveränderlich sind. Jedes Mal, wenn es so aussieht, als würden Sie einen Charakter an Ihre new_stringZeichenfolge anhängen , wird theoretisch jedes Mal eine neue Zeichenfolge erstellt. CPython weiß jedoch, wie dies in bestimmten Fällen optimiert werden kann, von denen dieser triviale Fall einer ist.

Beste Übung

Theoretisch ist es besser, Ihre Teilzeichenfolgen in einer Liste zu sammeln und später zu verbinden:

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)

Wie wir jedoch in den folgenden Zeitangaben für CPython sehen werden, dauert dies tatsächlich länger, da CPython die Verkettung von Zeichenfolgen optimieren kann.

Timings

Hier sind die Timings:

>>> 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 optimiert die Verkettung von Zeichenfolgen, während andere Implementierungen möglicherweise nicht :

... verlassen Sie sich nicht auf CPythons effiziente Implementierung der direkten Verkettung von Zeichenfolgen für Anweisungen in der Form a + = b oder a = a + b. Diese Optimierung ist selbst in CPython fragil (funktioniert nur bei einigen Typen) und ist in Implementierungen ohne Refcounting überhaupt nicht vorhanden. In leistungsempfindlichen Teilen der Bibliothek sollte stattdessen das Formular '' .join () verwendet werden. Dadurch wird sichergestellt, dass die Verkettung in linearer Zeit über verschiedene Implementierungen hinweg erfolgt.

Schnelle Antwort (TL; DR)

Beispiel

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

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

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

Detaillierte Antwort

Hintergrund

Diese Antwort wird bereitgestellt, um die folgenden Bedenken von @odigity auszuräumen:

Beeindruckend. Ich war zuerst entsetzt über die von Paolo vorgeschlagene Lösung, aber das trat in den Hintergrund des Grauens, das ich beim Lesen des ersten Kommentars empfand: "Das ist sehr pythonisch. Gute Arbeit!" Ich bin so beunruhigt, dass eine so helle Community der Meinung ist, dass es eine gute Idee ist, solche kryptischen Methoden für etwas so Grundlegendes zu verwenden. Warum ist es nicht nur an reverse ()?

Problem

• Kontext
  • Python 2.x.
  • Python 3.x.
• Szenario:
  • Entwickler möchte einen String transformieren
  • Bei der Transformation wird die Reihenfolge aller Zeichen umgekehrt

Lösung

• Beispiel01 erzeugt das gewünschte Ergebnis unter Verwendung der erweiterten Slice-Notation .

Tücken

• Entwickler könnten so etwas erwarten string.reverse()
• Die native idiomatische (auch " pythonische ") Lösung ist für neuere Entwickler möglicherweise nicht lesbar
• Entwickler könnten versucht sein, ihre eigene Version von string.reverse()zu implementieren , um die Slice-Notation zu vermeiden.
• Die Ausgabe der Slice-Notation kann in einigen Fällen kontraintuitiv sein:
  • siehe zB Beispiel02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • verglichen mit
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • verglichen mit
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • Die unterschiedlichen Ergebnisse der Indizierung [-1]können einige Entwickler abschrecken

Begründung

Python muss einen besonderen Umstand beachten: Eine Zeichenfolge ist ein iterierbarer Typ.

Ein Grund für den Ausschluss einer string.reverse()Methode besteht darin, Python-Entwicklern einen Anreiz zu geben, die Kraft dieses besonderen Umstands zu nutzen.

Vereinfacht ausgedrückt bedeutet dies einfach, dass jedes einzelne Zeichen in einer Zeichenfolge einfach als Teil einer sequentiellen Anordnung von Elementen bearbeitet werden kann, genau wie Arrays in anderen Programmiersprachen.

Um zu verstehen, wie dies funktioniert, kann das Überprüfen von Beispiel 02 einen guten Überblick bieten.

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

Fazit

Die kognitive Belastung, die mit dem Verständnis der Funktionsweise der Slice-Notation in Python verbunden ist, kann für einige Anwender und Entwickler, die nicht viel Zeit in das Erlernen der Sprache investieren möchten, tatsächlich zu groß sein.

Sobald die Grundprinzipien verstanden sind, kann die Leistungsfähigkeit dieses Ansatzes gegenüber Manipulationsmethoden mit festen Strings jedoch recht günstig sein.

Für diejenigen, die anders denken, gibt es alternative Ansätze wie Lambda-Funktionen, Iteratoren oder einfache einmalige Funktionsdeklarationen.

Auf Wunsch kann ein Entwickler seine eigene string.reverse () -Methode implementieren. Es ist jedoch gut, die Gründe für diesen Aspekt von Python zu verstehen.

Siehe auch

• alternativer einfacher Ansatz
• alternativer einfacher Ansatz
• alternative Erklärung der Slice-Notation

Die vorhandenen Antworten sind nur dann korrekt, wenn Unicode-Modifikatoren / Graphem-Cluster ignoriert werden. Ich werde später darauf eingehen, aber zuerst einen Blick auf die Geschwindigkeit einiger Umkehralgorithmen werfen:

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

Sie können sehen, dass die Zeit für das Listenverständnis ( reversed = string[::-1]) in allen Fällen bei weitem die niedrigste ist (auch nach dem Beheben meines Tippfehlers).

String-Umkehrung

Wenn Sie wirklich eine Zeichenfolge im gesunden Menschenverstand umkehren möchten, ist dies viel komplizierter. Nehmen Sie zum Beispiel die folgende Zeichenfolge ( brauner Finger zeigt nach links , gelber Finger zeigt nach oben ). Das sind zwei Grapheme, aber 3 Unicode-Codepunkte. Der zusätzliche ist ein Skin-Modifikator .

example = "👈🏾👆"

Wenn Sie es jedoch mit einer der angegebenen Methoden umkehren, zeigt der braune Finger nach oben und der gelbe Finger nach links . Der Grund dafür ist, dass sich der "braune" Farbmodifikator noch in der Mitte befindet und auf alles angewendet wird, was davor ist. Also haben wir

• U: Finger zeigt nach oben
• M: brauner Modifikator
• L: Finger zeigt nach links

und

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

Unicode-Graphem-Cluster sind etwas komplizierter als nur Modifikator-Codepunkte. Zum Glück gibt es eine Bibliothek für den Umgang mit Graphemen :

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

und daher wäre die richtige Antwort

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

das ist auch bei weitem das langsamste:

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

Der Code

#!/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. Verwenden der Slice-Notation

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

2. Verwenden der Funktion reverse ()

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

3. Rekursion verwenden

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

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

Eine weniger verwirrende Sichtweise wäre:

string = 'happy'
print(string)

'glücklich'

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

'yppah'

Auf Englisch lautet [-1 :: - 1] wie folgt:

"Beginnen Sie bei -1, gehen Sie den ganzen Weg und machen Sie Schritte von -1"

Kehren Sie eine Zeichenfolge in Python um, ohne reverse () oder [:: - 1] zu verwenden.

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

Dies ist auch ein interessanter Weg:

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

o.ä:

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

Eine andere "exotischere" Art, Byterarray zu verwenden, das .reverse () unterstützt

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

wird herstellen:

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

Dies funktioniert, indem eine Zeichenfolge durchlaufen und ihre Werte in umgekehrter Reihenfolge einer anderen Zeichenfolge zugewiesen werden.

Hier ist nichts Besonderes:

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

Hier ist eine ohne [::-1]oder reversed(zu Lernzwecken):

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

Sie können +=Zeichenfolgen verketten, sind jedoch join()schneller.

Rekursive Methode:

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

Beispiel:

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

Alle oben genannten Lösungen sind perfekt, aber wenn wir versuchen, eine Zeichenfolge mit der for-Schleife in Python umzukehren, wird dies etwas schwierig. So können wir eine Zeichenfolge mit der for-Schleife umkehren

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

Ich hoffe, dass dieser für jemanden hilfreich sein wird.

Das ist mein Weg:

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

Es gibt viele Möglichkeiten, eine Zeichenfolge umzukehren, aber ich habe auch eine andere nur zum Spaß erstellt. Ich denke, dieser Ansatz ist nicht so schlecht.

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

Diese Klasse verwendet Python Magic-Funktionen, um eine Zeichenfolge umzukehren:

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)  

Ausgabe

dlrow olleh

Referenz

Mit Python 3 können Sie die Zeichenfolge direkt umkehren, sodass sie keiner anderen Variablen zugewiesen wird. Zuerst müssen Sie die Zeichenfolge in eine Liste konvertieren und dann die reverse()Funktion nutzen.

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

Dies ist eine einfache und aussagekräftige Umkehrfunktion, die leicht zu verstehen und zu codieren ist

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

Hier ist einfach:

print "loremipsum" [- 1 :: - 1]

und einige logisch:

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

Ausgabe:

Muspimerol

Kehren Sie eine Zeichenfolge ohne Python-Magie um.

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

Sicher, in Python können Sie sehr ausgefallene 1-Zeilen-Sachen machen. :)
Hier ist eine einfache Allrounder-Lösung, die in jeder Programmiersprache funktionieren kann.

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

AUSGABE :

o l l e h

Sie können die Umkehrfunktion mit einer umfassenden Liste verwenden. Aber ich verstehe nicht, warum diese Methode in Python 3 eliminiert wurde, war unnötig.

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