blocks|key|2003073|text|我能想到的最有效的方法就是使用str.find()方法的offset参数编写一个。这避免了大量内存使用，并在不需要时依赖于regexp的开销。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2003074|编辑2016-8-2:更新为可选地支持正则表达式分隔符|2003075|def+isplit(source,+sep=None,+regex=False):
++++"""
++++generator+version+of+str.split()

++++:param+source:
++++++++source+string+(unicode+or+bytes)

++++:param+sep:
++++++++separator+to+split+on.

++++:param+regex:
++++++++if+True,+will+treat+sep+as+regular+expression.

++++:returns:
++++++++generator+yielding+elements+of+string.
++++"""
++++if+sep+is+None:
++++++++#+mimic+default+python+behavior
++++++++source+=+source.strip()
++++++++sep+=+"\\s%2B"
++++++++if+isinstance(source,+bytes):
++++++++++++sep+=+sep.encode("ascii")
++++++++regex+=+True
++++if+regex:
++++++++#+version+using+re.finditer()
++++++++if+not+hasattr(sep,+"finditer"):
++++++++++++sep+=+re.compile(sep)
++++++++start+=+0
++++++++for+m+in+sep.finditer(source):
++++++++++++idx+=+m.start()
++++++++++++assert+idx+>=+start
++++++++++++yield+source[start:idx]
++++++++++++start+=+m.end()
++++++++yield+source[start:]
++++else:
++++++++#+version+using+str.find(),+less+overhead+than+re.finditer()
++++++++sepsize+=+len(sep)
++++++++start+=+0
++++++++while+True:
++++++++++++idx+=+source.find(sep,+start)
++++++++++++if+idx+==+-1:
++++++++++++++++yield+source[start:]
++++++++++++++++return
++++++++++++yield+source[start:idx]
++++++++++++start+=+idx+%2B+sepsize|code-block|syntax|javascript|2003076|你可以随心所欲地使用它。|2003077|>>>+print+list(isplit("abcb","b"))
['a','c','']|2003078|虽然每次执行find()或分片时都会在字符串中查找一些开销，但这应该是最小的，因为字符串在内存中表示为连续数组。|2003079|entityMap^0|F|A|S|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

The most efficient way I can think of it to write one using the <code>offset</code> parameter of the <code>str.find()</code> method. This avoids lots of memory use, and relying on the overhead of a regexp when it's not needed. 

[edit 2016-8-2: updated this to optionally support regex separators]

<pre><code>def isplit(source, sep=None, regex=False):
 """
 generator version of str.split()

 :param source:
 source string (unicode or bytes)

 :param sep:
 separator to split on.

 :param regex:
 if True, will treat sep as regular expression.

 :returns:
 generator yielding elements of string.
 """
 if sep is None:
 # mimic default python behavior
 source = source.strip()
 sep = "\\s+"
 if isinstance(source, bytes):
 sep = sep.encode("ascii")
 regex = True
 if regex:
 # version using re.finditer()
 if not hasattr(sep, "finditer"):
 sep = re.compile(sep)
 start = 0
 for m in sep.finditer(source):
 idx = m.start()
 assert idx &gt;= start
 yield source[start:idx]
 start = m.end()
 yield source[start:]
 else:
 # version using str.find(), less overhead than re.finditer()
 sepsize = len(sep)
 start = 0
 while True:
 idx = source.find(sep, start)
 if idx == -1:
 yield source[start:]
 return
 yield source[start:idx]
 start = idx + sepsize
</code></pre>

This can be used like you want...

<pre><code>&gt;&gt;&gt; print list(isplit("abcb","b"))
['a','c','']
</code></pre>

While there is a little bit of cost seeking within the string each time find() or slicing is performed, this should be minimal since strings are represented as continguous arrays in memory.

