ฉันคิดว่าสิ่งที่ฉันต้องการทำเป็นงานที่ค่อนข้างธรรมดา แต่ฉันไม่พบข้อมูลอ้างอิงบนเว็บ ฉันมีข้อความที่มีเครื่องหมายวรรคตอนและฉันต้องการรายการคำศัพท์

"Hey, you - what are you doing here!?"

ควรจะเป็น

['hey', 'you', 'what', 'are', 'you', 'doing', 'here']

แต่ Python str.split()ใช้งานได้กับอาร์กิวเมนต์เดียวเท่านั้นดังนั้นฉันจึงมีคำทั้งหมดด้วยเครื่องหมายวรรคตอนหลังจากที่ฉันแยกด้วยช่องว่าง ความคิดใด ๆ

กรณีที่นิพจน์ทั่วไปมีความชอบธรรม:

import re
DATA = "Hey, you - what are you doing here!?"
print re.findall(r"[\w']+", DATA)
# Prints ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

re.split ()

re.split (รูปแบบ, สตริง [, maxsplit = 0])

แยกสตริงด้วยการเกิดขึ้นของรูปแบบ หากมีการใช้วงเล็บในรูปแบบแล้วข้อความของกลุ่มทั้งหมดในรูปแบบจะถูกส่งกลับเป็นส่วนหนึ่งของรายการผลลัพธ์ ถ้า maxsplit ไม่ใช่ศูนย์จะเกิดการแยก maxsplit ส่วนใหญ่และส่วนที่เหลือของสตริงจะถูกส่งกลับเป็นองค์ประกอบสุดท้ายของรายการ (หมายเหตุความเข้ากันไม่ได้: ในรุ่น Python 1.5 ดั้งเดิม maxsplit จะถูกละเว้นซึ่งได้รับการแก้ไขในรุ่นที่ใหม่กว่า)

>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']

อีกวิธีที่รวดเร็วในการทำเช่นนี้โดยไม่มี regexp คือการแทนที่อักขระก่อนดังนี้:

>>> 'a;bcd,ef g'.replace(';',' ').replace(',',' ').split()
['a', 'bcd', 'ef', 'g']

คำตอบมากมาย แต่ฉันไม่สามารถหาวิธีแก้ปัญหาที่มีประสิทธิภาพในสิ่งที่ชื่อของคำถามที่แท้จริงถาม (แยกตัวแยกที่เป็นไปได้หลาย - แทนคำตอบมากมายแยกกับสิ่งที่ไม่ใช่คำซึ่งแตกต่างกัน) ดังนั้นนี่คือคำตอบของคำถามในชื่อเรื่องซึ่งขึ้นอยู่กับreโมดูลมาตรฐานและประสิทธิภาพของ Python :

>>> import re  # Will be splitting on: , <space> - ! ? :
>>> filter(None, re.split("[, \-!?:]+", "Hey, you - what are you doing here!?"))
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

ที่อยู่:

• […]แมตช์หนึ่งของตัวคั่นที่ระบุไว้ภายใน
• \-ในการแสดงออกปกติอยู่ที่นี่เพื่อป้องกันการตีความที่พิเศษของการ-เป็นตัวบ่งชี้ช่วงตัวละคร (ในA-Z)
• +ข้ามหนึ่งหรือมากกว่าตัวคั่น (มันอาจจะถูกมองข้ามขอบคุณfilter()แต่ไม่จำเป็นจะผลิตสตริงว่างระหว่างคั่นจับคู่) และ
• filter(None, …) ลบสตริงว่างที่อาจสร้างขึ้นโดยตัวแยกนำหน้าและต่อท้าย (เนื่องจากสตริงว่างมีค่าบูลีนเท็จ)

นี้ re.split()"แยกด้วยตัวคั่นหลายตัว"อย่างแม่นยำตามที่ถามในชื่อคำถาม

วิธีการแก้ปัญหานี้นอกจากนี้ยังมีภูมิคุ้มกันต่อปัญหาที่เกิดขึ้นกับตัวละครที่ไม่ใช่ ASCII ในคำที่พบในการแก้ปัญหาอื่น ๆ (ดูความคิดเห็นแรกที่คำตอบของ ghostdog74 )

