从Python中的字符串中删除除字母数字字符之外的所有内容

问题描述 投票：0回答：16

使用 Python 从字符串中删除所有非字母数字字符的最佳方法是什么？

这个问题的 PHP 变体中提出的解决方案可能需要一些小的调整，但对我来说似乎不太“Pythonic”。

郑重声明，我不仅想删除句号和逗号（以及其他标点符号），还想删除引号、括号等。

python string non-alphanumeric
16个回答
453
投票

我只是出于好奇而对一些功能进行了计时。在这些测试中，我从字符串 

string.printable
（内置 
string
模块的一部分）中删除非字母数字字符。发现使用编译的 
'[\W_]+'
和 
pattern.sub('', str)
速度最快。

$ python -m timeit -s \
     "import string" \
     "''.join(ch for ch in string.printable if ch.isalnum())" 
10000 loops, best of 3: 57.6 usec per loop

$ python -m timeit -s \
    "import string" \
    "filter(str.isalnum, string.printable)"                 
10000 loops, best of 3: 37.9 usec per loop

$ python -m timeit -s \
    "import re, string" \
    "re.sub('[\W_]', '', string.printable)"
10000 loops, best of 3: 27.5 usec per loop

$ python -m timeit -s \
    "import re, string" \
    "re.sub('[\W_]+', '', string.printable)"                
100000 loops, best of 3: 15 usec per loop

$ python -m timeit -s \
    "import re, string; pattern = re.compile('[\W_]+')" \
    "pattern.sub('', string.printable)" 
100000 loops, best of 3: 11.2 usec per loop
377
投票

正则表达式的救援：

import re
re.sub(r'\W+', '', your_string)

根据 Python 定义 

'\W
== 
[^a-zA-Z0-9_]
，排除所有 
numbers
、
letters
和 
_

80
投票

使用

str.translate()
方法。

假设您会经常这样做：

  1. 创建一个包含您要删除的所有字符的字符串：

    delchars = ''.join(c for c in map(chr, range(256)) if not c.isalnum())

  2. 每当你想捏紧一根绳子时：

    scrunched = s.translate(None, delchars)

设置成本可能与 

re.compile
相当；边际成本要低得多：

C:\junk>\python26\python -mtimeit -s"import string;d=''.join(c for c in map(chr,range(256)) if not c.isalnum());s=string.printable" "s.translate(None,d)"
100000 loops, best of 3: 2.04 usec per loop

C:\junk>\python26\python -mtimeit -s"import re,string;s=string.printable;r=re.compile(r'[\W_]+')" "r.sub('',s)"
100000 loops, best of 3: 7.34 usec per loop

注：使用 

string.printable
作为基准数据，给模式 
'[\W_]+'
带来了不公平的优势；所有非字母数字字符都在一堆......在典型数据中，需要进行不止一次替换：

C:\junk>\python26\python -c "import string; s = string.printable; print len(s),repr(s)"
100 '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

如果您给

re.sub
多做一些工作，会发生以下情况：

C:\junk>\python26\python -mtimeit -s"d=''.join(c for c in map(chr,range(256)) if not c.isalnum());s='foo-'*25" "s.translate(None,d)"
1000000 loops, best of 3: 1.97 usec per loop

C:\junk>\python26\python -mtimeit -s"import re;s='foo-'*25;r=re.compile(r'[\W_]+')" "r.sub('',s)"
10000 loops, best of 3: 26.4 usec per loop
70
投票

你可以尝试：

print ''.join(ch for ch in some_string if ch.isalnum())
17
投票
>>> import re
>>> string = "Kl13@£$%[};'\""
>>> pattern = re.compile('\W')
>>> string = re.sub(pattern, '', string)
>>> print string
Kl13
16
投票

怎么样：

def ExtractAlphanumeric(InputString):
    from string import ascii_letters, digits
    return "".join([ch for ch in InputString if ch in (ascii_letters + digits)])

如果这些字符出现在组合的 

InputString
和 
ascii_letters
字符串中，则使用列表理解来生成 
digits
中的字符列表。然后它将列表连接成一个字符串。

11
投票

我用 perfplot（我的一个项目）检查了结果，发现

pattern = re.compile("[\W_]")
pattern.sub("", s)

最快。对于短弦，

"".join(filter(str.isalnum, s))

也可以接受。

重现情节的代码：

import perfplot
import random
import re
import string

pattern = re.compile("[\W_]")
pattern_plus = re.compile("[\W_]+")


def setup(n):
    return "".join(random.choices(string.ascii_letters + string.digits, k=n))


def string_alphanum(s):
    return "".join(ch for ch in s if ch.isalnum())


def filter_str(s):
    return "".join(filter(str.isalnum, s))


