Das letzte Vorkommen von Teilzeichenfolgen in Zeichenfolgen finden und ersetzen

104

Ich habe also eine lange Liste von Zeichenfolgen im selben Format und möchte das letzte "." Zeichen in jedem und ersetzen Sie es durch ". -". Ich habe versucht, rfind zu verwenden, aber ich kann es anscheinend nicht richtig verwenden, um dies zu tun.

python string parsing

— Adam Magyar
quelle

Mögliches Duplikat von rreplace - Wie kann das letzte Vorkommen eines Ausdrucks in einer Zeichenfolge ersetzt werden?

— Graham

163

Das sollte es tun

old_string = "this is going to have a full stop. some written sstuff!"
k = old_string.rfind(".")
new_string = old_string[:k] + ". - " + old_string[k+1:]

— Aditya Sihag
quelle

1

Vielen Dank Mann. Ich werde das für eine Minute studieren müssen ... hier werden Scheiben verwendet, oder?

— Adam Magyar

@AdamMagyar ja, Container [a: b] schneidet von einem bis zu b-1 Index des Containers. Wenn 'a' weggelassen wird, ist der Standardwert 0; Wenn 'b' weggelassen wird, wird standardmäßig len (Container) verwendet. Der Plus-Operator verkettet nur. Wie Sie bereits erwähnt haben, gibt die Funktion rfind den Index zurück, um den der Ersetzungsvorgang stattfinden soll.

— Aditya Sihag

26

So ersetzen Sie von rechts:

def replace_right(source, target, replacement, replacements=None):
    return replacement.join(source.rsplit(target, replacements))

In Benutzung:

>>> replace_right("asd.asd.asd.", ".", ". -", 1)
'asd.asd.asd. -'

— Varinder Singh
quelle

1

Ich mag diese Lösung auf jeden Fall, aber replacements=NoneParameter zu haben scheint mir ein Fehler zu sein, denn wenn der Parameter weggelassen wird, gibt die Funktion einen Fehler aus (versucht in Python 2.7). Ich würde vorschlagen, entweder den Standardwert zu entfernen, ihn auf -1 zu setzen (für unbegrenztes Ersetzen) oder ihn besser zu machen replacements=1(was meiner Meinung nach das Standardverhalten für diese bestimmte Funktion sein sollte, je nachdem, was das OP will). Gemäß den Dokumenten ist dieser Parameter optional, muss aber ein int sein, wenn er angegeben ist.

— Bemerkung

Für den Fall, dass jemand einen Einzeiler dafür haben möchte : ". -".join("asd.asd.asd.".rsplit(".", 1)). Alles, was Sie tun, ist, eine Zeichenfolge von der rechten Seite für 1 Vorkommen aufzuteilen und die Zeichenfolge mithilfe des Ersatzes erneut zu verbinden.

— bsplosion

14

Ich würde einen regulären Ausdruck verwenden:

import re
new_list = [re.sub(r"\.(?=[^.]*$)", r". - ", s) for s in old_list]

— Tim Pietzcker
quelle

2

Dies ist die einzige Antwort, die funktioniert, wenn überhaupt kein Punkt vorhanden ist. Ich würde allerdings einen Lookahead verwenden:\.(?=[^.]*$)

— Georg

6

Ein Einzeiler wäre:

str=str[::-1].replace(".",".-",1)[::-1]

— Labyrinthe
quelle

1

Das ist falsch . Sie kehren die Zeichenfolge um, ersetzen sie und kehren sie dann zurück. Du machst .replaceauf einer umgekehrten Saite. Beide übergebenen Zeichenfolgen replacemüssen ebenfalls umgekehrt werden. Andernfalls sind die gerade eingefügten Buchstaben rückwärts, wenn Sie die Zeichenfolge ein zweites Mal umkehren. Sie können dies nur verwenden, wenn Sie einen Buchstaben durch einen Buchstaben ersetzen, und selbst dann würde ich dies nicht in Ihren Code aufnehmen, falls jemand es in Zukunft ändern muss und sich fragt, warum ein Wort sdrawkcab geschrieben ist.

— Boris

1

Sie können die folgende Funktion verwenden, die das erste Vorkommen des Wortes von rechts ersetzt.

def replace_from_right(text: str, original_text: str, new_text: str) -> str:
    """ Replace first occurrence of original_text by new_text. """
    return text[::-1].replace(original_text[::-1], new_text[::-1], 1)[::-1]

— Bambuste
quelle

0

a = "A long string with a . in the middle ending with ."

# Wenn Sie den Index des letzten Vorkommens einer Zeichenfolge ermitteln möchten, # finden wir in unserem Fall den Index des letzten Vorkommens von with

index = a.rfind("with")

# Das Ergebnis ist 44, da der Index bei 0 beginnt.

— Arpan Saini
quelle

-1

Naiver Ansatz:

a = "A long string with a . in the middle ending with ."
fchar = '.'
rchar = '. -'
a[::-1].replace(fchar, rchar[::-1], 1)[::-1]

Out[2]: 'A long string with a . in the middle ending with . -'

Aditya Sihags Antwort mit einer Single rfind:

pos = a.rfind('.')
a[:pos] + '. -' + a[pos+1:]

— Alex L.
quelle

Dies kehrt auch die Ersatzzeichenfolge um. Davon abgesehen ist es eine Wiederholung der Antwort von root und, wie ich dort sage, ziemlich ineffizient.

— Gareth Latty

@Lattyware Du meinst es kehrt sich um a?

— Alex L

Ich meine, es kehrt sich '. -'in der Ausgabe um.

— Gareth Latty

Nur zu erwarten, dass der Benutzer das Zeichenfolgenliteral von Hand umkehrt, ist keine gute Idee - es ist fehleranfällig und unklar.

— Gareth Latty

@Lattyware Einverstanden. Ich habe es zu einem Var gemacht. (Mir ist klar, dass es eine ineffiziente Methode ist und nicht in allen Fällen geeignet ist - Ihrereplace_right ist viel schöner)

— Alex L