blocks|key|2003131|text|这是我的实现，它比这里的其他答案快得多，也更完整。它有4个单独的子功能，用于不同的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2003132|我只复制str_split主函数的文档字符串：|offset|length|style|CODE|2003133|2003134|str_split(s,+*delims,+empty=None)|code-block|syntax|javascript|2003135|用其余参数拆分字符串s，可能会省略空部分(empty关键字参数负责此操作)。这是一个生成器函数。|2003136|当只提供一个分隔符时，字符串将被它简单地拆分。然后，默认情况下，empty为True。|2003137|str_split('[]aaa[][]bb[c',+'[]')
++++->+'',+'aaa',+'',+'bb[c'
str_split('[]aaa[][]bb[c',+'[]',+empty=False)
++++->+'aaa',+'bb[c'|2003138|当提供多个分隔符时，默认情况下，字符串按这些分隔符中可能最长的序列拆分，或者，如果empty设置为True，则分隔符之间还包括空字符串。请注意，这种情况下的分隔符只能是单个字符。|2003139|str_split('aaa,+bb+:+c;',+'+',+',',+':',+';')
++++->+'aaa',+'bb',+'c'
str_split('aaa,+bb+:+c;',+*'+,:;',+empty=True)
++++->+'aaa',+'',+'bb',+'',+'',+'c',+''|2003140|如果未提供分隔符，则使用string.whitespace，因此效果与str.split()相同，只是此函数是一个生成器。|2003141|str_split('aaa\\t++bb+c+\\n')
++++->+'aaa',+'bb',+'c'|2003142|2003143|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%2B1
++++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%2Bdlen
++++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%2Bdlen
++++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)|2003144|这个函数可以在Python3中工作，并且可以应用一个简单的，尽管相当丑陋的修复程序，使它在2和3版本中都能工作。该函数的第一行应更改为：|2003145|def+str_split(s,+*delims,+**kwargs):
++++"""...docstring..."""
++++empty+=+kwargs.get('empty')|2003146|entityMap^0|0|4|9|0|0|0|A|1|L|5|0|W|5|12|4|0|0|15|5|1D|4|0|0|C|H|Z|B|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1F|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|1G|8|@$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1L|8|@$D|1M|E|1N|F|G]|$D|1O|E|1P|F|G]]|9|@]|A|$]]|$1|R|3|S|5|K|7|1Q|8|@]|9|@]|A|$L|M]]|$1|T|3|U|5|6|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|V|3|W|5|K|7|1W|8|@]|9|@]|A|$L|M]]|$1|X|3|Y|5|6|7|1X|8|@$D|1Y|E|1Z|F|G]|$D|20|E|21|F|G]]|9|@]|A|$]]|$1|Z|3|10|5|K|7|22|8|@]|9|@]|A|$L|M]]|$1|11|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|12|3|13|5|K|7|24|8|@]|9|@]|A|$L|M]]|$1|14|3|15|5|6|7|25|8|@]|9|@]|A|$]]|$1|16|3|17|5|K|7|26|8|@]|9|@]|A|$L|M]]|$1|18|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|19|$]]

Here is my implementation, which is much, much faster and more complete than the other answers here. It has 4 separate subfunctions for different cases.

I'll just copy the docstring of the main <code>str_split</code> function:

<hr>

<pre><code>str_split(s, *delims, empty=None)
</code></pre>

Split the string <code>s</code> by the rest of the arguments, possibly omitting
empty parts (<code>empty</code> keyword argument is responsible for that).
This is a generator function.

When only one delimiter is supplied, the string is simply split by it.
<code>empty</code> is then <code>True</code> by default.

<pre><code>str_split('[]aaa[][]bb[c', '[]')
 -&gt; '', 'aaa', '', 'bb[c'
str_split('[]aaa[][]bb[c', '[]', empty=False)
 -&gt; 'aaa', 'bb[c'
</code></pre>

When multiple delimiters are supplied, the string is split by longest
possible sequences of those delimiters by default, or, if <code>empty</code> is set to
<code>True</code>, empty strings between the delimiters are also included. Note that
the delimiters in this case may only be single characters.

<pre><code>str_split('aaa, bb : c;', ' ', ',', ':', ';')
 -&gt; 'aaa', 'bb', 'c'
str_split('aaa, bb : c;', *' ,:;', empty=True)
 -&gt; 'aaa', '', 'bb', '', '', 'c', ''
</code></pre>

When no delimiters are supplied, <code>string.whitespace</code> is used, so the effect
is the same as <code>str.split()</code>, except this function is a generator.

<pre><code>str_split('aaa\\t bb c \\n')
 -&gt; 'aaa', 'bb', 'c'
</code></pre>

<hr>

<pre><code>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&lt;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', '[]')
 -&gt; '', 'aaa', '', 'bb[c'
 str_split('[]aaa[][]bb[c', '[]', empty=False)
 -&gt; '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;', ' ', ',', ':', ';')
 -&gt; 'aaa', 'bb', 'c'
 str_split('aaa, bb : c;', *' ,:;', empty=True)
 -&gt; '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')
 -&gt; '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)&gt;=4 else ''.join(delims)
 if any(len(d)&gt;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)
</code></pre>

