Python使用正则表达式将多个空格替换为一个空格

首页

编程语言

热心网友

转载

2026-04-17

方法一：使用 re.sub() 替换连续空白字符

在Python文本处理中，字符串内包含多余的空格、制表符或换行符是一个常见问题。利用Python内置的re.sub()函数可以高效解决。其核心原理是使用正则表达式匹配所有连续的空白字符序列，并将其统一替换为单个空格，从而实现文本规范化。

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

import re

def replace_multiple_spaces(s):
    # 将一个或多个空白字符替换为单个空格
    pattern = r'\s+'
    return re.sub(pattern, ' ', s)

# 测试
text = "Hello    World   This  is   a    test"
result = replace_multiple_spaces(text)
print(f"原始: {repr(text)}")
print(f"处理后: {repr(result)}")
# 输出: 'Hello World This is a test'

代码中的r‘\s+’正则模式是关键，它能匹配任何空白字符（包括空格、制表符\t、换行符\n等）一次或多次。无论文本中存在多少冗余空白，此方法都能将其规整为单一空格，提升文本整洁度。

方法二：只替换空格（不包括制表符、换行符）

在某些特定场景下，您可能只需要压缩多余的空格字符，同时保留文本中用于格式化的制表符和换行符。这时需要采用更精准的匹配策略，仅针对空格字符进行操作。

import re

def replace_multiple_spaces_only(s):
    # 只将连续的空格替换为单个空格（保留制表符和换行符）
    pattern = r' +'
    return re.sub(pattern, ' ', s)

# 测试
text = "Hello    World\t\tTabbed\n\nNewLine"
result = replace_multiple_spaces_only(text)
print(f"原始: {repr(text)}")
print(f"处理后: {repr(result)}")
# 输出: 'Hello World\t\tTabbed\n\nNewLine'

请注意模式的变化：r‘ +’仅匹配连续的空格字符，而\t（制表符）和\n（换行符）等非空格空白字符将被完整保留。这在处理需要维持原始布局或特定分隔格式的文本数据时非常实用。

方法三：更精确的控制

面对复杂的实际项目需求，您可能需要更灵活的控制逻辑。例如，动态选择是否保留换行符。以下增强版函数提供了这种灵活性，通过条件判断实现差异化的处理流程。

import re

def normalize_spaces(s, preserve_newlines=True):
    """
    标准化空格
    :param s: 输入字符串
    :param preserve_newlines: 是否保留换行符
    :return: 处理后的字符串
    """
    if preserve_newlines:
        # 先按行分割，处理每行的空格，再合并
        lines = s.split('\n')
        processed_lines = [re.sub(r' +', ' ', line) for line in lines]
        return '\n'.join(processed_lines)
    else:
        # 替换所有连续空白字符为单个空格
        return re.sub(r'\s+', ' ', s)

# 测试
text = """Hello    World
This  is   a    test
With    multiple     spaces"""

result1 = normalize_spaces(text, preserve_newlines=True)
print("保留换行符:")
print(result1)
print()

result2 = normalize_spaces(text, preserve_newlines=False)
print("不保留换行符:")
print(result2)

此函数的巧妙之处在于其条件分支设计。当设置preserve_newlines=True时，它首先按换行符分割文本为多行，然后仅清理每行内部的多余空格，最后重新拼接以保持原有的段落和行结构。

方法四：同时处理开头和结尾的空格

全面的文本清洗通常需要兼顾字符串内部和首尾。以下方法实现了“一站式”清理方案，既能压缩内部连续空白，又能去除首尾多余空格，得到完全规整的字符串。

import re

def clean_and_normalize_spaces(s):
    """
    清理字符串：去除首尾空格，并将中间多个空格替换为一个空格
    """
    # 先替换连续空白字符为单个空格
    s = re.sub(r'\s+', ' ', s)
    # 去除首尾空格
    return s.strip()

# 测试
text = "   Hello    World   This  is   a    test   "
result = clean_and_normalize_spaces(text)
print(f"原始: {repr(text)}")
print(f"处理后: {repr(result)}")
# 输出: 'Hello World This is a test'