reโมดูลมีประสิทธิภาพมากขึ้น (ในความเร็วและกระชับ) กว่าการทำลูปหลามและการทดสอบ "ด้วยมือ"!

อีกวิธีหนึ่งโดยไม่ต้อง regex

import string
punc = string.punctuation
thestring = "Hey, you - what are you doing here!?"
s = list(thestring)
''.join([o for o in s if not o in punc]).split()

เคล็ดลับ: ใช้string.translateสำหรับการดำเนินการกับสตริงที่เร็วที่สุดที่ Python มี

หลักฐานบางอย่าง ...

ก่อนวิธีที่ช้า (ขออภัย pprzemek):

>>> import timeit
>>> S = 'Hey, you - what are you doing here!?'
>>> def my_split(s, seps):
...     res = [s]
...     for sep in seps:
...         s, res = res, []
...         for seq in s:
...             res += seq.split(sep)
...     return res
... 
>>> timeit.Timer('my_split(S, punctuation)', 'from __main__ import S,my_split; from string import punctuation').timeit()
54.65477919578552

ต่อไปเราใช้re.findall()(ตามที่กำหนดโดยคำตอบที่แนะนำ) เร็วขึ้นมาก:

>>> timeit.Timer('findall(r"\w+", S)', 'from __main__ import S; from re import findall').timeit()
4.194725036621094

ในที่สุดเราใช้translate:

>>> from string import translate,maketrans,punctuation 
>>> T = maketrans(punctuation, ' '*len(punctuation))
>>> timeit.Timer('translate(S, T).split()', 'from __main__ import S,T,translate').timeit()
1.2835021018981934

คำอธิบาย:

string.translate ถูกนำมาใช้ใน C และแตกต่างจากฟังก์ชั่นการจัดการสตริงใน Python string.translate ไม่ได้สร้างสตริงใหม่ ดังนั้นมันเร็วพอที่คุณจะได้รับการแทนที่สตริง

แม้ว่ามันจะค่อนข้างงุ่มง่ามเพราะมันต้องการโต๊ะแปลเพื่อทำเวทย์มนตร์นี้ คุณสามารถสร้างตารางการแปลได้ด้วยmaketrans()ฟังก์ชั่นอำนวยความสะดวก วัตถุประสงค์นี่คือการแปลอักขระที่ไม่ต้องการทั้งหมดเป็นช่องว่าง ตัวแทนแบบหนึ่งต่อหนึ่ง ไม่มีการสร้างข้อมูลใหม่อีกครั้ง ดังนั้นนี่คือรวดเร็ว !

split()ต่อไปเราจะใช้ดีเก่า split()โดยค่าเริ่มต้นจะทำงานกับอักขระช่องว่างทั้งหมดจัดกลุ่มไว้ด้วยกันเพื่อแยก ผลลัพธ์จะเป็นรายการคำที่คุณต้องการ และวิธีนี้เร็วกว่าเกือบ 4x re.findall()!

ฉันมีปัญหาคล้ายกันและไม่ต้องการใช้โมดูล 'อีก'

def my_split(s, seps):
    res = [s]
    for sep in seps:
        s, res = res, []
        for seq in s:
            res += seq.split(sep)
    return res

print my_split('1111  2222 3333;4444,5555;6666', [' ', ';', ','])
['1111', '', '2222', '3333', '4444', '5555', '6666']

ก่อนอื่นฉันต้องการเห็นด้วยกับคนอื่น ๆ ว่า regex หรือstr.translate(...)โซลูชันพื้นฐานนั้นมีประสิทธิภาพมากที่สุด สำหรับกรณีการใช้งานของฉันประสิทธิภาพของฟังก์ชั่นนี้ไม่สำคัญดังนั้นฉันจึงต้องการเพิ่มแนวคิดที่ฉันพิจารณาด้วยเกณฑ์นั้น

เป้าหมายหลักของฉันคือการพูดคุยแนวคิดจากคำตอบอื่น ๆ ในโซลูชันที่สามารถใช้กับสตริงที่มีมากกว่าคำ regex (เช่นบัญชีดำส่วนย่อยที่ชัดเจนของอักขระเครื่องหมายวรรคตอนและตัวอักษรคำที่อนุญาตพิเศษ)