This function works in Python 3, and an easy, though quite ugly, fix can be applied to make it work in both 2 and 3 versions. The first lines of the function should be changed to:

<pre><code>def str_split(s, *delims, **kwargs):
 """...docstring..."""
 empty = kwargs.get('empty')
</code></pre>

blocks|key|1789501|text|def+split_generator(f,s):
++++"""
++++f+is+a+string,+s+is+the+substring+we+split+on.
++++This+produces+a+generator+rather+than+a+possibly
++++memory+intensive+list.+
++++"""
++++i=0
++++j=0
++++while+j<len(f):
++++++++if+i>=len(f):
++++++++++++yield+f[j:]
++++++++++++j=i
++++++++elif+f[i]+!=+s:
++++++++++++i=i%2B1
++++++++else:
++++++++++++yield+[f[j:i]]
++++++++++++j=i%2B1
++++++++++++i=i%2B1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1789502|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def split_generator(f,s):
 """
 f is a string, s is the substring we split on.
 This produces a generator rather than a possibly
 memory intensive list. 
 """
 i=0
 j=0
 while j&lt;len(f):
 if i&gt;=len(f):
 yield f[j:]
 j=i
 elif f[i] != s:
 i=i+1
 else:
 yield [f[j:i]]
 j=i+1
 i=i+1
</code></pre>

blocks|key|1789594|text|我写了一个@ninjagecko答案的版本，它的行为更像string.split+(即，默认情况下以空格分隔，您可以指定一个分隔符)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1789595|def+isplit(string,+delimiter+=+None):
++++"""Like+string.split+but+returns+an+iterator+(lazy)

++++Multiple+character+delimters+are+not+handled.
++++"""

++++if+delimiter+is+None:
++++++++#+Whitespace+delimited+by+default
++++++++delim+=+r"\s"

++++elif+len(delimiter)+!=+1:
++++++++raise+ValueError("Can+only+handle+single+character+delimiters",
++++++++++++++++++++++++delimiter)

++++else:
++++++++#+Escape,+incase+it's+"\",+"*"+etc.
++++++++delim+=+re.escape(delimiter)

++++return+(x.group(0)+for+x+in+re.finditer(r"[%5E{}]%2B".format(delim),+string))|code-block|syntax|javascript|1789596|下面是我使用的测试(在python3和python2中)：|1789597|#+Wrapper+to+make+it+a+list
def+helper(*args,++**kwargs):
++++return+list(isplit(*args,+**kwargs))

#+Normal+delimiters
assert+helper("1,2,3",+",")+==+["1",+"2",+"3"]
assert+helper("1;2;3,",+";")+==+["1",+"2",+"3,"]
assert+helper("1;2+;3,++",+";")+==+["1",+"2+",+"3,++"]

#+Whitespace
assert+helper("1+2+3")+==+["1",+"2",+"3"]
assert+helper("1\t2\t3")+==+["1",+"2",+"3"]
assert+helper("1\t2+\t3")+==+["1",+"2",+"3"]
assert+helper("1\n2\n3")+==+["1",+"2",+"3"]

#+Surrounding+whitespace+dropped
assert+helper("+1+2++3++")+==+["1",+"2",+"3"]

#+Regex+special+characters
assert+helper(r"1\2\3",+"\\")+==+["1",+"2",+"3"]
assert+helper(r"1*2*3",+"*")+==+["1",+"2",+"3"]

#+No+multi-char+delimiters+allowed
try:
++++helper(r"1,.2,.3",+",.")
++++assert+False
except+ValueError:
++++pass|1789598|python的regex模块说它does+"the+right+thing"+for+unicode空白，但我还没有实际测试过它。|offset|length|1789599|也可以作为gist使用。|1789600|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/re.html|1|https://gist.github.com/davidshepherd7/2857bfc620a648a90e7f^0|0|0|0|0|G|M|0|0|5|4|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@$M|15|N|16|1|17]]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@$M|19|N|1A|1|1B]]|A|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]]]

I wrote a version of @ninjagecko's answer that behaves more like string.split (i.e. whitespace delimited by default and you can specify a delimiter).

<pre><code>def isplit(string, delimiter = None):
 """Like string.split but returns an iterator (lazy)

 Multiple character delimters are not handled.
 """

 if delimiter is None:
 # Whitespace delimited by default
 delim = r"\s"

 elif len(delimiter) != 1:
 raise ValueError("Can only handle single character delimiters",
 delimiter)

 else:
 # Escape, incase it's "\", "*" etc.
 delim = re.escape(delimiter)

 return (x.group(0) for x in re.finditer(r"[^{}]+".format(delim), string))
