Pythonに `string.split（）`のジェネレータバージョンはありますか？
string.split() は、listインスタンスを返します。代わりに generator を返すバージョンはありますか？ジェネレーターバージョンを使用することに理由はありますか？
re.finditer 使用するメモリオーバーヘッドはごくわずかです。
def split_iter(string):
return (x.group(0) for x in re.finditer(r"[A-Za-z']+", string))
デモ：
>>> list( split_iter("A programmer's RegEx test.") )
['A', "programmer's", 'RegEx', 'test']
edit：これは、テスト方法が正しいと仮定して、これがpython 3.2.1 。非常に大きなサイズ（1GB程度）の文字列を作成し、forループでイテレート可能オブジェクトを反復処理しました（リストの内包表記ではなく、余分なメモリが生成されていました）。メモリの増加（つまり、メモリが増加した場合、1GBの文字列よりもはるかに少なかった）。
str.find()メソッドのoffsetパラメーターを使用して記述する最も効率的な方法です。これにより、大量のメモリ使用が回避され、不要な場合は正規表現のオーバーヘッドに依存します。
[2016-8-2を編集：オプションで正規表現の区切り文字をサポートするように更新]
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 >= 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
これはあなたが望むように使用することができます...
>>> print list(isplit("abcb","b"))
['a','c','']
Find（）またはスライシングが実行されるたびに文字列内で少しのコストシークがありますが、文字列はメモリ内の連続した配列として表されるため、これは最小限に抑える必要があります。
これはsplit()のジェネレーターバージョンであり、re.search()を介して実装され、サブストリングの割り当てが多すぎるという問題はありません。
import re
def itersplit(s, sep=None):
exp = re.compile(r'\s+' if sep is None else re.escape(sep))
pos = 0
while True:
m = exp.search(s, pos)
if not m:
if pos < len(s) or sep is not None:
yield s[pos:]
break
if pos < m.start() or sep is not None:
yield s[pos:m.start()]
pos = m.end()
sample1 = "Good evening, world!"
sample2 = " Good evening, world! "
sample3 = "brackets][all][][over][here"
sample4 = "][brackets][all][][over][here]["
assert list(itersplit(sample1)) == sample1.split()
assert list(itersplit(sample2)) == sample2.split()
assert list(itersplit(sample3, '][')) == sample3.split('][')
assert list(itersplit(sample4, '][')) == sample4.split('][')
編集：区切り文字が指定されていない場合の周囲の空白の処理を修正しました。
提案されたさまざまな方法でパフォーマンステストを行いました（ここでは繰り返しません）。いくつかの結果：
- _
str.split_（デフォルト= 0.3461570239996945 - 手動検索（文字による）（Dave Webbの回答の1つ）= 0.8260340550004912
- _
re.finditer_（ninjageckoの答え）= 0.698872097000276 - _
str.find_（Eli Collinsの回答の1つ）= 0.7230395330007013 - _
itertools.takewhile_（Ignacio Vazquez-Abramsの答え）= 2.023023967998597 str.split(..., maxsplit=1)recursion = N/A†
†再帰応答（_string.split_と_maxsplit = 1_）は、_string.split_ sの速度を考えると、妥当な時間内に完了することができません。とにかくメモリが問題にならない短い文字列のユースケースを参照してください。
timeitを使用してテスト：
_the_text = "100 " * 9999 + "100"
def test_function( method ):
def fn( ):
total = 0
for x in method( the_text ):
total += int( x )
return total
return fn
_これにより、メモリ使用量にもかかわらず_string.split_が非常に高速である理由について別の疑問が生じます。
ここに私の実装がありますが、これは他の回答よりもはるかに高速で完全です。さまざまなケースに対応する4つのサブ機能があります。
メインの_str_split_関数のdocstringをコピーするだけです：
_str_split(s, *delims, empty=None)
_文字列sを残りの引数で分割し、空の部分を省略します（emptyキーワード引数がその責任を負います）。これはジェネレーター関数です。
区切り文字が1つだけ指定されている場合、文字列はそれによって単純に分割されます。 emptyは、デフォルトではTrueになります。
_str_split('[]aaa[][]bb[c', '[]')
-> '', 'aaa', '', 'bb[c'
str_split('[]aaa[][]bb[c', '[]', empty=False)
-> 'aaa', 'bb[c'
_複数の区切り文字が指定されている場合、文字列はデフォルトでそれらの区切り文字の可能な限り長いシーケンスで分割されます。または、emptyがTrueに設定されている場合、区切り文字間の空の文字列も含まれます。この場合の区切り文字は1文字のみであることに注意してください。
_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)
_この関数はPython 3で動作し、非常にいものの簡単な修正を適用して2と3の両方のバージョンで動作させることができます。関数の最初の行を次のように変更する必要があります：
_def str_split(s, *delims, **kwargs):
"""...docstring..."""
empty = kwargs.get('empty')
_いいえ。ただし、 itertools.takewhile() を使用して簡単に記述できます。
編集：
非常にシンプルで中途半端な実装：
import itertools
import string
def isplitwords(s):
i = iter(s)
while True:
r = []
for c in itertools.takewhile(lambda x: not x in string.whitespace, i):
r.append(c)
else:
if r:
yield ''.join(r)
continue
else:
raise StopIteration()
readイテレータ（およびreturn one）もできるようにしたい場合は、これを試してください：
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)
使用法
>>> list(iter_split(iter("Good evening, world!")))
['Good', 'evening,', 'world!']
@ninjageckoの答えのバージョンを作成しました。これは、string.splitのように動作します（つまり、デフォルトで空白で区切られ、区切り文字を指定できます）。
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))
私が使用したテストは次のとおりです（python 3とpython 2）の両方で：
# 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
pythonの正規表現モジュールは、ユニコードの空白に対して "正しいこと" と言いますが、実際にはテストしていません。
Gist としても利用できます。
ジェネレーターバージョンのsplit()には明らかな利点はありません。ジェネレーターオブジェクトには、反復処理する文字列全体を含める必要があるため、ジェネレーターを使用してメモリを節約することはありません。
あなたがそれを書きたいなら、それはかなり簡単でしょう：
import string
def gsplit(s,sep=string.whitespace):
Word = []
for c in s:
if c in sep:
if Word:
yield "".join(Word)
Word = []
else:
Word.append(c)
if Word:
yield "".join(Word)
Find_iterソリューションを使用して特定の区切り文字のジェネレーターを返し、itertoolsのペアワイズレシピを使用して、元のsplitメソッドのように実際の単語を取得する前の次の反復を作成する方法を示したかったのです。
from more_itertools import pairwise
import re
string = "dasdha hasud hasuid hsuia dhsuai dhasiu dhaui d"
delimiter = " "
# split according to the given delimiter including segments beginning at the beginning and ending at the end
for prev, curr in pairwise(re.finditer("^|[{0}]+|$".format(delimiter), string)):
print(string[prev.end(): curr.start()])
注意：
- pythonでnextをオーバーライドするのは非常に悪い考えなので、prev＆nextの代わりにprev＆currを使用します
- これは非常に効率的です
more_itertools.spit_at は、str.splitイテレータ用。
>>> 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']
more_itertoolsはサードパーティのパッケージです。
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+1
else:
yield [f[j:i]]
j=i+1
i=i+1