โปรดทราบว่าในวิธีการใดวิธีหนึ่งอาจพิจารณาใช้string.punctuationแทนรายการที่กำหนดด้วยตนเอง

ตัวเลือก 1 - re.sub

ฉันรู้สึกประหลาดใจที่จะเห็นไม่มีคำตอบเพื่อให้ห่างไกลใช้re.sub ( ... ) ฉันพบว่าวิธีนี้เป็นวิธีที่ง่ายและเป็นธรรมชาติสำหรับปัญหานี้

import re

my_str = "Hey, you - what are you doing here!?"

words = re.split(r'\s+', re.sub(r'[,\-!?]', ' ', my_str).strip())

ในโซลูชันนี้ฉันซ้อนการโทรre.sub(...)ภายในre.split(...)- แต่ถ้าประสิทธิภาพมีความสำคัญการรวบรวม regex ภายนอกอาจเป็นประโยชน์ - สำหรับกรณีการใช้งานของฉันความแตกต่างไม่สำคัญดังนั้นฉันชอบความเรียบง่ายและอ่านง่าย

ตัวเลือก 2 - str.replace

นี่เป็นอีกสองสามบรรทัด แต่มีประโยชน์ในการขยายได้โดยไม่ต้องตรวจสอบว่าคุณต้องหลบหนีอักขระบางตัวใน regex

my_str = "Hey, you - what are you doing here!?"

replacements = (',', '-', '!', '?')
for r in replacements:
    my_str = my_str.replace(r, ' ')

words = my_str.split()

มันจะเป็นการดีที่สามารถแมป str.replace กับสตริงแทน แต่ฉันไม่คิดว่ามันจะสามารถทำได้ด้วยสายที่ไม่เปลี่ยนรูปและในขณะที่การแมปกับรายชื่อตัวละครจะใช้งานได้ ฟังดูมากเกินไป (แก้ไข: ดูตัวเลือกถัดไปสำหรับตัวอย่างการทำงาน)

ตัวเลือก 3 - functools.reduce

(ใน Python 2 reduceมีอยู่ในเนมสเปซส่วนกลางโดยไม่ต้องนำเข้าจากฟังก์ชั่นเครื่องมือ)

import functools

my_str = "Hey, you - what are you doing here!?"

replacements = (',', '-', '!', '?')
my_str = functools.reduce(lambda s, sep: s.replace(sep, ' '), replacements, my_str)
words = my_str.split()

join = lambda x: sum(x,[])  # a.k.a. flatten1([[1],[2,3],[4]]) -> [1,2,3,4]
# ...alternatively...
join = lambda lists: [x for l in lists for x in l]

จากนั้นจะกลายเป็นสามซับ:

fragments = [text]
for token in tokens:
    fragments = join(f.split(token) for f in fragments)

คำอธิบาย

นี่คือสิ่งที่อยู่ใน Haskell เรียกว่า List monad แนวคิดเบื้องหลัง monad คือเมื่อ "ใน monad" คุณ "อยู่ใน monad" จนกว่าสิ่งที่จะนำคุณออก ตัวอย่างเช่นใน Haskell สมมติว่าคุณจับคู่range(n) -> [1,2,...,n]ฟังก์ชันpython กับรายการ หากผลลัพธ์นั้นเป็นรายการผลลัพธ์นั้นจะถูกผนวกเข้ากับรายการแบบแทนที่ดังนั้นคุณจะได้รับสิ่งที่ต้องการmap(range, [3,4,1]) -> [0,1,2,0,1,2,3,0]หากผลที่ได้คือรายการมันจะผนวกในรายการในสถานที่เพื่อให้คุณจะได้รับสิ่งที่ต้องการสิ่งนี้เรียกว่า map-append (หรือ mappend หรืออาจเป็นแบบนั้น) แนวคิดที่นี่คือคุณได้รับการดำเนินการที่คุณกำลังใช้ (แยกโทเค็น) และเมื่อใดก็ตามที่คุณทำคุณจะเข้าร่วมผลลัพธ์ในรายการ

