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

我经常遇到这种情况，我通常的解决方案不需要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函数推广到任何指定的字符串。

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

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

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

试试看：

import re

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

这将打印['Hey'，'you'，'what'，'are'，'you'，'doing'，'here']

首先，我想同意其他人的观点，即基于正则表达式或str.translate（…）的解决方案是最具性能的。对于我的用例，这个函数的性能并不重要，所以我想添加一些我认为符合这个标准的想法。

我的主要目标是将其他一些答案中的想法归纳为一个解决方案，该解决方案可以适用于包含不仅仅是正则表达式单词的字符串（即，将标点符号字符的显式子集列入黑名单，而不是将单词字符列入白名单）。

注意，在任何方法中，也可以考虑使用string.p标点符号代替手动定义的列表。

选项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（…）内部-但如果性能很关键，那么在外部编译正则表达式可能会很有用-对于我的用例来说，差异并不大，所以我更喜欢简单性和可读性。

选项2-str.replace

这是几行，但它的优点是可以扩展，而不必检查是否需要转义正则表达式中的某个字符。

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在全局命名空间中可用，而无需从functools导入。）

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

正则表达式对正的情况：

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，但这是我没有它的解决方案：

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