¿Cómo puedo obtener una cadena después de una subcadena específica?

Por ejemplo, quiero obtener la cadena después "world"demy_string="hello python world , i'm a beginner "

La forma más fácil es probablemente dividir su palabra objetivo

my_string="hello python world , i'm a beginner "
print my_string.split("world",1)[1] 

dividir toma la palabra (o carácter) para dividir y, opcionalmente, un límite para el número de divisiones.

En este ejemplo, divida en "mundo" y limítelo a una sola división.

s1 = "hello python world , i'm a beginner "
s2 = "world"

print s1[s1.index(s2) + len(s2):]

Si desea tratar el caso en el s2que no está presente s1, utilice s1.find(s2)en lugar de index. Si el valor de retorno de esa llamada es -1, entonces s2no está en s1.

Me sorprende que nadie lo haya mencionado partition.

def substring_after(s, delim):
    return s.partition(delim)[2]

En mi humilde opinión, esta solución es más legible que @ arshajii. Aparte de eso, creo que @ arshajii's es el mejor para ser el más rápido: no crea copias / subcadenas innecesarias.

Quieres usar str.partition():

>>> my_string.partition("world")[2]
" , i'm a beginner "

porque esta opción es más rápida que las alternativas .

Tenga en cuenta que esto produce una cadena vacía si falta el delimitador:

>>> my_string.partition("Monty")[2]  # delimiter missing
''

Si desea tener la cadena original, pruebe si el segundo valor devuelto str.partition()no está vacío:

prefix, success, result = my_string.partition(delimiter)
if not success: result = prefix

También puede usar str.split()con un límite de 1:

>>> my_string.split("world", 1)[-1]
" , i'm a beginner "
>>> my_string.split("Monty", 1)[-1]  # delimiter missing
"hello python world , i'm a beginner "

Sin embargo, esta opción es más lenta . Para el mejor de los casos, str.partition()es fácilmente un 15% más rápido en comparación con str.split():

                                missing        first         lower         upper          last
      str.partition(...)[2]:  [3.745 usec]  [0.434 usec]  [1.533 usec]  <3.543 usec>  [4.075 usec]
str.partition(...) and test:   3.793 usec    0.445 usec    1.597 usec    3.208 usec    4.170 usec
      str.split(..., 1)[-1]:  <3.817 usec>  <0.518 usec>  <1.632 usec>  [3.191 usec]  <4.173 usec>
            % best vs worst:         1.9%         16.2%          6.1%          9.9%          2.3%

Esto muestra los tiempos por ejecución con entradas aquí, falta el delimitador (peor de los casos), colocado primero (mejor de los casos), o en la mitad inferior, la mitad superior o la última posición. El tiempo más rápido está marcado con [...]y <...>marca el peor.

La tabla anterior se produce mediante una contrarreloj integral para las tres opciones, que se presenta a continuación. Ejecuté las pruebas en Python 3.7.4 en un modelo 2017 Macbook Pro de 15 "con Intel Core i7 a 2.9 GHz y 16 GB de RAM.

Este script genera oraciones aleatorias con y sin el delimitador seleccionado al azar presente, y si está presente, en diferentes posiciones en la oración generada, ejecuta las pruebas en orden aleatorio con repeticiones (produciendo los resultados más justos que representan los eventos aleatorios del sistema operativo que tienen lugar durante la prueba), y luego imprime una tabla de resultados:

import random
from itertools import product
from operator import itemgetter
from pathlib import Path
from timeit import Timer

setup = "from __main__ import sentence as s, delimiter as d"
tests = {
    "str.partition(...)[2]": "r = s.partition(d)[2]",
    "str.partition(...) and test": (
        "prefix, success, result = s.partition(d)\n"
        "if not success: result = prefix"
    ),
    "str.split(..., 1)[-1]": "r = s.split(d, 1)[-1]",
}

placement = "missing first lower upper last".split()
delimiter_count = 3

wordfile = Path("/usr/dict/words")  # Linux
if not wordfile.exists():
    # macos
    wordfile = Path("/usr/share/dict/words")
words = [w.strip() for w in wordfile.open()]

def gen_sentence(delimiter, where="missing", l=1000):
    """Generate a random sentence of length l

    The delimiter is incorporated according to the value of where:

    "missing": no delimiter
    "first":   delimiter is the first word
    "lower":   delimiter is present in the first half
    "upper":   delimiter is present in the second half
    "last":    delimiter is the last word

    """
    possible = [w for w in words if delimiter not in w]
    sentence = random.choices(possible, k=l)
    half = l // 2
    if where == "first":
        # best case, at the start
        sentence[0] = delimiter
    elif where == "lower":
        # lower half
        sentence[random.randrange(1, half)] = delimiter
    elif where == "upper":
        sentence[random.randrange(half, l)] = delimiter
    elif where == "last":
        sentence[-1] = delimiter
    # else: worst case, no delimiter

    return " ".join(sentence)