คุณสามารถสรุปสิ่งนี้เป็นฟังก์ชั่นและมีtokens=string.punctuationค่าเริ่มต้น

ข้อดีของวิธีนี้:

• วิธีการนี้ (ซึ่งแตกต่างจากวิธีการที่ใช้วิธี regex แบบไร้เดียงสา) สามารถทำงานกับโทเค็นที่มีความยาวโดยพลการ
• คุณไม่ได้ จำกัด เพียงโทเค็นเท่านั้น คุณอาจมีเหตุผลโดยพลการแทนโทเค็นแต่ละตัวตัวอย่างเช่นหนึ่งใน "โทเค็น" อาจเป็นฟังก์ชั่นที่แยกตามลักษณะของวงเล็บที่ซ้อนกัน

ลองนี้:

import re

phrase = "Hey, you - what are you doing here!?"
matches = re.findall('\w+', phrase)
print matches

สิ่งนี้จะพิมพ์ ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

ใช้แทนที่สองครั้ง:

a = '11223FROM33344INTO33222FROM3344'
a.replace('FROM', ',,,').replace('INTO', ',,,').split(',,,')

ผลลัพธ์ใน:

['11223', '33344', '33222', '3344']

ฉันชอบอีกครั้งแต่นี่เป็นวิธีแก้ปัญหาของฉันหากปราศจาก:

from itertools import groupby
sep = ' ,-!?'
s = "Hey, you - what are you doing here!?"
print [''.join(g) for k, g in groupby(s, sep.__contains__) if not k]

sep .__ contain__เป็นวิธีที่ใช้โดยโอเปอเรเตอร์ 'in' โดยทั่วไปมันเป็นเช่นเดียวกับ

lambda ch: ch in sep

แต่สะดวกกว่าที่นี่

groupbyรับค่าสตริงและฟังก์ชันของเรา มันแยกสตริงในกลุ่มโดยใช้ฟังก์ชั่นนั้น: เมื่อใดก็ตามที่มีการเปลี่ยนแปลงค่าของฟังก์ชั่น - กลุ่มใหม่จะถูกสร้างขึ้น ดังนั้นกันยายน .__ contains__คือสิ่งที่เราต้องการ

groupbyส่งคืนลำดับคู่โดยที่ pair [0] เป็นผลลัพธ์ของฟังก์ชันของเราและ pair [1] เป็นกลุ่ม การใช้'if not k'เราจะกรองกลุ่มที่มีตัวคั่น (เนื่องจากผลลัพธ์ของsep .__ contain__เป็น True บนตัวคั่น) ทีนี้นั่นคือทั้งหมด - ตอนนี้เรามีลำดับของกลุ่มที่แต่ละคำเป็นคำ (จริง ๆ แล้วกลุ่มคือ iterable ดังนั้นเราจึงใช้การเข้าร่วมเพื่อแปลงเป็นสตริง)

โซลูชันนี้ค่อนข้างทั่วไปเนื่องจากใช้ฟังก์ชันเพื่อแยกสตริง (คุณสามารถแยกตามเงื่อนไขที่คุณต้องการ) นอกจากนี้มันไม่ได้สร้างสตริง / รายการกลาง (คุณสามารถลบการเข้าร่วมและการแสดงออกจะขี้เกียจเนื่องจากแต่ละกลุ่มเป็นตัววนซ้ำ)

แทนที่จะใช้ฟังก์ชั่นโมดูลใหม่ re.split คุณสามารถบรรลุผลลัพธ์เดียวกันโดยใช้วิธี series.str.split ของแพนด้า

ก่อนอื่นให้สร้างชุดข้อมูลด้วยสตริงด้านบนจากนั้นใช้วิธีการกับชุดข้อมูล

thestring = pd.Series("Hey, you - what are you doing here!?") thestring.str.split(pat = ',|-')

พารามิเตอร์patใช้ตัวคั่นและส่งกลับสตริงการแยกเป็นอาร์เรย์ ที่นี่ตัวคั่นทั้งสองจะถูกส่งผ่านโดยใช้ | (หรือผู้ประกอบการ) ผลลัพธ์จะเป็นดังนี้:

