专业提示：使用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倍！

我认为以下是满足您需求的最佳答案：

\W+可能适合这种情况，但可能不适合其他情况。

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

re.split（）

re.split（模式，字符串[，maxsplit=0]）按模式的出现次数拆分字符串。如果模式中使用了捕获括号，那么模式中所有组的文本也会作为结果列表的一部分返回。如果maxsplit为非零，则最多发生maxsplit拆分，字符串的剩余部分将作为列表的最后一个元素返回。（不兼容注意：在最初的Python1.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.']

我最近需要这样做，但需要一个与标准库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])

注意：此函数仅在分隔符由单个字符组成时有用（正如我的用例）。

首先，我不认为您的意图是在拆分函数中实际使用标点符号作为分隔符。您的描述表明您只是想从生成的字符串中删除标点符号。

我经常遇到这种情况，我通常的解决方案不需要re。

单行lambda函数，带列表理解：

（需要导入字符串）：

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

功能（传统）

作为传统函数，这仍然只有两行具有列表理解（除了导入字符串）：

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（“-”，“”）在拆分前将连字符转换为空格。

不带Lambda或列表理解的通用函数

对于更一般的解决方案（可以指定要删除的字符），并且不需要列表理解，您可以得到：

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

当然，您也可以将lambda函数推广到任何指定的字符串。

我喜欢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，因为每个组都是一个迭代器，所以表达式将变得懒惰）