def re_sub(s):
    return re.sub("[\W_]", "", s)


def re_sub_pattern(s):
    return pattern.sub("", s)


def re_sub_plus(s):
    return re.sub("[\W_]+", "", s)


def re_sub_pattern_plus(s):
    return pattern_plus.sub("", s)


b = perfplot.bench(
    setup=setup,
    kernels=[
        string_alphanum,
        filter_str,
        re_sub,
        re_sub_pattern,
        re_sub_plus,
        re_sub_pattern_plus,
    ],
    n_range=[2**k for k in range(15)],
)
b.save("out.png")
b.show()
8
投票
sent = "".join(e for e in sent if e.isalpha())
7
投票

作为此处其他一些答案的衍生，我提供了一种非常简单且灵活的方法来定义您想要将字符串内容限制为的一组字符。在这种情况下，我允许使用字母数字加破折号和下划线。只需根据您的用例从我的 

PERMITTED_CHARS
添加或删除字符即可。 

PERMITTED_CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-" 
someString = "".join(c for c in someString if c in PERMITTED_CHARS)
7
投票

使用 ASCII 可打印的随机字符串进行计时：

from inspect import getsource
from random import sample
import re
from string import printable
from timeit import timeit

pattern_single = re.compile(r'[\W]')
pattern_repeat = re.compile(r'[\W]+')
translation_tb = str.maketrans('', '', ''.join(c for c in map(chr, range(256)) if not c.isalnum()))


def generate_test_string(length):
    return ''.join(sample(printable, length))


def main():
    for i in range(0, 60, 10):
        for test in [
            lambda: ''.join(c for c in generate_test_string(i) if c.isalnum()),
            lambda: ''.join(filter(str.isalnum, generate_test_string(i))),
            lambda: re.sub(r'[\W]', '', generate_test_string(i)),
            lambda: re.sub(r'[\W]+', '', generate_test_string(i)),
            lambda: pattern_single.sub('', generate_test_string(i)),
            lambda: pattern_repeat.sub('', generate_test_string(i)),
            lambda: generate_test_string(i).translate(translation_tb),

        ]:
            print(timeit(test), i, getsource(test).lstrip('            lambda: ').rstrip(',\n'), sep='\t')


if __name__ == '__main__':
    main()

结果（Python 3.7）：

       Time       Length                           Code                           
6.3716264850008880  00  ''.join(c for c in generate_test_string(i) if c.isalnum())
5.7285426190064750  00  ''.join(filter(str.isalnum, generate_test_string(i)))
8.1875841680011940  00  re.sub(r'[\W]', '', generate_test_string(i))
8.0002205439959650  00  re.sub(r'[\W]+', '', generate_test_string(i))
5.5290945199958510  00  pattern_single.sub('', generate_test_string(i))
5.4417179649972240  00  pattern_repeat.sub('', generate_test_string(i))
4.6772285089973590  00  generate_test_string(i).translate(translation_tb)
23.574712151996210  10  ''.join(c for c in generate_test_string(i) if c.isalnum())
22.829975890002970  10  ''.join(filter(str.isalnum, generate_test_string(i)))
27.210196289997840  10  re.sub(r'[\W]', '', generate_test_string(i))
27.203713296003116  10  re.sub(r'[\W]+', '', generate_test_string(i))
24.008979928999906  10  pattern_single.sub('', generate_test_string(i))
23.945240008994006  10  pattern_repeat.sub('', generate_test_string(i))
21.830899796994345  10  generate_test_string(i).translate(translation_tb)
38.731336012999236  20  ''.join(c for c in generate_test_string(i) if c.isalnum())
37.942474347000825  20  ''.join(filter(str.isalnum, generate_test_string(i)))
42.169366310001350  20  re.sub(r'[\W]', '', generate_test_string(i))
41.933375883003464  20  re.sub(r'[\W]+', '', generate_test_string(i))
38.899814646996674  20  pattern_single.sub('', generate_test_string(i))
38.636144253003295  20  pattern_repeat.sub('', generate_test_string(i))
36.201238164998360  20  generate_test_string(i).translate(translation_tb)
49.377356811004574  30  ''.join(c for c in generate_test_string(i) if c.isalnum())
48.408927293996385  30  ''.join(filter(str.isalnum, generate_test_string(i)))
53.901889764994850  30  re.sub(r'[\W]', '', generate_test_string(i))
52.130339455994545  30  re.sub(r'[\W]+', '', generate_test_string(i))
50.061149017004940  30  pattern_single.sub('', generate_test_string(i))
49.366573111998150  30  pattern_repeat.sub('', generate_test_string(i))
46.649754120997386  30  generate_test_string(i).translate(translation_tb)
63.107938601999194  40  ''.join(c for c in generate_test_string(i) if c.isalnum())
65.116287978999030  40  ''.join(filter(str.isalnum, generate_test_string(i)))
71.477421126997800  40  re.sub(r'[\W]', '', generate_test_string(i))
66.027950693998720  40  re.sub(r'[\W]+', '', generate_test_string(i))
63.315361931003280  40  pattern_single.sub('', generate_test_string(i))
62.342320287003530  40  pattern_repeat.sub('', generate_test_string(i))
58.249303059004890  40  generate_test_string(i).translate(translation_tb)
73.810345625002810  50  ''.join(c for c in generate_test_string(i) if c.isalnum())
72.593953348005020  50  ''.join(filter(str.isalnum, generate_test_string(i)))
76.048324580995540  50  re.sub(r'[\W]', '', generate_test_string(i))
75.106637657001560  50  re.sub(r'[\W]+', '', generate_test_string(i))
74.681338128997600  50  pattern_single.sub('', generate_test_string(i))
72.430461594005460  50  pattern_repeat.sub('', generate_test_string(i))
69.394243567003290  50  generate_test_string(i).translate(translation_tb)


