Python中将字符串转换为全小写以去除所有非ASCII字母字符的最有效方法是什么？

Question

我有一个需要在 Python 中执行的简单任务，即将字符串转换为全小写并去除所有非 ascii 非字母字符。

例如：

"This is a Test" -> "thisisatest"
"A235th@#$&( er Ra{}|?>ndom" -> "atherrandom"

我有一个简单的功能来做到这一点：

import string
import sys

def strip_string_to_lowercase(s):
    tmpStr = s.lower().strip()
    retStrList = []
    for x in tmpStr:
        if x in string.ascii_lowercase:
            retStrList.append(x)

    return ''.join(retStrList)

但我不禁想到有一种更有效或更优雅的方式。

谢谢！

---

编辑：

感谢所有回答的人。我学习了很多 Python，在某些情况下还重新学习了。

Answer 1

另一个解决方案（不是pythonic，但非常快）是使用string.translate - 尽管请注意这不适用于unicode。还值得注意的是，您可以通过将字符移动到一个集合中来加速Dana's code（通过哈希查找，而不是每次都执行线性搜索）。以下是我得到的各种解决方案的时间安排：

import string, re, timeit

# Precomputed values (for str_join_set and translate)

letter_set = frozenset(string.ascii_lowercase + string.ascii_uppercase)
tab = string.maketrans(string.ascii_lowercase + string.ascii_uppercase,
                       string.ascii_lowercase * 2)
deletions = ''.join(ch for ch in map(chr,range(256)) if ch not in letter_set)

s="A235th@#$&( er Ra{}|?>ndom"

# From unwind's filter approach
def test_filter(s):
    return filter(lambda x: x in string.ascii_lowercase, s.lower())

# using set instead (and contains)
def test_filter_set(s):
    return filter(letter_set.__contains__, s).lower()

# Tomalak's solution
def test_regex(s):
    return re.sub('[^a-z]', '', s.lower())

# Dana's
def test_str_join(s):
    return ''.join(c for c in s.lower() if c in string.ascii_lowercase)

# Modified to use a set.
def test_str_join_set(s):
    return ''.join(c for c in s.lower() if c in letter_set)

# Translate approach.
def test_translate(s):
    return string.translate(s, tab, deletions)


for test in sorted(globals()):
    if test.startswith("test_"):
        assert globals()[test](s)=='atherrandom'
        print "%30s : %s" % (test, timeit.Timer("f(s)", 
              "from __main__ import %s as f, s" % test).timeit(200000))

这给了我：

               test_filter : 2.57138351271
           test_filter_set : 0.981806765698
                test_regex : 3.10069885233
             test_str_join : 2.87172979743
         test_str_join_set : 2.43197956381
            test_translate : 0.335367566218

[编辑] 也更新了过滤器解决方案。 （请注意，在这里使用 set.__contains__ 会有很大的不同，因为它避免了对 lambda 进行额外的函数调用。

Answer 2

>>> filter(str.isalpha, "This is a Test").lower()
'thisisatest'
>>> filter(str.isalpha, "A235th@#$&( er Ra{}|?>ndom").lower()
'atherrandom'

Answer 3

运行时效率不是特别高，但对于可怜、疲惫的编码员眼睛来说肯定更好：

def strip_string_and_lowercase(s):
    return ''.join(c for c in s.lower() if c in string.ascii_lowercase)

Answer 4

我愿意：

• 小写字符串
• 将所有[^a-z] 替换为""

这样：

def strip_string_to_lowercase():
  nonascii = re.compile('[^a-z]')
  return lambda s: nonascii.sub('', s.lower().strip())

编辑：原来的版本（下）确实很慢，尽管通过将其转换为闭包（上）可以获得一些性能。

def strip_string_to_lowercase(s):
  return re.sub('[^a-z]', '', s.lower().strip())

---

我对字符串 100,000 次迭代的性能测量

"A235th@#$&( er Ra{}|?>ndom"

透露：

