Trong Python, làm cách nào để tách chuỗi và giữ dấu phân cách?

Đây là cách đơn giản nhất để giải thích điều này. Đây là những gì tôi đang sử dụng:

re.split('\W', 'foo/bar spam\neggs')
-> ['foo', 'bar', 'spam', 'eggs']

Đây là những gì tôi muốn:

someMethod('\W', 'foo/bar spam\neggs')
-> ['foo', '/', 'bar', ' ', 'spam', '\n', 'eggs']

Lý do là tôi muốn tách một chuỗi thành các mã thông báo, thao tác với nó, sau đó đặt nó lại với nhau.

>>> re.split('(\W)', 'foo/bar spam\neggs')
['foo', '/', 'bar', ' ', 'spam', '\n', 'eggs']

Nếu bạn đang chia tách trên dòng mới, sử dụng splitlines(True).

>>> 'line 1\nline 2\nline without newline'.splitlines(True)
['line 1\n', 'line 2\n', 'line without newline']

(Không phải là một giải pháp chung, nhưng thêm vào đây trong trường hợp ai đó đến đây không nhận ra phương pháp này tồn tại.)

Một giải pháp không có regex khác hoạt động tốt trên Python 3

# Split strings and keep separator
test_strings = ['<Hello>', 'Hi', '<Hi> <Planet>', '<', '']

def split_and_keep(s, sep):
   if not s: return [''] # consistent with string.split()

   # Find replacement character that is not used in string
   # i.e. just use the highest available character plus one
   # Note: This fails if ord(max(s)) = 0x10FFFF (ValueError)
   p=chr(ord(max(s))+1) 

   return s.replace(sep, sep+p).split(p)

for s in test_strings:
   print(split_and_keep(s, '<'))


# If the unicode limit is reached it will fail explicitly
unicode_max_char = chr(1114111)
ridiculous_string = '<Hello>'+unicode_max_char+'<World>'
print(split_and_keep(ridiculous_string, '<'))

Nếu bạn chỉ có 1 dấu phân cách, bạn có thể sử dụng mức hiểu danh sách:

text = 'foo,bar,baz,qux'  
sep = ','

Bổ sung / chuẩn bị phân tách:

result = [x+sep for x in text.split(sep)]
#['foo,', 'bar,', 'baz,', 'qux,']
# to get rid of trailing
result[-1] = result[-1].strip(sep)
#['foo,', 'bar,', 'baz,', 'qux']

result = [sep+x for x in text.split(sep)]
#[',foo', ',bar', ',baz', ',qux']
# to get rid of trailing
result[0] = result[0].strip(sep)
#['foo', ',bar', ',baz', ',qux']

Dấu tách là phần tử riêng của nó:

result = [u for x in text.split(sep) for u in (x, sep)]
#['foo', ',', 'bar', ',', 'baz', ',', 'qux', ',']
results = result[:-1]   # to get rid of trailing

một ví dụ khác, phân tách trên không phải là số và giữ dấu phân cách

import re
a = "foo,bar@candy*ice%cream"
re.split('([^a-zA-Z0-9])',a)

đầu ra:

['foo', ',', 'bar', '@', 'candy', '*', 'ice', '%', 'cream']

giải trình

re.split('([^a-zA-Z0-9])',a)

() <- keep the separators
[] <- match everything in between
^a-zA-Z0-9 <-except alphabets, upper/lower and numbers.

Bạn cũng có thể chia một chuỗi bằng một chuỗi các chuỗi thay vì một biểu thức thông thường, như thế này:

def tokenizeString(aString, separators):
    #separators is an array of strings that are being used to split the the string.
    #sort separators in order of descending length
    separators.sort(key=len)
    listToReturn = []
    i = 0
    while i < len(aString):
        theSeparator = ""
        for current in separators:
            if current == aString[i:i+len(current)]:
                theSeparator = current
        if theSeparator != "":
            listToReturn += [theSeparator]
            i = i + len(theSeparator)
        else:
            if listToReturn == []:
                listToReturn = [""]
            if(listToReturn[-1] in separators):
                listToReturn += [""]
            listToReturn[-1] += aString[i]
            i += 1
    return listToReturn


print(tokenizeString(aString = "\"\"\"hi\"\"\" hello + world += (1*2+3/5) '''hi'''", separators = ["'''", '+=', '+', "/", "*", "\\'", '\\"', "-=", "-", " ", '"""', "(", ")"]))

# This keeps all separators  in result 
##########################################################################
import re
st="%%(c+dd+e+f-1523)%%7"
sh=re.compile('[\+\-//\*\<\>\%\(\)]')

