문자열 Python에서 a: 앞에 모든 것을 가져오려면 어떻게 해야 합니까?

문자열 Python에서 a: 앞에 모든 것을 가져오려면 어떻게 해야 합니까?

a: 앞에 있는 문자열의 모든 문자를 가져올 방법을 찾고 있습니다. 하지만 어디서부터 시작해야 할지 모르겠습니다.정규식을 사용할까요?만약 그렇다면, 어떻게?

string = "Username: How are you today?"

누가 제가 무엇을 할 수 있는지 예를 보여주실 수 있나요?

사용하기만 하면 됩니다.split기능.첫 번째 요소를 유지할 수 있도록 목록을 반환합니다.

>>> s1.split(':')
['Username', ' How are you today?']
>>> s1.split(':')[0]
'Username'

사용.index:

>>> string = "Username: How are you today?"
>>> string[:string.index(":")]
'Username'

인덱스는 다음 위치를 제공합니다.:줄로 묶은 다음, 당신은 그것을 자를 수 있습니다.

정규식을 사용하려는 경우:

>>> import re
>>> re.match("(.*?):",string).group()
'Username'                       

match문자열의 시작 부분부터 일치합니다.

사용할 수도 있습니다.itertools.takewhile

>>> import itertools
>>> "".join(itertools.takewhile(lambda x: x!=":", string))
'Username'

필요없습니다regex이 때문에

>>> s = "Username: How are you today?"

사용할 수 있습니다.split에서 문자열을 분할하는 방법':'성격

>>> s.split(':')
['Username', ' How are you today?']

그리고 요소를 잘라냅니다.[0]현의 첫 부분을 따다

>>> s.split(':')[0]
'Username'

저는 Python 3.7.0(IPython)에서 이러한 다양한 기술을 벤치마킹했습니다.

TLDR

• fastest(분할 기호일 때)cknown): 정규식 이전입니다.
• 가장 빠른(속도): s.partition(c)[0].
• 안전한(즉, 언제)c없을 수도 있음s): 파티션, 분할.
• 안전하지 않음: 인덱스, 정규식.

코드

import string, random, re

SYMBOLS = string.ascii_uppercase + string.digits
SIZE = 100

def create_test_set(string_length):
    for _ in range(SIZE):
        random_string = ''.join(random.choices(SYMBOLS, k=string_length))
        yield (random.choice(random_string), random_string)

for string_length in (2**4, 2**8, 2**16, 2**32):
    print("\nString length:", string_length)
    print("  regex (compiled):", end=" ")
    test_set_for_regex = ((re.compile("(.*?)" + c).match, s) for (c, s) in test_set)
    %timeit [re_match(s).group() for (re_match, s) in test_set_for_regex]
    test_set = list(create_test_set(16))
    print("  partition:       ", end=" ")
    %timeit [s.partition(c)[0] for (c, s) in test_set]
    print("  index:           ", end=" ")
    %timeit [s[:s.index(c)] for (c, s) in test_set]
    print("  split (limited): ", end=" ")
    %timeit [s.split(c, 1)[0] for (c, s) in test_set]
    print("  split:           ", end=" ")
    %timeit [s.split(c)[0] for (c, s) in test_set]
    print("  regex:           ", end=" ")
    %timeit [re.match("(.*?)" + c, s).group() for (c, s) in test_set]

결과.

String length: 16
  regex (compiled): 156 ns ± 4.41 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        19.3 µs ± 430 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  index:            26.1 µs ± 341 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  26.8 µs ± 1.26 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            26.3 µs ± 835 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            128 µs ± 4.02 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

String length: 256
  regex (compiled): 167 ns ± 2.7 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        20.9 µs ± 694 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  index:            28.6 µs ± 2.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  27.4 µs ± 979 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            31.5 µs ± 4.86 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            148 µs ± 7.05 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

String length: 65536
  regex (compiled): 173 ns ± 3.95 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        20.9 µs ± 613 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  index:            27.7 µs ± 515 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  27.2 µs ± 796 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            26.5 µs ± 377 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            128 µs ± 1.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

String length: 4294967296
  regex (compiled): 165 ns ± 1.2 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  partition:        19.9 µs ± 144 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
  index:            27.7 µs ± 571 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split (limited):  26.1 µs ± 472 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  split:            28.1 µs ± 1.69 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
  regex:            137 µs ± 6.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

구분 기호가 없거나 더 많은 구분 기호가 없는 상황에서 더 나은 예측 가능한 결과를 얻을 수 있기 때문에 이 목적을 위해 partition("분할보다 더 나은")을 사용할 수 있습니다.

RegEx를 사용하여 이 문제를 해결하려면 부정적인 미리 보기/부정적인 미리 보기 접근법을 사용할 수 있습니다.

예를 들어, 아래의 Python용 코드는 다음과 같습니다.

import re
string = "Username: How are you today?"
regex='(\S*)[:]'

data=re.findall(regex, string)
print(data)

언급URL : https://stackoverflow.com/questions/27387415/how-would-i-get-everything-before-a-in-a-string-python