str.maketrans
和 
str.translate
速度最快，但包含所有非 ASCII 字符。 
re.compile
和 
pattern.sub
速度较慢，但比 
''.join
和 
filter
更快。

5
投票

对于简单的单行代码（Python 3.0）：

''.join(filter( lambda x: x in '0123456789abcdefghijklmnopqrstuvwxyz', the_string_you_want_stripped ))

对于Python < 3.0:

filter( lambda x: x in '0123456789abcdefghijklmnopqrstuvwxyz', the_string_you_want_stripped )

注意：如果需要，您可以将其他字符添加到允许的字符列表中（例如“0123456789abcdefghijklmnopqrstuvwxyz.,_”）。

4
投票

Python 3

使用与 @John Machin 的答案相同的方法，但针对 Python 3 进行了更新：

  • 更大的字符集
  • 对
    translate
    的工作方式略有改变。

Python 代码现在假定以 UTF-8 编码
（来源：PEP 3120）

这意味着包含您要删除的所有字符的字符串会变得更大：

    
del_chars = ''.join(c for c in map(chr, range(1114111)) if not c.isalnum())

并且 

translate
方法现在需要使用我们可以使用 
maketrans()
创建的转换表：

    
del_map = str.maketrans('', '', del_chars)

现在，和以前一样，任何你想要“压缩”的字符串

s
：

    
scrunched = s.translate(del_map)

使用@Joe Machin 的最后一个计时示例，我们可以看到它仍然比 

re
快一个数量级：

    
> python -mtimeit -s"d=''.join(c for c in map(chr,range(1114111)) if not c.isalnum());m=str.maketrans('','',d);s='foo-'*25" "s.translate(m)"
    
1000000 loops, best of 5: 255 nsec per loop
    
> python -mtimeit -s"import re;s='foo-'*25;r=re.compile(r'[\W_]+')" "r.sub('',s)"
    
50000 loops, best of 5: 4.8 usec per loop
3
投票
for char in my_string:
    if not char.isalnum():
        my_string = my_string.replace(char,"")
3
投票

一个简单的解决方案，因为这里的所有答案都很复杂

filtered = ''
for c in unfiltered:
    if str.isalnum(c):
        filtered += c
    
print(filtered)
0
投票

如果您想保留诸如 áéíóúãẽĩõũ 之类的字符，请使用以下命令：

import re
re.sub('[\W\d_]+', '', your_string)
-3
投票

如果我理解正确的话，最简单的方法是使用正则表达式，因为它为您提供了很多灵活性，但另一种简单的方法是使用 for 循环，下面是带有示例的代码，我还计算了单词的出现次数并存储在字典中..

s = """An... essay is, generally, a piece of writing that gives the author's own 
argument — but the definition is vague, 
overlapping with those of a paper, an article, a pamphlet, and a short story. Essays 
have traditionally been 
sub-classified as formal and informal. Formal essays are characterized by "serious 
purpose, dignity, logical 
organization, length," whereas the informal essay is characterized by "the personal 
element (self-revelation, 
individual tastes and experiences, confidential manner), humor, graceful style, 
rambling structure, unconventionality 
or novelty of theme," etc.[1]"""

d = {}      # creating empty dic      
words = s.split() # spliting string and stroing in list
for word in words:
    new_word = ''
    for c in word:
        if c.isalnum(): # checking if indiviual chr is alphanumeric or not
            new_word = new_word + c
    print(new_word, end=' ')
    # if new_word not in d:
    #     d[new_word] = 1
    # else:
    #     d[new_word] = d[new_word] +1
print(d)

如果此答案有用，请评价！

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.