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ínimHe 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.