[Hey, you , what are you doing here!?]

ฉันทำความคุ้นเคยกับ Python อีกครั้งและต้องการสิ่งเดียวกัน ทางออกของ findall อาจจะดีกว่า แต่ฉันคิดว่าสิ่งนี้:

tokens = [x.strip() for x in data.split(',')]

การใช้ maketrans และการแปลคุณสามารถทำได้อย่างง่ายดายและเป็นระเบียบ

import string
specials = ',.!?:;"()<>[]#$=-/'
trans = string.maketrans(specials, ' '*len(specials))
body = body.translate(trans)
words = body.strip().split()

ในหลาม 3, คุณสามารถใช้วิธีการจากPY4E - งูใหญ่สำหรับทุกคน

เราสามารถแก้ปัญหาทั้งสองนี้โดยใช้วิธีการสตริงlower, และpunctuation translateวิธีtranslateที่ละเอียดอ่อนที่สุดคือ นี่คือเอกสารสำหรับtranslate:

your_string.translate(your_string.maketrans(fromstr, tostr, deletestr))

แทนที่ตัวอักษรในfromstrด้วยตัวอักษรที่อยู่ในตำแหน่งเดียวกันในและลบตัวอักษรทั้งหมดที่อยู่ในtostr และสามารถเป็นสตริงที่ว่างเปล่าและพารามิเตอร์สามารถละเว้นdeletestrfromstrtostrdeletestr

คุณสามารถดู "เครื่องหมายวรรคตอน":

In [10]: import string

In [11]: string.punctuation
Out[11]: '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'  

สำหรับตัวอย่างของคุณ:

In [12]: your_str = "Hey, you - what are you doing here!?"

In [13]: line = your_str.translate(your_str.maketrans('', '', string.punctuation))

In [14]: line = line.lower()

In [15]: words = line.split()

In [16]: print(words)
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']

สำหรับข้อมูลเพิ่มเติมคุณสามารถดู:

• PY4E - Python สำหรับทุกคน
• str.translate
• str.maketrans
• Python String maketrans () วิธีการ

อีกวิธีหนึ่งในการบรรลุเป้าหมายนี้คือการใช้ชุดเครื่องมือภาษาธรรมชาติ ( nltk )

import nltk
data= "Hey, you - what are you doing here!?"
word_tokens = nltk.tokenize.regexp_tokenize(data, r'\w+')
print word_tokens

ภาพพิมพ์นี้: ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

อุปสรรคที่ใหญ่ที่สุดของวิธีนี้คือการที่คุณต้องติดตั้งแพคเกจ nltk

ประโยชน์คือคุณสามารถทำสิ่งที่สนุกมากมายกับแพคเกจ nltk ที่เหลือเมื่อคุณได้รับโทเค็นของคุณ

ก่อนอื่นฉันไม่คิดว่าความตั้งใจของคุณคือการใช้เครื่องหมายวรรคตอนเป็นตัวคั่นในฟังก์ชันแบบแยก คำอธิบายของคุณแนะนำว่าคุณต้องการกำจัดเครื่องหมายวรรคตอนจากสตริงผลลัพธ์

ฉันเจอสิ่งนี้บ่อยมากและวิธีแก้ปัญหาตามปกติของฉันไม่ต้องการอีก

ฟังก์ชั่นแลมบ์ดาหนึ่งซับพร้อมรายการความเข้าใจ:

(ต้องการimport string):

split_without_punc = lambda text : [word.strip(string.punctuation) for word in 
    text.split() if word.strip(string.punctuation) != '']

# Call function
split_without_punc("Hey, you -- what are you doing?!")
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']

ฟังก์ชั่น (แบบดั้งเดิม)

ในฐานะที่เป็นฟังก์ชั่นแบบดั้งเดิมนี่เป็นเพียงสองบรรทัดที่มี list comprehension (เพิ่มเติมจากimport string):

def split_without_punctuation2(text):

    # Split by whitespace
    words = text.split()

    # Strip punctuation from each word
    return [word.strip(ignore) for word in words if word.strip(ignore) != '']

