मैं सब कुछ पहले कैसे प्राप्त करूंगा: एक स्ट्रिंग पायथन में

Question 1

मैं एक से पहले एक पत्र में सभी अक्षरों को पाने के लिए एक रास्ता तलाश रहा हूं: लेकिन मुझे पता नहीं है कि कहां से शुरू करना है। क्या मैं regex का उपयोग करूंगा? यदि हां, तो कैसे?

string = "Username: How are you today?"

क्या कोई मुझे एक उदाहरण दिखा सकता है कि मैं क्या कर सकता हूं?

Question 2

बस splitफ़ंक्शन का उपयोग करें । यह एक सूची देता है, इसलिए आप पहला तत्व रख सकते हैं:

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

Question 3

का उपयोग कर index:

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

सूचकांक आपको :स्ट्रिंग में स्थिति देगा , फिर आप इसे स्लाइस कर सकते हैं।

यदि आप regex का उपयोग करना चाहते हैं:

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

match स्ट्रिंग की शुरुआत से मेल खाता है।

आप भी उपयोग कर सकते हैं itertools.takewhile

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

Question 4

आप की जरूरत नहीं है regexइस के लिए

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

आप चरित्र splitपर स्ट्रिंग को विभाजित करने के लिए विधि का उपयोग कर सकते हैं':'

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

और [0]स्ट्रिंग का पहला भाग प्राप्त करने के लिए तत्व को बाहर करें

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

Question 5

मैंने पायथन 3.7.0 (आईपीथॉन) के तहत इन विभिन्न टेकनीकों को बेंचमार्क किया है।

TLDR

सबसे तेज़ (जब विभाजित प्रतीक cज्ञात होता है): पूर्व-संकलित रेगेक्स।
सबसे तेज (अन्यथा) 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)

Question 6

विभाजन () बेहतर हो सकता है तो इस उद्देश्य के लिए विभाजित () करें क्योंकि इसमें उन स्थितियों के लिए बेहतर पूर्वानुमान परिणाम हैं जिनके पास आपके पास कोई सीमांकक या अधिक सीमांकक नहीं है।