String ab x-ten Vorkommen eines Zeichens ausgeben

[SVblue]

Gegeben sei ein String s:

s ="Wenn ich nur wüsste wie es geht?"

Nun möchte ich nur den Teil ausgeben, der nach dem zweiten Vorkommen des Zeichen "i" folgt... hier also "e es geht?"
Wie ermittelt man die Zeichenposition des, in diesem Fall, zweiten "i"?

[Sirius3]

@SVblue: weißt Du wie man die Position des ersten i ermittelt?

[SVblue]

pos = s.find("i")

?

[snafu]

pos = s.find("i")

?

Ja, wobei man da ständig den Rückgabewert prüfen muss. Als Alternative gibt es ``s.index()``, welches einen ``ValueError`` wirft, falls eine Suche keinen Treffer zu keinem Treffer führte. Beide nehmen die gleichen Argumente an. Befasse dich mal mit der Doku der beiden Methoden und überlege mal, ob dir vielleicht eines der weiteren Argumente nützlich sein könnte.

[SVblue]

DANKE.

Code: Alles auswählen

pos = 0
for p in range(0,2):
    pos = s.find("i", pos)
    p=p+1
    pos=pos+1
print (s[pos:])

Das funktioniert schon... hatte nur gehofft dass es kürzer geht.

[Sirius3]

@SVblue: was soll denn das p=p+1 an dieser Stelle bewirken?
Wenn pos sowieso eins größer sein soll, kannst Du das auch gleich in eine Zeile schreiben.

[snafu]

Ich hätte es wahrscheinlich so gelöst:

Code: Alles auswählen

# -*- coding: utf-8 -*-

def get_fragment(text, character, from_occurence):
    pos = -1
    for num_occurences in range(1, from_occurence + 1):
        try:
            pos = text.index(character, pos + 1)
        except ValueError:
            return ''
    return text[pos + 1:]

def main():
    s = 'Wenn ich nur wüsste wie es geht?'
    print(get_fragment(s, 'i', 2))

if __name__ == '__main__':
    main()

Das Ermitteln der Position des n-ten Vorkommens liesse sich natürlich auch noch als eigene Funktion auslagen.

[ngulam]

ich könnte eine Funktion aus meiner STRING-Krabbelkiste verwenden, welche .split() nutzt

Code: Alles auswählen

# s full string
# c character to find
# n n-th occurrence of character, default: first
def rest_of_string_after_nth_character_occurance(s, c, n = 1):
    #print('search in: %s' % s)
    #print('searching: %s-occurrence of %s' % (n, c))
    parts = s.split(c, n)

    if len(parts) <= n:
        return 'result   : character "%s" not %s-times in string' % (c, n)

    nthpos = len(s) - len(parts[-1]) - len(c)
    
    # strip: not showing blanks
    # return 'result   : ' + s[nthpos+len(c):].strip()
    return  s[nthpos+len(c):].strip()

Funktioniert auch mit Zeichenfolgen (mehr als 1 Zeichen)

[/me]

Ich hätte es wahrscheinlich so gelöst:

Code: Alles auswählen

[...]
    for num_occurences in range(1, from_occurence + 1):
[...]

Hier reicht auch Folgendes:

Code: Alles auswählen

    for _ in range(from_occurence):

[snafu]

Stimmt, denn es kommt nur auf die Anzahl der Iterationen an. Ich weiß jetzt auch nicht mehr, wie ich darauf gekommen bin. War wahrscheinlich ein erster Denkansatz, der noch im späteren Code verblieben ist.

EDIT: Achja, es war vorher eine (unnötige) ``while``-Schleife mit ``break`` und ich hatte da am Ende nochmal getestet, ob alle ``occurences`` durchlaufen wurden. Später kam ich darauf, dass es mittels ``for`` natürlich viel einfacher geht.

[bb1898]

ich könnte eine Funktion aus meiner STRING-Krabbelkiste verwenden, welche .split() nutzt

Code: Alles auswählen

# s full string
# c character to find
# n n-th occurrence of character, default: first
def rest_of_string_after_nth_character_occurance(s, c, n = 1):
    #print('search in: %s' % s)
    #print('searching: %s-occurrence of %s' % (n, c))
    parts = s.split(c, n)

    if len(parts) <= n:
        return 'result   : character "%s" not %s-times in string' % (c, n)

    nthpos = len(s) - len(parts[-1]) - len(c)
    
    # strip: not showing blanks
    # return 'result   : ' + s[nthpos+len(c):].strip()
    return  s[nthpos+len(c):].strip()

Funktioniert auch mit Zeichenfolgen (mehr als 1 Zeichen)

Die Berechnung von nthpos scheint mir unnötig, parts[-1] enthält doch genau das, was gesucht wird.

[ngulam]

parts[-1] enthält doch genau das, was gesucht wird.

Hast recht!
Das war ein Überbleibsel einer Funktion zur Bestimmung der Position des gesuchten Teilstrings.
Danke für die genaue Draufsicht