split_without_punctuation2("Hey, you -- what are you doing?!")
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']

มันจะปล่อยให้คำย่อและยัติภังค์ยังคงเหมือนเดิม คุณสามารถใช้text.replace("-", " ")เพื่อเปลี่ยนยัติภังค์เป็นช่องว่างก่อนที่จะแยก

ฟังก์ชั่นทั่วไปที่ไม่มีแลมบ์ดาหรือรายการความเข้าใจ

สำหรับวิธีแก้ปัญหาทั่วไปเพิ่มเติม (ซึ่งคุณสามารถระบุอักขระที่ต้องการกำจัด) และหากไม่มีความเข้าใจในรายการคุณจะได้รับ:

def split_without(text: str, ignore: str) -> list:

    # Split by whitespace
    split_string = text.split()

    # Strip any characters in the ignore string, and ignore empty strings
    words = []
    for word in split_string:
        word = word.strip(ignore)
        if word != '':
            words.append(word)

    return words

# Situation-specific call to general function
import string
final_text = split_without("Hey, you - what are you doing?!", string.punctuation)
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']

แน่นอนว่าคุณสามารถใช้ฟังก์ชั่นแลมบ์ดากับสตริงอักขระที่ระบุได้เช่นกัน

ก่อนอื่นให้ใช้ re.compile () ก่อนทำการดำเนินการ RegEx ใด ๆ ในการวนซ้ำเนื่องจากมันทำงานได้เร็วกว่าการดำเนินการปกติ

ดังนั้นสำหรับปัญหาของคุณก่อนรวบรวมรูปแบบแล้วดำเนินการกับมัน

import re
DATA = "Hey, you - what are you doing here!?"
reg_tok = re.compile("[\w']+")
print reg_tok.findall(DATA)

นี่คือคำตอบพร้อมคำอธิบายบางอย่าง

st = "Hey, you - what are you doing here!?"

# replace all the non alpha-numeric with space and then join.
new_string = ''.join([x.replace(x, ' ') if not x.isalnum() else x for x in st])
# output of new_string
'Hey  you  what are you doing here  '

# str.split() will remove all the empty string if separator is not provided
new_list = new_string.split()

# output of new_list
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

# we can join it to get a complete string without any non alpha-numeric character
' '.join(new_list)
# output
'Hey you what are you doing'

หรือในหนึ่งบรรทัดเราสามารถทำสิ่งนี้:

(''.join([x.replace(x, ' ') if not x.isalnum() else x for x in st])).split()

# output
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']

คำตอบที่อัปเดต

สร้างฟังก์ชั่นที่รับอินพุตสองสาย (สตริงต้นทางที่จะแยกและสตริงตัวแยกรายการของตัวคั่น) และส่งออกรายการคำแยก:

def split_string(source, splitlist):
    output = []  # output list of cleaned words
    atsplit = True
    for char in source:
        if char in splitlist:
            atsplit = True
        else:
            if atsplit:
                output.append(char)  # append new word after split
                atsplit = False
            else: 
                output[-1] = output[-1] + char  # continue copying characters until next split
    return output

ฉันชอบวิธีแก้ปัญหาของ pprzemek เพราะไม่คิดว่าตัวคั่นเป็นตัวอักษรเดี่ยวและไม่พยายามใช้ประโยชน์จาก regex (ซึ่งจะไม่ทำงานได้ดีถ้าจำนวนตัวคั่นยาวเกินจริง)

นี่เป็นเวอร์ชันที่อ่านได้มากกว่าของโซลูชันด้านบนเพื่อความชัดเจน:

def split_string_on_multiple_separators(input_string, separators):
    buffer = [input_string]
    for sep in separators:
        strings = buffer
        buffer = []  # reset the buffer
        for s in strings:
            buffer = buffer + s.split(sep)

    return buffer

มีปัญหาเช่นเดียวกับ @ooboo และค้นหาหัวข้อนี้ @ ghostdog74 เป็นแรงบันดาลใจให้ฉันบางทีบางคนอาจพบว่าวิธีแก้ปัญหาของฉันมีประโยชน์

str1='adj:sg:nom:m1.m2.m3:pos'
splitat=':.'
''.join([ s if s not in splitat else ' ' for s in str1]).split()

