这是一篇自我回答的帖子。下面我将概述NLP领域中的一个常见问题，并提出几种有效的解决方法。
在文本清洗和预处理过程中，经常需要删除标点符号。标点符号被定义为string.punctuation中的任何字符：
>>> import string
string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
这是一个很常见的问题，并且已经被反复问过。最惯用的解决方案使用pandas str.replace。然而，当涉及到大量文本的情况时，可能需要考虑更高效的解决方案。
在处理数十万条记录时，有哪些好的、高性能的str.replace替代方案呢？
为了演示的目的，让我们考虑这个数据框。
df = pd.DataFrame({'text':['a..b?!??', '%hgh&12','abc123!!!', '$$$1234']})
df
text
0 a..b?!??
1 %hgh&12
2 abc123!!!
3 $$$1234
以下按性能递增的顺序逐一列出备选方案:
str.replace此选项用于将默认方法设为基准，以比较其他更高效的解决方法。
此方法使用 pandas 内置的 str.replace 函数来执行基于正则表达式的替换。
df['text'] = df['text'].str.replace(r'[^\w\s]+', '')
df
text
0 ab
1 hgh12
2 abc123
3 1234
这段代码非常容易编写，而且还很易读，但是运行速度较慢。
regex.sub使用re库中的sub函数，预编译正则表达式模式以提高性能，并在列表推导式内调用regex.sub。如果可以节省一些内存，请先将df['text']转换为列表，这样您就可以获得小型性能提升。
import re
p = re.compile(r'[^\w\s]+')
df['text'] = [p.sub('', x) for x in df['text'].tolist()]
df
text
0 ab
1 hgh12
2 abc123
3 1234
注意：如果您的数据中包含NaN值，那么这个方法（以及下面介绍的方法）将无法使用。请参阅“其他注意事项”部分。
str.translatePython的str.translate函数是用C实现的，因此非常快速。
它的工作原理如下：
str.translate，删除标点符号（从步骤1中排除的分隔符）。在这个例子中，我们考虑管道分隔符|。如果您的数据包含管道，则必须选择另一个分隔符。
import string
punct = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{}~' # `|` is not present here
transtab = str.maketrans(dict.fromkeys(punct, ''))
df['text'] = '|'.join(df['text'].tolist()).translate(transtab).split('|')
df
text
0 ab
1 hgh12
2 abc123
3 1234
str.translate 的性能是最好的。需要注意的是下面的图表还包括了另一种变体 Series.str.translate，出自于MaxU 的答案。
(有趣的是，我第二次重新运行时，结果与之前稍有不同。在第二次运行期间，似乎对于非常少量数据，re.sub 胜过了 str.translate。)
使用 translate 存在固有的风险（特别是自动化决定使用哪个分隔符的问题并不容易），但是这种折衷是值得冒险的。
使用列表推导式方法处理 NaNs； 需要注意的是，此方法（和下一个方法）只适用于您的数据没有NaNs的情况。当处理NaNs时，您需要确定非null值的索引并仅替换这些值。尝试像这样：
df = pd.DataFrame({'text': [
'a..b?!??', np.nan, '%hgh&12','abc123!!!', '$$$1234', np.nan]})
idx = np.flatnonzero(df['text'].notna())
col_idx = df.columns.get_loc('text')
df.iloc[idx,col_idx] = [
p.sub('', x) for x in df.iloc[idx,col_idx].tolist()]
df
text
0 ab
1 NaN
2 hgh12
3 abc123
4 1234
5 NaN
处理数据框：如果你正在处理包含需要替换每个列的数据框，那么程序很简单：
v = pd.Series(df.values.ravel())
df[:] = translate(v).values.reshape(df.shape)
或者，
v = df.stack()
v[:] = translate(v)
df = v.unstack()
translate函数在基准测试代码中定义。每种解决方案都有取舍，因此选择最适合您需求的解决方案将取决于您愿意牺牲什么。两个非常常见的考虑因素是性能（我们已经看到了）和内存使用情况。str.translate是一种占用内存较多的解决方案，因此请谨慎使用。另一个考虑因素是正则表达式的复杂性。有时，您可能想删除任何非字母数字或空格的内容。其他情况下，您需要保留某些字符，例如连字符、冒号和句子终止符[.!?]。明确指定这些字符会增加正则表达式的复杂度，这可能会影响这些解决方案的性能。确保在使用之前在自己的数据上进行测试并决定使用什么。最后，这种解决方案将删除Unicode字符。如果使用基于正则表达式的解决方案，则可能需要微调正则表达式，否则可以使用str.translate。对于更大的N，要获得更高的性能，请查看Paul Panzer的答案。附录：函数。def pd_replace(df):
return df.assign(text=df['text'].str.replace(r'[^\w\s]+', ''))
def re_sub(df):
p = re.compile(r'[^\w\s]+')
return df.assign(text=[p.sub('', x) for x in df['text'].tolist()])
def translate(df):
punct = string.punctuation.replace('|', '')
transtab = str.maketrans(dict.fromkeys(punct, ''))
return df.assign(
text='|'.join(df['text'].tolist()).translate(transtab).split('|')
)
# MaxU's version (https://dev59.com/YlUL5IYBdhLWcg3wYHHD#50444659)
def pd_translate(df):
punct = string.punctuation.replace('|', '')
transtab = str.maketrans(dict.fromkeys(punct, ''))
return df.assign(text=df['text'].str.translate(transtab))
性能基准测试代码
from timeit import timeit
import pandas as pd
import matplotlib.pyplot as plt
res = pd.DataFrame(
index=['pd_replace', 're_sub', 'translate', 'pd_translate'],
columns=[10, 50, 100, 500, 1000, 5000, 10000, 50000],
dtype=float
)
for f in res.index:
for c in res.columns:
l = ['a..b?!??', '%hgh&12','abc123!!!', '$$$1234'] * c
df = pd.DataFrame({'text' : l})
stmt = '{}(df)'.format(f)
setp = 'from __main__ import df, {}'.format(f)
res.at[f, c] = timeit(stmt, setp, number=30)
ax = res.div(res.min()).T.plot(loglog=True)
ax.set_xlabel("N");
ax.set_ylabel("time (relative)");
plt.show()
基本策略其实很简单。Unicode字符只有0x110000个不同的。由于挑战是关于大数据集的，因此制作一个查找表格是非常值得的，该表格在我们想要保留的字符ID处具有True，而在必须去掉的字符ID处具有False，例如我们示例中的标点符号。
这样的查找表格可以用于使用numpy的高级索引进行批量查找。由于查找是完全向量化的，并且基本上相当于解除引用指针数组，因此它比例如字典查找快得多。在这里，我们利用了numpy视图转换，它允许将Unicode字符重新解释为整数，基本上是免费的。
使用仅包含一个巨大字符串的数据数组来索引查找表格，结果是一个布尔掩码。然后可以使用此掩码来过滤掉不需要的字符。使用布尔索引，这也是一行代码。
到目前为止很简单。棘手的部分是将巨大字符串切成其各个部分。如果我们有一个分隔符，即在数据或标点符号列表中不存在的一个字符，则仍然很容易。使用此字符进行连接和重新分割。但是，自动查找分隔符是具有挑战性的，并且实现中的一半代码行数都用于此。
或者，我们可以将分割点保存在一个单独的数据结构中，跟踪它们因删除不需要的字符而移动，然后使用它们来切割处理过的字符串。由于将其分割成长度不均匀的部分并不是numpy的强项，因此这种方法比str.split慢，并且仅在分隔符如果存在的话计算起来太昂贵时才用作回退方法。
代码（时间/绘图基于@COLDSPEED的帖子）：
import numpy as np
import pandas as pd
import string
import re
spct = np.array([string.punctuation]).view(np.int32)
lookup = np.zeros((0x110000,), dtype=bool)
lookup[spct] = True
invlookup = ~lookup
OSEP = spct[0]
SEP = chr(OSEP)
while SEP in string.punctuation:
OSEP = np.random.randint(0, 0x110000)
SEP = chr(OSEP)
def find_sep_2(letters):
letters = np.array([letters]).view(np.int32)
msk = invlookup.copy()
msk[letters] = False
sep = msk.argmax()
if not msk[sep]:
return None
return sep
def find_sep(letters, sep=0x88000):
letters = np.array([letters]).view(np.int32)
cmp = np.sign(sep-letters)
cmpf = np.sign(sep-spct)
if cmp.sum() + cmpf.sum() >= 1:
left, right, gs = sep+1, 0x110000, -1
else:
left, right, gs = 0, sep, 1
idx, = np.where(cmp == gs)
idxf, = np.where(cmpf == gs)
sep = (left + right) // 2
while True:
cmp = np.sign(sep-letters[idx])
cmpf = np.sign(sep-spct[idxf])
if cmp.all() and cmpf.all():
return sep
if cmp.sum() + cmpf.sum() >= (left & 1 == right & 1):
left, sep, gs = sep+1, (right + sep) // 2, -1
else:
right, sep, gs = sep, (left + sep) // 2, 1
idx = idx[cmp == gs]
idxf = idxf[cmpf == gs]
def np_multi_strat(df):
L = df['text'].tolist()
all_ = ''.join(L)
sep = 0x088000
if chr(sep) in all_: # very unlikely ...
if len(all_) >= 0x110000: # fall back to separator-less method
# (finding separator too expensive)
LL = np.array((0, *map(len, L)))
LLL = LL.cumsum()
all_ = np.array([all_]).view(np.int32)
pnct = invlookup[all_]
NL = np.add.reduceat(pnct, LLL[:-1])
NLL = np.concatenate([[0], NL.cumsum()]).tolist()
all_ = all_[pnct]
all_ = all_.view(f'U{all_.size}').item(0)
return df.assign(text=[all_[NLL[i]:NLL[i+1]]
for i in range(len(NLL)-1)])
elif len(all_) >= 0x22000: # use mask
sep = find_sep_2(all_)
else: # use bisection
sep = find_sep(all_)
all_ = np.array([chr(sep).join(L)]).view(np.int32)
pnct = invlookup[all_]
all_ = all_[pnct]
all_ = all_.view(f'U{all_.size}').item(0)
return df.assign(text=all_.split(chr(sep)))
def pd_replace(df):
return df.assign(text=df['text'].str.replace(r'[^\w\s]+', ''))
p = re.compile(r'[^\w\s]+')
def re_sub(df):
return df.assign(text=[p.sub('', x) for x in df['text'].tolist()])
punct = string.punctuation.replace(SEP, '')
transtab = str.maketrans(dict.fromkeys(punct, ''))
def translate(df):
return df.assign(
text=SEP.join(df['text'].tolist()).translate(transtab).split(SEP)
)
# MaxU's version (https://dev59.com/YlUL5IYBdhLWcg3wYHHD#50444659)
def pd_translate(df):
return df.assign(text=df['text'].str.translate(transtab))
from timeit import timeit
import pandas as pd
import matplotlib.pyplot as plt
res = pd.DataFrame(
index=['translate', 'pd_replace', 're_sub', 'pd_translate', 'np_multi_strat'],
columns=[10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000,
1000000],
dtype=float
)
for c in res.columns:
if c >= 100000: # stress test the separator finder
all_ = np.r_[:OSEP, OSEP+1:0x110000].repeat(c//10000)
np.random.shuffle(all_)
split = np.arange(c-1) + \
np.sort(np.random.randint(0, len(all_) - c + 2, (c-1,)))
l = [x.view(f'U{x.size}').item(0) for x in np.split(all_, split)]
else:
l = ['a..b?!??', '%hgh&12','abc123!!!', '$$$1234'] * c
df = pd.DataFrame({'text' : l})
for f in res.index:
if f == res.index[0]:
ref = globals()[f](df).text
elif not (ref == globals()[f](df).text).all():
res.at[f, c] = np.nan
print(f, 'disagrees at', c)
continue
stmt = '{}(df)'.format(f)
setp = 'from __main__ import df, {}'.format(f)
res.at[f, c] = timeit(stmt, setp, number=16)
ax = res.div(res.min()).T.plot(loglog=True)
ax.set_xlabel("N");
ax.set_ylabel("time (relative)");
plt.show()
有趣的是，向量化的 Series.str.translate 方法与原始的 Python str.translate() 方法相比仍然稍微慢一些：
def pd_translate(df):
return df.assign(text=df['text'].str.translate(transtab))
apply。我需要制作一个自定义的标点符号列表，所以我使用了下面的代码，并用string.punctuation替换了我的标点符号列表。import string
def remove_punctuation(text):
return text.translate(str.maketrans('', '', string.punctuation))
df["new_col_name"] = df["col_name"].apply(remove_punctuation)