cum pot obține un șir de caractere după un anumit subșir .
De exemplu vreau pentru a obține șirul de dupa "lume" " în " my_string="buna ziua python lume , am'm un incepator "
Cel mai simplu mod este, probabil, doar pentru a împărți pe cuvânt țintă
my_string="hello python world , i'm a beginner "
print my_string.split("world",1)[1]
split ia cuvântul(sau caracter) spre split și, opțional, o limită a numărului de fisuri.
În acest exemplu split pe "lume" și de a limita la un singur split.
s1 = "hello python world , i'm a beginner "
s2 = "world"
print s1[s1.index(s2) + len(s2):]
Dacă doriți să se ocupe de cazul în care " s2 "este nu prezente în "s1", apoi utilizați s1.găsi(s2)
ca opus la "index". Dacă valoarea returnată de apelul este -1
, apoi " s2 "nu este în "s1".
Am'm-a surprins nimeni nu a pomenit de partiție`.
def substring_after(s, delim):
return s.partition(delim)[2]
IMHO, această soluție este mai ușor de citit decât @arshajii's. Altele decât că, eu cred ca @arshajii's este cel mai bun pentru a fi cel mai rapid ... a nu crea orice inutile copii/siruri de caractere.
Dacă doriți pentru a face acest lucru, folosind regex, ai putea pur și simplu utilizați un non-captarea group, pentru a obține cuvântul "lume" și apoi apuca tot ce a urmat după, așa
(?:world).*
De exemplu șirul este testat aici
Doriți să utilizați str.partiție()
:
>>> my_string.partition("world")[2]
" , i'm a beginner "
pentru că această opțiune este mai repede decât alternativele. Rețineți că aceasta produce un șir gol dacă delimitatorul lipsește:
>>> my_string.partition("Monty")[2] # delimiter missing
''
Dacă doriți să aveți șirul inițial, apoi testați dacă doua valoarea returnată de la str.partiție()` este non-gol:
prefix, success, result = my_string.partition(delimiter)
if not success: result = prefix
Ai putea folosi, de asemenea, str.split()
, cu o limită 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 "
Cu toate acestea, această opțiune este lent. Pentru cel mai bun scenariu, str.partiție()
este ușor despre 15% mai repede în comparație cu str.split()
:
nimic lipsesc în primul rând inferior superior ultima str.partiție(...)[2]: [3.745 usec] [0.434 usec] [1.533 usec] <3.543 usec> [4.075 usec] str.partiție(...) și 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> % cel mai bun vs rău: 1.9% 16.2% 6.1% 9.9% 2.3% `` Acest lucru arată timpii *pe de execuție* cu intrări aici delimitatorul este fie dispărut (cel mai rău caz), a plasat pe primul loc (în cel mai bun caz), sau, în cel mai mic de jumătate, jumătate de sus sau ultima poziție. Cel mai rapid timp este marcat cu [ ... ] " și " <...>
marchează mai rău.
Tabelul de mai sus este produs de un amplu proces de timp pentru toate cele trei opțiuni, produsă de mai jos. Am făcut testele pe Python 3.7.4 pe o 2017 model 15" Macbook Pro cu 2.9 GHz Intel Core i7 si 16 GB ram.
Acest script generează aleator exemple cu și fără selectate aleatoriu delimitator prezent, și dacă sunt prezente, în diferite poziții în generat propoziție, ruleaza testele în ordine aleatorie, cu repetări (care produc cea mai frumoasă rezultatele contabile pentru aleatorii OS evenimente care au loc în timpul testării), apoi imprimă un tabel de rezultate:
``python
import random
din itertools produs de import
de la operatorul de import itemgetter
din pathlib import Calea
din datănu import Timer
setup = "din principal import propoziție ca s, delimitator ca d"
teste = {
"str.partiție(...)[2]": "r = s.partitia(d)[2]",
"str.partiție(...) și de testare": (
"prefix, de succes, rezultatul = s.partitia(d)\n"
"dacă nu de succes: rezultat = prefix"
),
"str.split(..., 1)[-1]": "r = s.split(d, 1)[-1]",
}
plasament = "lipsește în primul rând inferior superior ultima".split()
delimiter_count = 3
wordfile = Calea("/usr / share/dict/cuvinte") # Linux
dacă nu wordfile.există():
wordfile = Calea("/usr/share/dict/cuvinte") cuvinte = [w.strip() pentru w în wordfile.open()] def gen_sentence(delimitator, unde="lipsă", l=1000): """de a Genera o întâmplare teză de lungime l Delimitatorul este încorporată în funcție de valoarea în cazul în care: "lipsă": nu există delimitator "primul": delimitator este primul cuvânt "mai": delimitator este prezent în prima jumătate a anului "sus": delimitator este prezent în a doua jumătate "ultima": delimitator este ultimul cuvânt """ posibil = [w pentru w în cuvinte, dacă delimitatorul nu în w] sentința = aleatoare.alegeri(posibil, k=l) jumătate = l // 2 in cazul in care a == "primul":
teză[0] = delimitator elif unde == "mai":
teză[aleatoare.randrange(1, jumătate)] = delimitator elif unde == "sus": teză[aleatoare.randrange(jumătate, l)] = delimitator elif unde == "ultima": teză[-1] = delimitator
întoarcere " ".alăturați-vă(teză) delimitatori = aleatoare.alegeri(cuvinte, k=delimiter_count) timpii = {} exemple = [
(w, d, gen_sentence(d, w)) pentru d, w în produs(delimitatori, de plasament) ] test_mix = [
(t, s) pentru t, s în produs(teste.elemente(), exemple) ] aleatoare.shuffle(test_mix) pentru că eu, (eticheta, de testare, în cazul în care, delimitator, propoziție) în a enumera(test_mix, 1): print(f"\rRunning teste cronometrate, {i:2d}/{len(testmix)}", end="") t = Timer(testare, configurare) numărul, = t.aranjarea automată() rezultate = t.repet(5, număr)
timpii.setdefault( eticheta, {} ).setdefault( unde, [] ).append(min(dt / numărul pentru dt în rezultate)) print() scale = [(1.0, 'sec'), (0.001, 'msec'), (1e-06, 'usec'), (1e-09, 'nsec')] width = max(map(len, timpii)) rânduri = [] bestrow = dict.fromkeys(plasament, (float("inf"), Nici unul)) worstrow = dict.fromkeys(plasament, (float("-inf"), Nici unul)) de rând, eticheta in enumera(teste): coloane = [] mai rău = float("-inf") pentru p în plasament: calendarul = min(timpii[etichetă][p]) dacă timing < bestrow[p][0]: bestrow[p] = (sincronizare, rând) dacă timing > worstrow[p][0]: worstrow[p] = (sincronizare, rând) mai rău = max(sincronizare, mai rău) coloane.append(calendarul) scară, unitate = next((s, u) pentru s, u în cântare daca mai rău >= s) rânduri.append( [f"{etichetă:>{width}}:", (f" {c / scara:.3f} {unitate} " pentru c în coloane)] ) colwidth = max(len(c) pentru r în rânduri pentru c în r[1:]) print(' ' (lățime + 1), (p.centru(colwidth) pentru p în plasament), sep=" ") pentru r, rând din enumera(rânduri): pentru c, p în a enumera(plasament, 1): dacă bestrow[p][1] == r: rând[c] = f"[{rând[c][1:-1]}]" elif worstrow[p][1] == r: rând[c] = f"<{rând[c][1:-1]}>" print(rând, sep=" ") procentele = [] pentru p în plasament: cel mai bun, cel mai rău = bestrow[p][0], worstrow[p][0] raport = ((cel mai rău - cel mai bun) / cel mai rău) procentele.append(f"{raport:{colwidth - 1}.1%} ") de imprimare("% cel mai bun vs rău:".rjust(lățime + 1), *procente, sep=" ") ``
L's o veche întrebare, dar m-am confruntat cu o foarte același scenariu, trebuie să împartă un șir de caractere folosind ca demiliter cuvântul "low" problema pentru mine a fost că am în același șir cuvântul de mai jos și mai jos.
Am rezolvat-o folosind re modulul de acest fel
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.'
utilizarea re.split cu regex pentru a se potrivi exact cuvântul
stringafterword = re.split('\\blow\\b',string)[-1]
print(stringafterword)
' reading is seen as positive (or bullish) for the Korean Won.'
generic cod este:
re.split('\\bTHE_WORD_YOU_WANT\\b',string)[-1]
Sper că acest lucru poate ajuta pe cineva!
Puteți utiliza acest pachet numit "subșir". Trebuie doar să tastați "pip instala subșir". Puteți obține subșirul de menționat doar începutul și sfârșitul caractere/indici.
De exemplu:
import substring
s = substring.substringByChar("abcdefghijklmnop", startChar="d", endChar="n")
print(s)
Ieșire: