Einen String ohne Verwendung von reverse () oder [:: - 1] umkehren?

Du kannst es auch mit Rekursion machen:

def reverse(text):
    if len(text) <= 1:
        return text

    return reverse(text[1:]) + text[0]

Und ein einfaches Beispiel für den String hello:

   reverse(hello)
 = reverse(Ello) + h           # The recursive step
 = reverse(llo) + e + h
 = reverse(lo) + l + e + h
 = reverse(o) + l + l + e + h  # Base case
 = o + l + l + e + h
 = olleh

Nur eine andere Option:

from collections import deque
def reverse(iterable):
    d = deque()
    d.extendleft(iterable)
    return ''.join(d)

EDIT

Die jüngsten Aktivitäten zu dieser Frage haben mich veranlasst, zurückzublicken und meine Lösung mithilfe eines Generators in einen schnellen Einzeiler zu ändern:

rev = ''.join([text[len(text) - count] for count in xrange(1,len(text)+1)])

Obwohl es hier offensichtlich einige bessere Antworten gibt, wie einen negativen Schritt in der Range- oder XRange-Funktion. Folgendes ist meine ursprüngliche Lösung:

Hier ist meine Lösung, ich erkläre es Schritt für Schritt

def reverse(text):

    lst = []
    count = 1

    for i in range(0,len(text)):

        lst.append(text[len(text)-count])
        count += 1

    lst = ''.join(lst)
    return lst

print reverse('hello')

Zuerst müssen wir der Funktion einen Parameter übergeben, in diesem Fall text.

Als nächstes setze ich eine leere Liste mit dem Namen lst zur späteren Verwendung. (Eigentlich wusste ich nicht, dass ich die Liste brauche, bis ich zur for - Schleife komme. Du wirst gleich sehen, warum das notwendig ist.)

Die Variable count ist sinnvoll, sobald ich in die Schleife for komme

Werfen wir also einen Blick auf eine grundlegende Version dessen, was wir erreichen wollen:

Es ist sinnvoll, das letzte Zeichen der Liste in umgekehrter Reihenfolge anzuhängen. Beispielsweise:

>>lst = []
>>Word = 'foo'
>>lst.append(Word[2])
>>print lst
['o']

Um die Reihenfolge jedoch weiter umzukehren, müssen wir Word[1] Und dann Word[0] Anhängen:

>>lst.append(Word[2])
>>lst.append(Word[1])
>>lst.append(Word[0])
>>print lst
['o','o','f']

Das ist großartig, wir haben jetzt eine Liste, die unser ursprüngliches Wort in umgekehrter Reihenfolge enthält und die mit .join() wieder in einen String umgewandelt werden kann. Aber es gibt ein Problem. Dies funktioniert für das Wort foo, es funktioniert sogar für jedes Wort, das eine Länge von 3 Zeichen hat. Aber was ist mit einem Wort mit 5 Zeichen? Oder 10 Zeichen? Jetzt wird es nicht funktionieren. Was wäre, wenn es eine Möglichkeit gäbe, den angehängten Index dynamisch zu ändern, sodass jedes Wort in umgekehrter Reihenfolge zurückgegeben wird?

Geben Sie für Schleife ein.

for i in range(0,len(text)):

    lst.append(text[len(text)-count])
    count += 1

Zunächst ist es notwendig, in range() anstatt nur in zu verwenden, da wir die Zeichen im Word durchlaufen müssen, aber wir müssen auch den Indexwert des Words so ziehen dass wir die Reihenfolge ändern.

Der erste Teil des Körpers unserer for-Schleife sollte vertraut aussehen. Es ist sehr ähnlich zu

>>lst.append(Word[..index..])

In der Tat ist das Grundkonzept genau das gleiche:

>>lst.append(text[..index..])

Also, was machen all die Sachen in der Mitte?

Nun, wir müssen zuerst den Index des letzten Buchstabens an unsere Liste anhängen. Dies ist die Länge des Wortes text, -1. Von nun an werden wir es als l(t) -1 bezeichnen

>>lst.append(text[len(text)-1])

Das allein wird immer den letzten Buchstaben unseres Wortes erhalten und an lst anhängen, unabhängig von der Länge des Wortes. Aber jetzt, da wir den letzten Buchstaben haben, der l(t) - 1 ist, brauchen wir den vorletzten Buchstaben, der l(t) ist - 2 usw., bis keine Zeichen mehr an die Liste angehängt werden müssen. Erinnern Sie sich an unsere Variable count von oben? Dies ist praktisch. Mit einer for - Schleife können wir dies tun Erhöhen Sie den Wert von count bei jeder Iteration um 1, sodass der Wert, um den wir subtrahieren, zunimmt, bis die for-Schleife das gesamte Wort durchlaufen hat:

