这是我的看法。。。。

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

我喜欢re，但这是我没有它的解决方案：

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__contains__是“in”运算符使用的方法。基本上与

lambda ch: ch in sep

但在这里更方便。

groupby获取字符串和函数。它使用该函数将字符串分成多个组：每当函数值发生变化时，就会生成一个新的组。因此，sep__contains__正是我们需要的。

groupby返回一个对序列，其中对[0]是我们函数的结果，对[1]是一个组。使用“if not k”，我们筛选出带有分隔符的组（因为sep.__contains__的结果在分隔符上为True）。好了，就这些了-现在我们有一个组序列，每个组都是一个单词（组实际上是一个可迭代的，所以我们使用join将其转换为字符串）。

这个解决方案非常通用，因为它使用一个函数来分隔字符串（您可以根据需要的任何条件进行拆分）。此外，它不创建中间字符串/列表（您可以删除join，因为每个组都是一个迭代器，所以表达式将变得懒惰）

我正在重新熟悉Python，需要同样的东西。findall解决方案可能更好，但我想到了这个：

tokens = [x.strip() for x in data.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中所谓的列表monad。monad背后的想法是，一旦“进入monad”，你就“留在monad”直到有什么东西把你带走。例如，在Haskell中，假设您将python range（n）->[1，2，…，n]函数映射到List上。如果结果是一个List，它将被附加到List中，所以你会得到类似map（range，[3,4,1]）->[0,1,2,0,1,2,3,0]的结果。这被称为map append（或mappend，或类似的东西）。这里的想法是，你已经得到了你正在应用的这个操作（对一个令牌进行拆分），每当你这样做时，你都会将结果加入到列表中。

您可以将其抽象为一个函数，并在默认情况下使用token=string.p标点符号。

这种方法的优点：

这种方法（与基于正则表达式的简单方法不同）可以使用任意长度的令牌（正则表达式也可以使用更高级的语法）。你不仅仅局限于象征；您可以使用任意逻辑来代替每个标记，例如，其中一个“标记”可以是一个函数，该函数根据括号的嵌套程度进行拆分。

另一种方式，不使用正则表达式

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.ttranslate不会生成新字符串。所以它的速度和字符串替换一样快。

不过，这有点尴尬，因为它需要一个翻译表来实现这一魔术。您可以使用maketrans（）方便函数创建转换表。这里的目标是将所有不需要的字符转换为空格。一换一的替代品。同样，不会产生新数据。所以这很快！

接下来，我们使用旧的split（）。默认情况下，split（）将对所有空白字符进行操作，将它们分组以进行拆分。结果将是您想要的单词列表。而且这种方法几乎比re.findall（）快4倍！