从Python中的字符串中删除特定字符

Question

我正在尝试使用 Python 从字符串中删除特定字符。这是我现在正在使用的代码。不幸的是，它似乎对字符串没有任何作用。

for char in line:
    if char in " ?.!/;:":
        line.replace(char,'')

我该如何正确地做到这一点？

---

_{请参阅为什么调用字符串方法（例如 .replace 或 .strip）不会修改（变异）字符串？有关此方法有什么问题的具体调试问题。这里的回答主要集中在如何解决问题。}

Answer 1

Python 中的字符串是不可变的（无法更改）。因此，line.replace(...) 的作用只是创建一个新字符串，而不是更改旧字符串。您需要将其重新绑定（分配）到line，以便使该变量采用新值，并删除这些字符。

而且，相对来说，你这样做的方式会有点慢。对于经验丰富的 Python 开发者来说，这也可能会有点令人困惑，他们会看到双重嵌套结构，并暂时认为正在发生更复杂的事情。

从 Python 2.6 和更新的 Python 2.x 版本开始*，您可以改为使用 str.translate，（请参阅下面的 Python 3 答案）：

line = line.translate(None, '!@#
或将正则表达式替换为 re.sub
import re
line = re.sub('[!@#$]', '', line)

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。
 Python 3 答案
在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。
当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。
因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似
translation_table = dict.fromkeys(map(ord, '!@#
<代码>dict.fromkeys和map< /code> 用于简洁地生成一个包含
{ord('!'): None, ord('@'): None, ...}

更简单的字典，如 另一个答案提出了，创建翻译表：
unicode_line = unicode_line.translate({ord(c): None for c in '!@#
或者，如 Joseph Lee，使用 str.maketrans：
unicode_line = unicode_line.translate(str.maketrans('', '', '!@#

 * 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：
import string
line = line.translate(string.maketrans('', ''), '!@#
此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。
)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。
 Python 3 答案
在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。
当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。
因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code> 用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：


 * 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。
), None)
unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code> 用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：


 * 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。
)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。
 Python 3 答案
在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。
当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。
因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code> 用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：


 * 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。
})

或者，如 Joseph Lee，使用 str.maketrans：


 * 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。
)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

))

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

})

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

})

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

))

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

})

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

), None) unicode_line = unicode_line.translate(translation_table)

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

)

或将正则表达式替换为 re.sub

括号内的字符构成一个字符类。该类中的 line 中的任何字符都将替换为 sub 的第二个参数：空字符串。

Python 3 答案

在Python 3 中，字符串是Unicode。你必须翻译得有点不同。 kevpie 在评论中提到了这一点答案，并在 str.translate 文档中注明。

当调用 Unicode 字符串的 translate 方法时，不能传递我们上面使用的第二个参数。您也不能将 None 作为第一个参数传递。相反，您传递一个翻译表（通常是字典）作为唯一的参数。该表映射字符的序数值（即调用ord ）到应替换它们的字符的序数值，或者（对我们有用）None 表示应删除它们。

因此，要使用 Unicode 字符串执行上述舞蹈，您可以在此处调用类似

<代码>dict.fromkeys和map< /code>用于简洁地生成一个包含

更简单的字典，如 另一个答案提出了，创建翻译表：

或者，如 Joseph Lee，使用 str.maketrans：

---

* 为了与早期的 Python 兼容，您可以创建一个“空”转换表来代替 None：

此处 string.maketrans 用于创建一个翻译表，其中只是一个包含序数值为 0 到 255 的字符的字符串。

Answer 2

我是否错过了这里的重点，或者只是以下内容：

string = "ab1cd1ef"
string = string.replace("1", "") 

print(string)
# result: "abcdef"

将其放入循环中：

a = "a!b@c#d$"
b = "!@#$"
for char in b:
    a = a.replace(char, "")

print(a)
# result: "abcd"

Answer 3

>>> line = "abc#@!?efg12;:?"
>>> ''.join( c for c in line if  c not in '?:!/;' )
'abc#@efg12'

Answer 4

使用 re.sub 正则表达式

从 Python 3.5 开始，使用正则表达式 re.sub 进行替换变得可用：

import re
re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)

示例

import re
line = 'Q: Do I write ;/.??? No!!!'
re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)

'QDoIwriteNo'

解释

正则表达式 (regex)，| 是逻辑 OR 和 \转义可能是实际正则表达式命令的空格和特殊字符。而 sub 代表替换，在本例中为空字符串 ''。