ป้อนข้อมูลบางอย่างในที่ว่างและแยกโดยใช้อักขระเดียวกันหากคุณไม่ต้องการแยกที่เว้นวรรค

นี่คือการแยกของฉันที่มีผู้กระทำความผิดหลายคน:

def msplit( str, delims ):
  w = ''
  for z in str:
    if z not in delims:
        w += z
    else:
        if len(w) > 0 :
            yield w
        w = ''
  if len(w) > 0 :
    yield w

ฉันคิดว่าต่อไปนี้เป็นคำตอบที่ดีที่สุดเพื่อตอบสนองความต้องการของคุณ:

\W+ อาจเหมาะสำหรับกรณีนี้ แต่อาจไม่เหมาะสำหรับกรณีอื่น

filter(None, re.compile('[ |,|\-|!|?]').split( "Hey, you - what are you doing here!?")

นี่ฉันใช้มัน ....

def split_string(source,splitlist):
    splits = frozenset(splitlist)
    l = []
    s1 = ""
    for c in source:
        if c in splits:
            if s1:
                l.append(s1)
                s1 = ""
        else:
            print s1
            s1 = s1 + c
    if s1:
        l.append(s1)
    return l

>>>out = split_string("First Name,Last Name,Street Address,City,State,Zip Code",",")
>>>print out
>>>['First Name', 'Last Name', 'Street Address', 'City', 'State', 'Zip Code']

ฉันชอบreplace()วิธีที่ดีที่สุด โพรซีเดอร์ต่อไปนี้เปลี่ยนตัวคั่นทั้งหมดที่กำหนดในสตริงsplitlistเป็นตัวคั่นแรกในsplitlistจากนั้นแยกข้อความบนตัวคั่นหนึ่งตัวนั้น นอกจากนี้ยังsplitlistคำนึงถึงว่าเป็นสตริงว่างหรือไม่ มันจะส่งคืนรายการคำโดยไม่มีสตริงว่างอยู่

def split_string(text, splitlist):
    for sep in splitlist:
        text = text.replace(sep, splitlist[0])
    return filter(None, text.split(splitlist[0])) if splitlist else [text]

def get_words(s):
    l = []
    w = ''
    for c in s.lower():
        if c in '-!?,. ':
            if w != '': 
                l.append(w)
            w = ''
        else:
            w = w + c
    if w != '': 
        l.append(w)
    return l

นี่คือการใช้งาน:

>>> s = "Hey, you - what are you doing here!?"
>>> print get_words(s)
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']

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

def tokenizeSentence_Reversible(sentence):
    setOfDelimiters = ['.', ' ', ',', '*', ';', '!']
    listOfTokens = [sentence]

    for delimiter in setOfDelimiters:
        newListOfTokens = []
        for ind, token in enumerate(listOfTokens):
            ll = [([delimiter, w] if ind > 0 else [w]) for ind, w in enumerate(token.split(delimiter))]
            listOfTokens = [item for sublist in ll for item in sublist] # flattens.
            listOfTokens = filter(None, listOfTokens) # Removes empty tokens: ''
            newListOfTokens.extend(listOfTokens)

        listOfTokens = newListOfTokens

    return listOfTokens

ฉันเพิ่งต้องการทำสิ่งนี้ แต่ต้องการฟังก์ชั่นที่ค่อนข้างตรงกับstr.splitฟังก์ชั่นไลบรารีมาตรฐานฟังก์ชั่นนี้จะทำงานเหมือนกับไลบรารีมาตรฐานเมื่อถูกเรียกด้วยอาร์กิวเมนต์ 0 หรือ 1

def split_many(string, *separators):
    if len(separators) == 0:
        return string.split()
    if len(separators) > 1:
        table = {
            ord(separator): ord(separator[0])
            for separator in separators
        }
        string = string.translate(table)
    return string.split(separators[0])

หมายเหตุ : ฟังก์ชั่นนี้จะมีประโยชน์ก็ต่อเมื่อตัวแยกของคุณประกอบด้วยอักขระเดียว (เช่นเดียวกับกรณีของฉัน)