def splitStringFull(sh, st):
   ls=sh.split(st)
   lo=[]
   start=0
   for l in ls:
     if not l : continue
     k=st.find(l)
     llen=len(l)
     if k> start:
       tmp= st[start:k]
       lo.append(tmp)
       lo.append(l)
       start = k + llen
     else:
       lo.append(l)
       start =llen
   return lo
  #############################

li= splitStringFull(sh , st)
['%%(', 'c', '+', 'dd', '+', 'e', '+', 'f', '-', '1523', ')%%', '7']

Một giải pháp đơn giản và lười biếng

Giả sử mô hình regex của bạn là split_pattern = r'(!|\?)'

Đầu tiên, bạn thêm một số ký tự giống như dấu phân cách mới, như '[cut]'

new_string = re.sub(split_pattern, '\\1[cut]', your_string)

Sau đó, bạn tách dấu phân cách mới, new_string.split('[cut]')

Nếu ai đó muốn tách chuỗi trong khi giữ dấu phân cách bằng regex mà không bắt nhóm:

def finditer_with_separators(regex, s):
    matches = []
    prev_end = 0
    for match in regex.finditer(s):
        match_start = match.start()
        if (prev_end != 0 or match_start > 0) and match_start != prev_end:
            matches.append(s[prev_end:match.start()])
        matches.append(match.group())
        prev_end = match.end()
    if prev_end < len(s):
        matches.append(s[prev_end:])
    return matches

regex = re.compile(r"[\(\)]")
matches = finditer_with_separators(regex, s)

Nếu một người giả định rằng regex được gói vào nhóm bắt giữ:

def split_with_separators(regex, s):
    matches = list(filter(None, regex.split(s)))
    return matches

regex = re.compile(r"([\(\)])")
matches = split_with_separators(regex, s)

Cả hai cách cũng sẽ loại bỏ các nhóm trống vô dụng và gây phiền nhiễu trong hầu hết các trường hợp.

Đây là một .splitgiải pháp đơn giản hoạt động mà không cần regex.

Đây là một câu trả lời cho Python split () mà không xóa dấu phân cách , vì vậy không chính xác những gì bài đăng gốc yêu cầu nhưng câu hỏi khác đã được đóng lại như một bản sao cho bài này.

def splitkeep(s, delimiter):
    split = s.split(delimiter)
    return [substr + delimiter for substr in split[:-1]] + [split[-1]]

Các xét nghiệm ngẫu nhiên:

import random

CHARS = [".", "a", "b", "c"]
assert splitkeep("", "X") == [""]  # 0 length test
for delimiter in ('.', '..'):
    for idx in range(100000):
        length = random.randint(1, 50)
        s = "".join(random.choice(CHARS) for _ in range(length))
        assert "".join(splitkeep(s, delimiter)) == s

Tôi gặp vấn đề tương tự khi cố gắng tách một đường dẫn tệp và đấu tranh để tìm một câu trả lời đơn giản. Điều này làm việc cho tôi và không liên quan đến việc phải thay thế các dấu phân cách trở lại văn bản phân tách:

my_path = 'folder1/folder2/folder3/file1'

import re

re.findall('[^/]+/|[^/]+', my_path)

trả về:

['folder1/', 'folder2/', 'folder3/', 'file1']

Tôi tìm thấy cách tiếp cận dựa trên máy phát điện này thỏa mãn hơn:

def split_keep(string, sep):
    """Usage:
    >>> list(split_keep("a.b.c.d", "."))
    ['a.', 'b.', 'c.', 'd']
    """
    start = 0
    while True:
        end = string.find(sep, start) + 1
        if end == 0:
            break
        yield string[start:end]
        start = end
    yield string[start:]

Nó tránh sự cần thiết phải tìm ra regex chính xác, trong khi về lý thuyết nên khá rẻ. Nó không tạo ra các đối tượng chuỗi mới và, hầu hết các công việc lặp lại cho phương thức tìm hiệu quả.

... và trong Python 3.8, nó có thể ngắn như:

def split_keep(string, sep):
    start = 0
    while (end := string.find(sep, start) + 1) > 0:
        yield string[start:end]
        start = end
    yield string[start:]

1. thay thế tất cả seperator: (\W)bằngseperator + new_seperator: (\W;)

2. chia theo new_seperator: (;)

def split_and_keep(seperator, s):
  return re.split(';', re.sub(seperator, lambda match: match.group() + ';', s))

print('\W', 'foo/bar spam\neggs')