delimiters = random.choices(words, k=delimiter_count)
timings = {}
sentences = [
    # where, delimiter, sentence
    (w, d, gen_sentence(d, w)) for d, w in product(delimiters, placement)
]
test_mix = [
    # label, test, where, delimiter sentence
    (*t, *s) for t, s in product(tests.items(), sentences)
]
random.shuffle(test_mix)

for i, (label, test, where, delimiter, sentence) in enumerate(test_mix, 1):
    print(f"\rRunning timed tests, {i:2d}/{len(test_mix)}", end="")
    t = Timer(test, setup)
    number, _ = t.autorange()
    results = t.repeat(5, number)
    # best time for this specific random sentence and placement
    timings.setdefault(
        label, {}
    ).setdefault(
        where, []
    ).append(min(dt / number for dt in results))

print()

scales = [(1.0, 'sec'), (0.001, 'msec'), (1e-06, 'usec'), (1e-09, 'nsec')]
width = max(map(len, timings))
rows = []
bestrow = dict.fromkeys(placement, (float("inf"), None))
worstrow = dict.fromkeys(placement, (float("-inf"), None))

for row, label in enumerate(tests):
    columns = []
    worst = float("-inf")
    for p in placement:
        timing = min(timings[label][p])
        if timing < bestrow[p][0]:
            bestrow[p] = (timing, row)
        if timing > worstrow[p][0]:
            worstrow[p] = (timing, row)
        worst = max(timing, worst)
        columns.append(timing)

    scale, unit = next((s, u) for s, u in scales if worst >= s)
    rows.append(
        [f"{label:>{width}}:", *(f" {c / scale:.3f} {unit} " for c in columns)]
    )

colwidth = max(len(c) for r in rows for c in r[1:])
print(' ' * (width + 1), *(p.center(colwidth) for p in placement), sep="  ")
for r, row in enumerate(rows):
    for c, p in enumerate(placement, 1):
        if bestrow[p][1] == r:
            row[c] = f"[{row[c][1:-1]}]"
        elif worstrow[p][1] == r:
            row[c] = f"<{row[c][1:-1]}>"
    print(*row, sep="  ")

percentages = []
for p in placement:
    best, worst = bestrow[p][0], worstrow[p][0]
    ratio = ((worst - best) / worst)
    percentages.append(f"{ratio:{colwidth - 1}.1%} ")

print("% best vs worst:".rjust(width + 1), *percentages, sep="  ")

Si desea hacer esto usando expresiones regulares, simplemente puede usar un grupo que no captura , para obtener la palabra "mundo" y luego tomar todo después, como así

(?:world).*

La cadena de ejemplo se prueba aquí

Puede usar este paquete llamado "subcadena". Simplemente escriba "pip install substring". Puede obtener la subcadena simplemente mencionando los caracteres / índices iniciales y finales.

Por ejemplo:

import substring

s = substring.substringByChar("abcdefghijklmnop", startChar="d", endChar="n")

print(s)

Salida:

s = defghijklmn

Es una vieja pregunta, pero me enfrenté al mismo escenario, necesito dividir una cadena usando como palabra "bajo", el problema para mí fue que tengo en la misma cadena la palabra de abajo y más abajo.

Lo resolví usando el módulo re de esta manera

import re

string = '...below...as higher prices mean lower demand to be expected. Generally, a high reading is seen as negative (or bearish), while a low reading is seen as positive (or bullish) for the Korean Won.'

use re.split con regex para que coincida con la palabra exacta

stringafterword = re.split('\\blow\\b',string)[-1]
print(stringafterword)
' reading is seen as positive (or bullish) for the Korean Won.'

El código genérico es:

re.split('\\bTHE_WORD_YOU_WANT\\b',string)[-1]

¡Espero que esto pueda ayudar a alguién!

Pruebe este enfoque general:

import re
my_string="hello python world , i'm a beginner "
p = re.compile("world(.*)")
print (p.findall(my_string))

#[" , i'm a beginner "]

En Python 3.9, removeprefixse agrega un nuevo método:

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

• Documentación: https://docs.python.org/3.9/library/stdtypes.html#str.removeprefix
• Anuncio: https://docs.python.org/3.9/whatsnew/3.9.html