มีเวอร์ชันกำเนิดของ `string.split ()` ใน Python หรือไม่

string.split()ส่งคืนอินสแตนซ์รายการ มีรุ่นที่ส่งคืนเครื่องกำเนิดไฟฟ้าแทนหรือไม่? มีเหตุผลใดบ้างที่จะมีรุ่นเครื่องกำเนิดไฟฟ้า?

มีความเป็นไปได้สูงที่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']

แก้ไข:ฉันเพิ่งยืนยันว่าสิ่งนี้ใช้หน่วยความจำคงที่ใน python 3.2.1 โดยถือว่าวิธีการทดสอบของฉันถูกต้อง ฉันสร้างสตริงที่มีขนาดใหญ่มาก (1GB หรือมากกว่านั้น) จากนั้นวนซ้ำผ่านการวนซ้ำด้วยการforวนซ้ำ (ไม่ใช่ความเข้าใจรายการซึ่งจะสร้างหน่วยความจำเพิ่มเติม) สิ่งนี้ไม่ได้ส่งผลให้หน่วยความจำเติบโตขึ้นอย่างเห็นได้ชัด (นั่นคือถ้ามีการเติบโตของหน่วยความจำก็จะน้อยกว่าสตริง 1GB มาก)

วิธีที่มีประสิทธิภาพที่สุดที่ฉันคิดได้คือการเขียนโดยใช้offsetพารามิเตอร์ของstr.find()วิธีการ วิธีนี้หลีกเลี่ยงการใช้หน่วยความจำจำนวนมากและอาศัยค่าใช้จ่ายของ regexp เมื่อไม่จำเป็น

[แก้ไข 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) = 0.8260340550004912
• re.finditer (คำตอบของ Ninjagecko) = 0.698872097000276
• str.find (หนึ่งในคำตอบของ Eli Collins) = 0.7230395330007013
• itertools.takewhile (คำตอบของ Ignacio Vazquez-Abrams) = 2.023023967998597
• str.split(..., maxsplit=1) การเรียกซ้ำ = N / A †

†คำตอบการเรียกซ้ำ ( string.splitมีmaxsplit = 1) ไม่สามารถดำเนินการให้เสร็จสิ้นในเวลาอันสมควรเนื่องจากstring.splitความเร็วของพวกเขาอาจทำงานได้ดีขึ้นกับสตริงที่สั้นกว่า แต่ฉันไม่เห็นกรณีการใช้งานสำหรับสตริงสั้น ๆ ซึ่งหน่วยความจำไม่ใช่ปัญหาอยู่ดี

ทดสอบโดยใช้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 ฟังก์ชันแยกกันสำหรับกรณีต่างๆ

ฉันจะคัดลอก docstring ของ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)

ฟังก์ชั่นนี้ใช้งานได้ใน 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()

ฉันไม่เห็นประโยชน์ที่ชัดเจนสำหรับเวอร์ชันเครื่องกำเนิดไฟฟ้าของ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)

ฉันเขียนคำตอบของ @ 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

โมดูล regex ของ python บอกว่า"สิ่งที่ถูกต้อง"สำหรับช่องว่างยูนิโคด แต่ฉันยังไม่ได้ทดสอบจริงๆ

ยังมีเป็นส่วนสำคัญ

หากคุณต้องการอ่านตัววนซ้ำ (เช่นเดียวกับการส่งกลับ ) ลองสิ่งนี้:

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!']

more_itertools.split_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 เป็นแพ็คเกจของบุคคลที่สาม

ฉันต้องการแสดงวิธีใช้โซลูชัน find_iter เพื่อส่งคืนเครื่องกำเนิดไฟฟ้าสำหรับตัวคั่นที่กำหนดจากนั้นใช้สูตรคู่จาก itertools เพื่อสร้างการทำซ้ำถัดไปก่อนหน้านี้ซึ่งจะได้คำจริงเช่นเดียวกับวิธีการแยกดั้งเดิม

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()])

บันทึก:

1. ฉันใช้ prev & curr แทน prev & next เพราะการแทนที่ next ใน python นั้นเป็นความคิดที่แย่มาก
2. ซึ่งค่อนข้างมีประสิทธิภาพ

วิธีที่โง่ที่สุดโดยไม่ต้อง regex / itertools:

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:]

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

นี่คือคำตอบง่ายๆ

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:]