</code></pre>

Here are the tests I used (in both python 3 and python 2):

<pre><code># Wrapper to make it a list
def helper(*args, **kwargs):
 return list(isplit(*args, **kwargs))

# Normal delimiters
assert helper("1,2,3", ",") == ["1", "2", "3"]
assert helper("1;2;3,", ";") == ["1", "2", "3,"]
assert helper("1;2 ;3, ", ";") == ["1", "2 ", "3, "]

# Whitespace
assert helper("1 2 3") == ["1", "2", "3"]
assert helper("1\t2\t3") == ["1", "2", "3"]
assert helper("1\t2 \t3") == ["1", "2", "3"]
assert helper("1\n2\n3") == ["1", "2", "3"]

# Surrounding whitespace dropped
assert helper(" 1 2 3 ") == ["1", "2", "3"]

# Regex special characters
assert helper(r"1\2\3", "\\") == ["1", "2", "3"]
assert helper(r"1*2*3", "*") == ["1", "2", "3"]

# No multi-char delimiters allowed
try:
 helper(r"1,.2,.3", ",.")
 assert False
except ValueError:
 pass
</code></pre>

python's regex module says that it <a href="https://docs.python.org/3/library/re.html" rel="nofollow">does "the right thing"</a> for unicode whitespace, but I haven't actually tested it.

Also available as a <a href="https://gist.github.com/davidshepherd7/2857bfc620a648a90e7f" rel="nofollow">gist</a>.

blocks|key|1789665|text|如果您还希望能够读取迭代器(以及返回迭代器)，请尝试以下命令：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1789666|import+itertools+as+it

def+iter_split(string,+sep=None):
++++sep+=+sep+or+'+'
++++groups+=+it.groupby(string,+lambda+s:+s+!=+sep)
++++return+(''.join(g)+for+k,+g+in+groups+if+k)|code-block|syntax|javascript|1789667|用法|1789668|>>>+list(iter_split(iter("Good+evening,+world!")))
['Good',+'evening,',+'world!']|1789669|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you would also like to be able to read an iterator (as well as return one) try this:

<pre><code>import itertools as it

def iter_split(string, sep=None):
 sep = sep or ' '
 groups = it.groupby(string, lambda s: s != sep)
 return (''.join(g) for k, g in groups if k)
</code></pre>

Usage

<pre><code>&gt;&gt;&gt; list(iter_split(iter("Good evening, world!")))
['Good', 'evening,', 'world!']
</code></pre>

blocks|key|1789826|text|more_itertools.split_at为迭代器提供了对str.split的模拟。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1789827|>>>+import+more_itertools+as+mit


>>>+list(mit.split_at("abcdcba",+lambda+x:+x+==+"b"))
[['a'],+['c',+'d',+'c'],+['a']]

>>>+"abcdcba".split("b")
['a',+'cdc',+'a']|code-block|syntax|javascript|1789828|more_itertools是一个第三方包。|1789829|entityMap|0|LINK|mutability|MUTABLE|url|https://more-itertools.readthedocs.io/en/latest/api.html#more_itertools.split_at^0|0|N|V|9|0|N|0|0|0|0|E|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<a href="https://more-itertools.readthedocs.io/en/latest/api.html#more_itertools.split_at" rel="nofollow noreferrer"><code>more_itertools.split_at</code></a> offers an analog to <code>str.split</code> for iterators.

<pre><code>&gt;&gt;&gt; import more_itertools as mit


&gt;&gt;&gt; list(mit.split_at("abcdcba", lambda x: x == "b"))
[['a'], ['c', 'd', 'c'], ['a']]

&gt;&gt;&gt; "abcdcba".split("b")
['a', 'cdc', 'a']
</code></pre>

<code>more_itertools</code> is a third-party package.

blocks|key|2003561|text|下面是一个简单的响应|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2003562|def+gen_str(some_string,+sep):
++++j=0
++++guard+=+len(some_string)-1
++++for+i,s+in+enumerate(some_string):
++++++++if+s+==+sep:
+++++++++++yield+some_string[j:i]
+++++++++++j=i%2B1
++++++++elif+i!=guard:
+++++++++++continue
++++++++else:
+++++++++++yield+some_string[j:]|code-block|syntax|javascript|2003563|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

here is a simple response

