假设这个字符串：
The fox jumped over the log.
变成：
The fox jumped over the log.
什么是最简单的（1-2 行）实现这一点，而不拆分和进入列表？
【问题讨论】：
>>> import re
>>> re.sub(' +', ' ', 'The quick brown fox')
'The quick brown fox'
【讨论】：
string.split 也能处理各种空格。
re.sub(' {2,}', ' ', 'The quick brown fox') 来防止用单空格重复替换单空格。
foo 是你的字符串：
" ".join(foo.split())
请注意，尽管这会删除“所有空白字符（空格、制表符、换行符、回车、换页符）”（感谢hhsaffar，请参阅 cmets）。即，"this is \t a test\n" 将有效地以"this is a test" 结束。
【讨论】：
import re
s = "The fox jumped over the log."
re.sub("\s\s+" , " ", s)
或
re.sub("\s\s+", " ", s)
因为逗号之前的空格在PEP 8 中被列为宠儿，在cmets 中被列为mentioned by user Martin Thoma。
【讨论】：
r"\s\s+"，这样它就不会尝试替换已经存在的单个空格。
"\s{2,}" 而不是不知道中等高级正则表达式行为的解决方法？
s，而是返回新值。
\s\s+，因为这不会将制表符规范化回正常的空格。 SPACE + TAB 确实会以这种方式被替换。
strip()（又名修剪）字符串，因为您可能不想要前导和尾随空格。
使用带有 "\s" 的正则表达式并执行简单的 string.split() 将也删除其他空格 - 例如换行符、回车符、制表符。除非需要这样做，否则仅多个空格，我将提供这些示例。
我使用11 paragraphs, 1000 words, 6665 bytes of Lorem Ipsum 进行实际时间测试，并在整个过程中使用了随机长度的额外空格：
original_string = ''.join(word + (' ' * random.randint(1, 10)) for word in lorem_ipsum.split(' '))
单行基本上会删除任何前导/尾随空格，并保留前导/尾随空格（但只有 ONE ;-)。
# setup = '''
import re
def while_replace(string):
while ' ' in string:
string = string.replace(' ', ' ')
return string
def re_replace(string):
return re.sub(r' {2,}' , ' ', string)
def proper_join(string):
split_string = string.split(' ')
# To account for leading/trailing spaces that would simply be removed
beg = ' ' if not split_string[ 0] else ''
end = ' ' if not split_string[-1] else ''
# versus simply ' '.join(item for item in string.split(' ') if item)
return beg + ' '.join(item for item in split_string if item) + end
original_string = """Lorem ipsum ... no, really, it kept going... malesuada enim feugiat. Integer imperdiet erat."""
assert while_replace(original_string) == re_replace(original_string) == proper_join(original_string)
#'''
# while_replace_test
new_string = original_string[:]
new_string = while_replace(new_string)
assert new_string != original_string
# re_replace_test
new_string = original_string[:]
new_string = re_replace(new_string)
assert new_string != original_string
# proper_join_test
new_string = original_string[:]
new_string = proper_join(new_string)
assert new_string != original_string
注意： “ Keep in mind that the main while 版本”复制了original_string，因为我相信一旦在第一次运行时修改，连续运行会更快（如果只是一点点）。由于这增加了时间，我将此字符串副本添加到其他两个中，以便时间仅在逻辑上显示差异。stmt on timeit instances will only be executed once;我这样做的原始方式，while 循环在同一标签上工作，original_string，因此第二次运行，将无事可做。它现在的设置方式，调用一个函数，使用两个不同的标签，这不是问题。我已经向所有工作人员添加了assert 语句，以验证我们每次迭代都会更改某些内容（对于那些可能持怀疑态度的人）。例如，更改为 this 并且它会中断：
# while_replace_test
new_string = original_string[:]
new_string = while_replace(new_string)
assert new_string != original_string # will break the 2nd iteration
while ' ' in original_string:
original_string = original_string.replace(' ', ' ')
Tests run on a laptop with an i5 processor running Windows 7 (64-bit).
timeit.Timer(stmt = test, setup = setup).repeat(7, 1000)
test_string = 'The fox jumped over\n\t the log.' # trivial
Python 2.7.3, 32-bit, Windows
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.001066 | 0.001260 | 0.001128 | 0.001092
re_replace_test | 0.003074 | 0.003941 | 0.003357 | 0.003349
proper_join_test | 0.002783 | 0.004829 | 0.003554 | 0.003035
Python 2.7.3, 64-bit, Windows
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.001025 | 0.001079 | 0.001052 | 0.001051
re_replace_test | 0.003213 | 0.004512 | 0.003656 | 0.003504
proper_join_test | 0.002760 | 0.006361 | 0.004626 | 0.004600
Python 3.2.3, 32-bit, Windows
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.001350 | 0.002302 | 0.001639 | 0.001357
re_replace_test | 0.006797 | 0.008107 | 0.007319 | 0.007440
proper_join_test | 0.002863 | 0.003356 | 0.003026 | 0.002975
Python 3.3.3, 64-bit, Windows
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.001444 | 0.001490 | 0.001460 | 0.001459
re_replace_test | 0.011771 | 0.012598 | 0.012082 | 0.011910
proper_join_test | 0.003741 | 0.005933 | 0.004341 | 0.004009
test_string = lorem_ipsum
# Thanks to http://www.lipsum.com/
# "Generated 11 paragraphs, 1000 words, 6665 bytes of Lorem Ipsum"
Python 2.7.3, 32-bit
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.342602 | 0.387803 | 0.359319 | 0.356284
re_replace_test | 0.337571 | 0.359821 | 0.348876 | 0.348006
proper_join_test | 0.381654 | 0.395349 | 0.388304 | 0.388193
Python 2.7.3, 64-bit
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.227471 | 0.268340 | 0.240884 | 0.236776
re_replace_test | 0.301516 | 0.325730 | 0.308626 | 0.307852
proper_join_test | 0.358766 | 0.383736 | 0.370958 | 0.371866
Python 3.2.3, 32-bit
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.438480 | 0.463380 | 0.447953 | 0.446646
re_replace_test | 0.463729 | 0.490947 | 0.472496 | 0.468778
proper_join_test | 0.397022 | 0.427817 | 0.406612 | 0.402053
Python 3.3.3, 64-bit
test | minum | maximum | average | median
---------------------+------------+------------+------------+-----------
while_replace_test | 0.284495 | 0.294025 | 0.288735 | 0.289153
re_replace_test | 0.501351 | 0.525673 | 0.511347 | 0.508467
proper_join_test | 0.422011 | 0.448736 | 0.436196 | 0.440318
对于琐碎的字符串，while 循环似乎是最快的，其次是 Pythonic 字符串拆分/连接，而正则表达式拉到后面。
对于非平凡的字符串，似乎还有更多需要考虑的地方。 32位2.7？这是救援的正则表达式！ 2.7 64 位？ while 循环是最好的，并且有相当大的优势。 32 位 3.2，使用“正确的”join。 64 位 3.3，使用 while 循环。再次。
最后，如果/在哪里/在需要时可以提高性能，但最好是remember the mantra：
IANAL、YMMV、自告人！
【讨论】：
' '.join(the_string.split())，我会更喜欢，因为这是通常的用例，但我想说谢谢您的工作！
' '.join(p for p in s.split(' ') if p) parts = s.split(' '); (' ' if not parts[0] else '') + ' '.join(p for p in s.split(' ') if p) + (' ' if not parts[-1] else '')！
我必须同意 Paul McGuire 的评论。对我来说，
' '.join(the_string.split())
比编写正则表达式要好得多。
我的测量结果（Linux 和 Python 2.5）显示 split-then-join 几乎比执行“re.sub(...)”快五倍，如果您预编译正则表达式一次并且仍然快三倍多次执行该操作。而且它更容易理解——更多更 Pythonic。
【讨论】：
与之前的解决方案类似，但更具体：将两个或多个空格替换为一个：
>>> import re
>>> s = "The fox jumped over the log."
>>> re.sub('\s{2,}', ' ', s)
'The fox jumped over the log.'
【讨论】：
一个简单的灵魂
>>> import re
>>> s="The fox jumped over the log."
>>> print re.sub('\s+',' ', s)
The fox jumped over the log.
【讨论】：
我尝试了以下方法，它甚至适用于极端情况，例如：
str1=' I live on earth '
' '.join(str1.split())
但如果你更喜欢正则表达式，可以这样做：
re.sub('\s+', ' ', str1)
尽管必须进行一些预处理才能删除尾随和结束空格。
【讨论】：
您还可以在 Pandas DataFrame 中使用字符串拆分技术，而无需使用 .apply(..)，如果您需要对大量字符串快速执行操作，这很有用。这是一行：
df['message'] = (df['message'].str.split()).str.join(' ')
【讨论】：
import re
string = re.sub('[ \t\n]+', ' ', 'The quick brown \n\n \t fox')
这将删除所有制表符、新行和带有单个空格的多个空格。
【讨论】：
Python 开发者解决方案：
import re
text1 = 'Python Exercises Are Challenging Exercises'
print("Original string: ", text1)
print("Without extra spaces: ", re.sub(' +', ' ', text1))
输出：Original string: Python Exercises Are Challenging Exercises
Without extra spaces: Python Exercises Are Challenging Exercises
【讨论】：
一行代码删除句子前后所有多余的空格：
sentence = " The fox jumped over the log. "
sentence = ' '.join(filter(None,sentence.split(' ')))
解释：
*剩下的元素应该是单词或带有标点符号的单词等。我没有对此进行广泛的测试，但这应该是一个很好的起点。万事如意！
【讨论】：
" ".join(foo.split()) 对于所提出的问题并不完全正确，因为它还 完全 删除了单个前导和/或尾随空格。因此，如果它们也应替换为 1 个空白，您应该执行以下操作：
" ".join(('*' + foo + '*').split()) [1:-1]
当然，它不那么优雅。
【讨论】：
在某些情况下，希望将每个连续出现的空白字符替换为 该 字符的单个实例。您可以使用带有反向引用的正则表达式来做到这一点。
(\s)\1{1,} 匹配任何空白字符，后跟该字符的一次或多次出现。现在，您需要做的就是指定第一组 (\1) 作为匹配的替换。
将其包装在一个函数中：
import re
def normalize_whitespace(string):
return re.sub(r'(\s)\1{1,}', r'\1', string)
>>> normalize_whitespace('The fox jumped over the log.')
'The fox jumped over the log.'
>>> normalize_whitespace('First line\t\t\t \n\n\nSecond line')
'First line\t \nSecond line'
【讨论】：
另一种选择：
>>> import re
>>> str = 'this is a string with multiple spaces and tabs'
>>> str = re.sub('[ \t]+' , ' ', str)
>>> print str
this is a string with multiple spaces and tabs
【讨论】：
对于用户生成的字符串，您可以获得的最快速度是：
if ' ' in text:
while ' ' in text:
text = text.replace(' ', ' ')
短路使它比pythonlarry's comprehensive answer 稍快。如果您追求效率并且严格希望清除单个空格种类中的额外空格，请选择此方法。
【讨论】：
因为@pythonlarry 在这里询问了缺少的基于生成器的版本
groupby 加入很简单。 Groupby 将使用相同的键对连续的元素进行分组。并返回每个组的键对和元素列表。因此，当键是空格时，将返回一个空格，否则返回整个组。
from itertools import groupby
def group_join(string):
return ''.join(' ' if chr==' ' else ''.join(times) for chr,times in groupby(string))
按变体分组很简单，但速度很慢。所以现在对于生成器变体。在这里，我们使用一个迭代器，即字符串，并产生除字符后面的字符之外的所有字符。
def generator_join_generator(string):
last=False
for c in string:
if c==' ':
if not last:
last=True
yield ' '
else:
last=False
yield c
def generator_join(string):
return ''.join(generator_join_generator(string))
所以我用其他一些 lorem ipsum 测量了时间。
Hello 和 World 之间用 64KB 的空格隔开
不要忘记原句
这里有趣的是几乎只有空间的字符串组连接并没有那么糟糕 时间显示始终是七次运行的中位数，每次运行一千次。
【讨论】：
非常令人惊讶 - 没有人发布比所有其他发布的解决方案更快的简单功能。就是这样：
def compactSpaces(s):
os = ""
for c in s:
if c != " " or (os and os[-1] != " "):
os += c
return os
【讨论】：
import re
Text = " You can select below trims for removing white space!! BR Aliakbar "
# trims all white spaces
print('Remove all space:',re.sub(r"\s+", "", Text), sep='')
# trims left space
print('Remove leading space:', re.sub(r"^\s+", "", Text), sep='')
# trims right space
print('Remove trailing spaces:', re.sub(r"\s+$", "", Text), sep='')
# trims both
print('Remove leading and trailing spaces:', re.sub(r"^\s+|\s+$", "", Text), sep='')
# replace more than one white space in the string with one white space
print('Remove more than one space:',re.sub(' +', ' ',Text), sep='')
结果：作为代码
"Remove all space:Youcanselectbelowtrimsforremovingwhitespace!!BRAliakbar"
"Remove leading space:You can select below trims for removing white space!! BR Aliakbar"
"Remove trailing spaces: You can select below trims for removing white space!! BR Aliakbar"
"Remove leading and trailing spaces:You can select below trims for removing white space!! BR Aliakbar"
"Remove more than one space: You can select below trims for removing white space!! BR Aliakbar"
【讨论】：
def unPretty(S):
# Given a dictionary, JSON, list, float, int, or even a string...
# return a string stripped of CR, LF replaced by space, with multiple spaces reduced to one.
return ' '.join(str(S).replace('\n', ' ').replace('\r', '').split())
【讨论】：
string = 'This is a string full of spaces and taps'
string = string.split(' ')
while '' in string:
string.remove('')
string = ' '.join(string)
print(string)
结果：
这是一个充满空格和抽头的字符串
【讨论】：
要删除空格，考虑单词之间的前导、尾随和额外空格，请使用：
(?<=\s) +|^ +(?=\s)| (?= +[\n\0])
第一个or 处理前导空格，第二个or 处理字符串开头的前导空格，最后一个处理尾随空格。
为了使用证明，此链接将为您提供测试。
https://regex101.com/r/meBYli/4
这将与re.split 函数一起使用。
【讨论】：
我没有对其他示例进行大量阅读，但我刚刚创建了这种用于合并多个连续空格字符的方法。
它不使用任何库，虽然它的脚本长度相对较长，但它的实现并不复杂：
def spaceMatcher(command):
"""
Function defined to consolidate multiple whitespace characters in
strings to a single space
"""
# Initiate index to flag if more than one consecutive character
iteration
space_match = 0
space_char = ""
for char in command:
if char == " ":
space_match += 1
space_char += " "
elif (char != " ") & (space_match > 1):
new_command = command.replace(space_char, " ")
space_match = 0
space_char = ""
elif char != " ":
space_match = 0
space_char = ""
return new_command
command = None
command = str(input("Please enter a command ->"))
print(spaceMatcher(command))
print(list(spaceMatcher(command)))
【讨论】：
这样做并且将会这样做：:)
# python... 3.x
import operator
...
# line: line of text
return " ".join(filter(lambda a: operator.is_not(a, ""), line.strip().split(" ")))
【讨论】：