यहाँ मेरा कार्यान्वयन है, जो कि, अन्य उत्तरों की तुलना में बहुत अधिक तेज और अधिक पूर्ण है। इसमें अलग-अलग मामलों के लिए 4 अलग उपखंड हैं।
मैं सिर्फ मुख्य str_splitसमारोह के डॉकस्ट्रिंग की नकल करूँगा :
str_split(s, *delims, empty=None)
sशेष तर्कों द्वारा स्ट्रिंग को विभाजित करें , संभवतः खाली भागों को छोड़ना ( emptyकीवर्ड तर्क इसके लिए जिम्मेदार है)। यह एक जनरेटर फ़ंक्शन है।
जब केवल एक सीमांकक की आपूर्ति की जाती है, तो स्ट्रिंग को इसके द्वारा विभाजित किया जाता है।
emptyफिर Trueडिफ़ॉल्ट रूप से है।
str_split('[]aaa[][]bb[c', '[]')
-> '', 'aaa', '', 'bb[c'
str_split('[]aaa[][]bb[c', '[]', empty=False)
-> 'aaa', 'bb[c'
जब कई सीमांकक की आपूर्ति की जाती है, तो स्ट्रिंग को डिफ़ॉल्ट रूप से उन सीमांकक के सबसे लंबे संभव अनुक्रमों द्वारा विभाजित किया जाता है, या, यदि emptyसेट किया जाता है
True, तो सीमांकक के बीच खाली तार भी शामिल होते हैं। ध्यान दें कि इस मामले में सीमांकक केवल एकल वर्ण हो सकते हैं।
str_split('aaa, bb : c;', ' ', ',', ':', ';')
-> 'aaa', 'bb', 'c'
str_split('aaa, bb : c;', *' ,:;', empty=True)
-> 'aaa', '', 'bb', '', '', 'c', ''
जब कोई सीमांकक की आपूर्ति नहीं की जाती string.whitespaceहै, तो इसका उपयोग किया जाता है, इसलिए इसका प्रभाव वैसा ही होता है, जैसे कि str.split()यह फ़ंक्शन एक जनरेटर है।
str_split('aaa\\t bb c \\n')
-> 'aaa', 'bb', 'c'
import string
def _str_split_chars(s, delims):
"Split the string `s` by characters contained in `delims`, including the \
empty parts between two consecutive delimiters"
start = 0
for i, c in enumerate(s):
if c in delims:
yield s[start:i]
start = i+1
yield s[start:]
def _str_split_chars_ne(s, delims):
"Split the string `s` by longest possible sequences of characters \
contained in `delims`"
start = 0
in_s = False
for i, c in enumerate(s):
if c in delims:
if in_s:
yield s[start:i]
in_s = False
else:
if not in_s:
in_s = True
start = i
if in_s:
yield s[start:]
def _str_split_word(s, delim):
"Split the string `s` by the string `delim`"
dlen = len(delim)
start = 0
try:
while True:
i = s.index(delim, start)
yield s[start:i]
start = i+dlen
except ValueError:
pass
yield s[start:]
def _str_split_word_ne(s, delim):
"Split the string `s` by the string `delim`, not including empty parts \
between two consecutive delimiters"
dlen = len(delim)
start = 0
try:
while True:
i = s.index(delim, start)
if start!=i:
yield s[start:i]
start = i+dlen
except ValueError:
pass
if start<len(s):
yield s[start:]
def str_split(s, *delims, empty=None):
"""\
Split the string `s` by the rest of the arguments, possibly omitting
empty parts (`empty` keyword argument is responsible for that).
This is a generator function.
When only one delimiter is supplied, the string is simply split by it.
`empty` is then `True` by default.
str_split('[]aaa[][]bb[c', '[]')
-> '', 'aaa', '', 'bb[c'
str_split('[]aaa[][]bb[c', '[]', empty=False)
-> 'aaa', 'bb[c'
When multiple delimiters are supplied, the string is split by longest
possible sequences of those delimiters by default, or, if `empty` is set to
`True`, empty strings between the delimiters are also included. Note that
the delimiters in this case may only be single characters.
str_split('aaa, bb : c;', ' ', ',', ':', ';')
-> 'aaa', 'bb', 'c'
str_split('aaa, bb : c;', *' ,:;', empty=True)
-> 'aaa', '', 'bb', '', '', 'c', ''
When no delimiters are supplied, `string.whitespace` is used, so the effect
is the same as `str.split()`, except this function is a generator.
str_split('aaa\\t bb c \\n')
-> 'aaa', 'bb', 'c'
"""
if len(delims)==1:
f = _str_split_word if empty is None or empty else _str_split_word_ne
return f(s, delims[0])
if len(delims)==0:
delims = string.whitespace
delims = set(delims) if len(delims)>=4 else ''.join(delims)
if any(len(d)>1 for d in delims):
raise ValueError("Only 1-character multiple delimiters are supported")
f = _str_split_chars if empty else _str_split_chars_ne
return f(s, delims)
यह फ़ंक्शन पायथन 3 में काम करता है, और एक आसान, हालांकि काफी बदसूरत है, इसे 2 और 3 दोनों संस्करणों में काम करने के लिए फिक्स लागू किया जा सकता है। फ़ंक्शन की पहली पंक्तियों को निम्न में बदलना चाहिए:
def str_split(s, *delims, **kwargs):
"""...docstring..."""
empty = kwargs.get('empty')