• f_re_0 took 2672.000 ms（这是这个答案的原始版本）
• f_re_1 took 2109.000 ms（这是上面显示的闭包版本）
• f_re_2 took 2031.000 ms（闭包版本，没有多余的strip()）
• f_fl_1 took 1953.000 ms (unwind's filter/lambda version)
• f_fl_2 took 1485.000 ms (Coady's filter version)
• f_jn_1 took 1860.000 ms (Dana's join version)

为了测试，我没有print结果。

Answer 5

Python 2.x translate 方法

转换为小写并过滤非ascii非字母字符：

from string import ascii_letters, ascii_lowercase, maketrans

table = maketrans(ascii_letters, ascii_lowercase*2)
deletechars = ''.join(set(maketrans('','')) - set(ascii_letters))

print "A235th@#$&( er Ra{}|?>ndom".translate(table, deletechars)
# -> 'atherrandom'

Python 3 translate 方法

过滤非ASCII：

ascii_bytes = "A235th@#$&(٠٫٢٥ er Ra{}|?>ndom".encode('ascii', 'ignore')

使用bytes.translate() 转换为小写并删除非字母字节：

from string import ascii_letters, ascii_lowercase

alpha, lower = [s.encode('ascii') for s in [ascii_letters, ascii_lowercase]]
table = bytes.maketrans(alpha, lower*2)           # convert to lowercase
deletebytes = bytes(set(range(256)) - set(alpha)) # delete nonalpha

print(ascii_bytes.translate(table, deletebytes))
# -> b'atherrandom'

Answer 6

类似于@Dana，但我认为这听起来像是一项过滤工作，并且应该在代码中可见。也无需显式调用join()：

def strip_string_to_lowercase(s):
  return filter(lambda x: x in string.ascii_lowercase, s.lower())

Answer 7

我在 Brian 的代码中添加了过滤器解决方案：

import string, re, timeit

# Precomputed values (for str_join_set and translate)

letter_set = frozenset(string.ascii_lowercase + string.ascii_uppercase)
tab = string.maketrans(string.ascii_lowercase + string.ascii_uppercase,
                       string.ascii_lowercase * 2)
deletions = ''.join(ch for ch in map(chr,range(256)) if ch not in letter_set)

s="A235th@#$&( er Ra{}|?>ndom"

def test_original(s):
    tmpStr = s.lower().strip()
    retStrList = []
    for x in tmpStr:
        if x in string.ascii_lowercase:
            retStrList.append(x)

    return ''.join(retStrList)


def test_regex(s):
    return re.sub('[^a-z]', '', s.lower())

def test_regex_closure(s):
  nonascii = re.compile('[^a-z]')
  def replacer(s):
    return nonascii.sub('', s.lower().strip())
  return replacer(s)


def test_str_join(s):
    return ''.join(c for c in s.lower() if c in string.ascii_lowercase)

def test_str_join_set(s):
    return ''.join(c for c in s.lower() if c in letter_set)

def test_filter_set(s):
    return filter(letter_set.__contains__, s.lower())

def test_filter_isalpha(s):
    return filter(str.isalpha, s).lower()

def test_filter_lambda(s):
    return filter(lambda x: x in string.ascii_lowercase, s.lower())

def test_translate(s):
    return string.translate(s, tab, deletions)

for test in sorted(globals()):
    if test.startswith("test_"):
        print "%30s : %s" % (test, timeit.Timer("f(s)", 
              "from __main__ import %s as f, s" % test).timeit(200000))

这给了我：

       test_filter_isalpha : 1.31981746283
        test_filter_lambda : 2.23935583992
           test_filter_set : 0.76511679557
             test_original : 2.13079176264
                test_regex : 2.44295629752
        test_regex_closure : 2.65205913042
             test_str_join : 2.25571266739
         test_str_join_set : 1.75565888961
            test_translate : 0.269259640541

似乎 isalpha 使用了与 set 算法类似的算法，至少在 O() 方面。

---

编辑： 添加了过滤器集，将过滤器功能重命名为更清晰一点。

Answer 8

这是列表理解的典型应用：

import string
s = "O235th@#$&( er Ra{}|?<ndom"
print ''.join(c for c in s.lower() if c in string.ascii_lowercase)

它不会像您的示例中那样过滤掉“

Answer 9

>>> import string
>>> a = "O235th@#$&( er Ra{}|?<ndom"
>>> ''.join(i for i in a.lower() if i in string.ascii_lowercase)
'otheraltndom'

基本上和你做的一样。

Answer 10

Python 2.x：

import string
valid_chars= string.ascii_lowercase + string.ascii_uppercase

def only_lower_ascii_alpha(text):
    return filter(valid_chars.__contains__, text).lower()

适用于 str 或 unicode 参数。

>>> only_lower_ascii_alpha("Hello there 123456!")
'hellothere'
>>> only_lower_ascii_alpha(u"435 café")
u'caf'

Answer 11

我个人会使用正则表达式，然后将最终字符串转换为小写。我不知道如何用 Python 编写它，但基本思想是：

1. 删除字符串中与不区分大小写的正则表达式“\w”不匹配的字符
2. 将字符串转换为小写

反之亦然。