>>for i in range(0,len(text)):
..        
..      lst.append(text[len(text)-count])
..      count += 1

Nachdem wir nun den Kern unserer Funktion haben, schauen wir uns an, was wir bisher haben:

def reverse(text):

    lst = []
    count = 1

    for i in range(0,len(text)):

        lst.append(text[len(text)-count])
        count += 1

Wir sind fast fertig! Wenn wir jetzt unsere Funktion mit dem Wort "Hallo" aufrufen, erhalten wir eine Liste, die wie folgt aussieht:

['o', 'l', 'l', 'e', ​​'h']

Wir wollen keine Liste, wir wollen einen String. Dafür können wir .join Verwenden:

def reverse(text):

    lst = []
    count = 1

    for i in range(0,len(text)):

        lst.append(text[len(text)-count])
        count += 1

    lst = ''.join(lst) # join the letters together without a space
    return lst

Und das ist es. Wenn wir das Wort auf reverse () "Hallo" nennen, erhalten wir Folgendes:

>>print reverse('hello')
olleh

Offensichtlich ist dies viel mehr Code, als in einer realen Lebenssituation erforderlich ist. Die Verwendung der Umkehrfunktion oder des erweiterten Slice ist die optimale Methode, um diese Aufgabe auszuführen. In manchen Fällen funktioniert dies jedoch nicht, und Sie benötigen dies. So oder so, ich dachte, ich würde es für jeden, der interessiert wäre, teilen.

Wenn ihr andere Ideen habt, würde ich sie gerne hören!

Verwenden Sie umgekehrt range:

def reverse(strs):
    for i in xrange(len(strs)-1, -1, -1):
        yield strs[i]
...         
>>> ''.join(reverse('hello'))
'olleh'

xrange oder range mit dem Schritt -1 geben Elemente in umgekehrter Reihenfolge zurück. Daher müssen wir von len(string)-1 zu -1 (exclusive) iterieren und Elemente abrufen von der Zeichenfolge eins nach dem anderen.

>>> list(xrange(len(strs) -1, -1 , -1))
[4, 3, 2, 1, 0]  #iterate over these indexes and fetch the items from the string

Einzeiler:

def reverse(strs):
    return ''.join([strs[i] for i in xrange(len(strs)-1, -1, -1)])
... 
>>> reverse('hello')
'olleh'

Ich habe nur Python für ein paar Tage codiert, aber ich denke, das war eine ziemlich saubere Lösung. Erstellen Sie eine leere Liste, durchlaufen Sie jeden Buchstaben in der Zeichenfolge und fügen Sie ihn an den Anfang der Liste an Geben Sie die verknüpfte Liste als Zeichenfolge zurück.

def reverse(text):
backwardstext = []
for letter in text:
    backwardstext.insert(0, letter)
return ''.join(backwardstext)

Ich habe das benutzt:

def reverse(text):
s=""
l=len(text)
for i in range(l):
    s+=text[l-1-i]
return s

Dies ist eine sehr interessante Frage, ich möchte eine einfache einzeilige Antwort anbieten:

>>> S='abcdefg'
>>> ''.join(item[1] for item in sorted(enumerate(S), reverse=True))
'gfedcba'

Kurze Erklärung:

enumerate() gibt [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f'), (6, 'g')] zurück. Die Indizes und die Werte. Um die Werte umzukehren, sortieren Sie sie einfach in umgekehrter Reihenfolge nach sorted(). Zum Schluss fügen Sie es einfach wieder zu einem str zusammen.

Inspiriert von Jons Antwort, wie wäre es mit dieser

Word = 'hello'
q = deque(Word)
''.join(q.pop() for _ in range(len(Word)))

reduce(lambda x, y : y + x, "hello world")

Ich habe verschiedene Versionen erstellt, um einen String in python in meinem Repo umzukehren: https://github.com/fedmich/Python-Codes/tree/ Master/Reverse% 20a% 20String

Sie können dies mit Listenverständnis oder Lambda-Technik tun :

# Reverse a string without using reverse() function
s = 'Federico';
li = list( s )  #convert string to list

ret = [ li[i-1] for i in xrange(len(li),0,-1)  ]    #1 liner lambda
print ( "".join( ret ) )

oder indem Sie eine Rückwärts-For-Schleife ausführen

# Reverse a string without using reverse() function
s = 'Federico';
r = []

length = len(s)
for i in xrange(length,0,-1):
    r.append( s[ i - 1] )

print ( "".join(r) )

def reverse(s):
    return "".join(s[i] for i in range(len(s)-1, -1, -1))

ich habe das gerade in der Code Academy gelöst und habe meine Antworten überprüft und bin über diese Liste gelaufen. mit einem sehr eingeschränkten Verständnis von python habe ich das gerade getan und es hat funktioniert.

def reverse(s):
    i = len(s) - 1
    sNew = ''
    while  i >= 0:
        sNew = sNew + str(s[i])
        i = i -1
    return sNew

Eine Golfversion: r=lambda x:"".join(x[i] for i in range(len(x-1),-1,-1)).

Die Antwort von Blender ist sehr schön, aber für eine sehr lange Saite ergibt sich ein unglaublicher RuntimeError: maximum recursion depth exceeded. Man könnte den gleichen Code in eine while-Schleife umgestalten, wie es häufig bei der Rekursion in Python der Fall ist. Offensichtlich immer noch schlecht aufgrund von Zeit- und Speicherproblemen, aber zumindest wird kein Fehler auftreten.

def reverse(text):
    answer = ""
    while text:
        answer = text[0] + answer
        text = text[1:]
    return answer

Alles, was ich getan habe, um eine umgekehrte Zeichenfolge zu erzielen, ist die Funktion xrange mit der Länge der Zeichenfolge in einer for-Schleife zu verwenden und wie folgt zurückzugehen:

myString = "ABC"

for index in xrange(len(myString),-1):
    print index

Meine Ausgabe ist "CBA"

Sie können Ihre Zeichenfolge ab dem letzten Zeichen einfach umkehren. Mit python können Sie mithilfe des Listenverständnisses die Liste der Zeichen in umgekehrter Reihenfolge erstellen und sie dann zusammenfügen, um die umgekehrte Zeichenfolge in einem Einzeiler zu erhalten:

def reverse(s):
  return "".join([s[-i-1] for i in xrange(len(s))])

wenn Sie nicht einmal eine negative Indizierung verwenden dürfen, sollten Sie s[-i-1] durch s[len(s)-i-1] ersetzen.

Dies ist meine Lösung mit der for i in range-Schleife:

def reverse(string):
    tmp = ""
    for i in range(1,len(string)+1):
        tmp += string[len(string)-i]            
    return tmp

Es ist ziemlich leicht zu verstehen. Ich beginne bei 1, um einen Index außerhalb der Grenzen zu vermeiden.

Ich habe auch gerade die entsprechende Übung zur Codeacademy gelöst und wollte meinen Ansatz mit anderen vergleichen. Ich habe die Lösung, die ich bisher verwendet habe, nicht gefunden. Deshalb habe ich mir gedacht, dass ich mich hier anmelde und meine Lösung anderen zur Verfügung stelle. Und vielleicht bekomme ich einen Vorschlag oder einen hilfreichen Kommentar zur Verbesserung des Codes.

Ok, hier geht es, ich habe keine Liste zum Speichern der Zeichenfolge verwendet, stattdessen habe ich gerade auf den Zeichenfolgenindex zugegriffen. Zuerst habe ich ein bisschen gebraucht, um mit len ​​() und der Indexnummer umzugehen, aber am Ende hat es geklappt :).

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

Ich frage mich immer noch, ob der reversestring = "" könnte auf elegantere Weise gelöst werden, oder wenn es sogar "schlechter Stil" ist, aber ich konnte bisher keine Antwort finden.

Hier ist einer, der eine Liste als Stapel verwendet:

def reverse(s):
  rev = [_t for _t in s]
  t = ''
  while len(rev) != 0:
    t+=rev.pop()
  return t

Das kann man einfach so machen

def rev(str):
   rev = ""
   for i in range(0,len(str)):
   rev = rev + str[(len(str)-1)-i]
   return rev

def reverseThatString(theString):
    reversedString = ""
    lenOfString = len(theString)
    for i,j in enumerate(theString):
        lenOfString -= 1
        reversedString += theString[lenOfString]
    return reversedString

So geht das mit einer while-Schleife:

def reverse(s):
    t = -1
    s2 = ''
    while abs(t) < len(s) + 1: 
        s2 = s2 + s[t]
        t  = t - 1
    return s2

def reverse(text):
    a=""
    l=len(text)
    while(l>=1):
        a+=text[l-1]
        l-=1
    return a

ich habe gerade die Zeichenfolge a mit den höchsten Indexen des Texts verkettet (die bei jeder Schleife weiter um 1 dekrementiert wird).

Heute wurde ich um dieselbe Aufgabe mit Stift und Papier gebeten, daher habe ich diese Funktion für Listen entwickelt:

def rev(s):
  l = len(s)
  for i,j in Zip(range(l-1, 0, -1), range(l//2)):
    s[i], s[j] = s[j], s[i]
  return s

die mit Zeichenfolgen mit "".join(rev(list("hello"))) verwendet werden können

Hier ist mein Beitrag:

def rev(test):  
    test = list(test)
    i = len(test)-1
    result = []

    print test
    while i >= 0:
        result.append(test.pop(i))
        i -= 1
    return "".join(result)

Sie haben viele alternative Antworten erhalten, aber nur um eine weitere einfache Lösung hinzuzufügen - das erste, was mir einfiel:

def reverse(text):
    reversed_text = ""   

    for n in range(len(text)):
        reversed_text += text[-1 - n]

    return reversed_text

Es ist nicht so schnell wie einige der anderen Optionen, die die Leute erwähnt haben (oder eingebaute Methoden), aber einfach zu befolgen, da wir einfach die Länge der Zeichenfolge text verwenden, um jeweils ein Zeichen durch Aufteilen zu verketten vom Ende nach vorne.

Sie können den Pop einfach wie vorgeschlagen verwenden. Hier sind ein Liner dafür

chaine = 'qwertyuiop'
''.join([chaine[-(x + 1)] for x in range(len(chaine))])
'poiuytrewq'
gg = list(chaine)
''.join([gg.pop() for _ in range(len(gg))])
'poiuytrewq'

Meine Lösung:

s = raw_input ("String eingeben")
drucken
Def Reverse (Text):

st = ""  
rev = ""  
count = len(text)  
print "Lenght of text: ", len(text)  
print  
for c in range(len(text)):  
    count = count - 1  
    st = st + "".join(text[c])  
    rev = rev + "".join(text[count])  
    print "count:       ", count  
    print "print c:     ", c  
    print "text[c]:     ", text[c]  
    print  
print "Original:    ", st  
print "Reversed:    ", rev  
return rev  

rückseite (n)

Ergebnisbildschirm

String joca eingeben

Textlänge: 4

anzahl: 3
drucke c: 0
Text [c]: j

anzahl: 2
print c: 1
Text [c]: o

anzahl: 1
drucke c: 2
Text [c]: c

anzahl: 0
print c: 3
Text [c]: a

Im Original: Joca
Umgekehrt: akust
Keiner

So kann ich mir vorstellen, ohne eingebaute Funktionen zu verwenden:

a = 'Word'
count = 0
for letter in a:
    count += 1

b = ''
for letter in a:
    b += a[count-1]
    count -= 1

Und wenn Sie b drucken:

print b
drow

Dies ist der einfachste Weg in der python 2.7-Syntax

def reverse(text):

      rev = ""
      final = ""

      for a in range(0,len(text)):
            rev = text[len(text)-a-1]
            final = final + rev
return final

Nicht sehr klug, aber knifflige Lösung

def reverse(t):
    for j in range(len(t) // 2):
        t = t[:j] + t[- j - 1] + t[j + 1:- j - 1] + t[j] + t[len(t) - j:]
    return t

Ich bevorzuge dies als die beste Möglichkeit, einen String mit einer for-Schleife umzukehren.

def reverse_a_string(str): 

    result=" "
    for i in range(len(str),1,-1):
        result= result+ str[i-1]
    return result

print reverse_a_string(input())

enterString=input("Enter a string to be reversed:")
string_List=list(enterString)
revedString=[]

for i in range(len(string_List)):
    revedString.append(string_List.pop())
#Pop last element and append it to the empty list
print "reversed string is:",''.join(revedString)
#as the out come is in list convert it into string using .join

Sample Output:
>>>Enter a string to be reversed :sampleReverse1  
>>>reversed string is:1esreveRelpmas 

führen Sie dies einfach aus, aber es wird jedes Zeichen in einer separaten Zeile gedruckt. Die zweite Version druckt es in einer Zeile.

def rev(str):
        for i in range(0,len(str)):
            print(list(str)[len(str)-i-1])

In einer Zeile drucken:

def rev(str):
    rev = list()
    for i in range(0,len(str)):
        rev.append((list(str)[len(str)-i-1]))
    print(''.join(rev))

Punktfrei:

from functools import partial
from operator import add

flip = lambda f: lambda x, y: f(y, x)
rev = partial(reduce, flip(add))

Prüfung:

>>> rev('hello')
'olleh'

m = input("Enter string::")
def rev(s):
    z = -1
    x = len(s)
    while x != 0:
        print(s[z], end='')
        z = z-1
        x = x-1
rev(m)

du hast genug Antwort.

Ich möchte nur einen anderen Weg teilen.

sie können zwei kleine Funktionen für die Umkehrung schreiben und die Ausgabe der Funktion mit der angegebenen Zeichenfolge vergleichen

var = ''

def Reverse (Daten):

for i in data:
    var = i + var
return var

wenn nicht var == data:

print "Kein Palindrom"

sonst:

print "Palindrom"

Einfache Methode,

>>> a = "hi hello"
>>> ''.join([a[len(a)-i-1] for i,j in enumerate(a)])
'olleh ih'
>>>