<pre><code>def gen_str(some_string, sep):
 j=0
 guard = len(some_string)-1
 for i,s in enumerate(some_string):
 if s == sep:
 yield some_string[j:i]
 j=i+1
 elif i!=guard:
 continue
 else:
 yield some_string[j:]
</code></pre>

blocks|key|2003579|text|最愚蠢的方法，没有regex+/+itertools：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2003580|def+isplit(text,+split='\n'):
++++while+text+!=+'':
++++++++end+=+text.find(split)

++++++++if+end+==+-1:
++++++++++++yield+text
++++++++++++text+=+''
++++++++else:
++++++++++++yield+text[:end]
++++++++++++text+=+text[end+%2B+1:]|code-block|syntax|javascript|2003581|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Dumbest method, without regex / itertools:

<pre><code>def isplit(text, split='\n'):
 while text != '':
 end = text.find(split)

 if end == -1:
 yield text
 text = ''
 else:
 yield text[:end]
 text = text[end + 1:]
</code></pre>

blocks|key|1789989|text|这是一个很老的问题，但这是我对高效算法的一点贡献：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1789990|def+str_split(text:+str,+separator:+str)+->+Iterable[str]:
++++i+=+0
++++n+=+len(text)
++++while+i+<=+n:
++++++++j+=+text.find(separator,+i)
++++++++if+j+==+-1:
++++++++++++j+=+n
++++++++yield+text[i:j]
++++++++i+=+j+%2B+1|code-block|syntax|javascript|1789991|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Very old question, but here is my humble contribution with an efficient algorithm:
<pre><code>def str_split(text: str, separator: str) -&gt; Iterable[str]:
 i = 0
 n = len(text)
 while i &lt;= n:
 j = text.find(separator, i)
 if j == -1:
 j = n
 yield text[i:j]
 i = j + 1
</code></pre>

blocks|key|2003687|text|def+isplit(text,+sep=None,+maxsplit=-1):
++++if+not+isinstance(text,+(str,+bytes)):
++++++++raise+TypeError(f"requires+'str'+or+'bytes'+but+received+a+'{type(text).__name__}'")
++++if+sep+in+('',+b''):
++++++++raise+ValueError('empty+separator')

++++if+maxsplit+==+0+or+not+text:
++++++++yield+text
++++++++return

++++regex+=+(
++++++++re.escape(sep)+if+sep+is+not+None
++++++++else+[br'\s%2B',+r'\s%2B'][isinstance(text,+str)]
++++)
++++yield+from+re.split(regex,+text,+maxsplit=max(0,+maxsplit))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2003688|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-py prettyprint-override"><code>def isplit(text, sep=None, maxsplit=-1):
 if not isinstance(text, (str, bytes)):
 raise TypeError(f&quot;requires 'str' or 'bytes' but received a '{type(text).__name__}'&quot;)
 if sep in ('', b''):
 raise ValueError('empty separator')

 if maxsplit == 0 or not text:
 yield text
 return

 regex = (
 re.escape(sep) if sep is not None
 else [br'\s+', r'\s+'][isinstance(text, str)]
 )
 yield from re.split(regex, text, maxsplit=max(0, maxsplit))
</code></pre>

blocks|key|1790041|text|这是一个基于拆分和最大拆分的答案。这不使用递归。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1790042|def+gsplit(todo):
++++chunk=+100
++++while+todo:
++++++++splits+=+todo.split(maxsplit=chunk)
++++++++if+len(splits)+==+chunk:
++++++++++++todo+=+splits.pop()
++++++++else:
++++++++++++todo=None
++++++++for+item+in+splits:
++++++++++++yield+item|code-block|syntax|javascript|1790043|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is an answer that is based on split and maxsplit. This does not use recursion.
<pre><code>def gsplit(todo):
 chunk= 100
 while todo:
 splits = todo.split(maxsplit=chunk)
 if len(splits) == chunk:
 todo = splits.pop()
 else:
 todo=None
 for item in splits:
 yield item
</code></pre>

<a href="http://docs.python.org/library/stdtypes.html#str.split" rel="noreferrer"><code>string.split()</code></a> returns a list instance. Is there a version that returns a <a href="http://docs.python.org/tutorial/classes.html#generators" rel="noreferrer">generator</a> instead? Are there any reasons against having a generator version?

Is there a generator version of `string.split()` in Python?

返回一个列表实例。有没有返回的版本？有什么理由反对使用生成器版本吗？

问Python中有没有`string.split()`的生成器版本？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中有没有`string.split()`的生成器版本？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中有没有`string.split()`的生成器版本？
EN