处理流程清晰高效：首先使用re.sub将字符串内部所有连续的空白字符“压缩”为单个空格，然后调用字符串的strip()方法移除开头和结尾的所有空白字符。两步操作确保字符串从内到外完全整洁。

方法五：使用 split() 和 join()（无需正则）

如果您希望避免使用正则表达式，Python内置的字符串方法提供了简洁高效的替代方案。split()与join()的组合是处理此问题的经典方法，代码直观且无需额外导入模块。

def replace_spaces_simple(s):
    """
    使用 split() 和 join() 方法替换多个空格
    """
    # split() 默认按空白字符分割，并自动去除空字符串
    # join() 用单个空格连接
    return ' '.join(s.split())

# 测试
text = "Hello    World   This  is   a    test"
result = replace_spaces_simple(text)
print(f"原始: {repr(text)}")
print(f"处理后: {repr(result)}")
# 输出: 'Hello World This is a test'

s.split()方法在不传入参数时，默认会按任意空白字符（空格、制表符、换行符等）进行分割，并自动过滤掉产生的空字符串元素。随后，‘ ‘.join()使用单个空格将分割后的单词列表重新连接成一个规整的字符串。一行代码即可完成复杂清洗。

完整示例对比

为了帮助您直观理解不同方法的效果差异，我们将几种主要方案应用于同一测试文本，并对比输出结果。

import re

def compare_methods(text):
    print(f"原始文本: {repr(text)}\n")
    
    # 方法1: 正则替换所有空白字符
    result1 = re.sub(r'\s+', ' ', text)
    print(f"方法1 (替换所有空白字符): {repr(result1)}")
    
    # 方法2: 正则只替换空格
    result2 = re.sub(r' +', ' ', text)
    print(f"方法2 (只替换空格): {repr(result2)}")
    
    # 方法3: split/join
    result3 = ' '.join(text.split())
    print(f"方法3 (split/join): {repr(result3)}")
    
    # 方法4: 清理并标准化
    result4 = re.sub(r'\s+', ' ', text).strip()
    print(f"方法4 (清理并标准化): {repr(result4)}")

# 测试
test_text = "  Hello    World\t\tTabbed\n\nNewLine  "
compare_methods(test_text)

输出示例

原始文本: ‘ Hello World\t\tTabbed\n\nNewLine ’

方法1 (替换所有空白字符): ‘ Hello World Tabbed NewLine ’

方法2 (只替换空格): ‘ Hello World\t\tTabbed\n\nNewLine ’

方法3 (split/join): ‘Hello World Tabbed NewLine’

方法4 (清理并标准化): ‘Hello World Tabbed NewLine’

从对比输出可以清晰看出各方法的区别：方法2保留了原始的制表符和换行符；方法1清除了所有特殊空白字符但首尾仍留有空格；方法3和方法4得到了最“干净”的结果（无首尾空格，内部单一空格），但方法3基于字符串操作，方法4基于正则表达式。

性能对比

在处理大规模文本数据时，执行效率成为一个重要考量因素。以下我们通过简单的时间测试来对比几种核心方法的性能表现。

import timeit

text = "Hello    World   This  is   a    test" * 1000

# 方法1: 正则替换所有空白字符
def method1():
    return re.sub(r'\s+', ' ', text)

# 方法2: 正则只替换空格
def method2():
    return re.sub(r' +', ' ', text)

# 方法3: split/join
def method3():
    return ' '.join(text.split())

print("正则替换所有空白字符:", timeit.timeit(method1, number=1000))
print("正则只替换空格:", timeit.timeit(method2, number=1000))
print("split/join方法:", timeit.timeit(method3, number=1000))

通常，split()和join()的组合由于直接调用Python高度优化的内置字符串操作，避免了正则表达式的编译和匹配开销，在处理海量文本时往往表现出更优的性能。当然，对于小规模或一次性任务，性能差异可以忽略，选择最符合需求的方案即可。