Answer 5

提问者几乎已经明白了。就像 Python 中的大多数东西一样，答案比你想象的要简单。

>>> line = "H E?.LL!/;O:: "  
>>> for char in ' ?.!/;:':  
...  line = line.replace(char,'')  
...
>>> print line
HELLO

您不必执行嵌套的 if/for 循环，但您需要单独检查每个字符。

Answer 6

对于字符串中仅允许某些字符的反向要求，您可以使用带有补集运算符[^ABCabc]的正则表达式。例如，要删除除 ascii 字母、数字和连字符之外的所有内容：

>>> import string
>>> import re
>>>
>>> phrase = '  There were "nine" (9) chick-peas in my pocket!!!      '
>>> allow = string.letters + string.digits + '-'
>>> re.sub('[^%s]' % allow, '', phrase)

'Therewerenine9chick-peasinmypocket'

来自 python 正则表达式文档 :

不在某个范围内的字符可以通过补码来匹配
该集。如果该集合的第一个字符是'^'，则所有字符
不在集合中的将被匹配。例如，[^5] 将匹配
除 '5' 之外的任何字符，并且 [^^] 将匹配除 '5' 之外的任何字符
<代码>'^'。如果 ^ 不是数组中的第一个字符，则它没有特殊含义
设置。

Answer 7

line = line.translate(None, " ?.!/;:")

Answer 8

>>> s = 'a1b2c3'
>>> ''.join(c for c in s if c not in '123')
'abc'

Answer 9

Python 中的字符串是不可变的。 replace 方法在替换后返回一个新字符串。尝试：

for char in line:
    if char in " ?.!/;:":
        line = line.replace(char,'')

这与您的原始代码相同，只是在循环内添加了对 line 的赋值。

请注意，字符串 replace() 方法会替换字符串中出现的所有个字符，因此您可以使用 replace() 做得更好> 对于要删除的每个字符，而不是循环遍历字符串中的每个字符。

Answer 10

试试这个：

def rm_char(original_str, need2rm):
    ''' Remove charecters in "need2rm" from "original_str" '''
    return original_str.translate(str.maketrans('','',need2rm))

这个方法在 Python 3 中运行良好

Answer 11

令我惊讶的是，还没有人推荐使用内置的 filter 功能。

    import operator
    import string # only for the example you could use a custom string

    s = "1212edjaq"

假设我们要过滤掉所有不是数字的内容。使用过滤器内置方法“...相当于生成器表达式（item for item in iterable if function(item)）”[Python 3 内置函数：Filter]

    sList = list(s)
    intsList = list(string.digits)
    obj = filter(lambda x: operator.contains(intsList, x), sList)))

在 Python 3 中，此返回

    >>  <filter object @ hex>

To get a print string,

    nums = "".join(list(obj))
    print(nums)
    >> "1212"

I am not certain how filter 在效率方面排名，但在进行列表推导等操作时了解如何使用是一件好事。

更新

从逻辑上讲，由于过滤器有效，您也可以使用列表理解，并且根据我的阅读，它应该更有效，因为 lambda 是编程函数世界的华尔街对冲基金经理。另一个优点是它是一种不需要任何进口的单线产品。例如，使用上面定义的相同字符串“s”，

      num = "".join([i for i in s if i.isdigit()])

就是这样。返回将是原始字符串中所有数字字符的字符串。

如果您有可接受/不可接受字符的特定列表，则只需调整列表理解的“if”部分。

      target_chars = "".join([i for i in s if i in some_list]) 

或者，

      target_chars = "".join([i for i in s if i not in some_list])

Answer 12

使用 filter，你只需要一行

line = filter(lambda char: char not in " ?.!/;:", line)

这会将字符串视为可迭代对象，并检查每个字符是否 lambda 返回 True：

<前><代码>>>>帮助（过滤器）
有关模块 __builtin__ 中内置函数过滤器的帮助：

筛选（...）
过滤器（函数或无，序列）->列表、元组或字符串

返回那些 function(item) 为 true 的序列项。如果
function 为 None，返回 true 的项。如果序列是一个元组
或字符串，返回相同类型，否则返回列表。

Answer 13

以下是完成此任务的一些可能方法：

def attempt1(string):
    return "".join([v for v in string if v not in ("a", "e", "i", "o", "u")])


def attempt2(string):
    for v in ("a", "e", "i", "o", "u"):
        string = string.replace(v, "")
    return string


