Python no té una funció específica per eliminar espais superflus (és a dir, eliminar tots els espais del principi i del final d’un text, i entre paraules deixar-hi només un espai).
Hi ha una manera molt pythònica de fer-ho:
" ".join(text_amb_espais.split())
I això és ràpid? Doncs comparem 3 alternatives amb timeit:
- Aquesta de join i split
 
- Un bucle pas a pas: mirar caràcter a caràcter si hauríem de posar-lo al resultat final, depenent de si aquest o l’anterior són espais.
 
- Amb tantes substitucions com calgui de dos espais seguits a un.
 
El codi per mesurar-ho és:
from timeit import timeit
def eliminar_espais_split_join (text: str) -> str:
    return " ".join(text.split())
def eliminar_espais_posicio_a_posicio (text: str) -> str:
    anterior_es_espai = True
    sense_espais_redundants = ""
    for x in text:
        if x == " ":
            if not anterior_es_espai:
                sense_espais_redundants += x
                anterior_es_espai = True
        else:
            sense_espais_redundants += x
            anterior_es_espai = False
    if len(sense_espais_redundants) > 0:
        if sense_espais_redundants [-1] == " ":
            sense_espais_redundants = sense_espais_redundants[:-1]
    return sense_espais_redundants
def eliminar_espais_replace (text: str) -> str:
    r2 = text
    while (r1:= r2.replace("  ", " ")) != r2:
            r2 = r1
    if len(r2) > 0:
        if r2[0] == " ":
            r2 = r2[1:]
    if len(r2) > 0:
        if r2[-1] == " ":
            r2 = r2[:-1]
    return r2
TEXT_PROVA = "      Vivamus       quis        lacus     quis  sapien    elementum     finibus   et    sollicitudin nisi.   "
assert (eliminar_espais_posicio_a_posicio (TEXT_PROVA) == eliminar_espais_split_join(TEXT_PROVA))
assert (eliminar_espais_replace (TEXT_PROVA) == eliminar_espais_split_join(TEXT_PROVA))
EXECUCIONS = 100_000
temps = (timeit (lambda: eliminar_espais_split_join (TEXT_PROVA), number=EXECUCIONS),
         timeit (lambda: eliminar_espais_posicio_a_posicio (TEXT_PROVA), number=EXECUCIONS),
         timeit (lambda: eliminar_espais_replace(TEXT_PROVA), number=EXECUCIONS))
temps_minim = min(temps)
print (f"eliminar_espais_split_join: {temps [0] / temps_minim:.2f} vegades el mínim")
print (f"eliminar_espais_posicio_a_posicio: {temps [1] / temps_minim:.2f} vegades el mínim")
print (f"eliminar_espais_replace: {temps [2] / temps_minim:.2f} vegades el mínim")
I el resultat:
eliminar_espais_split_join: 1.00 vegades el mínim
eliminar_espais_replace: 2.25 vegades el mínim
eliminar_espais_posicio_a_posicio: 8.83 vegades el mínim
He provat algunes variants, sense que influeixin significativament en els resultats:
- Sense fer servir l’operador walrus (notació := al while) a eliminar_espais_replace.
 
- Amb substitucions de 2 i 3 espais concatenades a eliminar_espais_replace.
 
- Amb un índex per accedir als diferents caràcters a posicio_a_posicio.
 
O sigui, he deixat l’split_join al codi, la manera més genuïna del Python és alhora la més ràpida.