文章目录

前言

`

在自然语言处理（NLP）和机器学习领域，文本数据扮演着核心角色。然而，原始文本数据往往充满了噪声、冗余和不一致性。例如，“Apple”、“apple”和“APPLE”在语义上可能指代同一个实体，但对于机器而言，它们是不同的字符串。类似地，HTML 标签、URL、标点符号和停用词等都可能干扰模型对文本真实含义的理解。

文本数据标准化（Text Normalization）正是解决这些问题的关键步骤。它旨在将文本转换为一种标准、统一的形式，从而提高数据质量，降低特征维度，并最终提升机器学习模型的性能和泛化能力。

本教程将详细介绍文本数据中常用的标准化技术，包括：小写转换、HTML/URL/标点符号/特殊字符移除、分词、停用词过滤、词干提取和词形还原。我们将使用 Python 及其强大的库（如 NLTK、BeautifulSoup 和 re 模块）来实现这些功能，并通过一个综合示例，手把手教您构建一个高效的文本标准化流程。

1. 环境准备与工具链

在开始编写代码之前，我们需要搭建一个合适的 Python 开发环境并安装必要的库。强烈建议您使用虚拟环境 (Virtual Environment) 来管理项目依赖，以避免不同项目之间库版本的冲突。

1.1. Python 环境与虚拟环境

推荐使用 Anaconda 或 Miniconda 来管理 Python 环境。

  1. 安装 Anaconda 或 Miniconda：
    前往上述链接下载并安装适合您操作系统的版本。

  2. 创建虚拟环境：
    打开终端或 Anaconda Prompt，执行以下命令创建一个名为 nlp_env 的虚拟环境，并指定 Python 版本为 3.9：

    conda create -n nlp_env python=3.9

    如果您更喜欢使用 venv（Python 内置模块）：

    python -m venv nlp_env

  3. 激活虚拟环境：

    • Conda 环境：
      conda activate nlp_env
    • venv 环境：
      • Windows: .\nlp_env\Scripts\activate
      • macOS/Linux: source nlp_env/bin/activate

    激活后，您的终端提示符前会显示环境名称（例如 (nlp_env)），表示您当前处于该虚拟环境中。所有后续安装的库都将隔离在该环境中。

1.2. 核心库安装

在激活的虚拟环境中，安装本教程将使用的核心库：

pip install nltk beautifulsoup4
  • nltk (Natural Language Toolkit): Python 中最流行的 NLP 库之一，提供了丰富的文本处理工具和资源。
  • beautifulsoup4: 一个用于从 HTML 和 XML 文件中提取数据的库，尤其擅长解析复杂的 HTML 结构。
  • re (Regular Expression): Python 内置模块，用于处理正则表达式，适合进行模式匹配和字符串替换。

1.3. NLTK 数据包下载

NLTK 库的许多功能依赖于外部数据包（如停用词列表、词形还原字典、分词模型等）。首次使用前，您需要下载这些数据包。

打开 Python 解释器或创建一个 Python 脚本，然后运行以下代码：

import nltk

# 下载所有必要的 NLTK 数据包
# 如果您已经下载过某些包，可以跳过
# 'punkt' 用于分词
# 'stopwords' 用于停用词列表
# 'wordnet' 用于词形还原
# 'omw-1.4' 是 wordnet 的依赖，确保下载以避免 WordNetLemmatizer 报错
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')
nltk.download('omw-1.4') # Open Multilingual Wordnet

print("\nNLTK 数据包下载完成。")

下载过程中可能需要一些时间，请耐心等待。下载完成后，您就可以在代码中使用这些资源了。

2. 文本数据标准化的核心概念与必要性

2.1. 为什么需要标准化？

在将文本数据用于机器学习模型训练之前，进行标准化至关重要，原因如下：

  • 一致性：确保相同语义的词语有相同的表示形式（例如，“Run”、“run”、“RUNNING”都变成“run”），这有助于模型识别模式。
  • 噪声消除：移除与任务无关的字符、标签、URL 等，这些噪声会干扰模型的学习过程。
  • 特征维度降低：通过词干提取、词形还原、停用词移除等方法，可以减少词汇表中不必要的词形变体和高频低信息量的词语，从而降低特征空间维度，提高模型效率和泛化能力。
  • 提高模型性能：干净、一致的数据能让模型更好地捕捉文本的内在含义和模式，从而带来更准确的预测和更好的性能。

2.2. 标准化流程概览

文本标准化的具体步骤和顺序并非一成不变，它高度依赖于您的具体任务和数据特性。然而，一个常见的文本标准化流程通常遵循以下顺序：

  1. 文本清理：
    • 小写转换
    • 移除 HTML 标签
    • 移除 URL
    • 移除标点符号
    • 移除特殊字符（如数字，如果它们不是任务的关键信息）
  2. 结构化处理：
    • 词元化（分词）
  3. 语义处理：
    • 移除停用词
    • 词干提取 或 词形还原 (二选一或根据情况组合)

在实际应用中，您可能需要根据实验和评估结果，灵活调整这些步骤的组合和顺序。

3. 文本标准化技术详解与实现

本节将逐一介绍各种文本标准化技术，并提供清晰的 Python 代码实现。

3.1. 小写转换 (Lowercasing)

  • “为什么”：这是最简单的标准化步骤之一，目的是将文本中的所有字母转换为小写。这样可以确保“Apple”、“apple”和“APPLE”被视为同一个词，消除因大小写不同而产生的不一致性。
  • “是什么”：将字符串中的所有大写字母转换为对应的小写字母。
  • “怎么做”：使用 Python 内置的 str.lower() 方法。
# 3.1_lowercasing.py

def to_lowercase(text: str) -> str:
    """将文本转换为小写。"""
    return text.lower()

# 示例
text_lower = "Hello World! This is an EXAMPLE."
print(f"原始文本: {text_lower}")
print(f"小写转换: {to_lowercase(text_lower)}")
# 输出: hello world! this is an example.

3.2. 移除 HTML 标签

  • “为什么”：当从网页抓取文本数据时，HTML 标签（如 <div>, <p>, <a>）会作为非语义信息混入文本中。这些标签对于大多数 NLP 任务来说是噪声，需要被移除。
  • “是什么”：从字符串中识别并删除所有 HTML 标记。
  • “怎么做”：
    • 推荐：使用 BeautifulSoup 库。它是一个功能强大的 HTML 解析器，能够健壮地处理各种复杂的、不规范的 HTML 结构。
    • 替代方案：使用正则表达式 (re 模块)。虽然对于简单的 HTML 标签有效，但正则表达式在处理嵌套、不完整或复杂的 HTML 结构时容易出错，不推荐用于生产环境。
# 3.2_remove_html.py

import re
from bs4 import BeautifulSoup

def remove_html_bs(text: str) -> str:
    """使用 BeautifulSoup 移除 HTML 标签。"""
    soup = BeautifulSoup(text, 'html.parser')
    # get_text() 方法可以从 HTML/XML 文档中提取所有文本内容
    # separator=' ' 参数确保在标签之间的文本之间插入空格，避免单词粘连
    return soup.get_text(separator=' ')

def remove_html_regex(text: str) -> str:
    """使用正则表达式移除 HTML 标签 (适用于简单情况)。"""
    clean = re.compile('<.*?>') # 匹配任意 < 和 > 之间的内容
    return re.sub(clean, '', text)

# 示例
html_text = "<p>This is a <b>bold</b> text with an <a href='#'>anchor</a>.</p>"
print(f"原始 HTML: {html_text}")
print(f"BeautifulSoup 移除: {remove_html_bs(html_text)}")
print(f"Regex 移除: {remove_html_regex(html_text)}")
# 输出:
# BeautifulSoup 移除: This is a bold text with an anchor.
# Regex 移除: This is a bold text with an anchor.

# 复杂 HTML 示例，展示 BeautifulSoup 的健壮性
complex_html = "<div><p>Hello World!</p><!-- comment --><span>Next Part</span>"
print(f"\n复杂 HTML: {complex_html}")
print(f"BeautifulSoup 移除: {remove_html_bs(complex_html)}")
print(f"Regex 移除: {remove_html_regex(complex_html)}")
# 输出:
# BeautifulSoup 移除: Hello World! Next Part
# Regex 移除: Hello World!Next Part (注意：Regex 可能会导致单词粘连，因为它只移除了标签，未处理标签间的空格)

最佳实践：对于任何非微不足道的 HTML 清理任务，强烈推荐使用 BeautifulSoup。正则表达式虽然看起来方便，但在处理 HTML 的复杂性方面存在固有限制。

3.3. 移除 URL

  • “为什么”：URL（统一资源定位符）在大多数文本分析任务中属于噪声，因为它们通常不包含有用的语义信息，但会增加词汇量。
  • “是什么”：从文本中检测并删除所有网址。
  • “怎么做”：使用正则表达式来匹配常见的 URL 模式。
# 3.3_remove_urls.py

import re

def remove_urls(text: str) -> str:
    """移除文本中的 URL。"""
    # 匹配 http/https/ftp 开头或 www. 开头或以 .com/.org/.net 等结尾的 URL
    url_pattern = re.compile(r'https?://\S+|www\.\S+|\S+\.(com|org|net|io|co|uk|gov|edu|cn)\S*')
    return url_pattern.sub('', text)

# 示例
url_text = "Visit my website at https://www.example.com or check out http://blog.test.org. Also, see www.another.net. This is a text."
print(f"原始文本: {url_text}")
print(f"移除 URL: {remove_urls(url_text)}")
# 输出: Visit my website at  or check out . Also, see . This is a text.

3.4. 移除标点符号 (Punctuation)

  • “为什么”：标点符号通常不携带语义信息，但在分词后会增加词汇表的大小（例如，“hello.” 和 “hello” 会被视为两个不同的词）。移除它们有助于统一词形。
  • “是什么”：从文本中删除所有的标点符号。
  • “怎么做”：
    • 使用 str.translate 和 string.punctuation (推荐，效率高)。
    • 使用正则表达式 re.sub。
# 3.4_remove_punctuation.py

import string
import re

def remove_punctuation_translate(text: str) -> str:
    """使用 str.translate 移除标点符号 (高效)。"""
    # 创建一个翻译表，将所有标点符号映射为空字符串
    translator = str.maketrans('', '', string.punctuation)
    return text.translate(translator)

def remove_punctuation_regex(text: str) -> str:
    """使用正则表达式移除标点符号。"""
    # 匹配所有非单词字符和非空格字符
    # 也可以简单用 re.sub(r'[^\w\s]', '', text)
    return re.sub(r'[^\w\s]', '', text)

# 示例
punc_text = "Hello, World! How are you doing today? I'm fine."
print(f"原始文本: {punc_text}")
print(f"Translate 移除标点: {remove_punctuation_translate(punc_text)}")
print(f"Regex 移除标点: {remove_punctuation_regex(punc_text)}")
# 输出:
# Translate 移除标点: Hello World How are you doing today Im fine
# Regex 移除标点: Hello World How are you doing today Im fine

3.5. 移除特殊字符与数字 (Optional)

  • “为什么”：取决于具体任务。在某些情况下，数字或某些特殊字符（如版权符号 ©、商标符号 ™ 等）可能被视为噪声。而在其他任务中（如金融文本分析），数字可能至关重要。
  • “是什么”：移除所有非字母字符或非字母数字字符。
  • “怎么做”：使用正则表达式。
# 3.5_remove_special_chars_numbers.py

import re

def remove_numbers(text: str) -> str:
    """移除文本中的数字。"""
    return re.sub(r'\d+', '', text) # 匹配一个或多个数字

def remove_non_alphabetic(text: str) -> str:
    """移除所有非字母字符 (保留空格)。"""
    return re.sub(r'[^a-zA-Z\s]', '', text)

def remove_non_alphanumeric(text: str) -> str:
    """移除所有非字母数字字符 (保留空格)。"""
    return re.sub(r'[^a-zA-Z0-9\s]', '', text)

# 示例
special_text = "Product_A costs $123.45. This is 99% good! ©2023."
print(f"原始文本: {special_text}")
print(f"移除数字: {remove_numbers(special_text)}")
print(f"移除非字母: {remove_non_alphabetic(special_text)}")
print(f"移除非字母数字: {remove_non_alphanumeric(special_text)}")
# 输出:
# 移除数字: Product_A costs $. This is % good! ©.
# 移除非字母: ProductA costs  This is  good
# 移除非字母数字: Product_A costs 12345 This is 99 good 2023

重要提示：在移除特殊字符或数字时，请务必根据您的具体分析任务来决定。过度清理可能导致有价值的信息丢失。

3.6. 词元化 / 分词 (Tokenization)

  • “为什么”：分词是大多数 NLP 任务的第一步，它将连续的文本分解成更小的、有意义的单元，称为词元 (tokens)。这些词元可以是单词、标点符号、数字等。
  • “是什么”：将文本字符串分割成一个词元列表。
  • “怎么做”：使用 NLTK 库中的 word_tokenize（单词分词）和 sent_tokenize（句子分词）。
# 3.6_tokenization.py

from nltk.tokenize import word_tokenize, sent_tokenize

def tokenize_words(text: str) -> list[str]:
    """将文本分割为单词词元。"""
    return word_tokenize(text)

def tokenize_sentences(text: str) -> list[str]:
    """将文本分割为句子词元。"""
    return sent_tokenize(text)

# 示例
token_text = "This is an example sentence. It shows tokenization."
print(f"原始文本: {token_text}")
print(f"单词词元: {tokenize_words(token_text)}")
print(f"句子词元: {tokenize_sentences(token_text)}")
# 输出:
# 单词词元: ['This', 'is', 'an', 'example', 'sentence', '.', 'It', 'shows', 'tokenization', '.']
# 句子词元: ['This is an example sentence.', 'It shows tokenization.']

注意：在进行分词之前，通常会进行小写转换和噪声移除。分词后，标点符号可能仍然存在，如果您希望将它们单独处理，可以在分词前或分词后移除。

3.7. 移除停用词 (Stopwords)

  • “为什么”：停用词（如“the”、“a”、“is”、“and”等）是文本中频率很高但通常不携带太多语义信息的词语。移除它们可以减少数据噪声，降低特征维度，并帮助模型关注更重要的关键词。
  • “是什么”：从词元列表中过滤掉预定义的停用词。
  • “怎么做”：使用 NLTK 提供的多种语言的停用词列表。
# 3.7_remove_stopwords.py

from nltk.corpus import stopwords

def remove_stopwords(tokens: list[str], language: str = 'english') -> list[str]:
    """
    从词元列表中移除停用词。
    :param tokens: 单词词元列表。
    :param language: 停用词语言，默认为 'english'。
    """
    stop_words = set(stopwords.words(language))
    # 列表推导式，只保留不在停用词列表中的词元
    return [word for word in tokens if word.lower() not in stop_words]

# 示例
# 假定我们已经进行了小写转换和分词
tokens = ['This', 'is', 'a', 'sample', 'text', 'for', 'removing', 'stopwords', '.', 'It', 'is', 'quite', 'useful']
processed_tokens = [word.lower() for word in tokens if word.isalpha()] # 先转小写并只保留字母
print(f"原始词元 (已小写): {processed_tokens}")
print(f"移除停用词: {remove_stopwords(processed_tokens)}")
# 输出: 移除停用词: ['sample', 'text', 'removing', 'stopwords', 'quite', 'useful']

# 最佳实践：
# - 停用词列表可以根据任务和领域进行自定义。
# - 对于某些 NLP 任务（如情感分析），一些“停用词”可能具有情感倾向，不应移除。

3.8. 词形还原 (Lemmatization) 与 词干提取 (Stemming)

  • “为什么”：在英语等形态复杂的语言中，一个单词可能有多种变形（例如：run, runs, running, ran）。这些变形在语义上是相同的，但作为独立的词会增加词汇量。词干提取和词形还原旨在将这些词形归一化到它们的基本形式。
3.8.1. 词干提取 (Stemming)
  • “是什么”：一个启发式的过程，通过移除单词的后缀来将其简化为词干（不一定是实际的词）。它通常比词形还原更快，但准确性较低。
  • “怎么做”：NLTK 提供了多种词干提取器，如 Porter Stemmer 和 Lancaster Stemmer。Porter Stemmer 是最常用的。
# 3.8.1_stemming.py

from nltk.stem import PorterStemmer, LancasterStemmer

def apply_porter_stemmer(tokens: list[str]) -> list[str]:
    """使用 Porter Stemmer 对词元列表进行词干提取。"""
    porter = PorterStemmer()
    return [porter.stem(word) for word in tokens]

def apply_lancaster_stemmer(tokens: list[str]) -> list[str]:
    """使用 Lancaster Stemmer 对词元列表进行词干提取。"""
    lancaster = LancasterStemmer()
    return [lancaster.stem(word) for word in tokens]

# 示例
words = ["running", "runner", "runs", "ran", "easily", "beautiful", "fishes", "fishing"]
print(f"原始词汇: {words}")
print(f"Porter Stemmer: {apply_porter_stemmer(words)}")
print(f"Lancaster Stemmer: {apply_lancaster_stemmer(words)}")
# 输出:
# Porter Stemmer: ['run', 'runner', 'run', 'ran', 'easili', 'beauti', 'fish', 'fish']
# Lancaster Stemmer: ['run', 'run', 'run', 'ran', 'easy', 'beau', 'fish', 'fish']

缺点：词干提取的结果不一定是合法的单词（例如 easili），这会影响可读性。

3.8.2. 词形还原 (Lemmatization)
  • “是什么”：一个更复杂的过程，它利用词典和形态学分析来将单词还原为其“词元”（lemma），即词的规范形式。它会返回一个合法的单词，并且可以考虑词的词性（Part-of-Speech, POS）来提高准确性。
  • “怎么做”：使用 NLTK 的 WordNetLemmatizer。为了获得最佳效果，通常需要先进行词性标注。
# 3.8.2_lemmatization.py

from nltk.stem import WordNetLemmatizer
from nltk.corpus import wordnet # 用于词性标注映射

# 辅助函数：将 NLTK 的词性标签映射到 WordNet 的词性标签
def get_wordnet_pos(tag):
    if tag.startswith('J'): #形容词
        return wordnet.ADJ
    elif tag.startswith('V'): #动词
        return wordnet.VERB
    elif tag.startswith('N'): #名词
        return wordnet.NOUN
    elif tag.startswith('R'): #副词
        return wordnet.ADV
    else:
        return wordnet.NOUN # 默认返回名词

# 注意：为了准确的词形还原，通常需要先进行词性标注 (POS Tagging)
# NLTK 也提供 pos_tag 函数，但本示例不包含完整 POS Tagging 流程以保持简洁。
# 实际项目中，通常会这样使用：
# from nltk import pos_tag
# tagged_tokens = pos_tag(tokens)

def apply_wordnet_lemmatizer(tokens: list[str]) -> list[str]:
    """
    使用 WordNetLemmatizer 对词元列表进行词形还原。
    注意: 未使用词性标注，可能会影响部分准确性。
    """
    lemmatizer = WordNetLemmatizer()
    return [lemmatizer.lemmatize(word) for word in tokens]

def apply_wordnet_lemmatizer_with_pos(tokens_with_pos: list[tuple[str, str]]) -> list[str]:
    """
    使用 WordNetLemmatizer 对词元列表进行词形还原，并考虑词性。
    :param tokens_with_pos: (词元, NLTK词性标签) 的列表。
    """
    lemmatizer = WordNetLemmatizer()
    lemmas = []
    for word, tag in tokens_with_pos:
        # 使用辅助函数将NLTK词性标签转换为WordNet词性标签
        pos = get_wordnet_pos(tag)
        lemmas.append(lemmatizer.lemmatize(word, pos=pos))
    return lemmas


# 示例
words = ["running", "runner", "runs", "ran", "easily", "beautiful", "fishes", "fishing"]
print(f"原始词汇: {words}")
print(f"WordNet Lemmatizer (无词性): {apply_wordnet_lemmatizer(words)}")

# 模拟带有词性标签的词元 (实际项目中会通过 pos_tag 获得)
# 例如：pos_tag(["running", "runs", "ran", "easily", "beautiful", "fishes", "fishing"])
# 假设的词性标签（此处为手动简化示例）
words_pos_mock = [
    ("running", "VBG"), # 动名词/现在分词
    ("runs", "VBZ"),    # 动词单三形式
    ("ran", "VBD"),     # 动词过去式
    ("easily", "RB"),   # 副词
    ("beautiful", "JJ"), # 形容词
    ("fishes", "NNS"),  # 名词复数
    ("fishing", "VBG")  # 动名词/现在分词
]
print(f"WordNet Lemmatizer (带词性): {apply_wordnet_lemmatizer_with_pos(words_pos_mock)}")

# 输出 (无词性):
# WordNet Lemmatizer (无词性): ['running', 'runner', 'run', 'ran', 'easily', 'beautiful', 'fish', 'fishing']
# 注意：'running' 和 'fishing' 并没有还原，因为默认词性为名词

# 输出 (带词性):
# WordNet Lemmatizer (带词性): ['run', 'run', 'run', 'easy', 'beautiful', 'fish', 'fish']
# 注意：带词性的还原更准确，'running'和'fishing'被还原为'run'和'fish'。

选择建议：

  • 词干提取：适用于需要快速处理、对精度要求不高，或者最终词形不需要是合法单词的场景（例如信息检索）。
  • 词形还原：适用于对精度要求较高、希望保留词语原形且是合法单词的场景（例如情感分析、机器翻译）。它通常需要更多的计算资源。

4. 综合应用：构建文本标准化函数

现在，我们将上述一些关键的标准化步骤组合起来，创建一个综合性的文本预处理函数。这个函数将接收原始文本作为输入，并返回一个干净、标准化的词元列表。

处理顺序：

  1. 小写转换
  2. 移除 HTML 标签
  3. 移除 URL
  4. 移除标点符号
  5. 移除数字
  6. 分词
  7. 移除停用词
  8. 词形还原（这里选择词形还原，因为它更准确）
# 4.0_combined_normalization.py

import re
import string
from bs4 import BeautifulSoup
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords, wordnet
from nltk.stem import WordNetLemmatizer
from nltk import pos_tag # 用于词性标注

# 辅助函数：将 NLTK 的词性标签映射到 WordNet 的词性标签
def get_wordnet_pos(tag):
    if tag.startswith('J'):
        return wordnet.ADJ
    elif tag.startswith('V'):
        return wordnet.VERB
    elif tag.startswith('N'):
        return wordnet.NOUN
    elif tag.startswith('R'):
        return wordnet.ADV
    else:
        return wordnet.NOUN # 默认返回名词

def normalize_text_pipeline(text: str) -> list[str]:
    """
    一个综合性的文本标准化处理管道。

    参数:
        text (str): 待处理的原始文本。

    返回:
        list[str]: 经过标准化处理后的单词词元列表。
    """
    # 1. 小写转换
    text = text.lower()

    # 2. 移除 HTML 标签 (使用 BeautifulSoup 确保健壮性)
    soup = BeautifulSoup(text, 'html.parser')
    text = soup.get_text(separator=' ')

    # 3. 移除 URL
    url_pattern = re.compile(r'https?://\S+|www\.\S+|\S+\.(com|org|net|io|co|uk|gov|edu|cn)\S*')
    text = url_pattern.sub('', text)

    # 4. 移除标点符号
    translator = str.maketrans('', '', string.punctuation)
    text = text.translate(translator)

    # 5. 移除数字 (根据任务决定是否需要)
    text = re.sub(r'\d+', '', text)

    # 6. 分词
    tokens = word_tokenize(text)

    # 7. 移除停用词
    stop_words = set(stopwords.words('english'))
    # 过滤掉停用词，并确保只保留字母词元 (过滤掉分词后可能残留的空字符串等)
    filtered_tokens = [word for word in tokens if word.isalpha() and word not in stop_words]

    # 8. 词形还原 (带词性标注以提高准确性)
    lemmatizer = WordNetLemmatizer()
    # 对过滤后的词元进行词性标注
    tagged_tokens = pos_tag(filtered_tokens)
    lemmas = []
    for word, tag in tagged_tokens:
        pos = get_wordnet_pos(tag)
        lemmas.append(lemmatizer.lemmatize(word, pos=pos))

    return lemmas

# 示例
sample_raw_text = """
<p>Hello World! This is a <b>sample</b> text with some <a href="http://example.com">links</a> and numbers like 123.45.
It's quite amazing and running smoothly! Best wishes from GFG_AI.</p>
"""

normalized_tokens = normalize_text_pipeline(sample_raw_text)
print(f"原始文本:\n{sample_raw_text}")
print(f"标准化后的词元:\n{normalized_tokens}")

# 预期输出:
# 标准化后的词元:
# ['hello', 'world', 'sample', 'text', 'link', 'amazing', 'run', 'smoothly', 'best', 'wish', 'gfg_ai']

5. 完整代码示例

将上述所有代码片段整合到一个 text_normalization.py 文件中，方便您直接运行。

# text_normalization.py

import re
import string
import nltk
from bs4 import BeautifulSoup
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords, wordnet
from nltk.stem import WordNetLemmatizer, PorterStemmer, LancasterStemmer
from nltk import pos_tag

# --- NLTK 数据包下载 (确保已运行，否则会报错) ---
# nltk.download('punkt')
# nltk.download('stopwords')
# nltk.download('wordnet')
# nltk.download('omw-1.4')
# print("NLTK 数据包检查/下载完成。")
# ----------------------------------------------------

# --- 1. 文本清理函数 ---

def to_lowercase(text: str) -> str:
    """将文本转换为小写。"""
    return text.lower()

def remove_html(text: str) -> str:
    """使用 BeautifulSoup 移除 HTML 标签。"""
    soup = BeautifulSoup(text, 'html.parser')
    return soup.get_text(separator=' ')

def remove_urls(text: str) -> str:
    """移除文本中的 URL。"""
    url_pattern = re.compile(r'https?://\S+|www\.\S+|\S+\.(com|org|net|io|co|uk|gov|edu|cn)\S*')
    return url_pattern.sub('', text)

def remove_punctuation(text: str) -> str:
    """移除文本中的所有标点符号。"""
    translator = str.maketrans('', '', string.punctuation)
    return text.translate(translator)

def remove_numbers(text: str) -> str:
    """移除文本中的所有数字。"""
    return re.sub(r'\d+', '', text)

def remove_non_alphabetic(text: str) -> str:
    """移除所有非字母字符 (保留空格)。"""
    return re.sub(r'[^a-zA-Z\s]', '', text)

def remove_non_alphanumeric(text: str) -> str:
    """移除所有非字母数字字符 (保留空格)。"""
    return re.sub(r'[^a-zA-Z0-9\s]', '', text)


# --- 2. 结构化处理函数 ---

def tokenize_words(text: str) -> list[str]:
    """将文本分割为单词词元。"""
    return word_tokenize(text)

def tokenize_sentences(text: str) -> list[str]:
    """将文本分割为句子词元。"""
    return sent_tokenize(text)


# --- 3. 语义处理函数 ---

def remove_stopwords(tokens: list[str], language: str = 'english') -> list[str]:
    """
    从词元列表中移除停用词。
    :param tokens: 单词词元列表。
    :param language: 停用词语言，默认为 'english'。
    """
    stop_words = set(stopwords.words(language))
    return [word for word in tokens if word.lower() not in stop_words]

def apply_porter_stemmer(tokens: list[str]) -> list[str]:
    """使用 Porter Stemmer 对词元列表进行词干提取。"""
    porter = PorterStemmer()
    return [porter.stem(word) for word in tokens]

def apply_lancaster_stemmer(tokens: list[str]) -> list[str]:
    """使用 Lancaster Stemmer 对词元列表进行词干提取。"""
    lancaster = LancasterStemmer()
    return [lancaster.stem(word) for word in tokens]

# 辅助函数：将 NLTK 的词性标签映射到 WordNet 的词性标签
def get_wordnet_pos(tag):
    if tag.startswith('J'):
        return wordnet.ADJ
    elif tag.startswith('V'):
        return wordnet.VERB
    elif tag.startswith('N'):
        return wordnet.NOUN
    elif tag.startswith('R'):
        return wordnet.ADV
    else:
        return wordnet.NOUN # 默认返回名词

def apply_wordnet_lemmatizer(tokens_with_pos: list[tuple[str, str]]) -> list[str]:
    """
    使用 WordNetLemmatizer 对词元列表进行词形还原，并考虑词性。
    :param tokens_with_pos: (词元, NLTK词性标签) 的列表。
    """
    lemmatizer = WordNetLemmatizer()
    lemmas = []
    for word, tag in tokens_with_pos:
        pos = get_wordnet_pos(tag)
        lemmas.append(lemmatizer.lemmatize(word, pos=pos))
    return lemmas


# --- 4. 综合文本标准化管道 ---

def normalize_text_pipeline(text: str) -> list[str]:
    """
    一个综合性的文本标准化处理管道。
    包括：小写 -> 移除HTML -> 移除URL -> 移除标点 -> 移除数字 -> 分词 -> 移除停用词 -> 词形还原。

    参数:
        text (str): 待处理的原始文本。

    返回:
        list[str]: 经过标准化处理后的单词词元列表。
    """
    print("\n--- 原始文本 ---")
    print(text)

    # 1. 小写转换
    text = to_lowercase(text)
    print("\n--- 1. 小写转换后 ---")
    print(text)

    # 2. 移除 HTML 标签
    text = remove_html(text)
    print("\n--- 2. 移除 HTML 标签后 ---")
    print(text)

    # 3. 移除 URL
    text = remove_urls(text)
    print("\n--- 3. 移除 URL 后 ---")
    print(text)

    # 4. 移除标点符号
    text = remove_punctuation(text)
    print("\n--- 4. 移除标点符号后 ---")
    print(text)

    # 5. 移除数字 (根据任务决定是否需要)
    text = remove_numbers(text)
    print("\n--- 5. 移除数字后 ---")
    print(text)

    # 6. 分词
    tokens = tokenize_words(text)
    print("\n--- 6. 分词后 ---")
    print(tokens)

    # 7. 移除停用词
    stop_words_filtered_tokens = remove_stopwords(tokens, language='english')
    # 进一步过滤掉非字母词元（分词后可能残留的空格或特殊字符处理后的空字符串）
    final_tokens_pre_lemmatization = [word for word in stop_words_filtered_tokens if word.isalpha()]
    print("\n--- 7. 移除停用词 (并过滤非字母词元) 后 ---")
    print(final_tokens_pre_lemmatization)

    # 8. 词形还原 (带词性标注以提高准确性)
    tagged_tokens = pos_tag(final_tokens_pre_lemmatization)
    lemmas = apply_wordnet_lemmatizer(tagged_tokens)
    print("\n--- 8. 词形还原后 ---")
    print(lemmas)

    return lemmas

# --- 主执行部分 ---
if __name__ == "__main__":
    sample_raw_text = """
    <p>Hello World! This is a <b>sample</b> text with some <a href="http://example.com">links</a> and numbers like 123.45.
    It's quite amazing and running smoothly! Best wishes from GFG_AI and the GeeksForGeeks Team.</p>
    """

    print("--- 开始文本标准化管道处理 ---")
    final_normalized_tokens = normalize_text_pipeline(sample_raw_text)
    print("\n--- 最终标准化后的词元列表 ---")
    print(final_normalized_tokens)

    print("\n--- 独立功能演示 ---")
    # 词干提取演示
    stem_words = ["running", "runner", "runs", "ran", "easily", "beautiful", "fishes", "fishing"]
    print(f"\n原始词汇 (词干提取演示): {stem_words}")
    print(f"Porter Stemmer: {apply_porter_stemmer(stem_words)}")
    print(f"Lancaster Stemmer: {apply_lancaster_stemmer(stem_words)}")

    # 无词性词形还原演示
    lem_words_no_pos = ["running", "runs", "ran", "easily", "beautiful", "fishes", "fishing"]
    # 假设无词性，直接传递列表
    # WordNetLemmatizer(pos='')时，默认是NOUN。这里需要为每个词设置默认pos。
    lem_words_no_pos_tagged = [(word, 'NN') for word in lem_words_no_pos] # 模拟所有词都是名词
    lemmas_no_pos = [WordNetLemmatizer().lemmatize(word) for word in lem_words_no_pos]
    print(f"\n原始词汇 (无词性词形还原演示): {lem_words_no_pos}")
    print(f"WordNet Lemmatizer (无词性): {lemmas_no_pos}")

6. 运行与验证

  1. 保存代码：将上述完整代码保存为 text_normalization.py 文件。
  2. 激活环境：确保您已经激活了之前创建的虚拟环境（例如 nlp_env）。
    • conda activate nlp_env (如果使用 Conda)
    • source nlp_env/bin/activate (如果使用 venv)
  3. 运行 NLTK 数据包下载：如果您是第一次运行，请在终端中进入 Python 解释器或创建一个单独的脚本，运行 1.3 节的 nltk.download() 代码，确保所有必要的 NLTK 数据包都已下载。
  4. 运行脚本：在终端中，导航到保存 text_normalization.py 文件的目录，然后执行：
    python text_normalization.py

运行后，您会在终端看到详细的文本处理过程输出，以及最终标准化后的词元列表。此外，还有独立的词干提取和无词性词形还原的演示结果。

预期输出：
（由于中间步骤的打印，输出会比较长，但最终结果应与 4.0 节的预期输出类似，可能会有细微差异取决于 pos_tag 和 lemmatizer 的具体行为）

--- 开始文本标准化管道处理 ---

--- 原始文本 ---
... (原始文本内容) ...

--- 1. 小写转换后 ---
...

--- 2. 移除 HTML 标签后 ---
...

--- 3. 移除 URL 后 ---
...

--- 4. 移除标点符号后 ---
...

--- 5. 移除数字后 ---
...

--- 6. 分词后 ---
['hello', 'world', 'this', 'is', 'a', 'sample', 'text', 'with', 'some', 'links', 'and', 'numbers', 'its', 'quite', 'amazing', 'and', 'running', 'smoothly', 'best', 'wishes', 'from', 'gfg_ai', 'and', 'the', 'geeksforgeeks', 'team']

--- 7. 移除停用词 (并过滤非字母词元) 后 ---
['hello', 'world', 'sample', 'text', 'links', 'numbers', 'quite', 'amazing', 'running', 'smoothly', 'best', 'wishes', 'gfg_ai', 'geeksforgeeks', 'team']

--- 8. 词形还原后 ---
['hello', 'world', 'sample', 'text', 'link', 'number', 'quite', 'amaze', 'run', 'smoothly', 'best', 'wish', 'gfg_ai', 'geeksforgeeks', 'team']

--- 最终标准化后的词元列表 ---
['hello', 'world', 'sample', 'text', 'link', 'number', 'quite', 'amaze', 'run', 'smoothly', 'best', 'wish', 'gfg_ai', 'geeksforgeeks', 'team']

--- 独立功能演示 ---

原始词汇 (词干提取演示): ['running', 'runner', 'runs', 'ran', 'easily', 'beautiful', 'fishes', 'fishing']
Porter Stemmer: ['run', 'runner', 'run', 'ran', 'easili', 'beauti', 'fish', 'fish']
Lancaster Stemmer: ['run', 'run', 'run', 'ran', 'easy', 'beau', 'fish', 'fish']

原始词汇 (无词性词形还原演示): ['running', 'runs', 'ran', 'easily', 'beautiful', 'fishes', 'fishing']
WordNet Lemmatizer (无词性): ['running', 'run', 'ran', 'easily', 'beautiful', 'fish', 'fishing']

7. 未来展望与最佳实践

文本标准化是一个复杂且高度依赖应用场景的过程。以下是一些进一步的考虑和最佳实践建议：

  • 国际化与多语言支持：
    • 本教程主要关注英文文本。对于其他语言，分词、停用词和词形还原/词干提取的规则大相径庭。例如，中文需要专门的分词器（如 jieba）。
    • 字符集问题：处理 Unicode 字符和不同语言的特殊符号。
  • 领域特定标准化：
    • 在特定领域（如医疗、法律、金融）中，某些“停用词”可能具有重要意义，或者存在需要特殊处理的缩写、专有名词、特殊符号。
    • 构建领域特定的停用词列表或词典。
  • 正则表达式的局限性：
    • 虽然 re 模块功能强大，但对于复杂且不规范的文本结构（如 HTML、XML），单纯依靠正则表达式往往力不从心，易引入错误。
    • 最佳实践：优先使用专门的解析库（如 BeautifulSoup for HTML/XML），而非一味依赖正则表达式。
  • 数据量考量与性能优化：
    • 对于大规模文本数据，上述函数链式调用可能存在性能瓶颈。
    • 优化方向：
      • 批处理：一次性处理多条文本而不是单条。
      • 并行/分布式处理：利用 multiprocessing 或 Spark、Dask 等框架进行加速。
      • 预编译正则表达式：re.compile() 可以提高重复匹配的效率。
      • JIT 编译：对于一些 CPU 密集型任务，可以考虑使用 Numba 等库进行 JIT 编译加速。
  • 自定义停用词/词典：
    • 根据您的数据和任务，自定义停用词列表，或构建同义词词典进行进一步的归一化。
  • N-gram 生成：
    • 除了单个词元，有时还需要考虑词元序列（N-gram），例如“纽约”是两个词但表达一个概念。这通常在标准化步骤之后进行。
  • 非结构化文本的挑战：
    • 本教程侧重于相对规整的文本。对于社交媒体数据（包含大量表情符号、缩写、网络流行语）、语音转文本（包含错误识别、口语化表达）等，需要更高级的清洗和标准化技术。
  • 迭代与实验：
    • 没有一套放之四海而皆准的文本标准化规则。最佳实践是通过实验，在不同的标准化策略下训练和评估您的模型，从而找到最适合您任务的组合。

总结

本教程作为您深入解析了 Python 中文本数据标准化的各项核心技术。从基础的字符串操作到利用 NLTK 和 BeautifulSoup 等高级库，我们涵盖了文本清理、结构化处理和语义处理等多个层面。

掌握文本标准化技能，是您在自然语言处理和机器学习领域迈出的坚实一步。它能帮助您将原始、嘈杂的文本数据转化为模型可以理解和有效学习的优质数据，从而为您的 NLP 项目打下坚实基础，并显著提升模型性能。希望这份教程能为您在数据预处理的道路上提供清晰的指引和强大的工具！

# python # 自然语言处理 # 机器学习
Logo
码道开发者社区

码道开发者社区，聚焦华为云码道 CodeArts 代码智能体，沉淀 Agent、Skill、鸿蒙开发实战内容，供开发者查阅资料、交流技术、分享工程实践

更多推荐

cover

状态丢失排障：Claude 持久记忆的跨会话局限与知芽 Notebook Skill 单元记忆如何沉淀可复用知识资产

avatar 码道开发者社区
cover

vs code 下载安装 以及 如何配置 claude code 和codex

avatar 码道开发者社区
cover

GitHub不再让一个模型写到底：HydraFusion多模型编排，官方评测成本降低67%

avatar 码道开发者社区