def attempt3(string):
    import re
    for v in ("a", "e", "i", "o", "u"):
        string = re.sub(v, "", string)
    return string


def attempt4(string):
    return string.replace("a", "").replace("e", "").replace("i", "").replace("o", "").replace("u", "")


for attempt in [attempt1, attempt2, attempt3, attempt4]:
    print(attempt("murcielago"))

PS：示例使用元音代替“？.!/;:”...是的，“murcielago”是西班牙语单词，表示“蝙蝠”...有趣的单词，因为它包含所有元音:)

PS2：如果您对性能感兴趣，您可以使用简单的代码来衡量这些尝试，例如：

import timeit


K = 1000000
for i in range(1,5):
    t = timeit.Timer(
        f"attempt{i}('murcielago')",
        setup=f"from __main__ import attempt{i}"
    ).repeat(1, K)
    print(f"attempt{i}",min(t))

在我的框中，您会得到：

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

所以看来尝试4对于该特定输入来说是最快的。

Answer 14

这是我的 Python 2/3 兼容版本。由于翻译 api 已更改。

def remove(str_, chars):
    """Removes each char in `chars` from `str_`.

    Args:
        str_: String to remove characters from
        chars: String of to-be removed characters

    Returns:
        A copy of str_ with `chars` removed

    Example:
            remove("What?!?: darn;", " ?.!:;") => 'Whatdarn'
    """
    try:
        # Python2.x
        return str_.translate(None, chars)
    except TypeError:
        # Python 3.x
        table = {ord(char): None for char in chars}
        return str_.translate(table)

Answer 15

#!/usr/bin/python
import re

strs = "how^ much for{} the maple syrup? $20.99? That's[] ricidulous!!!"
print strs
nstr = re.sub(r'[?|$|.|!|a|b]',r' ',strs)#i have taken special character to remove but any #character can be added here
print nstr
nestr = re.sub(r'[^a-zA-Z0-9 ]',r'',nstr)#for removing special character
print nestr

Answer 16

您还可以使用函数来使用列表替换不同类型的正则表达式或其他模式。这样，您就可以混合正则表达式、字符类和真正基本的文本模式。当您需要替换大量元素（例如 HTML 元素）时，它非常有用。

*注意：适用于 Python 3.x

import re  # Regular expression library


def string_cleanup(x, notwanted):
    for item in notwanted:
        x = re.sub(item, '', x)
    return x

line = "<title>My example: <strong>A text %very% $clean!!</strong></title>"
print("Uncleaned: ", line)

# Get rid of html elements
html_elements = ["<title>", "</title>", "<strong>", "</strong>"]
line = string_cleanup(line, html_elements)
print("1st clean: ", line)

# Get rid of special characters
special_chars = ["[!@#$]", "%"]
line = string_cleanup(line, special_chars)
print("2nd clean: ", line)

在函数 string_cleanup 中，它将字符串 x 和不需要的列表作为参数。对于该元素或模式列表中的每个项目，如果需要替代品，就会完成。

输出：

Uncleaned:  <title>My example: <strong>A text %very% $clean!!</strong></title>
1st clean:  My example: A text %very% $clean!!
2nd clean:  My example: A text very clean

Answer 17

我使用的方法可能不会那么有效，但它非常简单。我可以使用切片和格式化一次性删除不同位置的多个字符。
这是一个例子：

words = "things"
removed = "%s%s" % (words[:3], words[-1:])

这将导致“removed”包含“this”一词。

格式化对于在打印字符串中打印变量非常有帮助。它可以使用 % 后跟变量的数据类型来插入任何数据类型；所有数据类型都可以使用%s，浮点数（也称为小数）和整数可以使用%d。

切片可用于对字符串进行复杂的控制。当我输入 words[:3] 时，它允许我选择字符串中从开头（冒号在数字之前，这意味着“从头到”）到第4个字符（包含第4个字符）。 3 等于第四个位置的原因是因为 Python 从 0 开始。然后，当我输入 word[-1:] 时，它表示倒数第二个字符（冒号在数字后面） ）。输入 -1 将使 Python 从最后一个字符而不是第一个字符开始计数。同样，Python 将从 0 开始。因此，word[-1:] 基本上表示“从倒数第二个字符到字符串末尾”。

因此，通过切断我想要删除的字符之前的字符和之后的字符并将它们夹在一起，我可以删除不需要的字符。 把它想象成一根香肠。中间很脏，所以我想把它扔掉。我只是剪掉我想要的两端，然后将它们放在一起，中间没有不需要的部分。

如果我想删除多个连续的字符，我只需在 [] （切片部分）中移动数字即可。或者，如果我想从不同位置删除多个字符，我可以简单地一次将多个切片夹在一起。

示例：

 words = "control"
 removed = "%s%s" % (words[:2], words[-2:])

删除等于“酷”。

words = "impacts"
removed = "%s%s%s" % (words[1], words[3:5], words[-1])

删除等于“macs”。

在本例中，[3:5] 表示位置 3 处的字符到位置 5 处的字符（不包括最终位置处的字符）。

请记住，Python 从 0 开始计数，因此您也需要这样做。

Answer 18

在 Python 3.5 中

例如，

os.rename(file_name, file_name.translate({ord(c): None for c in '0123456789'}))

，从字符串中删除所有数字

Answer 19

以下花絮已在此线程中进行了解释。我只是把它放在一起作为答案。

"".join(filter(lambda x: x not in " ?.!/;:", line))   

Answer 20

这个怎么样：

def text_cleanup(text):
    new = ""
    for i in text:
        if i not in " ?.!/;:":
            new += i
    return new

Answer 21

下面一个..不使用正则表达式概念..

ipstring ="text with symbols!@#$^&*( ends here"
opstring=''
for i in ipstring:
    if i.isalnum()==1 or i==' ':
        opstring+=i
    pass
print opstring

Answer 22

递归分割：
s=字符串； chars=要删除的字符

def strip(s,chars):
if len(s)==1:
    return "" if s in chars else s
return strip(s[0:int(len(s)/2)],chars) +  strip(s[int(len(s)/2):len(s)],chars)

示例：

print(strip("Hello!","lo"))    #He!

Answer 23

您可以使用 re 模块的正则表达式替换。使用 ^ 表达式可以让您从字符串中准确选择您想要的内容。

    import re
    text = "This is absurd!"
    text = re.sub("[^a-zA-Z]","",text) # Keeps only Alphabets
    print(text)

输出将是“Thisisabsurd”。仅显示 ^ 符号之后指定的内容。

Answer 24

# 对于目录中的每个文件，重命名文件名

   file_list = os.listdir (r"D:\Dev\Python")

   for file_name in file_list:

       os.rename(file_name, re.sub(r'\d+','',file_name))

Answer 25

即使下面的方法也可以

line = "a,b,c,d,e"
alpha = list(line)
        while ',' in alpha:
            alpha.remove(',')
finalString = ''.join(alpha)
print(finalString)

输出：abcde

Answer 26

字符串方法replace不会修改原始字符串。它保留原始版本并返回修改后的副本。

您想要的是这样的： line = line.replace(char,'')

def replace_all(line, )for char in line:
    if char in " ?.!/;:":
        line = line.replace(char,'')
    return line

但是，每次删除字符时都创建一个新字符串，效率非常低。我推荐以下内容：

def replace_all(line, baddies, *):
    """
    The following is documentation on how to use the class,
    without reference to the implementation details:

    For implementation notes, please see comments begining with `#`
    in the source file.

    [*crickets chirp*]

    """

    is_bad = lambda ch, baddies=baddies: return ch in baddies
    filter_baddies = lambda ch, *, is_bad=is_bad: "" if is_bad(ch) else ch
    mahp = replace_all.map(filter_baddies, line)
    return replace_all.join('', join(mahp))

    # -------------------------------------------------
    # WHY `baddies=baddies`?!?
    #     `is_bad=is_bad`
    # -------------------------------------------------
    # Default arguments to a lambda function are evaluated
    # at the same time as when a lambda function is
    # **defined**.
    #
    # global variables of a lambda function
    # are evaluated when the lambda function is
    # **called**
    #
    # The following prints "as yellow as snow"
    #
    #     fleece_color = "white"
    #     little_lamb = lambda end: return "as " + fleece_color + end
    #
    #     # sometime later...
    #
    #     fleece_color = "yellow"
    #     print(little_lamb(" as snow"))
    # --------------------------------------------------
replace_all.map = map
replace_all.join = str.join

Answer 27

如果您希望字符串仅使用 ASCII 代码允许的字符，您可以使用这段代码：

for char in s:
    if ord(char) < 96 or ord(char) > 123:
        s = s.replace(char, "")

它将删除 a....z 之外的所有字符，甚至是大写字母。